[
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nSTATUS_DRAFT = 0\nSTATUS_PENDING = 1\nSTATUS_PUBLISHED = 2\nstatus = STATUS_PUBLISHED\n# Int constants - can assign any int\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Enum**\n\n**Fix:**\n```python\nfrom enum import Enum, auto\nclass Status(Enum):\n DRAFT = auto()\n PENDING = auto()\n PUBLISHED = auto()\nstatus = Status.PUBLISHED\n# Type-safe, iterable, comparable\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_enum"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef greet(name):\n return 'Hello, ' + name\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Return Type**\n\n**Fix:**\n```python\ndef greet(name: str) -> str:\n return 'Hello, ' + name\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_return_type"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nnext_week = today.replace(day=today.day + 7)\n# Can overflow month\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing timedelta for Arithmetic**\n\n**Fix:**\n```python\nfrom datetime import timedelta\nnext_week = today + timedelta(weeks=1)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_timedelta_for_arithmetic"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Singleton:\n _inst = None\n def __new__(cls):\n if not cls._inst:\n cls._inst = super().__new__(cls)\n return cls._inst\n```"
},
{
"role": "assistant",
"content": "**Issue: Singleton Overkill**\n\n**Fix:**\n```python\nimport logging\nlogger = logging.getLogger(__name__)\n# Python modules ARE singletons\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"singleton_overkill"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(data: dict[str, list[tuple[int, float, str]]]):\n # Hard to read and maintain\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: TypeAlias for Complex Types**\n\n**Fix:**\n```python\nfrom typing import TypeAlias\nPoint: TypeAlias = tuple[int, float, str]\nDataset: TypeAlias = dict[str, list[Point]]\ndef process(data: Dataset): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"typealias_for_complex_types"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexecutor = ThreadPoolExecutor(max_workers=5)\nexecutor.submit(task)\n```"
},
{
"role": "assistant",
"content": "**Issue: ThreadPoolExecutor Without Context Manager**\n\n**Fix:**\n```python\nwith ThreadPoolExecutor(max_workers=5) as executor:\n future = executor.submit(task)\n result = future.result()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"threadpoolexecutor_without_context_manager"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncount = 0\nfor _ in items: count += 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing len() builtin**\n\n**Fix:**\n```python\ncount = len(items)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_len()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconfig = {\n 'host': os.environ.get('DB_HOST', 'localhost'),\n 'port': int(os.environ.get('DB_PORT', '5432'))\n}\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Configuration Validation**\n\n**Fix:**\n```python\nfrom pydantic import BaseModel, validator\nclass DatabaseConfig(BaseModel):\n host: str = 'localhost'\n port: int = 5432\n @validator('port')\n def validate_port(cls, v):\n if not (1 <= v <= 65535): raise ValueError('Invalid port')\n return v\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_configuration_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor url in urls:\n r = requests.get(url)\n```"
},
{
"role": "assistant",
"content": "**Issue: Rate Limiting**\n\n**Fix:**\n```python\nimport time\nfor i, url in enumerate(urls):\n r = requests.get(url)\n time.sleep(0.1) # Rate limiting\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"rate_limiting"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = []\nfor url in urls:\n results.append(requests.get(url))\n# Sequential - slow for I/O\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing ThreadPoolExecutor**\n\n**Fix:**\n```python\nfrom concurrent.futures import ThreadPoolExecutor\nwith ThreadPoolExecutor(max_workers=10) as executor:\n results = list(executor.map(requests.get, urls))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_threadpoolexecutor"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef connect_prod(): return connect(host='prod.db', port=5432)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing functools.partial**\n\n**Fix:**\n```python\nfrom functools import partial\nconnect_prod = partial(connect, host='prod.db', port=5432)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_functools.partial"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@click.command()\n@click.option('--port', default=8080)\ndef start(port): run_server(port)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CLI Validation**\n\n**Fix:**\n```python\n@click.command()\n@click.option('--port', default=8080,\n type=click.IntRange(1, 65535))\n@click.option('--workers', default=4,\n type=click.IntRange(1, 32))\ndef start(port, workers): run_server(port, workers)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_cli_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = '%s=%s' % (a, b)\n```"
},
{
"role": "assistant",
"content": "**Issue: Percent Formatting**\n\n**Fix:**\n```python\nr = f'{a}={b}'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"percent_formatting"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_add_pos(): assert add(2,3)==5\ndef test_add_neg(): assert add(-1,-1)==-2\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Parametrized Tests**\n\n**Fix:**\n```python\n@pytest.mark.parametrize('a,b,e', [(2,3,5),(-1,-1,-2),(0,0,0)])\ndef test_add(a,b,e): assert add(a,b)==e\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_parametrized_tests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(order):\n save(order); email(order); analytics(order)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Observer Pattern**\n\n**Fix:**\n```python\nclass EventBus:\n def __init__(self): self._h = {}\n def on(self, evt, h): self._h.setdefault(evt, []).append(h)\n def emit(self, evt, data):\n for h in self._h.get(evt, []): h(data)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_observer_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef find(arr, target):\n lo, hi = 0, len(arr) - 1\n while lo <= hi:\n mid = (lo + hi) // 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n lo = mid + 1\n else:\n hi = mid - 1\n return -1\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual binary search**\n\n**Fix:**\n```python\nimport bisect\ndef find(arr, target):\n idx = bisect.bisect_left(arr, target)\n if idx < len(arr) and arr[idx] == target:\n return idx\n return -1\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_binary_search"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncursor.execute(f\"SELECT * FROM users WHERE name = '{name}'\")\n```"
},
{
"role": "assistant",
"content": "**Issue: SQL Injection**\n\n**Fix:**\n```python\ncursor.execute(\"SELECT * FROM users WHERE name = ?\", (name,))\n```"
}
],
"source": "python_training",
"tags": [
"python",
"sql_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ns = requests.Session()\n```"
},
{
"role": "assistant",
"content": "**Issue: Connection Pool Settings**\n\n**Fix:**\n```python\nfrom urllib3.util import Retry\nfrom requests.adapters import HTTPAdapter\ns = requests.Session()\ns.mount('https://', HTTPAdapter(pool_maxsize=20))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"connection_pool_settings"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef chunks(lst, n):\n result = []\n for i in range(0, len(lst), n):\n result.append(lst[i:i+n])\n return result\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual chunking**\n\n**Fix:**\n```python\nfrom itertools import islice\ndef chunks(iterable, n):\n it = iter(iterable)\n while batch := list(islice(it, n)):\n yield batch\n# Generator - memory efficient for large data\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_chunking"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass AppError(Exception):\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Custom Exception Inheritance**\n\n**Fix:**\n```python\nclass AppError(Exception):\n def __init__(self, code, message):\n self.code = code\n self.message = message\n def __str__(self):\n return f'[{self.code}] {self.message}'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"custom_exception_inheritance"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlogger.info(\"Payment processed\")\n# No context - which payment? which user?\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Log Context**\n\n**Fix:**\n```python\nlogger.info(\"Payment processed\", extra={'user_id': user_id, 'amount': amount})\n# Structured logging with context for easier debugging\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_log_context"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nage = int(request.args['age'])\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Input Validation**\n\n**Fix:**\n```python\ntry:\n age = int(request.args['age'])\n if not 0 <= age <= 150: raise ValueError\nexcept (ValueError, TypeError):\n raise BadRequest('Invalid age')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_input_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Meta(type):\n def __new__(mcs, name, bases, attrs):\n return super().__new__(mcs, name, bases, attrs)\n```"
},
{
"role": "assistant",
"content": "**Issue: Metaclass Overuse**\n\n**Fix:**\n```python\ndef validated(cls):\n for n, a in cls.__dict__.items():\n if isinstance(a, Field): setattr(cls, n, a)\n return cls\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"metaclass_overuse"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def process_all(urls):\n tasks = [fetch(url) for url in urls]\n return await asyncio.gather(*tasks)\n# Thousands of concurrent requests\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio semaphore**\n\n**Fix:**\n```python\nasync def process_all(urls):\n semaphore = asyncio.Semaphore(50)\n async def limited_fetch(url):\n async with semaphore:\n return await fetch(url)\n tasks = [limited_fetch(url) for url in urls]\n return await asyncio.gather(*tasks)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_asyncio_semaphore"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nunique = []\nfor item in items:\n if item not in unique: unique.append(item)\n```"
},
{
"role": "assistant",
"content": "**Issue: Using set for Uniqueness**\n\n**Fix:**\n```python\nunique = list(dict.fromkeys(items))\n# Preserves order, O(1) lookup\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"using_set_for_uniqueness"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncurrent_user = None # Global - shared across threads!\ndef middleware(request):\n global current_user\n current_user = authenticate(request)\n```"
},
{
"role": "assistant",
"content": "**Issue: Thread Local Storage Missing**\n\n**Fix:**\n```python\nimport threading\nthread_local = threading.local()\ndef middleware(request):\n thread_local.current_user = authenticate(request)\n# Each thread has its own current_user\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"thread_local_storage_missing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexcept (TypeError, ValueError):\n handle()\n```"
},
{
"role": "assistant",
"content": "**Issue: except* (Python 3.11)**\n\n**Fix:**\n```python\nexcept* (TypeError, ValueError):\n handle()\n# Handles ExceptionGroup\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"except*_(python_3.11)"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nredirect(request.args.get('next'))\n```"
},
{
"role": "assistant",
"content": "**Issue: Open Redirect**\n\n**Fix:**\n```python\nfrom urllib.parse import urlparse\ndef is_safe_url(url):\n parsed = urlparse(url)\n return parsed.netloc == '' or parsed.netloc == request.host\nredirect(request.args.get('next') if is_safe_url(request.args.get('next')) else '/')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"open_redirect"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nqueue = []\nqueue.append(item)\nitem = queue.pop(0) # O(n)\n```"
},
{
"role": "assistant",
"content": "**Issue: Using list for FIFO queue**\n\n**Fix:**\n```python\nfrom collections import deque\nqueue = deque()\nqueue.append(item)\nitem = queue.popleft() # O(1)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_list_for_fifo_queue"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntext.encode('utf-8')\n# Silent data loss with replace errors\n```"
},
{
"role": "assistant",
"content": "**Issue: String Encoding Error**\n\n**Fix:**\n```python\ntext.encode('utf-8', errors='strict')\n# Or errors='replace', 'xmlcharrefreplace'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_encoding_error"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass OrderProcessor:\n def __init__(self):\n self.db = DatabaseConnection()\n self.email = EmailService()\n self.logger = Logger()\n```"
},
{
"role": "assistant",
"content": "**Issue: Hardcoded dependencies**\n\n**Fix:**\n```python\nclass OrderProcessor:\n def __init__(\n self,\n db: DatabaseConnection,\n email: EmailService,\n logger: Logger\n ):\n self.db = db\n self.email = email\n self.logger = logger\n # Dependency Injection - testable, flexible\n```"
}
],
"source": "python_training",
"tags": [
"python",
"hardcoded_dependencies"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom concurrent.futures import ThreadPoolExecutor\n# I/O bound - use asyncio instead\n```"
},
{
"role": "assistant",
"content": "**Issue: concurrent.futures vs asyncio**\n\n**Fix:**\n```python\nimport asyncio\n# asyncio is better for I/O-bound tasks\n# concurrent.futures is better for CPU-bound\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"concurrent.futures_vs_asyncio"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor item in items:\n if item.valid:\n found = True; break\n```"
},
{
"role": "assistant",
"content": "**Issue: any/all Instead of Loop**\n\n**Fix:**\n```python\nfound = any(item.valid for item in items)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"any/all_instead_of_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(val):\n if isinstance(val, str):\n return val.upper()\n elif isinstance(val, int):\n return val * 2\n elif isinstance(val, list):\n return [process(x) for x in val]\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual isinstance checks**\n\n**Fix:**\n```python\nfrom typing import Union\ndef process(val: Union[str, int, list]) -> Any:\n if isinstance(val, str):\n return val.upper()\n if isinstance(val, int):\n return val * 2\n if isinstance(val, list):\n return [process(x) for x in val]\n raise TypeError(f'Unsupported type: {type(val).__name__}')\n# Use structural pattern matching (3.10+)\nmatch val:\n case str():\n return val.upper()\n case int():\n return val * 2\n case list():\n return [process(x) for x in val]\n case _:\n raise TypeError(f'Unsupported: {type(val).__name__}')\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_isinstance_checks"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif args.command == 'serve': serve()\nelif args.command == 'build': build()\nelif args.command == 'test': test()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CLI Subcommands**\n\n**Fix:**\n```python\nimport click\n@click.group()\ndef cli(): '''MyApp CLI'''\n pass\n\n@cli.command()\n@click.option('--port', default=8080)\ndef serve(port): '''Start development server'''\n run_server(port)\n\n@cli.command()\ndef build(): '''Build the application'''\n build_app()\n\n@cli.command()\ndef test(): '''Run tests'''\n run_tests()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_cli_subcommands"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nmerged = {}\nfor d in [d1, d2, d3]:\n merged.update(d)\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual dict merge**\n\n**Fix:**\n```python\nmerged = {**d1, **d2, **d3}\n# Python 3.5+ dict unpacking\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_dict_merge"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ns = 'hello'\ns[0] = 'H'\n# TypeError\n```"
},
{
"role": "assistant",
"content": "**Issue: String Immutability Misuse**\n\n**Fix:**\n```python\ns = 'Hello' + s[1:] # Strings are immutable\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_immutability_misuse"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef first_item(items):\n return items[0]\n# No type info on return\n```"
},
{
"role": "assistant",
"content": "**Issue: Generic Type with TypeVar**\n\n**Fix:**\n```python\nfrom typing import TypeVar, Sequence\nT = TypeVar('T')\ndef first_item(items: Sequence[T]) -> T:\n return items[0]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"generic_type_with_typevar"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif os.environ.get('ENV') == 'production':\n DEBUG = False\n DB_URL = os.environ['PROD_DB']\n# Grows unmaintainable\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Environment-Specific Config**\n\n**Fix:**\n```python\nfrom pydantic import BaseModel\nclass BaseConfig(BaseModel):\n app_name: str = 'myapp'\nclass DevConfig(BaseConfig):\n debug: bool = True\nclass ProdConfig(BaseConfig):\n debug: bool = False\n sentry_dsn: str = os.environ['SENTRY_DSN']\nENV_MAP = {'dev': DevConfig, 'production': ProdConfig}\ndef get_config(): return ENV_MAP[os.environ.get('ENV', 'dev')]()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_environment-specific_config"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nquery = 'SELECT * FROM users WHERE id = ' + user_id\ncursor.execute(query)\n```"
},
{
"role": "assistant",
"content": "**Issue: SQL Injection**\n\n**Fix:**\n```python\ncursor.execute('SELECT * FROM users WHERE id = ?', (user_id,))\n# Parameterized queries\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sql_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf['full'] = df.apply(lambda r: r['first']+' '+r['last'], axis=1)\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Apply Instead of Vectorize**\n\n**Fix:**\n```python\ndf['full'] = df['first'] + ' ' + df['last']\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_apply_instead_of_vectorize"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nrequest_data = {}\n# Shared across threads\n```"
},
{
"role": "assistant",
"content": "**Issue: threading.local**\n\n**Fix:**\n```python\nrequest_data = threading.local()\n# Thread-local storage\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"threading.local"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfilename = request.args.get('file')\nreturn open('/uploads/' + filename)\n```"
},
{
"role": "assistant",
"content": "**Issue: Path Traversal**\n\n**Fix:**\n```python\nfrom pathlib import Path\nALLOWED = Path('/uploads').resolve()\np = (ALLOWED / filename).resolve()\nif not str(p).startswith(str(ALLOWED)): raise ValueError\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"path_traversal"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Python 3.9 code\nfrom typing import Union, Optional\n# Using old-style imports unnecessarily\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing_extensions for Python 3.10+**\n\n**Fix:**\n```python\nfrom typing import Union, Optional # 3.10+:\nfrom typing import TypeAlias # 3.10+\nmatch status: # 3.10+\n case 200: handle_ok()\n case 404: handle_not_found()\n# Use modern syntax where available\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing_extensions_for_python_3.10+"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport copy\nnew_config = copy.deepcopy(config)\n```"
},
{
"role": "assistant",
"content": "**Issue: Unnecessary deepcopy**\n\n**Fix:**\n```python\nimport json\nnew_config = json.loads(json.dumps(config))\n# Or better: use copy.deepcopy only when needed\n# For simple dicts: {**config} is faster\n```"
}
],
"source": "python_training",
"tags": [
"python",
"unnecessary_deepcopy"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ns = text.lower()\ns = s.strip()\ns = s.replace(' ', '_')\n```"
},
{
"role": "assistant",
"content": "**Issue: String Method Chaining**\n\n**Fix:**\n```python\ns = text.lower().strip().replace(' ', '_')\n# Chain string methods\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_method_chaining"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef is_str_list(val):\n if isinstance(val, list) and all(isinstance(x, str) for x in val):\n # Type checker doesn't know\n process(val)\n```"
},
{
"role": "assistant",
"content": "**Issue: TypeGuard**\n\n**Fix:**\n```python\nfrom typing import TypeGuard\ndef is_str_list(val: list) -> TypeGuard[list[str]]:\n return all(isinstance(x, str) for x in val)\nif is_str_list(val): process(val) # Type narrowed\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"typeguard"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexcept Exception as e:\n return None\n# Masks all errors\n```"
},
{
"role": "assistant",
"content": "**Issue: Too Broad except**\n\n**Fix:**\n```python\nexcept (ValueError, TypeError) as e:\n return None\n# Catch only expected errors\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"too_broad_except"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nusers = session.query(User).select(User.id, User.name).all()\n# Returns tuples, not User objects\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Select vs Filter**\n\n**Fix:**\n```python\nusers = session.query(User).filter(User.active == True).all()\n# Returns User objects\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_select_vs_filter"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor url in urls:\n r = requests.get(url)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Session in requests**\n\n**Fix:**\n```python\nwith requests.Session() as s:\n for url in urls:\n r = s.get(url)\n# Connection reuse\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_session_in_requests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nFROM python:3.11\nRUN pip install -r requirements.txt\nCMD [\"python\", \"app.py\"]\n```"
},
{
"role": "assistant",
"content": "**Issue: Running as root in Docker**\n\n**Fix:**\n```python\nFROM python:3.11-slim\nWORKDIR /app\nCOPY requirements.txt .\nRUN pip install --no-cache-dir -r requirements.txt\nCOPY . .\nRUN useradd -m appuser\nUSER appuser\nCMD [\"python\", \"app.py\"]\n```"
}
],
"source": "python_training",
"tags": [
"python",
"running_as_root_in_docker"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = requests.get(url)\nreturn r.json()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Pagination**\n\n**Fix:**\n```python\nall_items = []\nwhile url:\n r = requests.get(url)\n data = r.json()\n all_items.extend(data['items'])\n url = data.get('next_page')\nreturn all_items\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_pagination"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif type(obj) == str:\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing isinstance() check**\n\n**Fix:**\n```python\nif isinstance(obj, str):\n# isinstance handles inheritance\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_isinstance()_check"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nposts = session.query(Post).filter_by(category='tech').all()\n# Template accesses post.author.name -> N+1\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Eager Loading Missing**\n\n**Fix:**\n```python\nfrom sqlalchemy.orm import selectinload\nposts = session.query(Post).options(\n selectinload(Post.author)\n).filter_by(category='tech').all()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_eager_loading_missing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif text.isdigit():\n # Fails on '1/2', '123'\n```"
},
{
"role": "assistant",
"content": "**Issue: String isdigit vs isnumeric**\n\n**Fix:**\n```python\nif text.isnumeric():\n # Handles more Unicode digits\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_isdigit_vs_isnumeric"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif attr == 'name': obj.name = val\nelif attr == 'age': obj.age = val\n```"
},
{
"role": "assistant",
"content": "**Issue: setattr for Dynamic Attributes**\n\n**Fix:**\n```python\nsetattr(obj, attr, val)\n# Dynamic attribute setting\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"setattr_for_dynamic_attributes"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nraise Exception('Something went wrong')\n```"
},
{
"role": "assistant",
"content": "**Issue: Raising Generic Exception**\n\n**Fix:**\n```python\nraise ValueError('Input data is invalid')\n# Use specific exception types\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"raising_generic_exception"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = session.execute(\n text(f\"SELECT * FROM users WHERE name LIKE '%{user_input}%'\"))\n# String formatting in SQL!\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Raw SQL Injection**\n\n**Fix:**\n```python\nresults = session.execute(\n text(\"SELECT * FROM users WHERE name LIKE :name\"),\n {\"name\": f\"%{user_input}%\"})\n# Parameterized query\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_raw_sql_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_user(user_id):\n session = Session()\n return session.query(User).filter_by(id=user_id).first()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Repository Pattern**\n\n**Fix:**\n```python\nclass UserRepository:\n def __init__(self, session: Session):\n self.session = session\n\n def get_by_id(self, user_id: int) -> User:\n return self.session.query(User).filter_by(id=user_id).first()\n\n def save(self, user: User):\n self.session.add(user)\n self.session.commit()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_repository_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nassert result._internal_cache == {'k': 'v'}\n```"
},
{
"role": "assistant",
"content": "**Issue: Testing Implementation Details**\n\n**Fix:**\n```python\nassert result.get('k') == 'v'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"testing_implementation_details"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_file(filename):\n path = os.path.join('/data', filename)\n return open(path).read()\n```"
},
{
"role": "assistant",
"content": "**Issue: Path Traversal**\n\n**Fix:**\n```python\nfrom pathlib import Path\ndef get_file(filename):\n base = Path('/data').resolve()\n target = (base / filename).resolve()\n if not str(target).startswith(str(base)):\n raise ValueError('Path traversal detected')\n return target.read_text()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"path_traversal"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexcept BaseException as e:\n handle(e)\n# Catches KeyboardInterrupt, SystemExit\n```"
},
{
"role": "assistant",
"content": "**Issue: Catching BaseException**\n\n**Fix:**\n```python\nexcept Exception as e:\n handle(e)\n# BaseException includes KeyboardInterrupt\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"catching_baseexception"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Package without __init__.py\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing __init__.py**\n\n**Fix:**\n```python\n# Python 3.3+ supports implicit namespace packages\n# But explicit __init__.py is clearer\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing___init__.py"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = await long_computation()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.shield**\n\n**Fix:**\n```python\nresult = await asyncio.shield(long_computation())\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.shield"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.route('/api/process', methods=['POST'])\ndef process():\n data = request.json\n name = data['name'] # KeyError if missing\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing request validation middleware**\n\n**Fix:**\n```python\n@app.route('/api/process', methods=['POST'])\ndef process():\n data = request.get_json()\n if not data or 'name' not in data:\n return {'error': 'Missing name field'}, 400\n name = data['name']\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_request_validation_middleware"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = User.objects.extra(\n where=[\"last_login > %s\"],\n params=[threshold]\n)\n```"
},
{
"role": "assistant",
"content": "**Issue: Django - Raw SQL in QuerySet**\n\n**Fix:**\n```python\nfrom django.db.models import Q\nresults = User.objects.filter(\n last_login__gt=threshold\n)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"django_-_raw_sql_in_queryset"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nreturn r.json()\n```"
},
{
"role": "assistant",
"content": "**Issue: API Response Parsing**\n\n**Fix:**\n```python\ntry:\n return r.json()\nexcept requests.JSONDecodeError:\n logger.error('Invalid JSON: ' + r.text[:200])\n raise\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"api_response_parsing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# app.py - growing monolith\n@app.route('/users')\ndef users():\n ...\n@app.route('/orders')\ndef orders():\n ...\n```"
},
{
"role": "assistant",
"content": "**Issue: Flask - Not using Blueprint**\n\n**Fix:**\n```python\nfrom flask import Blueprint\nuser_bp = Blueprint('users', __name__)\norder_bp = Blueprint('orders', __name__)\n\n# user_routes.py\n@user_bp.route('/users')\ndef users():\n ...\n\n# app.py\napp.register_blueprint(user_bp)\napp.register_blueprint(order_bp)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"flask_-_not_using_blueprint"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntotal = 0\nfor i in items: total += i\n```"
},
{
"role": "assistant",
"content": "**Issue: Generator Expression for sum/max/min**\n\n**Fix:**\n```python\ntotal = sum(items)\n# Built-in functions are C-optimized\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"generator_expression_for_sum/max/min"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexecutor.shutdown()\n# Doesn't wait\n```"
},
{
"role": "assistant",
"content": "**Issue: Executor Shutdown Wait**\n\n**Fix:**\n```python\nexecutor.shutdown(wait=True)\n# Wait for all tasks to complete\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"executor_shutdown_wait"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n_cache = {}\ndef get_large_object(obj_id):\n if obj_id not in _cache:\n _cache[obj_id] = load_object(obj_id)\n return _cache[obj_id]\n# Cache never shrinks - memory leak\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing WeakRef for Cache**\n\n**Fix:**\n```python\nimport weakref\n_cache = weakref.WeakValueDictionary()\ndef get_large_object(obj_id):\n obj = _cache.get(obj_id)\n if obj is None:\n obj = load_object(obj_id)\n _cache[obj_id] = obj\n return obj\n# Objects garbage collected when no strong refs\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_weakref_for_cache"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nraise ValueError(\"Invalid user input\")\nraise ValueError(\"Database connection failed\")\n# All ValueError - hard to handle specifically\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Exception Hierarchy**\n\n**Fix:**\n```python\nclass AppError(Exception):\n def __init__(self, message, code=None):\n super().__init__(message)\n self.code = code\nclass ValidationError(AppError): pass\nclass DatabaseError(AppError): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_exception_hierarchy"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor name, age in zip(names, ages):\n # Stops at shortest\n```"
},
{
"role": "assistant",
"content": "**Issue: zip_longest**\n\n**Fix:**\n```python\nfrom itertools import zip_longest\nfor name, age in zip_longest(names, ages, fillvalue=None):\n # Pads shorter iterable\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"zip_longest"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef divide(a, b):\n if b == 0: raise ValueError(\"Division by zero\")\n return a / b\n # Error doesn't include actual values\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Error Context**\n\n**Fix:**\n```python\ndef divide(a, b):\n if b == 0: raise ValueError(f\"Division by zero: {a} / {b}\")\n return a / b\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_error_context"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nrunning_total = 0\nfor x in values:\n running_total += x\n process(running_total)\n```"
},
{
"role": "assistant",
"content": "**Issue: itertools.accumulate**\n\n**Fix:**\n```python\nfrom itertools import accumulate\nfor total in accumulate(values):\n process(total)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"itertools.accumulate"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif ptype == 'stripe': p = Stripe()\nelif ptype == 'paypal': p = PayPal()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Factory Pattern**\n\n**Fix:**\n```python\nclass Factory:\n _map = {'stripe': Stripe, 'paypal': PayPal}\n @classmethod\n def create(cls, ptype): return cls._map[ptype]()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_factory_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncounter = 0\ndef increment():\n global counter\n counter += 1 # Not atomic!\n```"
},
{
"role": "assistant",
"content": "**Issue: Thread Safety Missing**\n\n**Fix:**\n```python\nimport threading\nlock = threading.Lock()\ncounter = 0\ndef increment():\n global counter\n with lock: counter += 1\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"thread_safety_missing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntask = asyncio.create_task(long_running())\n# If cancelled, resources leaked\n```"
},
{
"role": "assistant",
"content": "**Issue: asyncio Task cancellation**\n\n**Fix:**\n```python\ntask = asyncio.create_task(long_running())\ntry:\n result = await task\nexcept asyncio.CancelledError:\n await cleanup_resources()\n raise\n```"
}
],
"source": "python_training",
"tags": [
"python",
"asyncio_task_cancellation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test1(): process({'name':'Alice','age':30})\ndef test2(): process({'name':'Bob','age':25})\n```"
},
{
"role": "assistant",
"content": "**Issue: Test Data Sprawl**\n\n**Fix:**\n```python\ndef user(**kw):\n d = {'name':'Test','age':30}\n d.update(kw)\n return d\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"test_data_sprawl"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process_order(order):\n db.save(order)\n db.save(order.items)\n db.save(order.payment)\n # If payment fails, order and items already saved\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Unit of Work**\n\n**Fix:**\n```python\nfrom contextlib import contextmanager\n@contextmanager\ndef unit_of_work(session):\n try:\n yield session\n session.commit()\n except Exception:\n session.rollback()\n raise\n\n# All changes atomic\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_unit_of_work"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlogger.info(f\"User input: {user_input}\")\n```"
},
{
"role": "assistant",
"content": "**Issue: Log Injection**\n\n**Fix:**\n```python\nimport logging\nlogger.info(\"User input: %s\", user_input)\n# Use % formatting to prevent log injection via \\n\n```"
}
],
"source": "python_training",
"tags": [
"python",
"log_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncounter = 0\nasync def increment():\n global counter\n counter += 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Race condition in asyncio**\n\n**Fix:**\n```python\nimport asyncio\nlock = asyncio.Lock()\ncounter = 0\nasync def increment():\n global counter\n async with lock:\n counter += 1\n```"
}
],
"source": "python_training",
"tags": [
"python",
"race_condition_in_asyncio"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef handle_request(request):\n # Auth check\n # Rate limiting\n # Logging\n # CORS\n # Request processing\n # Error handling\n # Response formatting\n ...\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Middleware pattern**\n\n**Fix:**\n```python\nclass Middleware:\n def __init__(self, handler=None):\n self.handler = handler\n\n def process(self, request):\n # Pre-processing\n if self.handler:\n return self.handler.process(request)\n return None\n\nclass AuthMiddleware(Middleware): ...\nclass RateLimitMiddleware(Middleware): ...\n\n# Chain: AuthMiddleware(RateLimitMiddleware(handler))\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_middleware_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef generate_token():\n token = str(uuid.uuid4())\n if token in existing_tokens:\n return generate_token()\n return token\n```"
},
{
"role": "assistant",
"content": "**Issue: Race Condition in Token**\n\n**Fix:**\n```python\ndef generate_token():\n token = secrets.token_urlsafe(32)\n # UUIDs + secrets are already unique enough\n # No need to check existence\n return token\n```"
}
],
"source": "python_training",
"tags": [
"python",
"race_condition_in_token"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor name, grp in df.groupby('cat'):\n print(name, grp['val'].mean())\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas GroupBy Loop**\n\n**Fix:**\n```python\nresult = df.groupby('cat')['val'].agg(['mean','sum','count'])\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_groupby_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef calc(x):\n return x * 3.14159\n# Recomputed each call\n```"
},
{
"role": "assistant",
"content": "**Issue: Precomputed Constant**\n\n**Fix:**\n```python\nPI = 3.14159\ndef calc(x): return x * PI\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"precomputed_constant"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = requests.get(url)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Timeout in requests**\n\n**Fix:**\n```python\nr = requests.get(url, timeout=(5, 30))\n# Connect timeout, read timeout\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_timeout_in_requests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nSTATUS_DRAFT = 0\nSTATUS_PENDING = 1\nSTATUS_PUBLISHED = 2\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual enum with integers**\n\n**Fix:**\n```python\nfrom enum import IntEnum\nclass Status(IntEnum):\n DRAFT = 0\n PENDING = 1\n PUBLISHED = 2\n# Type-safe, iterable, comparable\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_enum_with_integers"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def process():\n return requests.get(url).json()\n```"
},
{
"role": "assistant",
"content": "**Issue: Blocking Call in Async**\n\n**Fix:**\n```python\nimport aiohttp\nasync def process():\n async with aiohttp.ClientSession() as s:\n async with s.get(url) as r: return await r.json()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"blocking_call_in_async"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n[obj.method() for obj in objs]\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing operator.methodcaller**\n\n**Fix:**\n```python\nfrom operator import methodcaller\nlist(map(methodcaller('method'), objs))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_operator.methodcaller"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwith open('f') as f:\n pass\n# Return value ignored\n```"
},
{
"role": "assistant",
"content": "**Issue: Context Manager Return Value**\n\n**Fix:**\n```python\nwith open('f') as f:\n data = f.read()\n# Use the context manager resource\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"context_manager_return_value"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Synchronizing threads with flags\nflag = False\ndef phase1():\n global flag\n do_work(); flag = True\nwhile not flag: pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing threading.Barrier**\n\n**Fix:**\n```python\nbarrier = threading.Barrier(2)\ndef phase1():\n do_work()\n barrier.wait()\ndef phase2():\n barrier.wait()\n process()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_threading.barrier"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Inspecting object attributes\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing dir() builtin**\n\n**Fix:**\n```python\nattrs = dir(obj)\n# List all attributes and methods\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_dir()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nusers = session.query(User).all()\nfor user in users:\n print(user.posts) # Lazy loads each post\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy N+1 Query**\n\n**Fix:**\n```python\nfrom sqlalchemy.orm import joinedload\nusers = session.query(User).options(joinedload(User.posts)).all()\n# Single query with JOIN\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_n+1_query"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndb.connect(); db.auth(u); db.authz(u); cache.sess(u)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Facade Pattern**\n\n**Fix:**\n```python\nclass AuthFacade:\n def auth(self, u):\n db.connect(); db.auth(u); db.authz(u)\n cache.sess(u)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_facade_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconfig = {'host': 'localhost', 'port': 8080}\n```"
},
{
"role": "assistant",
"content": "**Issue: dataclass vs dict**\n\n**Fix:**\n```python\n@dataclass\nclass Config:\n host: str = 'localhost'\n port: int = 8080\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"dataclass_vs_dict"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def fetch_many(urls):\n return await asyncio.gather(*[fetch(u) for u in urls])\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.Semaphore**\n\n**Fix:**\n```python\nsem = asyncio.Semaphore(10)\nasync def limited(u):\n async with sem: return await fetch(u)\nreturn await asyncio.gather(*[limited(u) for u in urls])\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.semaphore"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexcept Exception, e:\n handle(e)\n```"
},
{
"role": "assistant",
"content": "**Issue: except Exception, e (Python 2 style)**\n\n**Fix:**\n```python\nexcept Exception as e:\n handle(e)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"except_exception,_e_(python_2_style)"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor i in range(len(items)):\n process(i, items[i])\n```"
},
{
"role": "assistant",
"content": "**Issue: zip vs enumerate**\n\n**Fix:**\n```python\nfor i, item in enumerate(items):\n process(i, item)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"zip_vs_enumerate"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nd.setdefault(key, []).append(item)\n# Creates list even if key exists\n```"
},
{
"role": "assistant",
"content": "**Issue: Using dict.setdefault incorrectly**\n\n**Fix:**\n```python\nfrom collections import defaultdict\nd = defaultdict(list)\nd[key].append(item)\n# Or: d.setdefault(key, []).append(item) is actually correct\n# The issue is performance - defaultdict is cleaner\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_dict.setdefault_incorrectly"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom datetime import datetime\ndt = datetime.strptime(text, '%Y-%m-%d %H:%M:%S')\n```"
},
{
"role": "assistant",
"content": "**Issue: dateutil.parser for Parsing**\n\n**Fix:**\n```python\nfrom dateutil import parser\ndt = parser.parse(text)\n# Handles many formats\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"dateutil.parser_for_parsing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process_data(data, key):\n return data[key]\n```"
},
{
"role": "assistant",
"content": "**Issue: Type Hints Missing**\n\n**Fix:**\n```python\ndef process_data(data: dict[str, Any], key: str) -> Any:\n return data[key]\n# Type hints enable static analysis and IDE support\n```"
}
],
"source": "python_training",
"tags": [
"python",
"type_hints_missing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwith open('data.json') as f: data = json.load(f)\nwith open('data.json','w') as f: json.dump(data, f)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing File Lock**\n\n**Fix:**\n```python\nimport fcntl\nwith open('data.json','r+') as f:\n fcntl.flock(f, fcntl.LOCK_EX)\n data = json.load(f)\n f.seek(0); f.truncate()\n json.dump(data, f)\n fcntl.flock(f, fcntl.LOCK_UN)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_file_lock"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_config():\n with open('config.yaml') as f:\n return yaml.safe_load(f)\n# Called thousands of times\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Cache for Expensive Call**\n\n**Fix:**\n```python\nfrom functools import lru_cache\n@lru_cache(maxsize=1)\ndef get_config():\n with open('config.yaml') as f:\n return yaml.safe_load(f)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_cache_for_expensive_call"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconn = connect()\ntry: use(conn)\nfinally: conn.close()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing contextlib.closing**\n\n**Fix:**\n```python\nfrom contextlib import closing\nwith closing(connect()) as conn:\n use(conn)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_contextlib.closing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_user_create():\n db.setup()\n user = User(name='Alice')\n db.add(user)\n ...\n db.teardown()\n\ndef test_user_update():\n db.setup() # Repeated setup\n user = User(name='Alice')\n db.add(user)\n ...\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing test fixtures**\n\n**Fix:**\n```python\n@pytest.fixture\ndef db_session():\n session = Session()\n yield session\n session.close()\n\n@pytest.fixture\ndef sample_user(db_session):\n user = User(name='Alice')\n db_session.add(user)\n db_session.commit()\n return user\n\ndef test_user_create(db_session, sample_user):\n ...\n\ndef test_user_update(db_session, sample_user):\n ...\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_test_fixtures"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nstack = []\nstack.append(1)\nstack.insert(0, 2) # O(n)\n```"
},
{
"role": "assistant",
"content": "**Issue: Using list for stack operations**\n\n**Fix:**\n```python\nfrom collections import deque\nstack = deque()\nstack.append(1)\nstack.appendleft(2) # O(1)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_list_for_stack_operations"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# No security headers set\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Security Headers**\n\n**Fix:**\n```python\nresponse.headers['X-Content-Type-Options'] = 'nosniff'\nresponse.headers['X-Frame-Options'] = 'DENY'\nresponse.headers['Content-Security-Policy'] = \"default-src 'self'\"\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_security_headers"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\npattern = 'C:\\\\Users\\\\test'\n# Double escaping\n```"
},
{
"role": "assistant",
"content": "**Issue: Raw String for Regex**\n\n**Fix:**\n```python\npattern = r'C:\\Users\\test'\n# Raw string - single backslash\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"raw_string_for_regex"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_add_positive():\n assert add(2, 3) == 5\n\ndef test_add_negative():\n assert add(-1, -1) == -2\n\ndef test_add_zero():\n assert add(0, 0) == 0\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing parameterized tests**\n\n**Fix:**\n```python\n@pytest.mark.parametrize('a,b,expected', [\n (2, 3, 5),\n (-1, -1, -2),\n (0, 0, 0),\n (100, -50, 50),\n])\ndef test_add(a, b, expected):\n assert add(a, b) == expected\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_parameterized_tests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncache = {}\ndef get(k):\n if k not in cache: cache[k] = compute(k)\n return cache[k]\n```"
},
{
"role": "assistant",
"content": "**Issue: Unbounded Cache**\n\n**Fix:**\n```python\n@lru_cache(maxsize=1024)\ndef get(k): return compute(k)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"unbounded_cache"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwith lock_a:\n with lock_b:\n process()\n```"
},
{
"role": "assistant",
"content": "**Issue: Deadlock Prevention**\n\n**Fix:**\n```python\nimport threading\nwith threading.Lock():\n with lock_b:\n pass\n# Always acquire in same order\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"deadlock_prevention"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = [add(a,b) for a,b in pairs]\n```"
},
{
"role": "assistant",
"content": "**Issue: starmap**\n\n**Fix:**\n```python\nfrom itertools import starmap\nresults = list(starmap(add, pairs))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"starmap"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef draw(obj):\n obj.draw()\n```"
},
{
"role": "assistant",
"content": "**Issue: Protocol for Duck Typing**\n\n**Fix:**\n```python\nfrom typing import Protocol\nclass Drawable(Protocol):\n def draw(self) -> None: ...\ndef draw(obj: Drawable): obj.draw()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"protocol_for_duck_typing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nTHRESHOLD = 100\ndef check(value):\n return value > THRESHOLD\n```"
},
{
"role": "assistant",
"content": "**Issue: Global Variable Lookup**\n\n**Fix:**\n```python\nTHRESHOLD = 100\ndef check(value, threshold=THRESHOLD):\n return value > threshold\n# Default arg captures value at definition time (local lookup)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"global_variable_lookup"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ngroups = {}\nfor item in sorted(items, key=key):\n k = key(item)\n if k not in groups: groups[k] = []\n groups[k].append(item)\n```"
},
{
"role": "assistant",
"content": "**Issue: itertools.groupby**\n\n**Fix:**\n```python\nfrom itertools import groupby\nfor k, grp in groupby(sorted(items, key=key), key=key):\n process(list(grp))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"itertools.groupby"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def run(cmd):\n return subprocess.run(cmd, capture_output=True)\n```"
},
{
"role": "assistant",
"content": "**Issue: Blocking subprocess in Async**\n\n**Fix:**\n```python\nasync def run(cmd):\n p = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE)\n stdout, _ = await p.communicate()\n return stdout\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"blocking_subprocess_in_async"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasyncio.create_task(background_job())\n```"
},
{
"role": "assistant",
"content": "**Issue: asyncio.create_task Without Reference**\n\n**Fix:**\n```python\ntask = asyncio.create_task(background_job())\ntask.add_done_callback(handle_result)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"asyncio.create_task_without_reference"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process()\nexcept ValueError:\n logger.error('Error')\n# Continues after logging\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing raise after except**\n\n**Fix:**\n```python\ntry:\n process()\nexcept ValueError:\n logger.error('Error')\n raise\n# Re-raise after logging\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_raise_after_except"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport signal\nimport sys\ndef shutdown(signum, frame):\n sys.exit(0)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing graceful shutdown**\n\n**Fix:**\n```python\nimport signal\nimport sys\n\ndef graceful_shutdown(signum, frame):\n logger.info('Shutting down gracefully...')\n # Close connections\n # Finish current requests\n # Cleanup resources\n sys.exit(0)\n\nsignal.signal(signal.SIGTERM, graceful_shutdown)\nsignal.signal(signal.SIGINT, graceful_shutdown)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_graceful_shutdown"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass CSVExporter:\n def export(self, d): return format_csv(d)\nclass JSONExporter:\n def export(self, d): return format_json(d)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Template Method**\n\n**Fix:**\n```python\nfrom abc import ABC, abstractmethod\nclass Exporter(ABC):\n def export(self, data, path):\n with open(path,'w') as f: f.write(self.format(data))\n @abstractmethod\n def format(self, data): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_template_method"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@click.command()\n@click.option('--input', '-i')\ndef cli(input): process(input)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CLI Help Text**\n\n**Fix:**\n```python\n@click.command()\n@click.option('--input', '-i', required=True, help='Input file path')\n@click.version_option(version='1.0.0')\ndef cli(input):\n '''Process data files and convert between formats.\n \n Examples:\\n myapp -i input.json -o output.yaml\n '''\n process(input)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_cli_help_text"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nqueue = []\nqueue.append(item)\nitem = queue.pop(0)\n# O(n) pop from front\n```"
},
{
"role": "assistant",
"content": "**Issue: list as Queue**\n\n**Fix:**\n```python\nfrom collections import deque\nqueue = deque()\nqueue.append(item)\nitem = queue.popleft()\n# O(1)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"list_as_queue"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Config only loaded at startup - requires restart for changes\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Configuration Hot Reload**\n\n**Fix:**\n```python\nimport time\nclass HotReloadConfig:\n def __init__(self, path):\n self.path = Path(path)\n self._config = self._load()\n self._mtime = self.path.stat().st_mtime\n def _load(self):\n return yaml.safe_load(self.path.read_text()) or {}\n def get(self, key, default=None):\n if self.path.stat().st_mtime > self._mtime:\n self._config = self._load()\n self._mtime = self.path.stat().st_mtime\n return self._config.get(key, default)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_configuration_hot_reload"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwith open('a') as a:\n with open('b') as b:\n with open('c') as c:\n```"
},
{
"role": "assistant",
"content": "**Issue: Nested Context Managers**\n\n**Fix:**\n```python\nfrom contextlib import ExitStack\nwith ExitStack() as stack:\n files = [stack.enter_context(open(f)) for f in ['a','b','c']]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"nested_context_managers"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def increment():\n global counter\n counter += 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.Lock**\n\n**Fix:**\n```python\nlock = asyncio.Lock()\nasync def increment():\n global counter\n async with lock: counter += 1\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.lock"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(duck):\n return duck.quack() + duck.waddle()\n# No type checking\n```"
},
{
"role": "assistant",
"content": "**Issue: Protocol for Structural Subtyping**\n\n**Fix:**\n```python\nfrom typing import Protocol\nclass Quackable(Protocol):\n def quack(self) -> str: ...\n def waddle(self) -> str: ...\ndef process(duck: Quackable) -> str:\n return duck.quack() + duck.waddle()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"protocol_for_structural_subtyping"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nSQLALCHEMY_DATABASE_URI = 'postgresql://user:pass@localhost/db'\n```"
},
{
"role": "assistant",
"content": "**Issue: Hardcoded database URL**\n\n**Fix:**\n```python\nimport os\nSQLALCHEMY_DATABASE_URI = os.environ.get(\n 'DATABASE_URL',\n 'postgresql://user:pass@localhost/db'\n)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"hardcoded_database_url"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndefaults = [None] * count\n```"
},
{
"role": "assistant",
"content": "**Issue: itertools.repeat**\n\n**Fix:**\n```python\nfrom itertools import repeat\ndefaults = repeat(None, count)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"itertools.repeat"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ngreeting = 'Hello, {}!'.format(name)\n```"
},
{
"role": "assistant",
"content": "**Issue: format() Instead of f-string**\n\n**Fix:**\n```python\ngreeting = f'Hello, {name}!'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"format()_instead_of_f-string"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport sys\nold = sys.stdout\nsys.stdout = io.StringIO()\nprocess()\noutput = sys.stdout.getvalue()\nsys.stdout = old\n```"
},
{
"role": "assistant",
"content": "**Issue: contextlib.redirect_stdout**\n\n**Fix:**\n```python\nfrom contextlib import redirect_stdout\nimport io\nbuf = io.StringIO()\nwith redirect_stdout(buf):\n process()\noutput = buf.getvalue()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"contextlib.redirect_stdout"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport xml.etree.ElementTree as ET\ntree = ET.parse(user_file)\n```"
},
{
"role": "assistant",
"content": "**Issue: XXE Vulnerability**\n\n**Fix:**\n```python\nfrom lxml import etree\nparser = etree.XMLParser(resolve_entities=False)\ntree = etree.parse(user_file, parser)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"xxe_vulnerability"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_fetch():\n return asyncio.run(fetch_data())\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Async Tests**\n\n**Fix:**\n```python\n@pytest.mark.asyncio\nasync def test_fetch():\n assert (await fetch_data()).status == 200\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_async_tests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = await asyncio.gather(\n fetch_a(),\n fetch_b(),\n fetch_c()\n)\n```"
},
{
"role": "assistant",
"content": "**Issue: asyncio.gather without error handling**\n\n**Fix:**\n```python\nresults = await asyncio.gather(\n fetch_a(),\n fetch_b(),\n fetch_c(),\n return_exceptions=True\n)\n# Prevents one failure from cancelling all tasks\n```"
}
],
"source": "python_training",
"tags": [
"python",
"asyncio.gather_without_error_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = requests.get(url)\nreturn r.json()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Error Handling in requests**\n\n**Fix:**\n```python\nr = requests.get(url, timeout=10)\nr.raise_for_status()\nreturn r.json()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_error_handling_in_requests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = requests.get(url)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Redirect Handling**\n\n**Fix:**\n```python\nr = requests.get(url, allow_redirects=True)\n# Or: allow_redirects=False to prevent SSRF\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_redirect_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncounter = 0\ndef inc():\n global counter\n counter += 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Thread Safety Issue**\n\n**Fix:**\n```python\nimport threading\ncounter = 0\nlock = threading.Lock()\ndef inc():\n global counter\n with lock: counter += 1\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"thread_safety_issue"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor u in users:\n if u.id == uid: return u\n```"
},
{
"role": "assistant",
"content": "**Issue: O(n) Search in List**\n\n**Fix:**\n```python\nusers_by_id = {u.id: u for u in users}\nreturn users_by_id.get(uid)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"o(n)_search_in_list"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process()\nexcept Error:\n handle()\n cleanup()\n# cleanup runs even on error\n```"
},
{
"role": "assistant",
"content": "**Issue: else Clause Missing**\n\n**Fix:**\n```python\ntry:\n process()\nexcept Error:\n handle()\nelse:\n cleanup()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"else_clause_missing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef calculate_price(order):\n if order.customer_type == 'regular':\n return order.total\n elif order.customer_type == 'vip':\n return order.total * 0.9\n elif order.customer_type == 'enterprise':\n return order.total * 0.8\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Strategy Pattern**\n\n**Fix:**\n```python\nfrom abc import ABC, abstractmethod\nclass PricingStrategy(ABC):\n @abstractmethod\n def apply(self, total: float) -> float: ...\n\nclass RegularPricing(PricingStrategy):\n def apply(self, total): return total\n\nclass VIPPricing(PricingStrategy):\n def apply(self, total): return total * 0.9\n\n# Open/Closed Principle - add new strategies without modifying existing code\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_strategy_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process()\nexcept ValueError:\n raise AppError('Failed')\n# Original traceback lost\n```"
},
{
"role": "assistant",
"content": "**Issue: Exception Chaining Lost**\n\n**Fix:**\n```python\ntry:\n process()\nexcept ValueError as e:\n raise AppError('Failed') from e\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"exception_chaining_lost"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef transfer(from_acc, to_acc, amount):\n # Without isolation, concurrent transfers corrupt balances\n from_balance = session.query(Account).get(from_acc).balance\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Transaction Isolation**\n\n**Fix:**\n```python\nfrom_acc = session.query(Account).filter_by(id=from_acc).with_for_update().first()\nto_acc = session.query(Account).filter_by(id=to_acc).with_for_update().first()\n# Pessimistic locking prevents concurrent modification\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_transaction_isolation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf['year'] = [d.year for d in df['date']]\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Datetime Loop**\n\n**Fix:**\n```python\ndf['year'] = df['date'].dt.year\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_datetime_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconfig = {'host': 'localhost', 'port': 8080}\n# Hardcoded defaults\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CLI Configuration**\n\n**Fix:**\n```python\nfrom pathlib import Path\nimport yaml\nDEFAULT_CONFIG = {'host': 'localhost', 'port': 8080}\ndef load_config(config_path=None):\n config = DEFAULT_CONFIG.copy()\n path = Path(config_path) or Path.home() / '.config' / 'myapp' / 'config.yaml'\n if path.exists():\n config.update(yaml.safe_load(path.read_text()) or {})\n return config\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_cli_configuration"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Point:\n def __init__(self, x, y):\n self.x = x; self.y = y\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing __new__ for Immutable**\n\n**Fix:**\n```python\nclass Point:\n def __new__(cls, x, y):\n inst = super().__new__(cls)\n inst.x = x; inst.y = y\n return inst\n def __init__(self, x, y): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing___new___for_immutable"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlist = [1, 2, 3]\nstr = 'hello'\n# Shadows built-ins\n```"
},
{
"role": "assistant",
"content": "**Issue: Variable Shadowing**\n\n**Fix:**\n```python\nitems = [1, 2, 3]\ntext = 'hello'\n# Don't shadow built-ins\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"variable_shadowing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = []\nfor i in items:\n if cond(i): result.append(xform(i))\nprocess(result)\n```"
},
{
"role": "assistant",
"content": "**Issue: Unnecessary List Creation**\n\n**Fix:**\n```python\ndef gen():\n for i in items:\n if cond(i): yield xform(i)\nprocess(gen())\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"unnecessary_list_creation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ngreeting = \"Hello %s, you are %d years old\" % (name, age)\n```"
},
{
"role": "assistant",
"content": "**Issue: Using old-style String formatting**\n\n**Fix:**\n```python\ngreeting = f'Hello {name}, you are {age} years old'\n# f-strings (3.6+) are cleaner and faster\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_old-style_string_formatting"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_point():\n return 0, 1 # Tuple - what does each value mean?\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing NamedTuple**\n\n**Fix:**\n```python\nfrom typing import NamedTuple\nclass Point(NamedTuple):\n x: float\n y: float\ndef get_point(): return Point(0, 1)\n# NamedTuple is immutable, hashable, and self-documenting\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_namedtuple"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# No code quality checks\n```"
},
{
"role": "assistant",
"content": "**Issue: Not using pre-commit hooks**\n\n**Fix:**\n```python\n# .pre-commit-config.yaml\nrepos:\n - repo: https://github.com/psf/black\n rev: 23.7.0\n hooks:\n - id: black\n - repo: https://github.com/pycqa/flake8\n rev: 6.1.0\n hooks:\n - id: flake8\n - repo: https://github.com/pycqa/isort\n rev: 5.12.0\n hooks:\n - id: isort\n\n# pip install pre-commit\n# pre-commit install\n```"
}
],
"source": "python_training",
"tags": [
"python",
"not_using_pre-commit_hooks"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif hasattr(obj, 'attr'):\n use(obj.attr)\n```"
},
{
"role": "assistant",
"content": "**Issue: hasattr vs try/except**\n\n**Fix:**\n```python\ntry:\n use(obj.attr)\nexcept AttributeError:\n handle_missing()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"hasattr_vs_try/except"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Logs only go to stdout - hard to search across services\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Log Aggregation**\n\n**Fix:**\n```python\n# Docker logging driver in docker-compose.yml:\nservices:\n app:\n logging:\n driver: fluentd\n options:\n fluentd-address: \"localhost:24224\"\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_log_aggregation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncounter = 0\ndef inc():\n global counter\n counter += 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Global Variable Mutation**\n\n**Fix:**\n```python\ndef make_counter():\n count = [0]\n def inc(): count[0] += 1; return count[0]\n return inc\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"global_variable_mutation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nT = TypeVar('T')\ndef first(items: Sequence[T]) -> T: return items[0]\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.TypeVar Bound**\n\n**Fix:**\n```python\nT = TypeVar('T', bound=SupportsAdd)\ndef first(items: Sequence[T]) -> T: return items[0]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.typevar_bound"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlogger.info(\"Processing user input\") # Too noisy for production\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Log Levels**\n\n**Fix:**\n```python\nlogger.debug(\"Processing user input: %s\", sanitized_input)\nlogger.info(\"Request completed in %.2fms\", duration)\nlogger.warning(\"Rate limit approaching: %d/%d\", current, limit)\nlogger.error(\"Database connection failed: %s\", str(e))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_log_levels"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef parse_expr(expr):\n return eval(expr)\n```"
},
{
"role": "assistant",
"content": "**Issue: eval() on User Input**\n\n**Fix:**\n```python\nimport ast\nimport operator\nALLOWED = {ast.Add: operator.add, ast.Sub: operator.sub}\ndef eval_node(node):\n if isinstance(node, ast.Constant):\n return node.value\n if isinstance(node, ast.BinOp):\n left = eval_node(node.left)\n right = eval_node(node.right)\n return ALLOWED[type(node.op)](left, right)\n raise ValueError('Not allowed')\n```"
}
],
"source": "python_training",
"tags": [
"python",
"eval()_on_user_input"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfile = open('data.txt')\ndata = file.read()\n# File left open if exception occurs\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Context Manager for Resources**\n\n**Fix:**\n```python\nwith open('data.txt') as f:\n data = f.read()\n# Context manager guarantees cleanup\n# Or custom: @contextmanager for DB connections, locks, etc.\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_context_manager_for_resources"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf_clean = df.dropna()\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Aggressive dropna**\n\n**Fix:**\n```python\ndf_clean = df.dropna(subset=['critical_col'])\ndf['age'] = df['age'].fillna(df['age'].median())\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_aggressive_dropna"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndone, _ = await asyncio.wait(tasks)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.wait FIRST_COMPLETED**\n\n**Fix:**\n```python\ndone, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)\nfor p in pending: p.cancel()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.wait_first_completed"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport time\nasync def delay():\n time.sleep(1) # Blocks event loop\n```"
},
{
"role": "assistant",
"content": "**Issue: Blocking sleep in async**\n\n**Fix:**\n```python\nimport asyncio\nasync def delay():\n await asyncio.sleep(1) # Non-blocking\n```"
}
],
"source": "python_training",
"tags": [
"python",
"blocking_sleep_in_async"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom typing import List, Dict\n# Old style annotations\nfrom __future__ import annotations\n# Forward refs work without quotes\n```"
},
{
"role": "assistant",
"content": "**Issue: Using __future__ annotations (recommended)**\n\n**Fix:**\n```python\n# Already correct - from __future__ annotations enables:\n# 1. Forward references without quotes\n# 2. No need to import List, Dict from typing\n# 3. Annotations are strings by default (PEP 563)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using___future___annotations_(recommended)"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def handler(request):\n # Context not shared with child tasks\n asyncio.create_task(process())\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing contextvars propagation**\n\n**Fix:**\n```python\nimport contextvars\nrequest_id = contextvars.ContextVar('request_id')\nasync def handler(request):\n request_id.set(request.id)\n await process() # Context propagates to child tasks\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_contextvars_propagation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nrequests.get('http://api.com/endpoint')\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing HTTPS**\n\n**Fix:**\n```python\nrequests.get('https://api.com/endpoint')\n# Always use HTTPS\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_https"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = await asyncio.gather(*tasks)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.TaskGroup**\n\n**Fix:**\n```python\nasync with asyncio.TaskGroup() as tg:\n for t in tasks: tg.create_task(t)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.taskgroup"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef last_day(month):\n if month in [1,3,5,7,8,10,12]: return 31\n elif month in [4,6,9,11]: return 30\n else:\n if is_leap(year): return 29\n return 28\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing calendar module**\n\n**Fix:**\n```python\nimport calendar\nlast = calendar.monthrange(year, month)[1]\n# Returns days in month\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_calendar_module"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_process(): process(data)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Assert**\n\n**Fix:**\n```python\ndef test_process():\n r = process(data)\n assert r.status == 'success'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_assert"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nsquares = (x**2 for x in range(1000000))\n# But need len(), indexing\n```"
},
{
"role": "assistant",
"content": "**Issue: Generator vs List**\n\n**Fix:**\n```python\nsquares = [x**2 for x in range(1000000)]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"generator_vs_list"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(items):\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Type on Collection**\n\n**Fix:**\n```python\ndef process(items: list[int]) -> None:\n pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_type_on_collection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nt = threading.Thread(target=work)\nt.start()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing join**\n\n**Fix:**\n```python\nt = threading.Thread(target=work)\nt.start()\nt.join()\n# Wait for thread completion\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_join"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nt = threading.Thread(target=long_running_task)\nt.start()\nt.join() # Blocks forever if task hangs\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Timeout on Thread Join**\n\n**Fix:**\n```python\nt = threading.Thread(target=long_running_task)\nt.start()\nt.join(timeout=30)\nif t.is_alive():\n logger.warning(\"Task didn't complete in 30s\")\n handle_timeout()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_timeout_on_thread_join"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef create(cls):\n return cls()\n```"
},
{
"role": "assistant",
"content": "**Issue: typing.Type**\n\n**Fix:**\n```python\nfrom typing import Type\ndef create(cls: Type[Object]) -> Object:\n return cls()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"typing.type"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nname = 'world'\ngreeting = 'Hello ' + name + '!'\n```"
},
{
"role": "assistant",
"content": "**Issue: Inefficient String Formatting**\n\n**Fix:**\n```python\ngreeting = f'Hello {name}!'\n# f-strings are faster than concatenation\n```"
}
],
"source": "python_training",
"tags": [
"python",
"inefficient_string_formatting"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nos.system('grep ' + user_input)\n```"
},
{
"role": "assistant",
"content": "**Issue: Command Injection**\n\n**Fix:**\n```python\nimport shlex\nsubprocess.run(['grep', shlex.quote(user_input)])\n# Or subprocess with list args\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"command_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Range:\n def __init__(self, start, end):\n self.start = start\n self.end = end\n def get_all(self):\n return list(range(self.start, self.end))\n# Loads all values into memory\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Iterator Protocol**\n\n**Fix:**\n```python\nclass Range:\n def __init__(self, start, end):\n self.start = start\n self.end = end\n def __iter__(self):\n return iter(range(self.start, self.end))\n# Lazy iteration - memory efficient\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_iterator_protocol"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.route('/api/users')\ndef get_users():\n users = db.query(User).all()\n return jsonify([u.to_dict() for u in users])\n```"
},
{
"role": "assistant",
"content": "**Issue: Flask - Missing error handler**\n\n**Fix:**\n```python\n@app.route('/api/users')\ndef get_users():\n try:\n users = db.query(User).all()\n return jsonify([u.to_dict() for u in users])\n except Exception as e:\n logger.error('Failed to fetch users: %s', e)\n return jsonify({'error': 'Internal error'}), 500\n\n@app.errorhandler(404)\ndef not_found(e):\n return jsonify({'error': 'Not found'}), 404\n```"
}
],
"source": "python_training",
"tags": [
"python",
"flask_-_missing_error_handler"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Drawable(Protocol):\n def draw(self): pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing runtime_checkable**\n\n**Fix:**\n```python\n@runtime_checkable\nclass Drawable(Protocol):\n def draw(self): pass\n# isinstance(obj, Drawable) works\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_runtime_checkable"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass QueryBuilder:\n def filter(self, **kwargs):\n self._filters.update(kwargs)\n return self # type: ignore\n def order_by(self, field):\n self._order = field\n return self # type: ignore\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.Self for Return Type**\n\n**Fix:**\n```python\nfrom typing import Self\nclass QueryBuilder:\n def filter(self, **kwargs) -> Self:\n self._filters.update(kwargs)\n return self\n def order_by(self, field) -> Self:\n self._order = field\n return self\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.self_for_return_type"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport glob\nfiles = glob.glob('/data/*.csv')\n```"
},
{
"role": "assistant",
"content": "**Issue: glob Instead of pathlib**\n\n**Fix:**\n```python\nfrom pathlib import Path\nfiles = list(Path('/data').glob('*.csv'))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"glob_instead_of_pathlib"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\np = Path('/data/link')\n```"
},
{
"role": "assistant",
"content": "**Issue: Symlink Security**\n\n**Fix:**\n```python\np = Path('/data/link').resolve(strict=True)\nif not str(p).startswith(str(ALLOWED)): raise PermissionError\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"symlink_security"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclient = httpx.AsyncClient()\nresp = await client.get(url)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing async with for httpx**\n\n**Fix:**\n```python\nasync with httpx.AsyncClient() as client:\n resp = await client.get(url)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_async_with_for_httpx"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# setup.py\nfrom setuptools import setup\nsetup(name='mypackage', version='0.1.0')\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing pyproject.toml**\n\n**Fix:**\n```python\n# pyproject.toml\n[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n\n[project]\nname = \"mypackage\"\nversion = \"0.1.0\"\ndependencies = [\"requests>=2.28\"]\n\n[project.scripts]\nmycli = \"mypackage.cli:main\"\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_pyproject.toml"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_send_email():\n send_email('test@test.com', 'Hello')\n assert email_was_sent() # Hits real SMTP server\n```"
},
{
"role": "assistant",
"content": "**Issue: Testing with real dependencies**\n\n**Fix:**\n```python\nfrom unittest.mock import patch, MagicMock\n@patch('app.send_smtp')\ndef test_send_email(mock_smtp):\n send_email('test@test.com', 'Hello')\n mock_smtp.assert_called_once_with(\n to='test@test.com',\n body='Hello'\n )\n```"
}
],
"source": "python_training",
"tags": [
"python",
"testing_with_real_dependencies"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = ''\nfor item in items:\n result += item + ', '\n# O(n^2)\n```"
},
{
"role": "assistant",
"content": "**Issue: String Concatenation in Loop**\n\n**Fix:**\n```python\nresult = ', '.join(items)\n# O(n)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_concatenation_in_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nreturn 0, 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing NamedTuple**\n\n**Fix:**\n```python\nfrom typing import NamedTuple\nclass Point(NamedTuple): x: float; y: float\nreturn Point(0, 1)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_namedtuple"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_process():\n obj = Processor()\n obj.process()\n assert obj._internal_counter == 5 # Testing private state\n```"
},
{
"role": "assistant",
"content": "**Issue: Testing implementation details**\n\n**Fix:**\n```python\ndef test_process():\n obj = Processor()\n result = obj.process()\n assert result == expected_output # Test behavior, not internals\n```"
}
],
"source": "python_training",
"tags": [
"python",
"testing_implementation_details"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef group_by_key(items, key_fn):\n groups = {}\n for item in items:\n k = key_fn(item)\n if k not in groups:\n groups[k] = []\n groups[k].append(item)\n return groups\n```"
},
{
"role": "assistant",
"content": "**Issue: Inefficient groupby**\n\n**Fix:**\n```python\nfrom itertools import groupby\ndef group_by_key(items, key_fn):\n return {\n k: list(v) for k, v in groupby(sorted(items, key=key_fn), key_fn)\n }\n```"
}
],
"source": "python_training",
"tags": [
"python",
"inefficient_groupby"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif x == None: pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Comparing to None**\n\n**Fix:**\n```python\nif x is None: pass\n# is for None comparison\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"comparing_to_none"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexecutor.map(process, data)\n# Can't pickle lambda/local functions\n```"
},
{
"role": "assistant",
"content": "**Issue: ProcessPoolExecutor Pickle Error**\n\n**Fix:**\n```python\n# Define at module level\ndef process(item): ...\nexecutor.map(process, data)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"processpoolexecutor_pickle_error"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Distributed system - can't trace requests across services\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Correlation IDs**\n\n**Fix:**\n```python\nimport contextvars\nrequest_id_ctx = contextvars.ContextVar('request_id')\n@app.before_request\ndef set_request_id():\n request_id_ctx.set(request.headers.get('X-Request-ID') or str(uuid.uuid4()))\n# Add to log formatter: '%(request_id)s'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_correlation_ids"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef retry(func):\n def wrapper(*a, **kw):\n for _ in range(3):\n try: return func(*a, **kw)\n except: pass\n return wrapper\n```"
},
{
"role": "assistant",
"content": "**Issue: Decorator Without Parameters**\n\n**Fix:**\n```python\ndef retry(attempts=3):\n def decorator(func):\n @functools.wraps(func)\n def wrapper(*a, **kw):\n for _ in range(attempts):\n try: return func(*a, **kw)\n except: pass\n return wrapper\n return decorator\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"decorator_without_parameters"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def read():\n with open('f.yaml') as f: return yaml.safe_load(f)\n```"
},
{
"role": "assistant",
"content": "**Issue: Blocking File Operations in Async**\n\n**Fix:**\n```python\nimport aiofiles\nasync def read():\n async with aiofiles.open('f.yaml') as f:\n return yaml.safe_load(await f.read())\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"blocking_file_operations_in_async"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n key.delete()\nexcept KeyError:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: contextlib.suppress**\n\n**Fix:**\n```python\nfrom contextlib import suppress\nwith suppress(KeyError):\n key.delete()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"contextlib.suppress"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def long_running():\n for i in range(1000): await process(i)\n```"
},
{
"role": "assistant",
"content": "**Issue: Task Cancellation Ignored**\n\n**Fix:**\n```python\nasync def long_running():\n try:\n for i in range(1000): await process(i)\n except asyncio.CancelledError:\n await cleanup()\n raise\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"task_cancellation_ignored"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nDB_HOST = 'localhost'\nDB_PORT = 5432\nDB_NAME = 'mydb'\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing environment variable handling**\n\n**Fix:**\n```python\nimport os\nfrom dotenv import load_dotenv\nload_dotenv()\n\nDB_HOST = os.getenv('DB_HOST', 'localhost')\nDB_PORT = int(os.getenv('DB_PORT', '5432'))\nDB_NAME = os.environ['DB_NAME'] # Required - fails early if missing\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_environment_variable_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process()\nexcept ValueError:\n raise RuntimeError('Process failed')\n```"
},
{
"role": "assistant",
"content": "**Issue: Exception Without Context**\n\n**Fix:**\n```python\ntry:\n process()\nexcept ValueError as e:\n raise RuntimeError('Process failed: ' + str(e)) from e\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"exception_without_context"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Field:\n def __set__(self, obj, val): self.val = val\n```"
},
{
"role": "assistant",
"content": "**Issue: Descriptor Without __set_name__**\n\n**Fix:**\n```python\nclass Field:\n def __set_name__(self, owner, name): self.name = name\n def __set__(self, obj, val):\n if not validate(val): raise ValueError('Invalid ' + self.name)\n object.__setattr__(self, 'val', val)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"descriptor_without___set_name__"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nd = {}\nfor i in items:\n c = i.cat\n if c not in d: d[c] = []\n d[c].append(i)\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual defaultdict**\n\n**Fix:**\n```python\nfrom collections import defaultdict\nd = defaultdict(list)\nfor i in items: d[i.cat].append(i)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"manual_defaultdict"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(data: Any) -> Any:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Any Type Usage**\n\n**Fix:**\n```python\ndef process(data: dict[str, int]) -> list[str]:\n pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"any_type_usage"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef main():\n if not os.path.exists(args.input):\n print(f\"Error: {args.input} not found\")\n sys.exit(1)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CLI Error Handling**\n\n**Fix:**\n```python\nimport click\nclass CliError(click.ClickException): pass\n@click.command()\ndef main(input_file):\n if not os.path.exists(input_file):\n raise CliError(f\"Input not found: {input_file}\")\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_cli_error_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n result = process_data()\nexcept ProcessError as e:\n raise RuntimeError(\"Failed to process\") # Loses original traceback\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Exception Chaining**\n\n**Fix:**\n```python\ntry:\n result = process_data()\nexcept ProcessError as e:\n raise RuntimeError(\"Failed to process data\") from e # Preserves chain\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_exception_chaining"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom module import *\n# Pollutes namespace\n```"
},
{
"role": "assistant",
"content": "**Issue: Star Import**\n\n**Fix:**\n```python\nfrom module import specific_func, SpecificClass\n# Explicit imports\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"star_import"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf = pd.read_csv('data.csv')\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas No Duplicate Check**\n\n**Fix:**\n```python\ndf = pd.read_csv('data.csv')\nif df.duplicated().any():\n df = df.drop_duplicates(subset=['id'], keep='first')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_no_duplicate_check"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor i in range(len(items)):\n print(items[i])\n```"
},
{
"role": "assistant",
"content": "**Issue: Repeated len() Call**\n\n**Fix:**\n```python\nfor i, item in enumerate(items):\n print(item)\n# enumerate is Pythonic and faster than range(len())\n```"
}
],
"source": "python_training",
"tags": [
"python",
"repeated_len()_call"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Database:\n _instance = None\n def __new__(cls):\n if not cls._instance:\n cls._instance = super().__new__(cls)\n return cls._instance\n```"
},
{
"role": "assistant",
"content": "**Issue: Singleton Overkill**\n\n**Fix:**\n```python\n# Python modules ARE singletons\n# db.py\ndef get_connection():\n return connect(config)\n\n# app.py\nfrom db import get_connection\n# Single instance per module import"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"singleton_overkill"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def handle():\n send_notification(user_id) # Forgetting await\n return {'status': 'ok'}\n```"
},
{
"role": "assistant",
"content": "**Issue: Unawaited coroutine**\n\n**Fix:**\n```python\nasync def handle():\n await send_notification(user_id) # Properly awaited\n return {'status': 'ok'}\n```"
}
],
"source": "python_training",
"tags": [
"python",
"unawaited_coroutine"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(data):\n try:\n return int(data)\n except ValueError:\n return 0\n# Silent error - no logging\n```"
},
{
"role": "assistant",
"content": "**Issue: Silent Exception Handling**\n\n**Fix:**\n```python\nimport logging\ndef process(data):\n try:\n return int(data)\n except ValueError:\n logger.warning('Invalid data: %r', data)\n return 0"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"silent_exception_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Manual test setup\ndef test_index():\n app = create_app()\n with app.test_client() as client:\n resp = client.get('/')\n assert resp.status_code == 200\n```"
},
{
"role": "assistant",
"content": "**Issue: Flask - Not using flask-testing**\n\n**Fix:**\n```python\nimport pytest\n@pytest.fixture\ndef client():\n app = create_app()\n app.config['TESTING'] = True\n with app.test_client() as client:\n yield client\n\ndef test_index(client):\n resp = client.get('/')\n assert resp.status_code == 200\n```"
}
],
"source": "python_training",
"tags": [
"python",
"flask_-_not_using_flask-testing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nformatted = '0' * (10 - len(code)) + code\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.zfill()**\n\n**Fix:**\n```python\nformatted = code.zfill(10)\n# Zero-pad to width 10\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.zfill()"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor x in values:\n if x < 0: return False\nreturn True\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing all() builtin**\n\n**Fix:**\n```python\nreturn all(x >= 0 for x in values)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_all()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconn = DB(); try: use(conn)\nfinally: conn.close()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing __enter__/__exit__**\n\n**Fix:**\n```python\nclass DB:\n def __enter__(self): return self\n def __exit__(self,*a): self.close()\nwith DB() as conn: use(conn)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing___enter__/__exit__"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwith open('large_file.txt') as f:\n lines = f.readlines() # Loads entire file\n for line in lines:\n process(line)\n```"
},
{
"role": "assistant",
"content": "**Issue: Inefficient file processing**\n\n**Fix:**\n```python\nwith open('large_file.txt') as f:\n for line in f: # Iterates line by line\n process(line)\n# Memory efficient for large files\n```"
}
],
"source": "python_training",
"tags": [
"python",
"inefficient_file_processing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif hasattr(obj, 'attr'):\n val = obj.attr\nelse:\n val = default\n```"
},
{
"role": "assistant",
"content": "**Issue: getattr with default**\n\n**Fix:**\n```python\nval = getattr(obj, 'attr', default)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"getattr_with_default"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = requests.get(url)\nwith open('file', 'wb') as f: f.write(r.content)\n```"
},
{
"role": "assistant",
"content": "**Issue: Streaming Download**\n\n**Fix:**\n```python\nr = requests.get(url, stream=True)\nwith open('file', 'wb') as f:\n for chunk in r.iter_content(8192):\n f.write(chunk)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"streaming_download"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport copy\nc = copy.deepcopy(config)\n```"
},
{
"role": "assistant",
"content": "**Issue: Deep Copy When Shallow OK**\n\n**Fix:**\n```python\nc = config.copy()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"deep_copy_when_shallow_ok"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport re\nfor line in file:\n if re.match(r'^ERROR', line):\n process(line)\n```"
},
{
"role": "assistant",
"content": "**Issue: Regex Compiled Each Iteration**\n\n**Fix:**\n```python\nimport re\nPATTERN = re.compile(r'^ERROR')\nfor line in file:\n if PATTERN.match(line):\n process(line)"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"regex_compiled_each_iteration"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfound = item in large_list\n# large_list has 1M+ items\n```"
},
{
"role": "assistant",
"content": "**Issue: Linear Search in Large List**\n\n**Fix:**\n```python\nfound = item in large_set\n# Use set() for O(1) lookups instead of O(n)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"linear_search_in_large_list"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Config:\n def __init__(self, host, port, timeout, retries):\n self.host = host\n self.port = port\n self.timeout = timeout\n self.retries = retries\n def __repr__(self):\n return f'Config({self.host}, {self.port})'\n def __eq__(self, other):\n return isinstance(other, Config) and self.host == other.host\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing dataclass for Config**\n\n**Fix:**\n```python\n@dataclass\nclass Config:\n host: str = 'localhost'\n port: int = 8080\n timeout: float = 30.0\n retries: int = 3\n# Auto-generates __init__, __repr__, __eq__, __hash__\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_dataclass_for_config"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndict1 = {}\nfor i in range(len(keys)):\n dict1[keys[i]] = vals[i]\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing zip() builtin**\n\n**Fix:**\n```python\ndict1 = dict(zip(keys, vals))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_zip()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom flask import Flask\napp = Flask(__name__)\napp.config['SECRET_KEY'] = os.environ['SECRET_KEY']\n\n@app.route('/')\ndef index():\n return 'Hello'\n```"
},
{
"role": "assistant",
"content": "**Issue: Flask - Missing app factory**\n\n**Fix:**\n```python\nfrom flask import Flask\ndef create_app():\n app = Flask(__name__)\n app.config.from_object('config.Config')\n register_blueprints(app)\n return app\n```"
}
],
"source": "python_training",
"tags": [
"python",
"flask_-_missing_app_factory"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = pd.concat([df1, df2], axis=1)\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Merge vs Concat**\n\n**Fix:**\n```python\nresult = pd.merge(df1, df2, on='user_id', how='left')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_merge_vs_concat"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Timer:\n def __enter__(self): self.start = time()\n def __exit__(self): print(time()-self.start)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing @contextmanager**\n\n**Fix:**\n```python\n@contextmanager\ndef timer():\n start = time()\n yield\n print(time() - start)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_@contextmanager"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Overly complex list comprehension\nresult = [x for x in data if x > 0 for y in other if y in x for z in third if z == y]\n```"
},
{
"role": "assistant",
"content": "**Issue: List comprehension abuse**\n\n**Fix:**\n```python\nresult = []\nfor x in data:\n if x <= 0:\n continue\n for y in other:\n if y in x:\n for z in third:\n if z == y:\n result.append(x)\n# Readability > cleverness\n```"
}
],
"source": "python_training",
"tags": [
"python",
"list_comprehension_abuse"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def server():\n while True:\n reader, writer = await asyncio.get_running_loop().accept()\n asyncio.create_task(handle(reader, writer))\n```"
},
{
"role": "assistant",
"content": "**Issue: Structural concurrency pattern**\n\n**Fix:**\n```python\nasync def server():\n server = await asyncio.start_unix_server(handle)\n async with server:\n await server.serve_forever()\n\nasync def handle(reader, writer):\n try:\n while True:\n data = await reader.read(1024)\n if not data:\n break\n writer.write(data)\n finally:\n writer.close()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"structural_concurrency_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef handle_request():\n data = requests.get('https://api.com/data')\n # Blocks the entire server\n```"
},
{
"role": "assistant",
"content": "**Issue: Blocking I/O in Main Thread**\n\n**Fix:**\n```python\nasync def handle_request():\n async with aiohttp.ClientSession() as session:\n async with session.get('https://api.com/data') as resp:\n return await resp.json()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"blocking_i/o_in_main_thread"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nreversed_str = ''.join(reversed(s))\n```"
},
{
"role": "assistant",
"content": "**Issue: String split/join for Reversing**\n\n**Fix:**\n```python\nreversed_str = s[::-1]\n# Slice reversal is fastest\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_split/join_for_reversing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass QueryBuilder:\n def filter(self, **kwargs):\n self._filters.update(kwargs)\n return self # Type is QueryBuilder, not subclass\n```"
},
{
"role": "assistant",
"content": "**Issue: Self Type for Fluent Interfaces**\n\n**Fix:**\n```python\nfrom typing import Self\nclass QueryBuilder:\n def filter(self, **kwargs) -> Self:\n self._filters.update(kwargs)\n return self\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"self_type_for_fluent_interfaces"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nuser_ctx = None\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing contextvars**\n\n**Fix:**\n```python\nimport contextvars\nuser_ctx = contextvars.ContextVar('user', default=None)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_contextvars"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Database:\n def __init__(self):\n self.conn = connect() # Multiple connections\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Singleton for shared resource**\n\n**Fix:**\n```python\nclass Database:\n _instance = None\n def __new__(cls):\n if cls._instance is None:\n cls._instance = super().__new__(cls)\n cls._instance.conn = connect()\n return cls._instance\n # Or better: use dependency injection container\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_singleton_for_shared_resource"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef log(func):\n def wrapper(*a, **kw): return func(*a, **kw)\n return wrapper\n```"
},
{
"role": "assistant",
"content": "**Issue: Decorator Losing Metadata**\n\n**Fix:**\n```python\nimport functools\ndef log(func):\n @functools.wraps(func)\n def wrapper(*a, **kw): return func(*a, **kw)\n return wrapper\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"decorator_losing_metadata"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nordered = []\nseen = set()\nfor item in items:\n if item not in seen:\n ordered.append(item)\n seen.add(item)\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual OrderedDict**\n\n**Fix:**\n```python\nfrom collections import OrderedDict\nordered = list(OrderedDict.fromkeys(items))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"manual_ordereddict"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass User(Base):\n id = Column(Integer, primary_key=True)\n posts = relationship('Post')\n # Deleting User leaves orphaned Posts\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Missing Relationship Cascade**\n\n**Fix:**\n```python\nclass User(Base):\n id = Column(Integer, primary_key=True)\n posts = relationship('Post', cascade='all, delete-orphan')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_missing_relationship_cascade"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Obj:\n def expensive(self):\n return compute()\n```"
},
{
"role": "assistant",
"content": "**Issue: Method Caching**\n\n**Fix:**\n```python\nfrom functools import cached_property\nclass Obj:\n @cached_property\n def expensive(self): return compute()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"method_caching"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process():\n db = Database(); cache = Redis()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Dependency Injection**\n\n**Fix:**\n```python\ndef process(db, cache):\n pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_dependency_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def read():\n with open('f.yaml') as f: return yaml.safe_load(f)\n```"
},
{
"role": "assistant",
"content": "**Issue: Blocking File I/O in Async**\n\n**Fix:**\n```python\nimport aiofiles\nasync def read():\n async with aiofiles.open('f.yaml') as f:\n return yaml.safe_load(await f.read())\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"blocking_file_i/o_in_async"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_sort():\n assert sort([3, 1, 2]) == [1, 2, 3]\n # One example, doesn't cover edge cases\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing property-based tests**\n\n**Fix:**\n```python\nfrom hypothesis import given, strategies as st\n@given(st.lists(st.integers(), min_size=0, max_size=100))\ndef test_sort_always_sorted(lst):\n result = sort(lst)\n assert result == sorted(lst)\n assert len(result) == len(lst)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_property-based_tests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef thread1():\n with lock_a:\n with lock_b: process()\ndef thread2():\n with lock_b:\n with lock_a: process()\n# Deadlock! Different lock orders\n```"
},
{
"role": "assistant",
"content": "**Issue: Deadlock Risk**\n\n**Fix:**\n```python\n# Always acquire locks in consistent order\ndef thread1():\n with lock_a:\n with lock_b: process()\ndef thread2():\n with lock_a:\n with lock_b: process()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"deadlock_risk"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nitems.sort(key=lambda x: (x[0], x[1], x[2]))\n# Unnecessary lambda\n```"
},
{
"role": "assistant",
"content": "**Issue: Using sorted with key function incorrectly**\n\n**Fix:**\n```python\nitems.sort(key=lambda x: x) # Already tuples\n# Or: items.sort() for default tuple comparison\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_sorted_with_key_function_incorrectly"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif date_str > '2024-01-01':\n # Works for ISO format but fragile\n```"
},
{
"role": "assistant",
"content": "**Issue: date comparison with strings**\n\n**Fix:**\n```python\nif date_obj > datetime.date(2024, 1, 1):\n # Proper date comparison\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"date_comparison_with_strings"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.get('/items')\ndef get_items():\n # Blocking DB call\n items = db.query(Item).all()\n return items\n```"
},
{
"role": "assistant",
"content": "**Issue: FastAPI - Synchronous endpoint**\n\n**Fix:**\n```python\n@app.get('/items')\nasync def get_items(session: AsyncSession = Depends(get_session)):\n result = await session.execute(select(Item))\n return result.scalars().all()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"fastapi_-_synchronous_endpoint"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.route('/api/user/<int:user_id>')\ndef get_user(user_id):\n return db.get_user(user_id)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Input Validation**\n\n**Fix:**\n```python\n@app.route('/api/user/<int:user_id>')\ndef get_user(user_id):\n if user_id <= 0:\n return {'error': 'Invalid ID'}, 400\n return db.get_user(user_id)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_input_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif order.type == 'regular': return order.total * 0.1\nelif order.type == 'premium': return order.total * 0.2\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Strategy Pattern**\n\n**Fix:**\n```python\nfrom abc import ABC, abstractmethod\nclass Strategy(ABC):\n @abstractmethod\n def calc(self, order): pass\nclass Regular(Strategy):\n def calc(self, o): return o.total * 0.1\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_strategy_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nevent = threading.Event()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.Event**\n\n**Fix:**\n```python\nevent = asyncio.Event()\nasync def waiter(): await event.wait()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.event"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ngrouped = df.groupby(['cat','month'])['sales'].sum()\npivoted = grouped.unstack()\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Manual Pivot**\n\n**Fix:**\n```python\npd.pivot_table(df, values='sales', index='cat', columns='month', aggfunc='sum')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_manual_pivot"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = ''\nfor item in items:\n result += item\n```"
},
{
"role": "assistant",
"content": "**Issue: String Concatenation in Loop**\n\n**Fix:**\n```python\nresult = ''.join(items)\n# join() pre-allocates, += creates new string each time\n```"
}
],
"source": "python_training",
"tags": [
"python",
"string_concatenation_in_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef validate(o):\n if not o.items: return False\n if o.total <= 0: return False\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Chain of Responsibility**\n\n**Fix:**\n```python\nclass Validator:\n def __init__(self, nxt=None): self._next = nxt\n def validate(self, o):\n if self.check(o) and self._next: return self._next.validate(o)\n return self.check(o)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_chain_of_responsibility"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_create():\n db.setup()\n u = create('test@test.com')\n assert u.email == 'test@test.com'\n db.teardown()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Test Fixtures**\n\n**Fix:**\n```python\n@pytest.fixture\ndef db():\n s = Session()\n yield s\n s.close()\ndef test_create(db):\n u = create('test@test.com')\n assert u.email == 'test@test.com'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_test_fixtures"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nsubset = df[df['age'] > 30]\nsubset['name'] = 'adult'\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas SettingWithCopyWarning**\n\n**Fix:**\n```python\ndf.loc[df['age'] > 30, 'name'] = 'adult'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_settingwithcopywarning"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwith A() as a:\n with B() as b:\n```"
},
{
"role": "assistant",
"content": "**Issue: Multiple Context Managers**\n\n**Fix:**\n```python\nwith A() as a, B() as b:\n # Python 3.1+ tuple syntax\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"multiple_context_managers"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def fetch_data():\n result = await api_call()\n # Exception swallowed if not awaited\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Async Exception Handling**\n\n**Fix:**\n```python\nasync def fetch_data():\n try:\n return await asyncio.wait_for(api_call(), timeout=5.0)\n except asyncio.TimeoutError:\n logger.warning(\"API call timed out\")\n return default_value\n except aiohttp.ClientError as e:\n logger.error(\"API error: %s\", e)\n raise\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_async_exception_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef query(table: str, column: str):\n # No SQL injection protection with plain str\n cursor.execute(f\"SELECT {column} FROM {table}\")\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.LiteralString**\n\n**Fix:**\n```python\nfrom typing import LiteralString\ndef query(table: LiteralString, column: LiteralString):\n # LiteralString tells static analyzers this isn't user input\n cursor.execute(f\"SELECT {column} FROM {table}\")\n# For runtime safety, use parameterized queries\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.literalstring"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif r.status_code == 200:\n process(r.json())\n```"
},
{
"role": "assistant",
"content": "**Issue: HTTP Status Code Check**\n\n**Fix:**\n```python\nr.raise_for_status()\nprocess(r.json())\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"http_status_code_check"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntasks = []\ndef producer():\n while True: tasks.append(generate_task())\ndef consumer():\n while tasks: process(tasks.pop(0))\n# Unbounded list - memory leak risk\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Queue for Producer-Consumer**\n\n**Fix:**\n```python\nfrom queue import Queue\ntask_queue = Queue(maxsize=1000)\ndef producer():\n while True: task_queue.put(generate_task())\ndef consumer():\n while True:\n task = task_queue.get()\n process(task)\n task_queue.task_done()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_queue_for_producer-consumer"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nrequests.get(f\"https://api.com/users?id={user_id}&token={api_token}\")\n```"
},
{
"role": "assistant",
"content": "**Issue: Sensitive Data in URL**\n\n**Fix:**\n```python\nrequests.get(\n \"https://api.com/users\",\n params={\"id\": user_id},\n headers={\"Authorization\": f\"Bearer {api_token}\"}\n)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"sensitive_data_in_url"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Config:\n pass\nc = Config()\nc.host = 'localhost'\nc.port = 8080\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing dataclass**\n\n**Fix:**\n```python\n@dataclass\nclass Config:\n host: str = 'localhost'\n port: int = 8080\n# Structured, typed configuration"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_dataclass"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef locked(f):\n def wrapper(*args, **kwargs):\n f.acquire()\n try: return f(*args, **kwargs)\n finally: f.release()\n return wrapper\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing ContextDecorator**\n\n**Fix:**\n```python\nfrom contextlib import contextmanager\n@contextmanager\ndef locked(resource):\n resource.acquire()\n try: yield resource\n finally: resource.release()\n# Reusable context manager\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_contextdecorator"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor _ in range(5):\n try: return api()\n except: pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Retry Without Backoff**\n\n**Fix:**\n```python\nfor attempt in range(5):\n try: return api()\n except:\n await asyncio.sleep(2 ** attempt)\n# Exponential backoff\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"retry_without_backoff"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport logging\nlogger = logging.getLogger(__name__)\nlogger.info('Processing...')\n# No handler configured\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing logging configuration**\n\n**Fix:**\n```python\nimport logging\nlogging.basicConfig(\n level=logging.INFO,\n format='%(asctime)s %(levelname)s %(name)s: %(message)s'\n)\nlogger = logging.getLogger(__name__)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_logging_configuration"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass DatabaseConnection:\n def __init__(self): self.connect()\n def close(self): self.disconnect()\n# Manual close - easily forgotten\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing __enter__/__exit__**\n\n**Fix:**\n```python\nclass DatabaseConnection:\n def __init__(self): self.connect()\n def __enter__(self): return self\n def __exit__(self, *args): self.close()\n# Usage: with DatabaseConnection() as conn: query(conn)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing___enter__/__exit__"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport time\ntime.sleep(1) # Wait for other threads - fragile\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Barrier for Coordination**\n\n**Fix:**\n```python\nimport threading\nbarrier = threading.Barrier(num_threads)\ndef worker(thread_id):\n do_phase1(thread_id)\n barrier.wait() # All threads reach here\n do_phase2(thread_id)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_barrier_for_coordination"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef transfer(from_acc, to_acc, amount):\n a1 = Account.objects.get(id=from_acc)\n a2 = Account.objects.get(id=to_acc)\n a1.balance -= amount\n a2.balance += amount\n a1.save()\n a2.save()\n```"
},
{
"role": "assistant",
"content": "**Issue: Django - Missing select_for_update**\n\n**Fix:**\n```python\nfrom django.db import transaction\n@transaction.atomic\ndef transfer(from_acc, to_acc, amount):\n a1 = Account.objects.select_for_update().get(id=from_acc)\n a2 = Account.objects.select_for_update().get(id=to_acc)\n a1.balance -= amount\n a2.balance += amount\n a1.save()\n a2.save()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"django_-_missing_select_for_update"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Database:\n def __init__(self, conn_string):\n self.conn = connect(conn_string)\n```"
},
{
"role": "assistant",
"content": "**Issue: Classmethod Without Override Hook**\n\n**Fix:**\n```python\nclass Database:\n def __init__(self, conn_string):\n self.conn = self.connect(conn_string)\n @classmethod\n def connect(cls, cs): return connect(cs)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"classmethod_without_override_hook"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nmerged = {}\nmerged.update(defaults)\nmerged.update(user_config)\nmerged.update(env_vars)\n```"
},
{
"role": "assistant",
"content": "**Issue: ChainMap for Merging**\n\n**Fix:**\n```python\nfrom collections import ChainMap\nmerged = ChainMap(env_vars, user_config, defaults)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"chainmap_for_merging"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.get('/users/{user_id}', response_model=dict)\ndef get_user(user_id: int):\n return db.get_user(user_id)\n```"
},
{
"role": "assistant",
"content": "**Issue: FastAPI - Missing response model**\n\n**Fix:**\n```python\nfrom pydantic import BaseModel\nclass UserOut(BaseModel):\n id: int\n username: str\n email: str\n class Config:\n from_attributes = True\n\n@app.get('/users/{user_id}', response_model=UserOut)\ndef get_user(user_id: int):\n return db.get_user(user_id)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"fastapi_-_missing_response_model"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass BaseConfig:\n def validate(self): pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.final**\n\n**Fix:**\n```python\n@final\nclass BaseConfig:\n def validate(self): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.final"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nf = open('data.txt')\ndata = f.read()\nf.close()\n# File left open if read() raises\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Context Manager**\n\n**Fix:**\n```python\nwith open('data.txt') as f:\n data = f.read()\n# Context manager guarantees cleanup\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_context_manager"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor line in f:\n if re.match(r'^\\d{4}', line): process(line)\n```"
},
{
"role": "assistant",
"content": "**Issue: Regex Compiled Each Iteration**\n\n**Fix:**\n```python\nPATTERN = re.compile(r'^\\d{4}')\nfor line in f:\n if PATTERN.match(line): process(line)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"regex_compiled_each_iteration"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nstripe.Charge.create(amount=a*100, currency=c)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Adapter Pattern**\n\n**Fix:**\n```python\nfrom abc import ABC, abstractmethod\nclass Gateway(ABC):\n @abstractmethod\n def charge(self, a, c): pass\nclass StripeAdapter(Gateway):\n def charge(self, a, c):\n return stripe.Charge.create(amount=a*100, currency=c)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_adapter_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = sorted(sorted(items, key=lambda x: x.age), key=lambda x: x.name)\n# Double sort\n```"
},
{
"role": "assistant",
"content": "**Issue: sorted with Multiple Keys**\n\n**Fix:**\n```python\nresult = sorted(items, key=lambda x: (x.name, x.age))\n# Single sort with tuple key\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sorted_with_multiple_keys"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Node:\n def __init__(self, k, v): self.k = k; self.v = v\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing __slots__**\n\n**Fix:**\n```python\nclass Node:\n __slots__ = ('k', 'v')\n def __init__(self, k, v): self.k = k; self.v = v\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing___slots__"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom flask import Flask, request, render_template_string\napp = Flask(__name__)\n@app.route('/search')\ndef search():\n q = request.args.get('q', '')\n return render_template_string(f'<h1>Results for {q}</h1>')\n```"
},
{
"role": "assistant",
"content": "**Issue: XSS in Template**\n\n**Fix:**\n```python\n# Jinja2 auto-escapes by default - use proper templates\nfrom flask import Flask, request, render_template\napp = Flask(__name__)\n@app.route('/search')\ndef search():\n q = request.args.get('q', '')\n return render_template('search.html', query=q)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"xss_in_template"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = eval(user_input)\n```"
},
{
"role": "assistant",
"content": "**Issue: eval() Usage**\n\n**Fix:**\n```python\nimport ast\nresult = ast.literal_eval(user_input)\n# Safe evaluation of literals\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"eval()_usage"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def serve_request(request):\n # Any exception crashes the whole handler\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Error Boundaries**\n\n**Fix:**\n```python\nasync def serve_request(request):\n try:\n return await handle_request(request)\n except ValidationError as e: return json_response({\"error\": str(e)}, 400)\n except NotFoundError: return json_response({\"error\": \"Not found\"}, 404)\n except Exception:\n logger.exception(\"Unhandled error\")\n return json_response({\"error\": \"Internal server error\"}, 500)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_error_boundaries"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def worker():\n while True: process(next_task())\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.Queue**\n\n**Fix:**\n```python\nqueue = asyncio.Queue(maxsize=1000)\nasync def worker():\n while True:\n task = await queue.get()\n await process(task)\n queue.task_done()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.queue"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef deduplicate(items):\n seen = []\n result = []\n for item in items:\n if item not in seen: # O(n) lookup\n seen.append(item)\n result.append(item)\n return result\n```"
},
{
"role": "assistant",
"content": "**Issue: Inefficient deduplication**\n\n**Fix:**\n```python\ndef deduplicate(items):\n seen = set()\n result = []\n for item in items:\n if item not in seen: # O(1) lookup\n seen.add(item)\n result.append(item)\n return result\n```"
}
],
"source": "python_training",
"tags": [
"python",
"inefficient_deduplication"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexcept TypeError: handle()\nexcept ValueError: handle()\nexcept KeyError: handle()\n```"
},
{
"role": "assistant",
"content": "**Issue: except Multiple Without Grouping**\n\n**Fix:**\n```python\nexcept (TypeError, ValueError, KeyError):\n handle()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"except_multiple_without_grouping"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_async_fetch():\n # Can't test async function synchronously\n result = fetch_data() # Returns coroutine, not result\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing async test**\n\n**Fix:**\n```python\nimport pytest\n@pytest.mark.asyncio\nasync def test_async_fetch():\n result = await fetch_data()\n assert result['status'] == 'ok'\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_async_test"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif item in large_list: process(item)\n# O(n)\n```"
},
{
"role": "assistant",
"content": "**Issue: In-Operator on List**\n\n**Fix:**\n```python\nlarge_set = set(large_list)\nif item in large_set: process(item)\n# O(1)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"in-operator_on_list"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_all(self): return list(range(self.start, self.end))\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Iterator Protocol**\n\n**Fix:**\n```python\ndef __iter__(self): return iter(range(self.start, self.end))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_iterator_protocol"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif key in d and d[key] > 0:\n process(d[key])\n```"
},
{
"role": "assistant",
"content": "**Issue: Inefficient Dict Lookup**\n\n**Fix:**\n```python\nval = d.get(key)\nif val is not None and val > 0:\n process(val)\n# .get() avoids double hash lookup\n```"
}
],
"source": "python_training",
"tags": [
"python",
"inefficient_dict_lookup"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(obj):\n if type(obj) != MyClass:\n raise TypeError\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing isinstance for Type Hint**\n\n**Fix:**\n```python\ndef process(obj: MyClass) -> None:\n # Type hints + isinstance check\n if not isinstance(obj, MyClass):\n raise TypeError\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_isinstance_for_type_hint"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif status == 200: ok()\nelif status == 404: nf()\nelif status == 500: err()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing match/case**\n\n**Fix:**\n```python\nmatch status:\n case 200: ok()\n case 404: nf()\n case 500: err()\n case _: unknown()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_match/case"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef contains_even(items):\n found = False\n for item in items:\n if item % 2 == 0:\n found = True\n break\n return found\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual flag variable**\n\n**Fix:**\n```python\ndef contains_even(items):\n return any(item % 2 == 0 for item in items)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_flag_variable"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconfig: dict = {\"host\": \"localhost\", \"port\": 8080}\n# No type checking on keys/values\n```"
},
{
"role": "assistant",
"content": "**Issue: TypedDict for Structured Data**\n\n**Fix:**\n```python\nfrom typing import TypedDict\nclass ServerConfig(TypedDict):\n host: str\n port: int\nconfig: ServerConfig = {\"host\": \"localhost\", \"port\": 8080}\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"typeddict_for_structured_data"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor x in values:\n if x > 100: return True\nreturn False\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing any() builtin**\n\n**Fix:**\n```python\nreturn any(x > 100 for x in values)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_any()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nsys.getsizeof(obj)\n```"
},
{
"role": "assistant",
"content": "**Issue: getsizeof Missing Nested**\n\n**Fix:**\n```python\ndef deep_size(o, seen=None):\n if seen is None: seen = set()\n if id(o) in seen: return 0\n seen.add(id(o))\n s = sys.getsizeof(o)\n if isinstance(o, dict): s += sum(deep_size(k,seen)+deep_size(v,seen) for k,v in o.items())\n return s\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"getsizeof_missing_nested"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Need relative dates\n```"
},
{
"role": "assistant",
"content": "**Issue: Relative Delta**\n\n**Fix:**\n```python\nfrom dateutil.relativedelta import relativedelta\none_month_later = today + relativedelta(months=1)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"relative_delta"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Service:\n def get(self, id):\n return db.query(User).get(id)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Repository Pattern**\n\n**Fix:**\n```python\nclass Repo:\n def get(self, id): return db.query(User).get(id)\nclass Service:\n def __init__(self, repo): self.repo = repo\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_repository_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nt = threading.Thread(target=background)\nt.start()\n# Prevents program exit\n```"
},
{
"role": "assistant",
"content": "**Issue: Thread Without Daemon**\n\n**Fix:**\n```python\nt = threading.Thread(target=background, daemon=True)\nt.start()\n# Daemon thread exits with program\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"thread_without_daemon"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport time\ndt = time.strftime('%Y-%m-%d', time.localtime(ts))\n```"
},
{
"role": "assistant",
"content": "**Issue: date.fromtimestamp**\n\n**Fix:**\n```python\ndt = datetime.date.fromtimestamp(ts)\n# Returns date object\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"date.fromtimestamp"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor chunk in chunks:\n df = pd.concat([df, chunk])\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Repeated Concat**\n\n**Fix:**\n```python\nwith open('out.csv','w') as f:\n for c in chunks: c.to_csv(f, header=f.tell()==0)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_repeated_concat"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = session.query(func.count(User.id)).all()\n# Returns [(42,)] - tuple, not int\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Scalar Query**\n\n**Fix:**\n```python\ncount = session.query(func.count(User.id)).scalar()\n# Returns 42 directly\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_scalar_query"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Point:\n def __init__(self, x, y):\n self.x = x\n self.y = y\n# Creating millions of instances\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing __slots__ for Memory**\n\n**Fix:**\n```python\nclass Point:\n __slots__ = ('x', 'y')\n def __init__(self, x, y):\n self.x = x\n self.y = y\n# Saves ~40% memory per instance (no __dict__)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing___slots___for_memory"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconfig = {'host': 'localhost', 'port': 8080}\n# Can be accidentally modified\nconfig['port'] = 9999\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Configuration Immutability**\n\n**Fix:**\n```python\nfrom types import MappingProxyType\nconfig = MappingProxyType({'host': 'localhost', 'port': 8080})\n# config['port'] = 9999 # TypeError: immutable\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_configuration_immutability"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport math\ndef calc(x):\n return math.sin(x) + math.cos(x)\n```"
},
{
"role": "assistant",
"content": "**Issue: Local Variable Optimization**\n\n**Fix:**\n```python\nimport math\ndef calc(x):\n sin = math.sin; cos = math.cos\n return sin(x) + cos(x)\n# Local lookup is faster\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"local_variable_optimization"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nnow = datetime.datetime.now()\n# Naive - no timezone\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing timezone awareness**\n\n**Fix:**\n```python\nnow = datetime.datetime.now(datetime.timezone.utc)\n# Timezone-aware\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_timezone_awareness"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_fetch():\n return fetch_data('https://api.com')\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Mock**\n\n**Fix:**\n```python\n@patch('requests.get')\ndef test_fetch(m):\n m.return_value.json.return_value = {'k':'v'}\n assert fetch_data('https://api.com') == {'k':'v'}\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_mock"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nsorted(data, key=lambda x: x.name)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing operator.attrgetter**\n\n**Fix:**\n```python\nfrom operator import attrgetter\nsorted(data, key=attrgetter('name'))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_operator.attrgetter"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = ''\nfor i in items: r += str(i)\n```"
},
{
"role": "assistant",
"content": "**Issue: String Concat in Loop**\n\n**Fix:**\n```python\nr = ''.join(str(i) for i in items)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_concat_in_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf[df['age'] > 30]['name'] = 'adult'\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Chained Indexing**\n\n**Fix:**\n```python\ndf.loc[df['age'] > 30, 'name'] = 'adult'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_chained_indexing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexcept Exception as e:\n handle(e)\n```"
},
{
"role": "assistant",
"content": "**Issue: Exception Group Handling**\n\n**Fix:**\n```python\nexcept ExceptionGroup as eg:\n for e in eg.exceptions:\n handle(e)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"exception_group_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(data):\n import json\n return json.loads(data)\n# Called in a hot loop\n```"
},
{
"role": "assistant",
"content": "**Issue: Unnecessary Import in Function**\n\n**Fix:**\n```python\nimport json\ndef process(data):\n return json.loads(data)\n# Module import is cached but function-local still has overhead\n```"
}
],
"source": "python_training",
"tags": [
"python",
"unnecessary_import_in_function"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncounts = {}\nfor item in items:\n counts[item] = counts.get(item, 0) + 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual Counter**\n\n**Fix:**\n```python\nfrom collections import Counter\ncounts = Counter(items)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"manual_counter"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef all_pairs(items):\n result = []\n for i in range(len(items)):\n for j in range(i+1, len(items)):\n result.append((items[i], items[j]))\n return result\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing itertools for combinations**\n\n**Fix:**\n```python\nfrom itertools import combinations\ndef all_pairs(items):\n return list(combinations(items, 2))\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_itertools_for_combinations"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexecutor.map(process, large_objects)\n```"
},
{
"role": "assistant",
"content": "**Issue: Large Objects in Thread Pool**\n\n**Fix:**\n```python\nexecutor.map(load_and_process, file_paths)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"large_objects_in_thread_pool"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\npath = '/home/user/app/config.yaml'\n```"
},
{
"role": "assistant",
"content": "**Issue: Hardcoded Paths**\n\n**Fix:**\n```python\nfrom pathlib import Path\nBASE = Path(__file__).resolve().parent\npath = BASE / 'config.yaml'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"hardcoded_paths"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlogger.info('Login: ' + username + ', ' + password)\n```"
},
{
"role": "assistant",
"content": "**Issue: Logging Sensitive Data**\n\n**Fix:**\n```python\nlogger.info('Login: ' + username)\n# Never log passwords or tokens\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"logging_sensitive_data"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = []\nfor lst in lists: result.extend(lst)\n```"
},
{
"role": "assistant",
"content": "**Issue: itertools.chain**\n\n**Fix:**\n```python\nfrom itertools import chain\nresult = list(chain.from_iterable(lists))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"itertools.chain"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# No docs on what config values mean\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Configuration Documentation**\n\n**Fix:**\n```python\n# config.py\n\"\"\"Configuration for MyApp.\n\nEnvironment variables:\n - APP_HOST: Server hostname (default: localhost)\n - APP_PORT: Server port (default: 8080)\n - DB_URL: Database connection string (required)\n - DEBUG: Enable debug mode (default: false)\n - LOG_LEVEL: Logging level (default: INFO)\n\"\"\"\nfrom pydantic_settings import BaseSettings\nclass Settings(BaseSettings):\n app_host: str = 'localhost'\n app_port: int = 8080\n db_url: str\n debug: bool = False\n log_level: str = 'INFO'\n class Config: env_file = '.env'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_configuration_documentation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n do_something()\nexcept:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Bare except**\n\n**Fix:**\n```python\ntry:\n do_something()\nexcept SpecificError:\n handle_error()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"bare_except"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef set_status(s): pass\n# s can be 'active' or 'inactive'\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Literal**\n\n**Fix:**\n```python\nfrom typing import Literal\ndef set_status(s: Literal['active', 'inactive']): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_literal"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntf = '/tmp/data_'+str(os.getpid())+'.csv'\n```"
},
{
"role": "assistant",
"content": "**Issue: Temporary File Issues**\n\n**Fix:**\n```python\nimport tempfile\nwith tempfile.NamedTemporaryFile(suffix='.csv') as f:\n write(f)\n f.flush(); process(f.name)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"temporary_file_issues"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef find_user(user_id):\n user = db.query(User).filter_by(id=user_id).first()\n if user:\n return user.to_dict()\n return None\n```"
},
{
"role": "assistant",
"content": "**Issue: Not using typing for return values**\n\n**Fix:**\n```python\nfrom typing import Optional\ndef find_user(user_id: int) -> Optional[dict]:\n user = db.query(User).filter_by(id=user_id).first()\n if user:\n return user.to_dict()\n return None\n```"
}
],
"source": "python_training",
"tags": [
"python",
"not_using_typing_for_return_values"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nsession = requests.Session()\n```"
},
{
"role": "assistant",
"content": "**Issue: requests Session Without Cleanup**\n\n**Fix:**\n```python\nsession = requests.Session()\ntry:\n session.get(url)\nfinally:\n session.close()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"requests_session_without_cleanup"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.post('/users')\ndef create_user(name: str, email: str):\n # No validation\n return {'name': name, 'email': email}\n```"
},
{
"role": "assistant",
"content": "**Issue: FastAPI - Missing Pydantic validation**\n\n**Fix:**\n```python\nfrom pydantic import BaseModel, EmailStr\nclass UserCreate(BaseModel):\n name: str = Field(..., min_length=1, max_length=100)\n email: EmailStr\n\n@app.post('/users')\ndef create_user(user: UserCreate):\n # Automatically validated\n return {'name': user.name, 'email': user.email}\n```"
}
],
"source": "python_training",
"tags": [
"python",
"fastapi_-_missing_pydantic_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport pickle\ndata = pickle.loads(request.data)\n```"
},
{
"role": "assistant",
"content": "**Issue: Insecure Deserialization**\n\n**Fix:**\n```python\n# Never unpickle user data\nimport json\ndata = json.loads(request.data)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"insecure_deserialization"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef create_user(name, email, phone=None, addr=None, country=None, prefs=None, avatar=None): pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Builder Pattern**\n\n**Fix:**\n```python\n@dataclass\nclass UserBuilder:\n name: str; email: str; phone: str = None\n def build(self): return User(**self.__dict__)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_builder_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nassert user.is_valid(), 'Invalid user'\n```"
},
{
"role": "assistant",
"content": "**Issue: assert For Validation**\n\n**Fix:**\n```python\nif not user.is_valid():\n raise ValueError('Invalid user')\n# assert can be disabled with -O\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"assert_for_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nengine = create_engine('postgresql://user:pass@host/db')\n# Default pool_size=5 - exhausted under load\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Connection Pool Exhaustion**\n\n**Fix:**\n```python\nengine = create_engine(\n 'postgresql://...',\n pool_size=20,\n max_overflow=10,\n pool_timeout=30,\n pool_recycle=1800,\n pool_pre_ping=True)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_connection_pool_exhaustion"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Point:\n def __init__(self, x, y):\n self.x = x\n self.y = y\n# Creating millions of instances\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing __slots__**\n\n**Fix:**\n```python\nclass Point:\n __slots__ = ('x', 'y')\n def __init__(self, x, y):\n self.x = x\n self.y = y\n# Saves ~40% memory per instance\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing___slots__"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_invalid_input():\n result = divide(1, 0)\n assert result is None\n```"
},
{
"role": "assistant",
"content": "**Issue: Testing exception handling**\n\n**Fix:**\n```python\nimport pytest\ndef test_invalid_input():\n with pytest.raises(ZeroDivisionError):\n divide(1, 0)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"testing_exception_handling"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport hashlib\nhash = hashlib.md5(password.encode()).hexdigest()\n```"
},
{
"role": "assistant",
"content": "**Issue: Weak Password Hash**\n\n**Fix:**\n```python\nimport hashlib\nhash = hashlib.sha256(password.encode()).hexdigest()\n# Better: use bcrypt or argon2\nimport argon2\nph = argon2.PasswordHasher()\nhash = ph.hash(password)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"weak_password_hash"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif len(items) > 0:\n process(items)\n```"
},
{
"role": "assistant",
"content": "**Issue: Using list as boolean check**\n\n**Fix:**\n```python\nif items:\n process(items)\n# Empty sequences are falsy\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_list_as_boolean_check"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif x is 1: pass\n# is checks identity, not equality\n```"
},
{
"role": "assistant",
"content": "**Issue: is vs == for Values**\n\n**Fix:**\n```python\nif x == 1: pass\n# Use == for value comparison\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"is_vs_==_for_values"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor item in items:\n new_record = Model(data=item)\n session.add(new_record)\nsession.commit()\n# 10K inserts = 10K round trips\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Bulk Operations**\n\n**Fix:**\n```python\nsession.bulk_save_objects([Model(data=item) for item in items])\n# Or faster:\nsession.execute(Model.__table__.insert(), [{\"data\": i} for i in items])\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_bulk_operations"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = []\nfor i in range(len(items)-1, -1, -1):\n result.append(items[i])\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing reversed() builtin**\n\n**Fix:**\n```python\nresult = list(reversed(items))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_reversed()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport re\nfor line in lines:\n match = re.match(r'\\d+', line)\n # Recompile regex each iteration\n```"
},
{
"role": "assistant",
"content": "**Issue: Inefficient Regex**\n\n**Fix:**\n```python\nimport re\nDIGIT_RE = re.compile(r'\\d+')\nfor line in lines:\n match = DIGIT_RE.match(line)\n# Compile once, reuse\n```"
}
],
"source": "python_training",
"tags": [
"python",
"inefficient_regex"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntoday = datetime.datetime.now()\n# Includes time - bad for date comparison\n```"
},
{
"role": "assistant",
"content": "**Issue: datetime.datetime vs date**\n\n**Fix:**\n```python\ntoday = datetime.date.today()\n# Date only\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"datetime.datetime_vs_date"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass EventEmitter:\n def __init__(self):\n self._callbacks = {}\n def on(self, event, callback):\n ...\n def emit(self, event, data):\n ...\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Observer Pattern**\n\n**Fix:**\n```python\nfrom typing import Callable, Any\nclass EventEmitter:\n def __init__(self):\n self._listeners: dict[str, list[Callable]] = {}\n\n def on(self, event: str, callback: Callable) -> None:\n self._listeners.setdefault(event, []).append(callback)\n\n def emit(self, event: str, *args: Any, **kwargs: Any) -> None:\n for cb in self._listeners.get(event, []):\n cb(*args, **kwargs)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_observer_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif __name__ == '__main__':\n print('Hello World')\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing entry point**\n\n**Fix:**\n```python\ndef main():\n print('Hello World')\n\nif __name__ == '__main__':\n main()\n# Separates entry point from module logic"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_entry_point"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass HttpRequest:\n def __init__(self, method, url, headers, body, auth, timeout, retries):\n # 10+ parameters\n ...\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Builder Pattern for complex objects**\n\n**Fix:**\n```python\nclass HttpRequestBuilder:\n def __init__(self):\n self._method = 'GET'\n self._url = ''\n self._headers = {}\n self._body = None\n self._timeout = 30\n\n def method(self, m): self._method = m; return self\n def url(self, u): self._url = u; return self\n def header(self, k, v): self._headers[k] = v; return self\n def body(self, b): self._body = b; return self\n def timeout(self, t): self._timeout = t; return self\n def build(self): return HttpRequest(**self.__dict__)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_builder_pattern_for_complex_objects"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif __name__ == '__main__':\n app.run(host='0.0.0.0', port=5000)\n```"
},
{
"role": "assistant",
"content": "**Issue: Not using gunicorn for production**\n\n**Fix:**\n```python\n# Use gunicorn:\n# gunicorn --workers 4 --bind 0.0.0.0:5000 app:app\n# Or uvicorn for async:\n# uvicorn app:app --host 0.0.0.0 --port 5000 --workers 4\n```"
}
],
"source": "python_training",
"tags": [
"python",
"not_using_gunicorn_for_production"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntext = str(dt) # Not human-friendly\n```"
},
{
"role": "assistant",
"content": "**Issue: strftime vs strptime**\n\n**Fix:**\n```python\ntext = dt.strftime('%Y-%m-%d %H:%M')\n# Format: '2024-01-15 14:30'\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"strftime_vs_strptime"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport argparse\nparser = argparse.ArgumentParser()\nparser.add_argument('--input', required=True)\nargs = parser.parse_args()\n# Works but verbose\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CLI Framework**\n\n**Fix:**\n```python\nimport click\n@click.command()\n@click.option('--input', '-i', required=True)\ndef cli(input):\n '''Process input file'''\n process(input)\nif __name__ == '__main__': cli()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_cli_framework"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n[str(x) for x in nums]\n```"
},
{
"role": "assistant",
"content": "**Issue: List Comprehension vs map**\n\n**Fix:**\n```python\nlist(map(str, nums))\n# map is faster for built-in functions\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"list_comprehension_vs_map"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_validate(): assert obj._validate('test')\n```"
},
{
"role": "assistant",
"content": "**Issue: Testing Private Methods**\n\n**Fix:**\n```python\ndef test_validate():\n with pytest.raises(ValidationError):\n MyClass(invalid_data)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"testing_private_methods"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor _ in range(3):\n try:\n return requests.get(url)\n except requests.RequestException:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual retry logic**\n\n**Fix:**\n```python\nfrom tenacity import retry, stop_after_attempt, wait_exponential\n@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1))\ndef fetch(url):\n return requests.get(url).raise_for_status()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_retry_logic"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def get_db():\n pool = await create_pool()\n try: return pool\n except: pool.close()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Async Context Manager**\n\n**Fix:**\n```python\nfrom contextlib import asynccontextmanager\n@asynccontextmanager\nasync def get_db():\n pool = await create_pool()\n try: yield pool\n finally: pool.close(); await pool.wait_closed()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_async_context_manager"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@pytest.fixture(scope='session')\ndef db(): yield connect()\n```"
},
{
"role": "assistant",
"content": "**Issue: Shared Test DB**\n\n**Fix:**\n```python\n@pytest.fixture(scope='function')\ndef db(): yield connect()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"shared_test_db"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass UserManager:\n def create_user(self): ...\n def send_email(self): ...\n def process_payment(self): ...\n def generate_report(self): ...\n def update_stats(self): ...\n```"
},
{
"role": "assistant",
"content": "**Issue: God class**\n\n**Fix:**\n```python\nclass UserService:\n def __init__(self, email_service, payment_service, stats_service):\n self.email = email_service\n self.payment = payment_service\n self.stats = stats_service\n\n def create_user(self):\n # Delegate concerns\n ...\n# Single Responsibility Principle\n```"
}
],
"source": "python_training",
"tags": [
"python",
"god_class"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntext = b'hello'.decode()\n# Works but implicit\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.encode/decode**\n\n**Fix:**\n```python\ntext = b'hello'.decode('utf-8')\n# Explicit encoding\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.encode/decode"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Config:\n def __init__(self, host, port, debug):\n self.host = host\n self.port = port\n self.debug = debug\n def __repr__(self):\n return f'Config({self.host}, {self.port})'\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing dataclass**\n\n**Fix:**\n```python\n@dataclass\nclass Config:\n host: str\n port: int = 8080\n debug: bool = False\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_dataclass"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif obj1 == obj2: pass\n# Equality, not identity\n```"
},
{
"role": "assistant",
"content": "**Issue: id() for Object Identity**\n\n**Fix:**\n```python\nif id(obj1) == id(obj2): pass\n# Same object in memory\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"id()_for_object_identity"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport subprocess\nsubprocess.run(f\"ping {host}\", shell=True)\n```"
},
{
"role": "assistant",
"content": "**Issue: Command Injection**\n\n**Fix:**\n```python\nimport shlex\nsubprocess.run(['ping', shlex.split(host)[0]])\n# Never use shell=True with user input\n```"
}
],
"source": "python_training",
"tags": [
"python",
"command_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef add(a, b):\n if isinstance(a, str): return a + b\n return a + b\n```"
},
{
"role": "assistant",
"content": "**Issue: typing.overload**\n\n**Fix:**\n```python\nfrom typing import overload\n@overload\ndef add(a: str, b: str) -> str: ...\n@overload\ndef add(a: int, b: int) -> int: ...\ndef add(a, b): return a + b\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"typing.overload"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef add_item(item, items=[]):\n items.append(item)\n return items\n```"
},
{
"role": "assistant",
"content": "**Issue: Mutable Default Arg**\n\n**Fix:**\n```python\ndef add_item(item, items=None):\n if items is None:\n items = []\n items.append(item)\n return items\n# Mutable defaults are shared across calls\n```"
}
],
"source": "python_training",
"tags": [
"python",
"mutable_default_arg"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef serialize(data):\n if isinstance(data, str): return serialize_str(data)\n if isinstance(data, int): return str(data)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing functools.singledispatch**\n\n**Fix:**\n```python\nfrom functools import singledispatch\n@singledispatch\ndef serialize(data): raise TypeError('Cannot serialize ' + str(type(data)))\n@serialize.register(str)\ndef _(d): return repr(d)\n@serialize.register(int)\ndef _(d): return str(d)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_functools.singledispatch"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nshared_list = []\n# Not thread-safe for append/pop\n```"
},
{
"role": "assistant",
"content": "**Issue: queue.Queue vs list**\n\n**Fix:**\n```python\nfrom queue import Queue\nq = Queue(maxsize=100)\nq.put(item)\nitem = q.get()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"queue.queue_vs_list"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process()\nexcept ValueError as e:\n logger.error('Failed')\n```"
},
{
"role": "assistant",
"content": "**Issue: except as e Without Using e**\n\n**Fix:**\n```python\ntry:\n process()\nexcept ValueError:\n logger.error('Failed')\n# Don't bind variable if not used\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"except_as_e_without_using_e"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_name(user) -> Union[str, None]:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Union Instead of Optional**\n\n**Fix:**\n```python\ndef get_name(user) -> str | None:\n pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"union_instead_of_optional"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = requests.get(url)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Retry in requests**\n\n**Fix:**\n```python\nfrom requests.adapters import HTTPAdapter\nfrom urllib3.util.retry import Retry\ns = requests.Session()\nr = Retry(total=3, backoff_factor=1)\ns.mount('https://', HTTPAdapter(max_retries=r))\ns.get(url)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_retry_in_requests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n_cache = {}\ndef expensive(key):\n if key not in _cache:\n _cache[key] = compute(key)\n return _cache[key]\n# Manual cache with no size limit\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing functools.cache**\n\n**Fix:**\n```python\nfrom functools import cache\n@cache\ndef expensive(key):\n return compute(key)\n# Built-in memoization\n# Or with size limit:\n@lru_cache(maxsize=128)\ndef expensive(key): return compute(key)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_functools.cache"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef find_largest(items):\n largest = items[0]\n for item in items[1:]:\n if item > largest:\n largest = item\n return largest\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual min/max with loop**\n\n**Fix:**\n```python\ndef find_largest(items):\n return max(items)\n# Built-in max/min are implemented in C\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_min/max_with_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_sort(): assert sort([3,1,2]) == [1,2,3]\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Property Testing**\n\n**Fix:**\n```python\nfrom hypothesis import given\nimport hypothesis.strategies as st\n@given(st.lists(st.integers(), max_size=100))\ndef test_sort(data): assert sort(data) == sorted(data)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_property_testing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nuser_id: str = \"abc123\"\ndb_id: str = \"42\"\n# Both are str, can be confused\n```"
},
{
"role": "assistant",
"content": "**Issue: NewType for Distinct Types**\n\n**Fix:**\n```python\nfrom typing import NewType\nUserId = NewType('UserId', str)\nDbId = NewType('DbId', int)\nuser_id = UserId(\"abc123\")\ndb_id = DbId(42)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"newtype_for_distinct_types"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif name.lower() == 'uberstrasse':\n # German ss != lowercased SS\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.casefold()**\n\n**Fix:**\n```python\nif name.casefold() == 'uberstrasse':\n # Proper Unicode case folding\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.casefold()"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwith open('huge.bin','rb') as f: data = f.read()\n```"
},
{
"role": "assistant",
"content": "**Issue: Loading Entire Binary File**\n\n**Fix:**\n```python\nimport mmap\nwith open('huge.bin','rb') as f:\n mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"loading_entire_binary_file"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom concurrent.futures import ThreadPoolExecutor\nwith ThreadPoolExecutor() as pool:\n results = pool.map(process_data, items)\n# CPU-bound work\n```"
},
{
"role": "assistant",
"content": "**Issue: GIL-Bound Parallelism**\n\n**Fix:**\n```python\nfrom concurrent.futures import ProcessPoolExecutor\nwith ProcessPoolExecutor() as pool:\n results = pool.map(process_data, items)\n# Use ProcessPoolExecutor for CPU-bound tasks\n```"
}
],
"source": "python_training",
"tags": [
"python",
"gil-bound_parallelism"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Comparing dates with different times\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing date normalization**\n\n**Fix:**\n```python\ndt_normalized = dt.replace(hour=0, minute=0, second=0, microsecond=0)\n# Compare date-only\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_date_normalization"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = future.result()\n```"
},
{
"role": "assistant",
"content": "**Issue: Future Without Timeout**\n\n**Fix:**\n```python\nresult = future.result(timeout=30)\n# Avoids indefinite blocking\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"future_without_timeout"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nloop = asyncio.new_event_loop()\nasyncio.run_coroutine_threadsafe(coro, loop)\n```"
},
{
"role": "assistant",
"content": "**Issue: run_coroutine_threadsafe Misuse**\n\n**Fix:**\n```python\ndef get_loop():\n try: return asyncio.get_running_loop()\n except RuntimeError:\n loop = asyncio.new_event_loop()\n asyncio.set_event_loop(loop)\n return loop\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"run_coroutine_threadsafe_misuse"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport pandas as pd\ndf = pd.read_csv('data.csv')\nresult = df.groupby('category')['value'].sum()\n# Overkill for simple aggregation\n```"
},
{
"role": "assistant",
"content": "**Issue: Using pandas for simple CSV**\n\n**Fix:**\n```python\nimport csv\nfrom collections import defaultdict\nresult = defaultdict(float)\nwith open('data.csv') as f:\n reader = csv.DictReader(f)\n for row in reader:\n result[row['category']] += float(row['value'])\n# No pandas dependency needed\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_pandas_for_simple_csv"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.route('/api/items')\ndef list_items():\n items = Item.query.all()\n return jsonify([i.to_dict() for i in items])\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing pagination**\n\n**Fix:**\n```python\n@app.route('/api/items')\ndef list_items():\n page = request.args.get('page', 1, type=int)\n per_page = request.args.get('per_page', 20, type=int)\n items = Item.query.paginate(page=page, per_page=per_page)\n return jsonify({\n 'items': [i.to_dict() for i in items.items],\n 'total': items.total,\n 'pages': items.pages\n })\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_pagination"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def stream():\n for i in range(1000): yield await fetch(i)\n```"
},
{
"role": "assistant",
"content": "**Issue: Async Generator Without Cleanup**\n\n**Fix:**\n```python\nasync def stream():\n try:\n for i in range(1000): yield await fetch(i)\n finally: cleanup_resources()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"async_generator_without_cleanup"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = []\nfor _ in range(10):\n threading.Thread(target=lambda: results.append(1)).start()\nassert len(results)==10\n```"
},
{
"role": "assistant",
"content": "**Issue: Flaky Test Race**\n\n**Fix:**\n```python\nthreads = [threading.Thread(target=lambda: results.append(1)) for _ in range(10)]\nfor t in threads: t.start()\nfor t in threads: t.join()\nassert len(results)==10\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"flaky_test_race"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = {}\nfor item in items:\n result.setdefault(item.cat, []).append(item)\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual defaultdict**\n\n**Fix:**\n```python\nfrom collections import defaultdict\nresult = defaultdict(list)\nfor item in items:\n result[item.cat].append(item)"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"manual_defaultdict"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_config(key):\n try: return config[key]\n except KeyError: return None\n # Can't distinguish missing from actual None\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Sentinel Values**\n\n**Fix:**\n```python\n_MISSING = object()\ndef get_config(key):\n result = config.get(key, _MISSING)\n if result is _MISSING: raise KeyError(f\"Config key not found: {key}\")\n return result\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_sentinel_values"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nformatted = ' ' * 10 + text + ' ' * 10\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.center()**\n\n**Fix:**\n```python\nformatted = text.center(30)\n# Center in 30-char width\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.center()"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Utils:\n def validate_email(email):\n return bool(re.match(r'.+@.+', email))\n```"
},
{
"role": "assistant",
"content": "**Issue: Staticmethod Without Decorator**\n\n**Fix:**\n```python\nclass Utils:\n @staticmethod\n def validate_email(email):\n return bool(re.match(r'.+@.+', email))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"staticmethod_without_decorator"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nall_posts = session.query(Post).all()\n# Table has millions of rows\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Query Without Limit**\n\n**Fix:**\n```python\npage = request.args.get('page', 1, type=int)\nposts = session.query(Post).limit(50).offset((page-1)*50).all()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_query_without_limit"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = requests.get(url)\n# Fails on transient network errors\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Retry Pattern**\n\n**Fix:**\n```python\nfrom tenacity import retry, stop_after_attempt, wait_exponential\n@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1))\ndef fetch(url):\n return requests.get(url, timeout=5).json()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_retry_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# No CSRF token\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CSRF Protection**\n\n**Fix:**\n```python\n# Flask: from flask_wtf import CSRFProtect\nCSRFProtect(app)\n# Django: {% csrf_token %}\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_csrf_protection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Adding new column to model but forgetting migration\nclass User(Base):\n email = Column(String(255)) # NEW COLUMN\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Migration Missing**\n\n**Fix:**\n```python\n# Always generate migration for schema changes\n# alembic revision --autogenerate -m \"add user email\"\n# alembic upgrade head\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_migration_missing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfuncs = [lambda: i for i in range(5)]\n# All return 4\n```"
},
{
"role": "assistant",
"content": "**Issue: Late Binding Closure**\n\n**Fix:**\n```python\nfuncs = [lambda i=i: i for i in range(5)]\n# Each captures its own i\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"late_binding_closure"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif type(x) in (int, float, str):\n```"
},
{
"role": "assistant",
"content": "**Issue: isinstance for Multiple Types**\n\n**Fix:**\n```python\nif isinstance(x, (int, float, str)):\n# Proper type checking\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"isinstance_for_multiple_types"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport os\npath = os.path.join('/data', 'files', 'data.txt')\nif os.path.exists(path):\n with open(path) as f:\n data = f.read()\n```"
},
{
"role": "assistant",
"content": "**Issue: Not using pathlib**\n\n**Fix:**\n```python\nfrom pathlib import Path\npath = Path('/data/files/data.txt')\nif path.exists():\n data = path.read_text()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"not_using_pathlib"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def fetch_data():\n result = requests.get(url) # Blocking!\n return result.json()\n```"
},
{
"role": "assistant",
"content": "**Issue: Mixing sync and async**\n\n**Fix:**\n```python\nasync def fetch_data():\n async with aiohttp.ClientSession() as session:\n async with session.get(url) as resp:\n return await resp.json()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"mixing_sync_and_async"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntotal = 0\nfor x in nums: total += x\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing sum() builtin**\n\n**Fix:**\n```python\ntotal = sum(nums)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_sum()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor i in range(len(names)):\n print(names[i], ages[i])\n```"
},
{
"role": "assistant",
"content": "**Issue: Using zip incorrectly**\n\n**Fix:**\n```python\nfor name, age in zip(names, ages):\n print(name, age)\n# zip() pairs elements cleanly\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_zip_incorrectly"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf[(df['age'] > 30) & (df['city'] == 'NYC')]\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Verbose Boolean Indexing**\n\n**Fix:**\n```python\ndf.query('age > 30 and city == \"NYC\"')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_verbose_boolean_indexing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_api():\n time.sleep(1)\n return api_call()\n```"
},
{
"role": "assistant",
"content": "**Issue: Slow Tests with Sleep**\n\n**Fix:**\n```python\n@patch('requests.get')\ndef test_api(m):\n m.return_value.json.return_value = {'data': []}\n return api_call()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"slow_tests_with_sleep"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process_data():\n # No timing info - hard to identify slow operations\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Performance Logging**\n\n**Fix:**\n```python\nimport time\ndef log_performance(func):\n def wrapper(*args, **kwargs):\n start = time.perf_counter()\n try: return func(*args, **kwargs)\n finally:\n elapsed = time.perf_counter() - start\n if elapsed > 0.1: logger.warning(\"%s took %.3fs\", func.__name__, elapsed)\n return wrapper\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_performance_logging"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor r,d,f in os.walk('/data'):\n for fn in f: process(os.path.join(r,fn))\n```"
},
{
"role": "assistant",
"content": "**Issue: os.walk Instead of pathlib**\n\n**Fix:**\n```python\nfor fp in Path('/data').rglob('*'):\n if fp.is_file(): process(fp)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"os.walk_instead_of_pathlib"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(items):\n data = list(items)\n return [x * 2 for x in data]\n```"
},
{
"role": "assistant",
"content": "**Issue: Unnecessary List Copy**\n\n**Fix:**\n```python\ndef process(items):\n return [x * 2 for x in items]\n# List comprehension creates a new list anyway\n```"
}
],
"source": "python_training",
"tags": [
"python",
"unnecessary_list_copy"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = []\nfor data in large_dataset:\n results.append(heavy_computation(data))\n# Sequential - doesn't use multiple cores\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing ProcessPoolExecutor**\n\n**Fix:**\n```python\nfrom concurrent.futures import ProcessPoolExecutor\nwith ProcessPoolExecutor(max_workers=4) as executor:\n results = list(executor.map(heavy_computation, large_dataset))\n# Bypasses GIL for CPU-bound work\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_processpoolexecutor"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor i in range(len(names)):\n process(names[i], ages[i])\n```"
},
{
"role": "assistant",
"content": "**Issue: zip for Parallel Iteration**\n\n**Fix:**\n```python\nfor name, age in zip(names, ages):\n process(name, age)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"zip_for_parallel_iteration"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nAPI_KEY = 'sk-abc123'\nDB_PASS = 'password123'\n```"
},
{
"role": "assistant",
"content": "**Issue: Hardcoded Secrets**\n\n**Fix:**\n```python\nimport os\nAPI_KEY = os.environ['API_KEY']\nDB_PASS = os.environ['DB_PASS']\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"hardcoded_secrets"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlogger.info(\"Auth attempt: user=%s, pass=%s\", username, password)\n# Password in logs!\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Log Redaction**\n\n**Fix:**\n```python\nimport re\nclass RedactingFilter(logging.Filter):\n SENSITIVE = [re.compile(r'(?i)password[\\w=]*')]\n def filter(self, record):\n record.msg = re.sub(self.SENSITIVE, '[REDACTED]', str(record.msg))\n return True\nlogger.addFilter(RedactingFilter())\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_log_redaction"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_user(user_id):\n session = Session()\n return session.query(User).get(user_id)\n # Session never closed\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Session Leak**\n\n**Fix:**\n```python\nfrom contextlib import contextmanager\n@contextmanager\ndef session_scope():\n session = Session()\n try:\n yield session\n session.commit()\n except Exception:\n session.rollback()\n raise\n finally:\n session.close()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_session_leak"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef fib(n):\n if n < 2: return n\n return fib(n-1) + fib(n-2)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing functools.lru_cache**\n\n**Fix:**\n```python\n@functools.lru_cache(maxsize=128)\ndef fib(n):\n if n < 2: return n\n return fib(n-1) + fib(n-2)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_functools.lru_cache"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = {}\nfor k, v in items:\n result[k] = result.get(k, 0) + v\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual Counter with dict.get**\n\n**Fix:**\n```python\nfrom collections import Counter\ncounter = Counter()\nfor k, v in items:\n counter[k] += v"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"manual_counter_dict_get"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nheap = []\nheap.append((priority, item))\nheap.sort(reverse=True)\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual Priority Queue**\n\n**Fix:**\n```python\nimport heapq\nheap = []\nheapq.heappush(heap, (-priority, item))\npriority, item = heapq.heappop(heap)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"manual_priority_queue"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport random\ntoken = random.randint(100000, 999999)\n```"
},
{
"role": "assistant",
"content": "**Issue: Insecure Random**\n\n**Fix:**\n```python\nimport secrets\ntoken = secrets.randbelow(900000) + 100000\n# secrets uses OS-level CSPRNG\n```"
}
],
"source": "python_training",
"tags": [
"python",
"insecure_random"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncleanup()\n# Should be in finally\n```"
},
{
"role": "assistant",
"content": "**Issue: finally Without try**\n\n**Fix:**\n```python\ntry:\n process()\nfinally:\n cleanup()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"finally_without_try"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef retry(func):\n def wrapper(*args, **kwargs):\n for _ in range(3):\n try: return func(*args, **kwargs)\n except: pass\n return wrapper\n# Loses function signature\n```"
},
{
"role": "assistant",
"content": "**Issue: ParamSpec for Decorator Type Safety**\n\n**Fix:**\n```python\nfrom typing import ParamSpec, Callable, TypeVar\nP = ParamSpec('P')\nR = TypeVar('R')\ndef retry(func: Callable[P, R]) -> Callable[P, R]:\n def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:\n for _ in range(3):\n try: return func(*args, **kwargs)\n except: pass\n return wrapper\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"paramspec_for_decorator_type_safety"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass API:\n def get(self, path):\n return requests.get(base_url + path)\n```"
},
{
"role": "assistant",
"content": "**Issue: String Concatenation for URLs**\n\n**Fix:**\n```python\nfrom urllib.parse import urljoin\nclass API:\n def get(self, path):\n url = urljoin(base_url, path)\n return requests.get(url)"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"string_concatenation_for_urls"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlist(map(str, filter(lambda x: x > 0, nums)))\n```"
},
{
"role": "assistant",
"content": "**Issue: map/filter vs Comprehensions**\n\n**Fix:**\n```python\n[str(x) for x in nums if x > 0]\n# More readable\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"map/filter_vs_comprehensions"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass TestUser:\n def setup_method(self):\n self.user = User('Alice')\n # Shared state between tests\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing test isolation**\n\n**Fix:**\n```python\nclass TestUser:\n @pytest.fixture(autouse=True)\n def clean_state(self):\n # Each test gets fresh state\n User.query.delete()\n yield\n db.session.rollback()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_test_isolation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf['domain'] = [e.split('@')[1] for e in df['email']]\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas String Loop**\n\n**Fix:**\n```python\ndf['domain'] = df['email'].str.split('@').str[1]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_string_loop"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nf = executor.submit(task)\nresult = f.result()\n# Blocks main thread\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing add_done_callback**\n\n**Fix:**\n```python\nf = executor.submit(task)\nf.add_done_callback(handle_result)\n# Non-blocking callback\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_add_done_callback"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom flask import Flask\napp = Flask(__name__)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing HTTPS Redirect**\n\n**Fix:**\n```python\nfrom flask import Flask\nimport flask_talisman\napp = Flask(__name__)\ntalisman = flask_talisman.Talisman(app)\n# Enforces HTTPS, HSTS, and other security headers\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_https_redirect"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport pickle\ndata = pickle.loads(user_input)\n```"
},
{
"role": "assistant",
"content": "**Issue: Insecure Deserialization**\n\n**Fix:**\n```python\nimport json\ndata = json.loads(user_input)\n# Use JSON or protobuf instead of pickle\n```"
}
],
"source": "python_training",
"tags": [
"python",
"insecure_deserialization"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process(data)\nexcept Exception:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Silent Exception Swallowing**\n\n**Fix:**\n```python\nimport logging\ntry:\n process(data)\nexcept Exception as e:\n logger.error('Processing failed', exc_info=True)\n raise\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"silent_exception_swallowing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf['enc'] = df['color'].map({'red':0, 'green':1})\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Manual Encoding**\n\n**Fix:**\n```python\nfrom sklearn.preprocessing import LabelEncoder\ndf['enc'] = LabelEncoder().fit_transform(df['color'])\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_manual_encoding"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexec(user_code)\n```"
},
{
"role": "assistant",
"content": "**Issue: exec() Usage**\n\n**Fix:**\n```python\n# Never exec user input\n# Use a sandbox or whitelist approach\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"exec()_usage"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nSTATUS_DRAFT = 0; STATUS_PUB = 1\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Enum**\n\n**Fix:**\n```python\nfrom enum import Enum, auto\nclass Status(Enum):\n DRAFT = auto(); PUBLISHED = auto()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_enum"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef get_item(key: str) -> Union[str, dict]:\n # Returns str for single key, dict for multiple\n pass\n# Caller can't know which type\n```"
},
{
"role": "assistant",
"content": "**Issue: Overload for Multiple Signatures**\n\n**Fix:**\n```python\nfrom typing import overload\n@overload\ndef get_item(key: str) -> str: ...\n@overload\ndef get_item(key: list[str]) -> dict[str, str]: ...\ndef get_item(key):\n if isinstance(key, str): return db.get(key)\n return {k: db.get(k) for k in key}\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"overload_for_multiple_signatures"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nResponseDict = dict[str, object]\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.TypeAlias**\n\n**Fix:**\n```python\nfrom typing import TypeAlias\nResponseDict: TypeAlias = dict[str, object]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.typealias"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nitems.sort()\n# Modifies in place\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing sorted() builtin**\n\n**Fix:**\n```python\nsorted_items = sorted(items)\n# Returns new list - doesn't modify original\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_sorted()_builtin"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif username == 'admin':\n # Won't match ' admin ' or 'admin\\n'\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.strip()**\n\n**Fix:**\n```python\nif username.strip() == 'admin':\n # Handles whitespace\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.strip()"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef is_dict(data: Any) -> bool:\n return isinstance(data, dict)\ndef process(data: Any):\n if is_dict(data):\n # Type checker still sees Any\n data['key'] # No autocomplete\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.TypeGuard**\n\n**Fix:**\n```python\nfrom typing import TypeGuard, Any\ndef is_dict(data: Any) -> TypeGuard[dict]:\n return isinstance(data, dict)\ndef process(data: Any):\n if is_dict(data):\n data['key'] # Type narrowed to dict\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.typeguard"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Manager:\n def create(self): pass\n def email(self): pass\n def log(self): pass\n def report(self): pass\n```"
},
{
"role": "assistant",
"content": "**Issue: God Object**\n\n**Fix:**\n```python\nclass Manager:\n def __init__(self, email_svc, logger, reporter):\n self.email = email_svc\n self.logger = logger\n self.reporter = reporter\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"god_object"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndata = list(csv.DictReader(f))\n```"
},
{
"role": "assistant",
"content": "**Issue: Loading Entire CSV**\n\n**Fix:**\n```python\nfor row in csv.DictReader(f): process(row)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"loading_entire_csv"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ncache = {}\ndef get(id):\n if id not in cache: cache[id] = load(id)\n return cache[id]\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing WeakRef Cache**\n\n**Fix:**\n```python\nimport weakref\ncache = weakref.WeakValueDictionary()\ndef get(id):\n o = cache.get(id)\n if o is None: o = load(id); cache[id] = o\n return o\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_weakref_cache"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntotal = sum([x ** 2 for x in range(1000000)])\n```"
},
{
"role": "assistant",
"content": "**Issue: Unnecessary Generator Materialization**\n\n**Fix:**\n```python\ntotal = sum(x ** 2 for x in range(1000000))\n# Generator expression saves memory (no intermediate list)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"unnecessary_generator_materialization"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwhile True:\n item = await queue.get()\n process(item)\n# Blocks forever if queue is empty\n```"
},
{
"role": "assistant",
"content": "**Issue: asyncio Queue without timeout**\n\n**Fix:**\n```python\nwhile True:\n try:\n item = await asyncio.wait_for(queue.get(), timeout=5.0)\n process(item)\n except asyncio.TimeoutError:\n break # Graceful shutdown\n```"
}
],
"source": "python_training",
"tags": [
"python",
"asyncio_queue_without_timeout"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.route('/transfer', methods=['POST'])\ndef transfer():\n amount = request.form['amount']\n process_transfer(amount)\n```"
},
{
"role": "assistant",
"content": "**Issue: CSRF Missing**\n\n**Fix:**\n```python\nfrom flask_wtf.csrf import CSRFProtect\ncsrf = CSRFProtect(app)\n\n@app.route('/transfer', methods=['POST'])\ndef transfer():\n amount = request.form['amount']\n # CSRF token validated automatically\n process_transfer(amount)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"csrf_missing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = callback()\n# May fail if not callable\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing callable() check**\n\n**Fix:**\n```python\nif callable(callback):\n result = callback()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_callable()_check"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport os\nold = os.getcwd()\nos.chdir('/tmp')\ntry: process()\nfinally: os.chdir(old)\n```"
},
{
"role": "assistant",
"content": "**Issue: contextlib.chdir**\n\n**Fix:**\n```python\nfrom contextlib import chdir\nimport os\nwith chdir('/tmp'):\n process()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"contextlib.chdir"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = text.replace('a', '').replace('b', '').replace('c', '')\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.translate()**\n\n**Fix:**\n```python\ntranslator = str.maketrans('', '', 'abc')\nresult = text.translate(translator)\n# Single pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.translate()"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport random\ntoken = random.randint(0, 999999)\n```"
},
{
"role": "assistant",
"content": "**Issue: Insecure Random**\n\n**Fix:**\n```python\nimport secrets\ntoken = secrets.token_urlsafe(32)\n# Cryptographically secure\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"insecure_random"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nheaders = {'Authorization': 'Bearer ' + token}\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Auth Token Refresh**\n\n**Fix:**\n```python\ndef get_token():\n if is_expired(token):\n global token\n token = refresh_token()\n return 'Bearer ' + token\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_auth_token_refresh"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nimport os\npath = os.path.join('/data', fn)\nos.makedirs(os.path.dirname(path))\n```"
},
{
"role": "assistant",
"content": "**Issue: os.path Operations**\n\n**Fix:**\n```python\nfrom pathlib import Path\npath = Path('/data') / fn\npath.parent.mkdir(parents=True, exist_ok=True)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"os.path_operations"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = []\nfor url in urls:\n results.append(await fetch(url))\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.gather**\n\n**Fix:**\n```python\nresults = await asyncio.gather(*[fetch(u) for u in urls])\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.gather"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwhile True:\n check(); time.sleep(5)\n```"
},
{
"role": "assistant",
"content": "**Issue: Polling File Watch**\n\n**Fix:**\n```python\nfrom watchdog.observers import Observer\nfrom watchdog.events import FileSystemEventHandler\nclass H(FileSystemEventHandler):\n def on_modified(self, e):\n if not e.is_directory: process(e.src_path)\nObserver().schedule(H(), '/data').start()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"polling_file_watch"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif (result := expensive_func()):\n process(result)\n```"
},
{
"role": "assistant",
"content": "**Issue: walrus Operator Misuse**\n\n**Fix:**\n```python\nresult = expensive_func()\nif result: process(result)\n# Walrus operator: use sparingly\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"walrus_operator_misuse"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Builder:\n def set(self, n): return self\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.Self**\n\n**Fix:**\n```python\nfrom typing import Self\nclass Builder:\n def set(self, n) -> Self: return self\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.self"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nexcept Exception:\n sys.exit(1)\n```"
},
{
"role": "assistant",
"content": "**Issue: SystemExit in except**\n\n**Fix:**\n```python\nexcept Exception:\n raise SystemExit(1)\n# or just: sys.exit(1) outside try/except\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"systemexit_in_except"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nd = vars(obj)\n# Fine but __dict__ is more explicit\n```"
},
{
"role": "assistant",
"content": "**Issue: Using vars() Instead of __dict__**\n\n**Fix:**\n```python\nd = obj.__dict__\n# Direct attribute access\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"using_vars()_instead_of___dict__"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Config:\n def __init__(self, h, p, t, r):\n self.h=h; self.p=p; self.t=t; self.r=r\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing dataclass**\n\n**Fix:**\n```python\n@dataclass\nclass Config:\n h: str='localhost'; p: int=8080; t: float=30.0; r: int=3\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_dataclass"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif type(x) == int:\n```"
},
{
"role": "assistant",
"content": "**Issue: type() vs isinstance()**\n\n**Fix:**\n```python\nif isinstance(x, int):\n# isinstance respects inheritance\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"type()_vs_isinstance()"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor i in range(len(items)):\n process(items[i])\n```"
},
{
"role": "assistant",
"content": "**Issue: Repeated len() Call**\n\n**Fix:**\n```python\nfor i, item in enumerate(items):\n process(item)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"repeated_len()_call"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass PaymentProcessor:\n def process(self):\n pass # Base class with no implementation\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing abc for Abstract Base Class**\n\n**Fix:**\n```python\nfrom abc import ABC, abstractmethod\nclass PaymentProcessor(ABC):\n @abstractmethod\n def process(self):\n '''Subclasses must implement'''\n pass\nclass StripeProcessor(PaymentProcessor):\n def process(self):\n return stripe.charge()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_abc_for_abstract_base_class"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# Only unit tests\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Integration Tests**\n\n**Fix:**\n```python\n@pytest.mark.integration\ndef test_flow(client, db):\n r = client.post('/users', json={'name':'Test'})\n assert r.status == 201\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_integration_tests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass User(Base):\n id = Column(Integer, primary_key=True)\n def active(self):\n return self.last_login > datetime.now() - timedelta(days=30)\n # Can't filter: User.active\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Column vs Property Confusion**\n\n**Fix:**\n```python\nfrom sqlalchemy.ext.hybrid import hybrid_property\n@hybrid_property\ndef active(self):\n return self.last_login > datetime.now() - timedelta(days=30)\n@active.expression\ndef active(cls):\n return cls.last_login > datetime.now() - timedelta(days=30)\n# Now filterable: session.query(User).filter(User.active.is_(True))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_column_vs_property_confusion"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nname, _, ext = filename.rsplit('.', 1)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.partition()**\n\n**Fix:**\n```python\nname, sep, ext = filename.rpartition('.')\n# Faster, no ValueError\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.partition()"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor i, item in enumerate(items):\n process(item)\n if i % 100 == 0: print(f\"Processed {i}/{len(items)}\")\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing CLI Progress Bar**\n\n**Fix:**\n```python\nfrom rich.progress import Progress\nwith Progress() as progress:\n task = progress.add_task(\"Processing...\", total=len(items))\n for item in items:\n process(item)\n progress.update(task, advance=1)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_cli_progress_bar"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync with session.get(url) as r:\n return await r.json()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing aiohttp Timeout**\n\n**Fix:**\n```python\nasync with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as r:\n return await r.json()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_aiohttp_timeout"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndf = pd.read_csv('large.csv')\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas Memory Waste**\n\n**Fix:**\n```python\ndf = pd.read_csv('large.csv',\n dtype={'name': 'category', 'age': 'int32'},\n usecols=['name', 'age'])\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_memory_waste"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def fetch():\n return await slow_call()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing asyncio.timeout**\n\n**Fix:**\n```python\nasync def fetch():\n async with asyncio.timeout(5.0):\n return await slow_call()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_asyncio.timeout"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef test_timeout():\n start = time.time()\n slow_operation()\n elapsed = time.time() - start\n assert elapsed > 0.1 # Flaky on slow machines\n```"
},
{
"role": "assistant",
"content": "**Issue: Flaky time-dependent test**\n\n**Fix:**\n```python\ndef test_timeout(mocker):\n clock = mocker.patch('time.time')\n clock.return_value = 1000.0\n slow_operation()\n clock.assert_called() # Test logic, not timing\n```"
}
],
"source": "python_training",
"tags": [
"python",
"flaky_time-dependent_test"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef set_status(status: str):\n # Accepts any string, including typos\n db.set(\"status\", status)\n```"
},
{
"role": "assistant",
"content": "**Issue: Literal Types for Restricted Values**\n\n**Fix:**\n```python\nfrom typing import Literal\ndef set_status(status: Literal['active', 'pending', 'closed']):\n db.set(\"status\", status)\n# Type checker restricts to exact values\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"literal_types_for_restricted_values"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nvalid = True\nfor item in items:\n if not item.valid:\n valid = False; break\n```"
},
{
"role": "assistant",
"content": "**Issue: all for Validation**\n\n**Fix:**\n```python\nvalid = all(item.valid for item in items)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"all_for_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = []\nfor lst in lists:\n result.extend(lst)\nreturn result\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing itertools.chain**\n\n**Fix:**\n```python\nfrom itertools import chain\nreturn list(chain.from_iterable(lists))\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_itertools.chain"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nuser = {'name': 'Alice', 'age': 30, 'email': 'a@b.com'}\n```"
},
{
"role": "assistant",
"content": "**Issue: NamedTuple vs dict**\n\n**Fix:**\n```python\nfrom typing import NamedTuple\nclass User(NamedTuple):\n name: str; age: int; email: str\nuser = User('Alice', 30, 'a@b.com')\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"namedtuple_vs_dict"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nAPI_KEY = 'sk-1234567890abcdef'\nclient = Client(api_key=API_KEY)\n```"
},
{
"role": "assistant",
"content": "**Issue: Hardcoded Secret**\n\n**Fix:**\n```python\nimport os\nfrom dotenv import load_dotenv\nload_dotenv()\nAPI_KEY = os.environ['API_KEY']\n```"
}
],
"source": "python_training",
"tags": [
"python",
"hardcoded_secret"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry: process_payment()\nexcept Exception: pass # Silent failure!\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Error Reporting**\n\n**Fix:**\n```python\ntry: process_payment()\nexcept ValidationError as e:\n logger.warning(\"Payment validation failed: %s\", e)\n return {\"error\": \"Invalid data\"}\nexcept Exception as e:\n logger.exception(\"Unexpected payment error\")\n sentry_sdk.capture_exception(e)\n raise\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_error_reporting"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process_user(user_id):\n user = session.query(User).get(user_id)\n session.close()\n return user.email # DetachedInstanceError\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Detached Instance Error**\n\n**Fix:**\n```python\ndef process_user(user_id):\n user = session.query(User).get(user_id)\n email = user.email # Access before close\n session.close()\n return email\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_detached_instance_error"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry: process(None)\nexcept ValueError: pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Testing Exceptions Wrongly**\n\n**Fix:**\n```python\nwith pytest.raises(ValueError, match='Input cannot be None'):\n process(None)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"testing_exceptions_wrongly"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n$.ajax({\n url: '/api/update',\n method: 'POST',\n data: {value: 42}\n})\n```"
},
{
"role": "assistant",
"content": "**Issue: Django - Missing CSRF for AJAX**\n\n**Fix:**\n```python\n$.ajax({\n url: '/api/update',\n method: 'POST',\n data: {value: 42, csrfmiddlewaretoken: '{{ csrf_token }}'},\n headers: {'X-CSRFToken': getCookie('csrftoken')}\n})\n```"
}
],
"source": "python_training",
"tags": [
"python",
"django_-_missing_csrf_for_ajax"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(data):\n global result\n result = transform(data)\n```"
},
{
"role": "assistant",
"content": "**Issue: Global Variable Mutation**\n\n**Fix:**\n```python\ndef process(data):\n return transform(data)\n# Return values instead of mutating globals"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"global_variable_mutation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndata = large_dataset\nhandlers = [lambda i=i: process(data[i]) for i in range(1000)]\n```"
},
{
"role": "assistant",
"content": "**Issue: Memory Leak in Closure**\n\n**Fix:**\n```python\ndef mk(i): return lambda: process(data[i])\nhandlers = [mk(i) for i in range(1000)]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"memory_leak_in_closure"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef count_words(text):\n counts = {}\n for word in text.split():\n if word in counts:\n counts[word] += 1\n else:\n counts[word] = 0\n```"
},
{
"role": "assistant",
"content": "**Issue: Inefficient data processing**\n\n**Fix:**\n```python\nfrom collections import Counter\ndef count_words(text):\n return Counter(text.split())\n```"
}
],
"source": "python_training",
"tags": [
"python",
"inefficient_data_processing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nf = Path(request.args.get('file'))\nreturn f.read_text()\n```"
},
{
"role": "assistant",
"content": "**Issue: Path Traversal Vulnerability**\n\n**Fix:**\n```python\nALLOWED = Path('/uploads').resolve()\ndef get(name):\n p = (ALLOWED / name).resolve()\n if not str(p).startswith(str(ALLOWED)): raise ValueError('Denied')\n return p.read_text()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"path_traversal_vulnerability"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass DB:\n def __init__(self): self.conn = expensive_connect()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Proxy Pattern**\n\n**Fix:**\n```python\nclass DBProxy:\n def __init__(self): self._db = None\n @property\n def db(self):\n if self._db is None: self._db = DB()\n return self._db\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_proxy_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nasync def fetch(url):\n async with aiohttp.ClientSession() as s:\n async with s.get(url) as r: return await r.json()\n```"
},
{
"role": "assistant",
"content": "**Issue: aiohttp Session Per Request**\n\n**Fix:**\n```python\nsession = aiohttp.ClientSession()\nasync def fetch(url):\n async with session.get(url) as r: return await r.json()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"aiohttp_session_per_request"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\napp = Flask(__name__)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing health check**\n\n**Fix:**\n```python\napp = Flask(__name__)\n\n@app.route('/health')\ndef health():\n return {'status': 'healthy'}\n\n# Docker HEALTHCHECK\n# docker build --health-cmd='curl -f http://localhost:5000/health'\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_health_check"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef execute(action, *args):\n if action == 'save': save(*args)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Command Pattern**\n\n**Fix:**\n```python\nfrom abc import ABC, abstractmethod\nclass Command(ABC):\n @abstractmethod\n def execute(self): pass\n def undo(self): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_command_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif ext == '.jpg' or ext == '.png' or ext == '.gif':\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing str.startswith tuple**\n\n**Fix:**\n```python\nif ext.startswith(('.jpg', '.png', '.gif')):\n# Tuple check - cleaner\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_str.startswith_tuple"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nd = {}\nif key not in d:\n d[key] = []\nd[key].append(item)\n```"
},
{
"role": "assistant",
"content": "**Issue: Using dict.get() with default factory**\n\n**Fix:**\n```python\nfrom collections import defaultdict\nd = defaultdict(list)\nd[key].append(item)\n# defaultdict handles missing keys automatically\n```"
}
],
"source": "python_training",
"tags": [
"python",
"using_dict.get()_with_default_factory"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlogger.info(f\"User {user_id} logged in from {ip_address}\")\n# Hard to parse and search\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Structured Logging**\n\n**Fix:**\n```python\nimport json\nclass JSONFormatter(logging.Formatter):\n def format(self, record):\n log_data = {\n \"timestamp\": self.formatTime(record),\n \"level\": record.levelname,\n \"message\": record.getMessage(),\n }\n return json.dumps(log_data)\nformatter = JSONFormatter()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_structured_logging"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef create(name: str, email: str, age: int): pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.Unpack**\n\n**Fix:**\n```python\nfrom typing import Unpack, TypedDict\nclass U(TypedDict, total=False): name: str; email: str; age: int\ndef create(**kw: Unpack[U]): pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.unpack"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nrequests==2.28\nflask\nnumpy\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing requirements.txt pinning**\n\n**Fix:**\n```python\nflask==2.3.2\nrequests==2.28.2\nnumpy==1.24.3\n# Pin all dependencies for reproducible builds\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_requirements.txt_pinning"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass User(Base):\n posts = relationship('Post', lazy='dynamic')\n # Each template access triggers query\n```"
},
{
"role": "assistant",
"content": "**Issue: SQLAlchemy Lazy Loading in Production**\n\n**Fix:**\n```python\nclass User(Base):\n posts = relationship('Post', lazy='joined')\n # Or use explicit options: options(joinedload(User.posts))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"sqlalchemy_lazy_loading_in_production"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@property\ndef age(self): return self._age\n@age.setter\ndef age(self, v): self._age = v\n```"
},
{
"role": "assistant",
"content": "**Issue: Property Without Validation**\n\n**Fix:**\n```python\n@property\ndef age(self): return self._age\n@age.setter\ndef age(self, v):\n if not isinstance(v, int) or v < 0: raise ValueError('Invalid age')\n self._age = v\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"property_without_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresult = search(data)\nif result:\n print(result)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing walrus operator**\n\n**Fix:**\n```python\nif result := search(data):\n print(result)\n# Assignment expression (Python 3.8+)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_walrus_operator"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nwhile not data_available(): time.sleep(0.1)\n```"
},
{
"role": "assistant",
"content": "**Issue: threading.Condition**\n\n**Fix:**\n```python\ncond = threading.Condition()\ndef producer():\n with cond:\n produce(); cond.notify()\ndef consumer():\n with cond:\n while not data_available(): cond.wait()\n consume()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"threading.condition"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif status == 200:\n return handle_ok(data)\nelif status == 404:\n return handle_not_found()\nelif status == 500:\n return handle_error()\nelse:\n return handle_unknown()\n```"
},
{
"role": "assistant",
"content": "**Issue: Not using match/case (3.10+)**\n\n**Fix:**\n```python\nmatch status:\n case 200:\n return handle_ok(data)\n case 404:\n return handle_not_found()\n case 500:\n return handle_error()\n case _:\n return handle_unknown()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"not_using_match/case_(3.10+)"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# views.py\ndef post_list(request):\n posts = Post.objects.all()\n # Template accesses post.author.name -> N+1\n return render(request, 'posts.html', {'posts': posts})\n```"
},
{
"role": "assistant",
"content": "**Issue: Django - N+1 Query**\n\n**Fix:**\n```python\nfrom django.db.models import Prefetch\ndef post_list(request):\n posts = Post.objects.select_related('author').all()\n # Single query with JOIN\n return render(request, 'posts.html', {'posts': posts})\n```"
}
],
"source": "python_training",
"tags": [
"python",
"django_-_n+1_query"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Cache:\n def get(self, k): return self._s.get(k)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Generic Class**\n\n**Fix:**\n```python\nfrom typing import Generic, TypeVar\nK, V = TypeVar('K'), TypeVar('V')\nclass Cache(Generic[K,V]):\n def __init__(self): self._s: dict[K,V] = {}\n def get(self, k: K) -> V|None: return self._s.get(k)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_generic_class"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef append(item, lst=[]):\n lst.append(item)\n return lst\n```"
},
{
"role": "assistant",
"content": "**Issue: Mutable Default Argument**\n\n**Fix:**\n```python\ndef append(item, lst=None):\n if lst is None: lst = []\n lst.append(item)\n return lst\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"mutable_default_argument"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Cache:\n def __init__(self): self._store = {}\n def get(self, key): return self._store.get(key)\n def set(self, key, value): self._store[key] = value\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing for Generic Classes**\n\n**Fix:**\n```python\nfrom typing import Generic, TypeVar\nK = TypeVar('K')\nV = TypeVar('V')\nclass Cache(Generic[K, V]):\n def __init__(self): self._store: dict[K, V] = {}\n def get(self, key: K) -> V | None: return self._store.get(key)\n def set(self, key: K, value: V) -> None: self._store[key] = value\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing_for_generic_classes"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nresults = executor.map(task, items)\n# Can't cancel individual tasks\n```"
},
{
"role": "assistant",
"content": "**Issue: map vs submit**\n\n**Fix:**\n```python\nfutures = [executor.submit(task, i) for i in items]\nresults = [f.result() for f in futures]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"map_vs_submit"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nstack = []\nstack.append(item)\nitem = stack.pop()\n```"
},
{
"role": "assistant",
"content": "**Issue: list as Stack**\n\n**Fix:**\n```python\nfrom collections import deque\nstack = deque()\nstack.append(item)\nitem = stack.pop()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"list_as_stack"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process_payments(payments):\n for payment in payments:\n process(payment) # One failure stops all\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Error Recovery**\n\n**Fix:**\n```python\nresults = {'success': [], 'errors': []}\nfor payment in payments:\n try: process(payment); results['success'].append(payment.id)\n except Exception as e: results['errors'].append({'id': payment.id, 'error': str(e)})\nreturn results\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_error_recovery"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nCOLOR_RED = 1\nCOLOR_GREEN = 2\nCOLOR_BLUE = 3\n```"
},
{
"role": "assistant",
"content": "**Issue: Manual Enum with constants**\n\n**Fix:**\n```python\nfrom enum import Enum\nclass Color(Enum):\n RED = 1\n GREEN = 2\n BLUE = 3\n# Type-safe, IDE autocomplete, prevents typos\n```"
}
],
"source": "python_training",
"tags": [
"python",
"manual_enum_with_constants"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nsorted(data, key=lambda x: x['name'])\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing operator.itemgetter**\n\n**Fix:**\n```python\nfrom operator import itemgetter\nsorted(data, key=itemgetter('name'))\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_operator.itemgetter"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor i in range(len(items)-1, -1, -1):\n process(items[i])\n```"
},
{
"role": "assistant",
"content": "**Issue: reversed List**\n\n**Fix:**\n```python\nfor item in reversed(items):\n process(item)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"reversed_list"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Config(TypedDict):\n host: str; port: int; debug: bool\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing typing.NotRequired**\n\n**Fix:**\n```python\nclass Config(TypedDict):\n host: str; port: int; debug: NotRequired[bool]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_typing.notrequired"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlongest = ''\nfor word in words:\n if len(word) > len(longest): longest = word\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing max/min with key**\n\n**Fix:**\n```python\nlongest = max(words, key=len)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_max/min_with_key"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process()\nexcept KeyboardInterrupt:\n logger.info('Cancelled')\nexcept:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Except KeyboardInterrupt**\n\n**Fix:**\n```python\ntry:\n process()\nexcept KeyboardInterrupt:\n logger.info('Cancelled')\n raise\nexcept Exception as e:\n handle(e)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"except_keyboardinterrupt"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# No __all__ - exports everything\n```"
},
{
"role": "assistant",
"content": "**Issue: Using __all__**\n\n**Fix:**\n```python\n__all__ = ['public_func', 'PublicClass']\n# Controls public API\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"using___all__"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n# No coverage tracking\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Coverage**\n\n**Fix:**\n```python\n# pytest.ini\naddopts = --cov=myapp --cov-report=term-missing --cov-fail-under=80\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_coverage"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@app.get('/users/{user_id}')\ndef get_user(user_id: int):\n db = get_database_connection() # Called every request\n return db.get_user(user_id)\n```"
},
{
"role": "assistant",
"content": "**Issue: FastAPI - Missing dependency injection**\n\n**Fix:**\n```python\nfrom fastapi import Depends\n@asynccontextmanager\nasync def get_db():\n db = SessionLocal()\n try:\n yield db\n finally:\n db.close()\n\n@app.get('/users/{user_id}')\ndef get_user(user_id: int, db: Session = Depends(get_db)):\n return db.get_user(user_id)\n```"
}
],
"source": "python_training",
"tags": [
"python",
"fastapi_-_missing_dependency_injection"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfor idx, row in df.iterrows(): process(row)\n```"
},
{
"role": "assistant",
"content": "**Issue: Pandas iterrows**\n\n**Fix:**\n```python\nprocess(df['col1'], df['col2'])\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"pandas_iterrows"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nlogging.basicConfig(filename='app.log', level=logging.INFO)\n# Single log file grows forever\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Log Rotation**\n\n**Fix:**\n```python\nfrom logging.handlers import RotatingFileHandler\nhandler = RotatingFileHandler('app.log', maxBytes=10*1024*1024, backupCount=5)\nlogger.addHandler(handler)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_log_rotation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\npip install flask requests\npython app.py\n```"
},
{
"role": "assistant",
"content": "**Issue: Not using virtual environment**\n\n**Fix:**\n```python\npython -m venv .venv\nsource .venv/bin/activate # Linux/Mac\n# .venv\\Scripts\\activate # Windows\npip install -r requirements.txt\npython app.py\n```"
}
],
"source": "python_training",
"tags": [
"python",
"not_using_virtual_environment"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass UserSerializer(serializers.ModelSerializer):\n class Meta:\n model = User\n fields = '__all__'\n```"
},
{
"role": "assistant",
"content": "**Issue: Django REST - Serializer field exposure**\n\n**Fix:**\n```python\nclass UserSerializer(serializers.ModelSerializer):\n class Meta:\n model = User\n fields = ['id', 'username', 'email']\n # Never expose password, is_active, etc.\n```"
}
],
"source": "python_training",
"tags": [
"python",
"django_rest_-_serializer_field_exposure"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif shape_type == 'circle':\n shape = Circle()\nelif shape_type == 'square':\n shape = Square()\nelif shape_type == 'triangle':\n shape = Triangle()\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Factory for polymorphic creation**\n\n**Fix:**\n```python\nfrom abc import ABC\nclass Shape(ABC): pass\n\nclass ShapeFactory:\n _creators = {\n 'circle': Circle,\n 'square': Square,\n 'triangle': Triangle,\n }\n @classmethod\n def create(cls, shape_type: str) -> Shape:\n creator = cls._creators.get(shape_type)\n if not creator:\n raise ValueError(f'Unknown shape: {shape_type}')\n return creator()\n```"
}
],
"source": "python_training",
"tags": [
"python",
"missing_factory_for_polymorphic_creation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nfrom typing import List, Dict\ndef get_users() -> List[Dict]:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Generic Type Hints**\n\n**Fix:**\n```python\nfrom typing import TypedDict\nclass User(TypedDict):\n id: int\n name: str\n\ndef get_users() -> list[User]:\n pass"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"generic_type_hints"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nif isinstance(x, int) or isinstance(x, float):\n```"
},
{
"role": "assistant",
"content": "**Issue: Multiple isinstance() checks**\n\n**Fix:**\n```python\nif isinstance(x, (int, float)):\n# Tuple check\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"multiple_isinstance()_checks"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass Notifier:\n def send(self, msg): pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Decorator Pattern**\n\n**Fix:**\n```python\nclass RetryDecorator:\n def __init__(self, wrapped): self.wrapped = wrapped\n def send(self, msg):\n for _ in range(3):\n try: return self.wrapped.send(msg)\n except: pass\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_decorator_pattern"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef __exit__(self): pass\n# Ignores exception info\n```"
},
{
"role": "assistant",
"content": "**Issue: Context Manager Without __exit__ args**\n\n**Fix:**\n```python\ndef __exit__(self, exc_type, exc_val, exc_tb):\n # Always handle exception args\n return False # Don't suppress exceptions\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"context_manager_without___exit___args"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef process(data: Union[str, list, dict]):\n if isinstance(data, str):\n return data.upper()\n # Type checker still sees Union\n```"
},
{
"role": "assistant",
"content": "**Issue: TypeGuard for Narrowing**\n\n**Fix:**\n```python\nfrom typing import TypeGuard\ndef is_string(data: object) -> TypeGuard[str]:\n return isinstance(data, str)\ndef process(data: Union[str, list, dict]):\n if is_string(data):\n return data.upper() # Type narrowed to str\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"typeguard_for_narrowing"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nr = requests.get(url)\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Headers in requests**\n\n**Fix:**\n```python\nheaders = {'User-Agent': 'MyApp/1.0', 'Accept': 'application/json'}\nr = requests.get(url, headers=headers)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_headers_in_requests"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\n@patch('db.connect')\n@patch('db.query')\n@patch('db.fetch')\n@patch('db.close')\n@patch('utils.format')\n@patch('utils.validate')\ndef test_create_user(mock_validate, mock_format, mock_close, ...):\n # Testing nothing real\n```"
},
{
"role": "assistant",
"content": "**Issue: Over-mocking**\n\n**Fix:**\n```python\ndef test_create_user(db_session):\n # Use test database, mock only external APIs\n user = User(name='Alice')\n db_session.add(user)\n db_session.commit()\n assert User.query.filter_by(name='Alice').first() is not None\n```"
}
],
"source": "python_training",
"tags": [
"python",
"over-mocking"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nrequests.post(url, data=json.dumps(data))\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing JSON Content-Type**\n\n**Fix:**\n```python\nrequests.post(url, json=data)\n# Sets Content-Type automatically\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_json_content-type"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ndef first(items):\n return items[0]\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Generic Type**\n\n**Fix:**\n```python\nfrom typing import TypeVar, Sequence\nT = TypeVar('T')\ndef first(items: Sequence[T]) -> T:\n return items[0]\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_generic_type"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nclass AsyncDB:\n async def __aenter__(self): ...\n async def __aexit__(self, *a): ...\n```"
},
{
"role": "assistant",
"content": "**Issue: asynccontextmanager**\n\n**Fix:**\n```python\n@asynccontextmanager\nasync def get_db():\n db = await connect()\n try: yield db\n finally: await db.close()\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"asynccontextmanager"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\nconfig = json.loads(os.environ['CONFIG_JSON'])\n# No validation - missing keys cause runtime errors\n```"
},
{
"role": "assistant",
"content": "**Issue: Missing Configuration Schema Validation**\n\n**Fix:**\n```python\nfrom pydantic import BaseModel, Field\nclass AppConfig(BaseModel):\n host: str = Field(default='localhost')\n port: int = Field(default=8080, ge=1, le=65535)\n db_url: str = Field(..., description='Database connection string')\ntry:\n config = AppConfig(**json.loads(os.environ['CONFIG_JSON']))\nexcept Exception as e:\n logger.error(\"Invalid config: %s\", e); sys.exit(1)\n```"
}
],
"source": "python_training_expansion",
"tags": [
"python",
"missing_configuration_schema_validation"
]
},
{
"messages": [
{
"role": "user",
"content": "Review this Python code:\n\n```python\ntry:\n process()\nexcept:\n pass\n```"
},
{
"role": "assistant",
"content": "**Issue: Bare except**\n\n**Fix:**\n```python\ntry:\n process()\nexcept (ValueError, TypeError) as e:\n logger.error('Processing failed: %s', e)\n# Catch specific exceptions\n```"
}
],
"source": "python_training",
"tags": [
"python",
"bare_except"
]
}
]