Docs: Fix stdlib json-logging

Co-Authored-By: Codex <codex@openai.com>

Author: heikkitoivonen

docs/stdlib/json.md

@@ -7,12 +7,11 @@ The `json` module provides JSON serialization and deserialization.
 | Function | Time | Space | Notes |
 |----------|------|-------|-------|
 | `json.dumps(obj)` | O(n) | O(n) | Serialize to string |
-| `json.dump(obj, fp)` | O(n) | O(k) | Write to file; k = buffer size (streams output) |
+| `json.dump(obj, fp)` | O(n) | O(d) | d = nesting depth; writes incrementally |
 | `json.loads(s)` | O(n) | O(n) | Parse JSON string |
-| `json.load(fp)` | O(n) | O(n) | Read from file |
+| `json.load(fp)` | O(n) | O(n) | Reads full file into memory |
 | `JSONEncoder.encode()` | O(n) | O(n) | Custom encoder |
 | `JSONDecoder.decode()` | O(n) | O(n) | Custom decoder |
-| `JSONDecodeError` | - | - | Exception for parse errors (subclass of ValueError) |
 
 ## Serialization (dumps/dump)
 
@@ -89,7 +88,7 @@ data = {'key': 'value', 'items': list(range(1000))}
 with open('data.json', 'w') as f:
     json.dump(data, f)  # O(n) serialization + write
 
-# Streaming: O(1) memory, O(n) time
+# Streaming: O(d) extra memory, O(n) time (object itself still in memory)
 # Writes to file incrementally
 ```
 
@@ -216,10 +215,7 @@ json_str = json.dumps(person, default=custom_serializer)  # O(n)
 
 ## Version Notes
 
-- **Python 2.6+**: Basic json module
-- **Python 3.4+**: Better performance
-- **Python 3.6+**: Preserves key order (dicts ordered)
-- **Python 3.9+**: Performance improvements
+- **Python 3.x**: `json` module is available
 
 ## Common Issues
 

docs/stdlib/keyword.md

@@ -6,8 +6,8 @@ The `keyword` module provides access to Python's set of keywords and allows chec
 
 | Operation | Time | Space | Notes |
 |-----------|------|-------|-------|
-| `keyword.iskeyword()` | O(1) | O(1) | Hash-based lookup |
-| Access keyword list | O(1) | O(1) | Pre-computed |
+| `keyword.iskeyword()` | O(n) | O(1) | n = string length |
+| Access keyword list | O(1) | O(1) | Pre-computed list |
 
 ## Checking for Keywords
 

docs/stdlib/linecache.md

@@ -9,7 +9,7 @@ The `linecache` module allows efficient retrieval of individual lines from Pytho
 | `getline()` first access | O(n) | O(n) | Loads entire file into cache; n = file lines |
 | `getline()` cached | O(1) | O(1) | Returns cached line |
 | `checkcache()` | O(k) | O(1) | k = cached files; checks mtime for invalidation |
-| `clearcache()` | O(1) | O(1) | Clear all cached files |
+| `clearcache()` | O(k) | O(1) | k = cached files; clears entries |
 
 ## Getting Lines from Files
 
@@ -34,11 +34,11 @@ for i in range(1, 4):
 ```python
 import linecache
 
-# Clear cache - O(1)
-linecache.checkcache()
+# Clear entire cache - O(k)
+linecache.clearcache()
 
-# Clear specific file - O(1)
-linecache.checkcache('myfile.py')
+# Invalidate cache entries if files changed
+linecache.checkcache()
 ```
 
 ## Related Documentation

docs/stdlib/locale.md

@@ -7,11 +7,11 @@ The `locale` module provides access to the POSIX locale database for language, c
 | Operation | Time | Space | Notes |
 |-----------|------|-------|-------|
 | `getlocale()` | O(1) | O(1) | Get current locale |
-| `setlocale(category, locale)` | O(1) | O(1) | Set locale |
+| `setlocale(category, locale)` | Varies | Varies | Depends on platform/C library |
 | `localeconv()` | O(1) | O(1) | Get locale info |
-| `format(format, value)` | O(n) | O(n) | n = value length |
+| `format_string(format, value)` | O(n) | O(n) | n = formatted output size |
 | `strxfrm(string)` | O(n) | O(n) | Transform string |
-| `strcoll(s1, s2)` | O(n) | O(n) | Compare locale-aware |
+| `strcoll(s1, s2)` | O(n) | O(1) | Compare locale-aware |
 
 ## Common Operations
 
@@ -58,7 +58,7 @@ import locale
 # Set German locale - O(1)
 locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')
 
-# O(n) format number - n = value length
+# O(n) format number - n = formatted output size
 value = 1234567.89
 formatted = locale.format_string("%.2f", value)
 # Returns: "1.234.567,89"
@@ -173,12 +173,12 @@ formatted = cache.format_number(1234.56, "%.2f")  # O(1)
 ```python
 import locale
 
-# Bad: Multiple setlocale calls - O(k) per call
+# Bad: Multiple setlocale calls - varies by platform
 for i in range(100):
-    locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')  # O(1)
+    locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')
     value = locale.format_string("%.2f", i)
 
-# Good: Set once - O(1) setup
+# Good: Set once (avoids repeated C library calls)
 locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')
 for i in range(100):
     value = locale.format_string("%.2f", i)  # O(n)
@@ -211,10 +211,8 @@ def efficient_sort(strings):
 
 ## Version Notes
 
-- **Python 2.6+**: Basic locale support
-- **Python 3.x**: Full locale support
-- **Platform-specific**: Available on Unix/Linux and Windows
-- **Encoding**: UTF-8 recommended for modern systems
+- **Python 3.x**: `locale` module is available
+- **Platform-specific**: Behavior depends on the underlying C library and locale data
 
 ## Related Documentation
 

docs/stdlib/logging.md

@@ -6,8 +6,8 @@ The `logging` module provides functionality for flexible event logging, with dif
 
 | Operation | Time | Space | Notes |
 |-----------|------|-------|-------|
-| `logging.basicConfig()` | O(1) | O(1) | Configure logging |
-| `logger.debug/info/warning/error()` | O(k) | O(1) | k = message length |
+| `logging.basicConfig()` | Varies | Varies | Creates handlers/formatters |
+| `logger.debug/info/warning/error()` | Varies | Varies | Depends on handlers, filters, and I/O |
 | `getLogger()` | O(1) avg | O(1) | Get logger instance |
 | Formatting message | O(k) | O(k) | k = formatted string |
 
@@ -18,13 +18,13 @@ The `logging` module provides functionality for flexible event logging, with dif
 ```python
 import logging
 
-# Configure logging - O(1)
+# Configure logging - cost depends on handlers
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s'
 )
 
-# Log messages - O(k)
+# Log messages - cost depends on handlers and I/O
 logging.debug('Debug message')      # Not shown (level=INFO)
 logging.info('Info message')        # O(10)
 logging.warning('Warning message')  # O(15)
@@ -42,7 +42,7 @@ logger = logging.getLogger(__name__)
 # Set level - O(1)
 logger.setLevel(logging.DEBUG)
 
-# Log messages - O(k)
+# Log messages - cost depends on handlers and I/O
 logger.debug('Debug: %s', variable)      # O(k)
 logger.info('Processing: %s', item)      # O(k)
 logger.warning('Issue: %s', issue)       # O(k)
@@ -73,12 +73,12 @@ formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(messag
 file_handler.setFormatter(formatter)
 console_handler.setFormatter(formatter)
 
-# Add handlers - O(1) each
+# Add handlers - O(1) each (list append)
 logger.addHandler(file_handler)      # O(1)
 logger.addHandler(console_handler)   # O(1)
 
-# Log - O(k)
-logger.info('Application started')   # O(k)
+# Log - cost depends on handlers and I/O
+logger.info('Application started')
 ```
 
 ## Log Levels
@@ -100,7 +100,7 @@ logger.setLevel(logging.WARNING)
 
 # Only WARNING and above are logged
 logger.debug('Not logged')      # Skipped
-logger.warning('Is logged')     # O(k)
+logger.warning('Is logged')
 ```
 
 ## Common Patterns
@@ -121,16 +121,16 @@ logger = logging.getLogger(__name__)
 
 def process_file(filename):
     try:
-        logger.info(f'Processing {filename}')      # O(k)
+        logger.info(f'Processing {filename}')
         with open(filename) as f:
             data = f.read()  # O(n)
-        logger.debug(f'Read {len(data)} bytes')    # O(k)
+        logger.debug(f'Read {len(data)} bytes')
         return process(data)
     except FileNotFoundError:
-        logger.error(f'File not found: {filename}')  # O(k)
+        logger.error(f'File not found: {filename}')
         return None
     except Exception as e:
-        logger.exception(f'Unexpected error: {e}')   # O(k)
+        logger.exception(f'Unexpected error: {e}')
         return None
 ```
 
@@ -144,9 +144,9 @@ logger = logging.getLogger(__name__)
 try:
     result = risky_operation()  # Might fail
 except ValueError as e:
-    logger.error(f'Invalid value: {e}')     # O(k)
+    logger.error(f'Invalid value: {e}')
 except Exception as e:
-    logger.exception('Unexpected error')    # O(k) - includes traceback
+    logger.exception('Unexpected error')    # Includes traceback
 ```
 
 ## Performance Considerations
@@ -172,14 +172,14 @@ logger.debug(f'User {username} logged in')   # Always format string
 ```python
 import logging
 
-# File handler - O(k) to write
+# File handler - cost depends on I/O and buffering
 handler = logging.FileHandler('app.log')
 
 # Buffering affects performance
 # Default: buffered (fast)
 # Unbuffered: flush each write (slow but safer)
 
-# Rotating file handler - O(k) per write
+# Rotating file handler - cost depends on I/O and rollover
 rotating = logging.handlers.RotatingFileHandler(
     'app.log',
     maxBytes=1000000,  # 1MB
@@ -189,9 +189,7 @@ rotating = logging.handlers.RotatingFileHandler(
 
 ## Version Notes
 
-- **Python 2.x**: logging module available
-- **Python 3.x**: Enhanced with better formatting
-- **All versions**: O(k) logging complexity
+- **Python 3.x**: `logging` module is available
 
 ## Related Modules
 

docs/stdlib/lzma.md

@@ -6,11 +6,11 @@ The `lzma` module provides XZ compression and decompression functionality.
 
 | Operation | Time | Space | Notes |
 |-----------|------|-------|-------|
-| `lzma.open(filename)` | O(1) | O(1) | Open file handle |
-| `LZMAFile.read()` | O(m) | O(m) | Decompress all, m = uncompressed size |
+| `lzma.open(filename)` | Varies | Varies | Depends on file I/O and options |
+| `LZMAFile.read()` | O(m) | O(m) | Full read, m = uncompressed size |
 | `LZMAFile.write(data)` | O(n) | O(k) | Compress and write, n = input size |
-| `compress(data)` | O(n) | O(n) | Compress bytes (higher constant than gzip) |
-| `decompress(data)` | O(m) | O(m) | Decompress bytes |
+| `compress(data)` | O(n) | O(n) | One-shot compression |
+| `decompress(data)` | O(m) | O(m) | One-shot decompression |
 
 ## Opening Files
 
@@ -19,9 +19,8 @@ The `lzma` module provides XZ compression and decompression functionality.
 ```python
 import lzma
 
-# Opening LZMA file: O(1) time
-# Just opens file handle
-f = lzma.open('file.xz', 'rb')  # O(1)
+# Opening LZMA file: cost depends on I/O and options
+f = lzma.open('file.xz', 'rb')
 
 # With context manager
 with lzma.open('file.xz', 'rb') as f:
@@ -34,7 +33,7 @@ with lzma.open('file.xz', 'rb') as f:
 import lzma
 
 # Just file handle, minimal memory
-f = lzma.open('file.xz', 'rb')  # O(1) space
+f = lzma.open('file.xz', 'rb')
 ```
 
 ## Reading (Decompression)
@@ -147,13 +146,15 @@ data = lzma.decompress(compressed)  # O(m)
 ```python
 import lzma
 
-# Streaming compression: O(n) time (high constant), O(k) space
+# Streaming compression: O(n) time, O(k) space
 compressor = lzma.LZMACompressor()
 
-result = b''
+# Avoid quadratic behavior by collecting chunks
+parts = []
 for chunk in data_chunks:
-    result += compressor.compress(chunk)  # O(n) total
-result += compressor.flush()  # Finalize
+    parts.append(compressor.compress(chunk))
+parts.append(compressor.flush())  # Finalize
+result = b''.join(parts)
 
 # Memory: large dictionary buffer, not entire data
 ```
@@ -166,9 +167,11 @@ import lzma
 # Streaming decompression: O(m) time, O(k) space
 decompressor = lzma.LZMADecompressor()
 
-result = b''
+# Avoid quadratic behavior by collecting chunks
+parts = []
 for chunk in compressed_chunks:
-    result += decompressor.decompress(chunk)  # O(m) total
+    parts.append(decompressor.decompress(chunk))
+result = b''.join(parts)
 
 # Memory: decompression buffer
 ```
@@ -201,17 +204,17 @@ import lzma
 
 data = large_data
 
-# Fast: preset 0 (still slower than gzip)
+# Fast: preset 0 (still slower than gzip in many cases)
 compressed = lzma.compress(data, preset=0)  # O(n)
-# Size reduction: ~30%
+# Size reduction depends on input data
 
 # Default: preset 6
 compressed = lzma.compress(data, preset=6)  # O(n)
-# Size reduction: ~50%
+# Size reduction depends on input data
 
 # Maximum: preset 9
 compressed = lzma.compress(data, preset=9)  # O(n) with high constant
-# Size reduction: ~55% (best ratio)
+# Size reduction depends on input data
 ```
 
 ## Streaming Decompression
@@ -362,7 +365,7 @@ bz2_result = bz2.compress(data)
 
 # LZMA (XZ): Slow, best compression
 # Time: O(n) with highest constant
-# Ratio: ~55%
+# Ratio depends on input data
 lzma_result = lzma.compress(data)
 ```
 
@@ -415,10 +418,7 @@ with lzma.open('huge.xz', 'rt') as f:
 
 ## Version Notes
 
-- **Python 3.3+**: LZMA module introduced
-- **Python 3.4+**: Enhanced performance
-- **Python 3.6+**: Performance improvements
-- **Python 3.9+**: Better compression options
+- **Python 3.x**: `lzma` module is available
 
 ## Related Documentation