knowledge_library.json

[
  {
    "topic": "python_functions",
    "tags": [
      "python",
      "functions",
      "def",
      "arguments",
      "parameters",
      "return"
    ],
    "content": "Python Functions:\n- Define with `def name(params):`, body indented 4 spaces\n- Parameters: positional args, keyword args (name=value), *args (variadic), **kwargs (keyword variadic)\n- Default values: `def f(x=10)`. NEVER use mutable defaults like `def f(x=[])`.\n- Return values: `return value`. No return = returns None.\n- Type hints: `def add(a: int, b: int) -> int:`. Optional.\n- Docstrings: triple-quoted string right after def line.\n- Lambda: `lambda x: x*2` for inline anonymous functions."
  },
  {
    "topic": "python_classes",
    "tags": [
      "python",
      "classes",
      "oop",
      "self",
      "inheritance",
      "methods"
    ],
    "content": "Python Classes:\n- Define with `class Name:`. Methods take `self` as first param.\n- `__init__(self, ...)` is constructor.\n- Instance variables: `self.var = value` inside __init__.\n- Inheritance: `class Child(Parent):`. Call `super().__init__()` in child __init__.\n- `@property` decorator for computed attributes.\n- `@staticmethod` for methods that don't need self.\n- `@classmethod` with `cls` as first param for factory methods.\n- `__str__` for string representation, `__repr__` for debugging representation."
  },
  {
    "topic": "python_imports",
    "tags": [
      "python",
      "import",
      "modules",
      "packages",
      "from"
    ],
    "content": "Python Imports:\n- `import module` imports the whole module. Access with `module.name`.\n- `from module import name` imports specific name into current namespace.\n- `from module import *` imports all public names (avoid this).\n- `import module as alias` for shorter names.\n- `from module import name as alias` for renaming.\n- Packages: directory with `__init__.py` file. Example: `from package.module import name`.\n- Common imports: `import os`, `import sys`, `import json`, `import re`, `import math`."
  },
  {
    "topic": "python_exceptions",
    "tags": [
      "python",
      "exceptions",
      "error",
      "try",
      "except",
      "finally",
      "raise"
    ],
    "content": "Python Error Handling:\n- `try:` block contains code that might raise an exception.\n- `except ExceptionType as e:` catches specific exception types.\n- `except Exception as e:` catches (almost) all exceptions.\n- `else:` runs if no exception occurred.\n- `finally:` ALWAYS runs (cleanup code).\n- `raise ValueError(\"message\")` to raise an exception.\n- Common exceptions: ValueError, TypeError, KeyError, IndexError, FileNotFoundError, ZeroDivisionError.\n- Context managers: `with open(path) as f:` auto-closes file even on error."
  },
  {
    "topic": "python_strings",
    "tags": [
      "python",
      "strings",
      "format",
      "f-strings",
      "methods",
      "split",
      "join"
    ],
    "content": "Python String Operations:\n- f-strings: `f\"Hello {name}\"` for string formatting.\n- `.format()`: `\"Hello {}\".format(name)`.\n- `.split(sep)`: split into list by separator.\n- `.join(iterable)`: join list into string with separator.\n- `.strip()`, `.lstrip()`, `.rstrip()`: remove whitespace.\n- `.lower()`, `.upper()`, `.title()`, `.capitalize()`: case changes.\n- `.replace(old, new)`: replace substrings.\n- `.startswith(prefix)`, `.endswith(suffix)`: check prefixes/suffixes.\n- `.find(sub)`, `.index(sub)`: find substring position.\n- Slice: `s[start:end:step]`. Reverse: `s[::-1]`."
  },
  {
    "topic": "python_lists",
    "tags": [
      "python",
      "lists",
      "list",
      "array",
      "comprehension",
      "append",
      "slice"
    ],
    "content": "Python Lists:\n- Create: `[1, 2, 3]` or `list(range(5))`.\n- `.append(item)`: add single item to end.\n- `.extend(iterable)`: add multiple items.\n- `.insert(index, item)`: insert at position.\n- `.pop(index)`: remove and return item at index (last if no index).\n- `.remove(value)`: remove first occurrence of value.\n- `.sort()`: sort in place. `.sort(reverse=True)` for descending.\n- `sorted(list)`: returns new sorted list.\n- List comprehension: `[x*2 for x in range(10) if x % 2 == 0]`.\n- Slice: `lst[start:end:step]`. Copy: `lst[:]`.\n- `len(lst)`, `min(lst)`, `max(lst)`, `sum(lst)`."
  },
  {
    "topic": "python_dicts",
    "tags": [
      "python",
      "dictionary",
      "dict",
      "hashmap",
      "keys",
      "values",
      "items"
    ],
    "content": "Python Dictionaries:\n- Create: `{\"key\": \"value\"}` or `dict(a=1, b=2)`.\n- Access: `d[\"key\"]`. Use `d.get(\"key\", default)` to avoid KeyError.\n- Set: `d[\"key\"] = value`.\n- `.keys()`, `.values()`, `.items()` for views.\n- `for k, v in d.items():` for iteration.\n- `key in d` to check existence.\n- `.pop(key)`, `.popitem()` to remove.\n- `.update(other_dict)` to merge.\n- Dict comprehension: `{x: x**2 for x in range(5)}`.\n- `defaultdict` from collections for default values.\n- `Counter` from collections for counting."
  },
  {
    "topic": "algorithm_sorting",
    "tags": [
      "algorithm",
      "sort",
      "sorting",
      "bubble",
      "merge",
      "quick",
      "binary search"
    ],
    "content": "Common Sorting Algorithms:\n- Built-in: `sorted(list)` or `list.sort()`. Uses Timsort (O(n log n)).\n- `sorted(list, key=lambda x: x[1])` for custom sort key.\n- `sorted(list, reverse=True)` for descending.\n- Binary search: `bisect_left(list, x)` from bisect module.\n- Sort by multiple criteria: `sorted(list, key=lambda x: (x.age, x.name))`.\n- Partial sort: `heapq.nsmallest(k, list)` or `heapq.nlargest(k, list)`.\n- Finding min/max with conditions: `min(list, key=func)`."
  },
  {
    "topic": "algorithm_recursion",
    "tags": [
      "algorithm",
      "recursion",
      "recursive",
      "base case",
      "stack",
      "memoization"
    ],
    "content": "Recursion:\n- A function that calls itself with smaller inputs.\n- Must have a BASE CASE to stop recursion (e.g., n <= 1).\n- Must make PROGRESS toward base case each call.\n- Stack limit: Python has ~1000 recursion depth limit.\n- Memoization: cache results with `@functools.lru_cache(maxsize=None)`.\n- Examples: factorial, fibonacci, tree traversal, divide-and-conquer.\n- Iterative alternative: use a stack (list) to simulate recursion.\n- Tail recursion: Python does NOT optimize tail recursion."
  },
  {
    "topic": "algorithm_search",
    "tags": [
      "algorithm",
      "search",
      "linear",
      "binary",
      "bfs",
      "dfs",
      "graph"
    ],
    "content": "Search Algorithms:\n- Linear search: check each element O(n). Works on unsorted data.\n- Binary search: divide-and-conquer on sorted data O(log n). Use bisect module.\n- BFS (Breadth-First Search): uses queue, finds shortest path in unweighted graph.\n- DFS (Depth-First Search): uses stack or recursion, good for exhaustive search.\n- Dijkstra: shortest path in weighted graph. Use `heapq` for priority queue.\n- A*: heuristic-guided search for pathfinding.\n- Graph representation: adjacency list `{node: [neighbors]}` or matrix."
  },
  {
    "topic": "testing_basics",
    "tags": [
      "testing",
      "pytest",
      "unittest",
      "assert",
      "test",
      "tdd"
    ],
    "content": "Python Testing:\n- Use pytest: `pip install pytest`. Run with `pytest` command.\n- Test files named `test_*.py` or `*_test.py`.\n- Test functions named `test_*`.\n- Use `assert` for checks: `assert add(2, 3) == 5`.\n- pytest discovers tests automatically.\n- Fixtures: use `@pytest.fixture` for setup/teardown.\n- `pytest.raises(ExceptionType)` for testing exceptions.\n- `pytest.mark.parametrize` for running same test with multiple inputs.\n- Coverage: `pytest --cov=module` to check code coverage.\n- Test categories: normal cases, edge cases, error cases, boundary values."
  },
  {
    "topic": "testing_patterns",
    "tags": [
      "testing",
      "mock",
      "patch",
      "fixture",
      "integration",
      "unit"
    ],
    "content": "Testing Patterns:\n- Unit test: tests a single function/method in isolation.\n- Integration test: tests multiple components together.\n- Mock: `unittest.mock.patch` or `pytest-mock` to replace dependencies.\n- Arrange-Act-Assert: set up data, execute code, verify result.\n- Given-When-Then: BDD style of describing tests.\n- Test doubles: Dummy, Stub, Spy, Mock, Fake.\n- Coverage metrics: line coverage, branch coverage, path coverage.\n- Property-based testing: `hypothesis` library generates random inputs.\n- Snapshot testing: compare output to saved reference."
  },
  {
    "topic": "code_quality_linting",
    "tags": [
      "code quality",
      "lint",
      "linter",
      "pylint",
      "flake8",
      "formatting"
    ],
    "content": "Code Quality:\n- Linting: automated checking for errors and style issues.\n- flake8: checks PEP 8 style, syntax errors, complexity.\n- pylint: more thorough checking, generates quality score.\n- black: opinionated code formatter (auto-fixes formatting).\n- isort: sorts imports alphabetically.\n- mypy: static type checker for type hints.\n- ruff: fast Rust-based linter and formatter (combines flake8+isort+more).\n- pre-commit: runs checks before git commit.\n- PEP 8: 79-char lines, 4-space indent, snake_case functions, CamelCase classes."
  },
  {
    "topic": "git_basics",
    "tags": [
      "git",
      "version control",
      "commit",
      "branch",
      "merge",
      "clone"
    ],
    "content": "Git Basics:\n- `git init`: initialize new repository.\n- `git clone <url>`: copy remote repository.\n- `git add <file>`: stage changes. `git add .` for all changes.\n- `git commit -m \"message\"`: save staged changes.\n- `git status`: see current state of working directory.\n- `git log`: view commit history. `git log --oneline` for compact view.\n- `git diff`: see unstaged changes. `git diff --staged` for staged changes.\n- `git branch <name>`: create branch. `git checkout <name>`: switch branch.\n- `git merge <branch>`: merge branch into current branch.\n- `git push`: upload commits to remote. `git pull`: download and merge."
  },
  {
    "topic": "file_io",
    "tags": [
      "python",
      "file",
      "io",
      "read",
      "write",
      "csv",
      "json",
      "open"
    ],
    "content": "Python File I/O:\n- Read: `with open(path) as f: content = f.read()`.\n- Read lines: `with open(path) as f: lines = f.readlines()`.\n- Write: `with open(path, 'w') as f: f.write(content)`.\n- Append: `with open(path, 'a') as f: f.write(content)`.\n- CSV: `import csv`. `csv.reader(f)` to read. `csv.writer(f)` to write.\n- JSON: `json.load(f)` to read. `json.dump(data, f)` to write. `json.dumps(obj)` to string.\n- Binary: `open(path, 'rb')` / `open(path, 'wb')`.\n- Path: use `os.path.join(dir, file)` for cross-platform paths.\n- Directory: `os.makedirs(path, exist_ok=True)`. `os.listdir(path)`.\n- Check exists: `os.path.exists(path)`. `os.path.isfile(path)`."
  },
  {
    "topic": "security_basics",
    "tags": [
      "security",
      "injection",
      "validation",
      "xss",
      "sql",
      "sanitize"
    ],
    "content": "Security Best Practices:\n- Input validation: NEVER trust user input. Validate type, length, format.\n- SQL injection: use parameterized queries, never string concatenation.\n- XSS (Cross-Site Scripting): escape output in HTML context.\n- eval() is DANGEROUS: use `ast.literal_eval()` for safe evaluation.\n- exec() is DANGEROUS: avoid entirely. Use restricted environments if necessary.\n- Password hashing: use bcrypt, argon2, or hashlib with salt.\n- HTTPS: always use for network communication.\n- Secret management: use environment variables, never hardcode secrets.\n- Dependency scanning: check for known vulnerabilities (Dependabot).\n- Principle of least privilege: give minimum necessary permissions."
  },
  {
    "topic": "security_sql_injection",
    "tags": [
      "security",
      "sql",
      "injection",
      "parameterized",
      "prepared"
    ],
    "content": "SQL Injection Prevention:\n- BAD: `f\"SELECT * FROM users WHERE name = '{name}'\"` \u2014 allows injection.\n- GOOD: use parameterized queries: `cursor.execute(\"SELECT * FROM users WHERE name = ?\", (name,))`.\n- ORMs (SQLAlchemy, Django) auto-parameterize queries.\n- Escape special characters if you must build strings.\n- Use stored procedures for complex operations.\n- Validate input: reject unexpected characters.\n- Limit database permissions per application user.\n- Monitor for injection attempts in logs."
  },
  {
    "topic": "design_patterns_creational",
    "tags": [
      "design patterns",
      "singleton",
      "factory",
      "builder",
      "prototype"
    ],
    "content": "Creational Design Patterns:\n- Singleton: ensure class has exactly one instance. Module-level variable in Python.\n- Factory: factory function returns objects without specifying exact class.\n- Factory Method: subclass decides which class to instantiate.\n- Abstract Factory: create families of related objects.\n- Builder: separate construction from representation. Build step-by-step.\n- Prototype: clone existing objects instead of creating new ones.\n- Python-specific: use `__new__` for singleton. Use classmethods as factories."
  },
  {
    "topic": "python_concurrency",
    "tags": [
      "python",
      "concurrent",
      "threading",
      "async",
      "multiprocessing",
      "asyncio"
    ],
    "content": "Python Concurrency:\n- Threading: `import threading`. Thread(target=func, args=(...)). GIL limits CPU parallelism.\n- Multiprocessing: `import multiprocessing`. Process(target=func). True parallelism.\n- asyncio: `async def`, `await`, `asyncio.run()`. Cooperative multitasking for I/O.\n- concurrent.futures: ThreadPoolExecutor for threads, ProcessPoolExecutor for processes.\n- Lock: prevent race conditions. `threading.Lock()`. Use `with lock:`.\n- Queue: thread-safe queue. `queue.Queue()`. For producer-consumer patterns.\n- Use asyncio for: web servers, API calls, file I/O operations.\n- Use multiprocessing for: CPU-heavy computations, data processing."
  },
  {
    "topic": "web_requests",
    "tags": [
      "web",
      "http",
      "requests",
      "api",
      "rest",
      "get",
      "post"
    ],
    "content": "HTTP Requests in Python:\n- `import requests`. Install: `pip install requests`.\n- GET: `r = requests.get(url, params={\"key\": \"value\"})`.\n- POST: `r = requests.post(url, json={\"key\": \"value\"})`.\n- Response: `r.status_code`, `r.json()`, `r.text`, `r.headers`.\n- Timeout: `requests.get(url, timeout=5)` to avoid hanging.\n- Error handling: `r.raise_for_status()` or check `r.status_code`.\n- Headers: `requests.get(url, headers={\"Authorization\": \"Bearer token\"})`.\n- Session: `s = requests.Session()` for persistent connections and cookies.\n- Authentication: `requests.get(url, auth=(\"user\", \"pass\"))`."
  },
  {
    "topic": "data_structures_advanced",
    "tags": [
      "data structures",
      "heap",
      "queue",
      "stack",
      "tree",
      "graph",
      "hash"
    ],
    "content": "Advanced Python Data Structures:\n- Heap (min): `import heapq`. `heapq.heappush(heap, item)`. `heapq.heappop(heap)`.\n- Heap (max): push negative values, or use custom key with wrapper.\n- Queue (FIFO): `from collections import deque`. `d.append()` / `d.popleft()`.\n- Stack (LIFO): use list. `.append()` / `.pop()`.\n- Priority Queue: `from queue import PriorityQueue` (thread-safe) or heapq.\n- Default dict: `from collections import defaultdict(lambda: 0)`.\n- Ordered dict: `from collections import OrderedDict` (Python 3.7+ dicts are ordered).\n- Named tuple: `from collections import namedtuple`. `Point = namedtuple('Point', ['x', 'y'])`.\n- ChainMap: combine multiple dicts.\n- Counter: `from collections import Counter`. `Counter(list).most_common(3)`."
  },
  {
    "topic": "tool_call_format",
    "tags": [
      "tool",
      "json",
      "format",
      "nanobot",
      "api",
      "function calling"
    ],
    "content": "Tool Call JSON Format:\n- Write file: {\"tool\": \"fs\", \"action\": \"write\", \"path\": \"filename.py\", \"content\": \"code here\"}\n- Read file: {\"tool\": \"fs\", \"action\": \"read\", \"path\": \"filename.py\"}\n- List dir: {\"tool\": \"fs\", \"action\": \"list\", \"path\": \"directory\"}\n- Check exists: {\"tool\": \"fs\", \"action\": \"exists\", \"path\": \"filename.py\"}\n- Delete: {\"tool\": \"fs\", \"action\": \"delete\", \"path\": \"filename.py\"}\n- Create dir: {\"tool\": \"fs\", \"action\": \"mkdir\", \"path\": \"directory\"}\n- Compile check: {\"tool\": \"compile\", \"path\": \"filename.py\"}\n- Run tests: {\"tool\": \"test\", \"path\": \"directory\"}\n- Search code: {\"tool\": \"search\", \"query\": \"pattern\", \"path\": \".\", \"ext\": \".py\"}\n- Run command: {\"tool\": \"shell\", \"cmd\": \"command string\"}\n- Git init: {\"tool\": \"git\", \"action\": \"init\", \"path\": \".\"}\n- Git commit: {\"tool\": \"git\", \"action\": \"commit\", \"message\": \"commit msg\"}\n- Done: {\"tool\": \"done\"}\n\nAlways emit JSON on a single line. After the tool call, include THOUGHT: and RESULT: on new lines."
  }
]