Claude Skills Blog
Guides, strategies, and insights for Claude Code power users, AI automation, and business transformation.
1053 articles • Updated weekly
Featured Articles
Claude Code Memory: Give Claude Persistent Context Across Every Session
Claude forgets everything between sessions — unless you build a memory system. Here's how to use CLAUDE.md files, /memory commands, and GraphRAG to give Claude persistent context across all your projects.
How to Use Claude Code Skills: Complete Guide (2026)
Learn how to use Claude Code skills to 10x your workflow. Install, combine & orchestrate 2,350+ skills, agents and swarms. Step-by-step guide.
The Complete Guide to AI-Powered SEO in 2026
How to optimize for Google AI Overviews, ChatGPT search, and Perplexity while keeping traditional SEO strong. The new playbook.
New to Claude Code?
Start with 360 free skills. No credit card, no commitment. Install in 2 minutes and see the difference.
Latest Articles
Claude Code for email.contentmanager: Python Email Content Accessors
Read and write EmailMessage body content with Python's email.contentmanager module and Claude Code — email contentmanager ContentManager for the class that maps content types to get and set handler functions allowing EmailMessage to support get_content and set_content with type-specific behaviour, email contentmanager raw_data_manager for the ContentManager instance that handles raw bytes and str payloads without any conversion, email contentmanager content_manager for the standard ContentManager instance used by email.policy.default that intelligently handles text plain text html multipart and binary content types, email contentmanager get_content_text for the handler that returns the decoded text payload of a text-star message part as a str, email contentmanager get_content_binary for the handler that returns the raw decoded bytes payload of a non-text message part, email contentmanager get_data_manager for the get-handler lookup used by EmailMessage get_content to find the right reader function for the content type, email contentmanager set_content text for the handler that creates and sets a text part correctly choosing charset and transfer encoding, email contentmanager set_content bytes for the handler that creates and sets a binary part with base64 encoding and optional filename Content-Disposition, email contentmanager EmailMessage get_content for the method that reads the message body using the registered content manager handlers, email contentmanager EmailMessage set_content for the method that sets the message body and MIME headers in one call, email contentmanager EmailMessage make_alternative make_mixed make_related for the methods that convert a simple message into a multipart container, email contentmanager EmailMessage add_attachment for the method that attaches a file or bytes to a multipart message, and email contentmanager integration with email.message and email.policy and email.mime and io for building high-level email readers attachment extractors text body accessors HTML readers and policy-aware MIME construction pipelines.
Claude Code for email.charset: Python Email Charset Encoding
Control header and body encoding for international email with Python's email.charset module and Claude Code — email charset Charset for the class that wraps a character set name with the encoding rules for header encoding and body encoding describing how to encode text for that charset in email messages, email charset Charset header_encoding for the attribute specifying whether headers using this charset should use QP quoted-printable encoding BASE64 encoding or no encoding, email charset Charset body_encoding for the attribute specifying the Content-Transfer-Encoding to use for message bodies in this charset such as QP or BASE64, email charset Charset output_codec for the attribute giving the Python codec name used to encode the string to bytes for the wire format, email charset Charset input_codec for the attribute giving the Python codec name used to decode incoming bytes to str, email charset Charset get_output_charset for returning the output charset name, email charset Charset header_encode for encoding a header string using the charset's header_encoding method, email charset Charset body_encode for encoding body content using the charset's body_encoding, email charset Charset convert for converting a string from the input_codec to the output_codec, email charset add_charset for registering a new charset with custom encoding rules in the global charset registry, email charset add_alias for adding an alias name that maps to an existing registered charset, email charset add_codec for registering a codec name mapping for use by the charset machinery, and email charset integration with email.message and email.mime and email.policy and email.encoders for building international email senders non-ASCII header encoders Content-Transfer-Encoding selectors charset-aware message constructors and MIME encoding pipelines.
Claude Code for email.utils: Python Email Address and Header Utilities
Parse and format RFC 2822 email addresses and dates with Python's email.utils module and Claude Code — email utils parseaddr for splitting a display-name plus angle-bracket address string into a realname and email address tuple, email utils formataddr for combining a realname and address string into a properly quoted RFC 2822 address with angle brackets, email utils getaddresses for parsing a list of raw address header strings each potentially containing multiple comma-separated addresses into a list of realname address tuples, email utils parsedate for parsing an RFC 2822 date string into a nine-tuple compatible with time.mktime, email utils parsedate_tz for parsing an RFC 2822 date string into a ten-tuple that includes the UTC offset timezone in seconds, email utils parsedate_to_datetime for parsing an RFC 2822 date string into an aware datetime object with timezone, email utils formatdate for formatting a POSIX timestamp or the current time as an RFC 2822 date string with optional usegmt and localtime flags, email utils format_datetime for formatting a datetime object as an RFC 2822 date string, email utils make_msgid for generating a globally unique Message-ID string with optional idstring and domain components, email utils decode_rfc2231 for decoding an RFC 2231 encoded parameter value into a tuple of charset language and value, email utils encode_rfc2231 for encoding a string as an RFC 2231 encoded parameter value, email utils collapse_rfc2231_value for collapsing a decoded RFC 2231 tuple to a Unicode string, and email utils integration with email.message and email.headerregistry and datetime and time for building address parsers date formatters message-id generators header extractors and RFC-compliant email construction utilities.
Claude Code for xml.sax.handler: Python SAX2 Handler Base Classes
Implement standards-compliant SAX2 event handlers for streaming XML with Python's xml.sax.handler module and Claude Code — xml sax handler ContentHandler for the base class providing startDocument endDocument startElement endElement characters startPrefixMapping endPrefixMapping ignorableWhitespace processingInstruction skippedEntity and setDocumentLocator no-op defaults ready to override, xml sax handler ErrorHandler for the base class with warning error and fatalError methods for receiving recoverable warnings non-fatal errors and fatal parsing errors from the SAX parser, xml sax handler EntityResolver for the base class with a resolveEntity method that produces an InputSource for external entity URIs enabling custom entity lookup or blocking, xml sax handler DTDHandler for the base class with notationDecl and unparsedEntityDecl methods for receiving DTD-level notation and entity declarations, xml sax handler feature_namespaces for the boolean feature URI that enables XML namespace processing in the SAX parser, xml sax handler feature_validation for the feature URI that enables DTD validation if supported by the backend parser, xml sax handler property_lexical_handler for the property URI used to register a LexicalHandler for comments CDATA sections and entity start and end events, xml sax handler all_features and all_properties for the lists of standard SAX2 feature and property URIs, and xml sax handler integration with xml.sax and xml.sax.saxutils and xml.parsers.expat and io for building content accumulator handlers streaming element collectors schema-like structure validators event loggers and multi-pass XML pipeline stages.
Claude Code for xml.sax.saxutils: Python SAX XML Utility Functions
Escape and unescape XML content and build SAX filter chains with Python's xml.sax.saxutils module and Claude Code — xml sax saxutils escape for escaping the five XML special characters ampersand less-than and greater-than in text content with optional extras dict for additional replacements, xml sax saxutils unescape for unescaping XML entity references back to their character equivalents with optional extras dict for additional entity mappings, xml sax saxutils quoteattr for escaping a string for safe use as an XML attribute value choosing between single and double quotes automatically to avoid escaping, xml sax saxutils XMLGenerator for the ContentHandler that serializes SAX2 events to an XML output stream with configurable encoding and short_empty_elements options, xml sax saxutils XMLFilterBase for the base class for building SAX filter chains that pass events through to a downstream ContentHandler while allowing selective interception and transformation, xml sax saxutils XMLFilterBase startElement endElement characters for the passthrough event methods available to override in a custom SAX filter, xml sax saxutils XMLGenerator startDocument startElement endElement characters ignorableWhitespace for the full event interface the generator implements to produce well-formed XML output, and xml sax saxutils integration with xml.sax and xml.sax.handler and xml.parsers.expat and io for building XML escaping utilities SAX event loggers element-stripping filters attribute-rewriting filters namespace-injecting filters and XML transformation pipelines.
Claude Code for xml.parsers.expat: Python Expat XML Parser Bindings
Parse XML at maximum speed using Python's xml.parsers.expat module and Claude Code — xml parsers expat ParserCreate for creating an Expat parser object with optional encoding and namespace separator arguments, xml parsers expat xmlparser Parse for feeding a bytes or string chunk to the parser triggering registered handlers, xml parsers expat xmlparser ParseFile for parsing a file-like object directly reading in chunks, xml parsers expat xmlparser StartElementHandler for the handler called with element name and attributes dict at each opening tag, xml parsers expat xmlparser EndElementHandler for the handler called with element name at each closing tag, xml parsers expat xmlparser CharacterDataHandler for the handler called with decoded text content from element bodies, xml parsers expat xmlparser ProcessingInstructionHandler for the handler called with target and data at each processing instruction, xml parsers expat xmlparser CommentHandler for the handler called with comment text, xml parsers expat xmlparser StartNamespaceDeclHandler and EndNamespaceDeclHandler for tracking XML namespace declarations, xml parsers expat xmlparser CurrentLineNumber and CurrentColumnNumber and CurrentByteIndex for the cursor position attributes available inside handler callbacks, xml parsers expat xmlparser SetParamEntityParsing for controlling external entity resolution, xml parsers expat xmlparser UseForeignDTD for disabling DTD loading, xml parsers expat ExpatError for the exception raised on malformed XML with lineno colno and offset attributes, and xml parsers expat integration with xml.sax and xml.etree.ElementTree and io and struct for building ultra-fast streaming XML processors element counters tag-frequency analyzers namespace extractors large-file XML scanners and custom SAX-style pipelines.
Claude Code for xml.dom.minidom: Python Lightweight DOM XML Parser
Parse and build XML documents with Python's xml.dom.minidom module and Claude Code — xml dom minidom parse for parsing an XML file into a DOM Document object, xml dom minidom parseString for parsing an XML bytes or string into a DOM Document, xml dom minidom Document for the top-level DOM node that owns the entire document tree with createElement createTextNode createComment createProcessingInstruction and createCDATASection factory methods, xml dom minidom Element for DOM element nodes with tagName getAttribute setAttribute removeAttribute getAttributeNode childNodes parentNode firstChild lastChild nextSibling previousSibling appendChild insertBefore removeChild replaceChild and getElementsByTagName, xml dom minidom Text for DOM text content nodes with data and nodeValue attributes, xml dom minidom Document toxml for serializing the entire document to an XML string with optional encoding, xml dom minidom Node toprettyxml for serializing to an indented XML string with configurable indent and newl separators, xml dom minidom Document createElementNS and createAttributeNS for namespace-aware node creation, xml dom minidom Node normalize for merging adjacent text nodes and removing empty text nodes in a subtree, and xml dom minidom integration with xml.dom and xml.etree.ElementTree and lxml for building DOM document builders element finders attribute extractors XML template engines element-to-dict converters and round-trip XML processors.
Claude Code for curses.textpad: Python Terminal Text Input Widget
Build terminal text input fields with Python's curses.textpad module and Claude Code — curses textpad Textbox for the interactive text editing widget that supports single-line and multi-line input within a curses window supporting cursor movement deletion insertion and navigation keystrokes, curses textpad Textbox edit for the method that enters the interactive editing loop reading keystrokes from the curses window until the user presses a termination key and returning to the caller, curses textpad Textbox gather for the method that returns the current content of the edit buffer as a string stripping trailing whitespace from each line, curses textpad Textbox do_command for the method dispatching a single keystroke command allowing programmatic input injection and custom validator integration, curses textpad rectangle for the utility function that draws a rectangular border around a sub-window to visually frame a text input field, curses textpad Textbox stripspaces for the attribute controlling whether trailing spaces are stripped from each line of the gathered text, and curses textpad integration with curses and curses.ascii and curses.panel for building terminal form fields inline editors search bars confirmation dialogs multi-line text editors and interactive TUI input pipelines.
Claude Code for curses.ascii: Python ASCII Character Classification
Classify and test ASCII characters with Python's curses.ascii module and Claude Code — curses ascii isalnum for testing if a character is alphanumeric ASCII letter or digit, curses ascii isalpha for testing if a character is an ASCII letter, curses ascii isblank for testing if a character is space or tab, curses ascii iscntrl for testing if a character is an ASCII control character with code 0 through 31 or 127, curses ascii isdigit for testing if a character is an ASCII decimal digit 0 through 9, curses ascii isgraph for testing if a character is a printable non-space ASCII character, curses ascii islower for testing if a character is a lowercase ASCII letter, curses ascii isprint for testing if a character is any printable ASCII character including space, curses ascii ispunct for testing if a character is an ASCII punctuation character, curses ascii isspace for testing if a character is an ASCII whitespace character, curses ascii isupper for testing if a character is an uppercase ASCII letter, curses ascii isxdigit for testing if a character is a hexadecimal digit, curses ascii isascii for testing if a character is within the standard 7-bit ASCII range, curses ascii isctrl for testing control characters, curses ascii ismeta for testing if a character has the high bit set meaning it is outside standard ASCII, curses ascii ascii for returning the 7-bit ASCII value of a character by masking off the high bit, curses ascii ctrl for returning the control character value corresponding to a regular character, curses ascii alt for returning the character with the high bit set, curses ascii unctrl for returning a printable string representation of a control character, and curses ascii integration with curses and string and re and io for building terminal input classifiers keystroke filters cursor navigators byte stream analyzers and ANSI control sequence parsers.
Claude Code for email.parser: Python RFC 5322 Email Parsers
Parse raw RFC 5322 email messages with Python's email.parser module and Claude Code — email parser Parser for parsing text string email messages into email.message.Message objects using the compat32 policy by default or a custom policy, email parser BytesParser for parsing raw bytes or binary file objects into email.message.Message or EmailMessage objects with optional policy control, email parser HeaderParser for parsing only the headers of a message without processing the body providing a fast path for header-only inspection, email parser BytesHeaderParser for parsing only the message headers from binary email bytes for efficient metadata extraction, email parser FeedParser for incrementally feeding raw message text in chunks to a stateful parser useful for streaming or network input, email parser BytesFeedParser for incrementally feeding binary chunks to a stateful parser that builds an email.message.Message as data arrives, email parser Parser parse for parsing a file object directly, email parser Parser parsestr for parsing a string directly, email parser BytesParser parsebytes for parsing a bytes object directly, email parser BytesParser parse for parsing a binary file object directly, and email parser integration with email.policy and email.message and email.generator and io and mailbox for building standards-compliant email processors header extractors streaming message readers mbox file parsers and email pipeline stages.
Claude Code for email.generator: Python Email Message Serializers
Serialize email messages to text and bytes with Python's email.generator module and Claude Code — email generator Generator for writing an email.message.Message or EmailMessage to a text file-like object using str output with configurable mangle_from_ and maxheaderlen settings, email generator BytesGenerator for writing a message to a binary file-like object producing RFC-compliant bytes output suitable for SMTP transmission or mbox storage, email generator DecodedGenerator for writing a message to a text stream with payload content decoded from base64 or quoted-printable transfer encoding back to human-readable text, email generator Generator flatten for the method that writes the entire message including all multipart sub-parts to the output stream, email generator as_string for generating the full RFC 5322 text representation of a message using policy default settings, email generator as_bytes for generating the full RFC 5322 binary representation of a message, email generator maxheaderlen for controlling the line length at which headers are folded during serialization, email generator mangle_from_ for prepending greater-than to From lines to prevent mbox format corruption, and email generator integration with email.policy and email.message and io and smtplib and mailbox for building SMTP wire-format serializers mbox file writers policy-aware message renderers multipart flatteners and email archive pipelines.
Claude Code for email.headerregistry: Python Typed Email Headers
Work with structured typed email headers using Python's email.headerregistry module and Claude Code — email headerregistry HeaderRegistry for the mapping from header field name to header class that the email policy uses to create typed header objects when parsing messages, email headerregistry Address for the data class representing a single RFC 5322 email address with display_name username and domain attributes and string rendering, email headerregistry Group for the data class representing an RFC 5322 address group with display_name and addresses list, email headerregistry UniqueUnstructuredHeader for single-occurrence unstructured headers like Subject, email headerregistry UniqueAddressHeader for single-occurrence address headers like From that return a single Address object, email headerregistry AddressHeader for repeatable address headers like To Cc Bcc that expose an addresses sequence, email headerregistry DateHeader for headers containing RFC 2822 datetime values like Date with a datetime attribute, email headerregistry ContentTypeHeader for structured content-type headers exposing content_type and params mapping, email headerregistry make_header for constructing a typed header object from a name-value pair, and email headerregistry integration with email.policy and email.message and email.utils for building RFC-compliant address parsers typed header inspectors display-name extractors domain-based address filters and structured message header validators.
Claude Code for email.policy: Python Email Parsing and Generation Policies
Control email header encoding and line folding with Python's email.policy module and Claude Code — email policy EmailPolicy for the abstract base class that defines how the email package parses and generates message headers and body, email policy Compat32 for the legacy policy that matches the behavior of Python 3.2 and earlier with lax header handling and bytes output, email policy default for the modern EmailPolicy instance that is strict and returns str from headers, email policy SMTP for the policy configured for SMTP wire format with max_line_length 998 and linesep CRLF, email policy SMTPUTF8 for the SMTP policy variant that allows UTF-8 in headers without encoding, email policy HTTP for the policy using LF line endings suited for HTTP payloads, email policy strict for enabling strict header parsing that raises errors on malformed headers, email policy EmailPolicy header_factory for the callable that creates typed header objects from name-value pairs, email policy EmailPolicy max_line_length for controlling the maximum line length before folding, email policy EmailPolicy linesep for setting the line separator to CRLF LF or other strings, email policy EmailPolicy utf8 for enabling UTF-8 header encoding without RFC 2047 encoding, and email policy integration with email.message and email.parser and email.generator and email.headerregistry for building policy-aware message parsers standards-compliant email generators header validators and RFC 5322 message serializers.
Claude Code for email.mime: Python MIME Message Construction
Build MIME email messages with Python's email.mime subpackage and Claude Code — email mime text MIMEText for creating plain text or HTML email parts with charset encoding, email mime multipart MIMEMultipart for building mixed alternative and related container messages that hold multiple body parts and attachments, email mime base MIMEBase for raw binary parts with custom maintype and subtype that can be encoded with base64 using email encoders encode_base64, email mime image MIMEImage for attaching PNG JPEG GIF and other image files as inline or attachment parts, email mime audio MIMEAudio for attaching MP3 WAV and other audio files, email mime application MIMEApplication for attaching PDFs ZIPs and generic binary payloads with octet-stream or custom subtypes, email mime nonmultipart MIMENonMultipart as the abstract base for all leaf MIME parts, and email mime integration with email.message and smtplib and email.policy and email.encoders for building plain text mailers HTML mailers multipart alternative messages inline image emails file attachment builders and complete SMTP dispatch pipelines.
Claude Code for urllib.response: Python HTTP Response Objects
Work with urllib HTTP response objects in Python with the urllib.response module and Claude Code — urllib response addinfourl for the concrete response class returned by urllib.request.urlopen wrapping the socket connection with read readline readlines and close methods plus info for the http.client.HTTPMessage headers object and geturl for the final URL after redirects and getcode for the HTTP status code, urllib response addinfo for the base mixin class that adds the info method to a file-like response object, urllib response addinfourl read for reading all or N bytes from the response body as bytes, urllib response addinfourl readline for reading one line from the response body, urllib response addinfourl readlines for reading all remaining lines as a list of bytes, urllib response addinfourl info for returning the http.client.HTTPMessage object containing the response headers, urllib response addinfourl geturl for returning the URL of the resource actually retrieved which may differ from the requested URL if redirects occurred, urllib response addinfourl getcode for returning the HTTP status code as an integer, urllib response addinfourl status for the alias to getcode on Python 3.9 plus, and urllib response integration with urllib.request and http.client and io and contextlib for building HTTP response readers header extractors content-type detectors redirect tracers and streaming download pipelines.
Claude Code for html.entities: Python HTML Entity Tables
Work with HTML named character references using Python's html.entities module and Claude Code — html entities html5 for the dictionary mapping every HTML5 named character reference such as amp quot nbsp copy trade mdash and thousands more to their Unicode string equivalent, html entities name2codepoint for the dictionary mapping HTML4 named entity names to their integer Unicode code points such as name2codepoint for amp giving 38 and name2codepoint for copy giving 169, html entities codepoint2name for the reverse mapping from integer Unicode code points to HTML4 entity names, html entities name2unichr for the dictionary mapping HTML4 entity names to their single Unicode character strings equivalent to chr of name2codepoint, and html entities integration with html and html.parser and re and unicodedata and codecs for building HTML entity encoders HTML5 named reference resolvers smart-quote expanders HTML-to-text converters entity frequency analyzers Unicode-to-entity translators and HTML sanitization pipelines.
Claude Code for xml.dom.pulldom: Python Pull-Mode XML Parser
Parse large XML documents on demand with Python's xml.dom.pulldom module and Claude Code — xml dom pulldom parse for creating a DOMEventStream from an XML file path or file-like object using SAX events that can be iterated to receive START_ELEMENT END_ELEMENT CHARACTERS PROCESSING_INSTRUCTION and COMMENT event tuples, xml dom pulldom parseString for creating a DOMEventStream from an XML bytes or string object, xml dom pulldom DOMEventStream for the iterator that yields event and node tuples where the event is one of the pulldom constants and the node is a minidom Node, xml dom pulldom expandNode for expanding a partially-parsed START_ELEMENT node into a full minidom subtree by reading ahead in the event stream allowing selective deep parsing, xml dom pulldom START_ELEMENT END_ELEMENT CHARACTERS PROCESSING_INSTRUCTION COMMENT IGNORABLE_WHITESPACE START_DOCUMENT END_DOCUMENT for the event type constants used to filter the event stream, xml dom pulldom default_bufsize for the buffer size used when parsing files in streaming mode, and xml dom pulldom integration with xml.dom.minidom and xml.sax and xml.etree.ElementTree and lxml for building memory-efficient XML stream processors selective element extractors large-file RSS readers XML-to-JSON converters and document-structure validators.
Claude Code for importlib.machinery: Python Import Machinery
Inspect and extend the Python import machinery with the importlib.machinery module and Claude Code — importlib machinery ModuleSpec for the class that carries all the metadata needed to load a module including name origin loader submodule_search_locations and parent, importlib machinery SourceFileLoader for the concrete loader that reads Python source files from disk compiles them to bytecode and executes them, importlib machinery SourcelessFileLoader for the loader that loads pre-compiled pyc bytecode files without the corresponding .py source, importlib machinery ExtensionFileLoader for the loader that loads C extension modules compiled as .so or .pyd shared libraries, importlib machinery FileFinder for the path-based finder that searches a directory for importable files using loader_details to match file extensions to loaders, importlib machinery PathFinder for the sys.meta_path finder that implements the standard sys.path-based search algorithm, importlib machinery BuiltinImporter for the importer that handles built-in modules like sys and builtins compiled into the interpreter, importlib machinery FrozenImporter for the importer that handles frozen modules compiled into the interpreter as marshalled bytecode, importlib machinery SOURCE_SUFFIXES for the list of file extensions recognized as Python source files, importlib machinery BYTECODE_SUFFIXES for the list of file extensions recognized as compiled bytecode files, importlib machinery EXTENSION_SUFFIXES for the list of file extensions recognized as C extension shared libraries, and importlib machinery integration with importlib abc and importlib util and sys meta_path and sys path_hooks for building custom file finders plugin loaders hot-reload systems bytecode preloaders and import-time instrumentation.
Claude Code for dummy_threading: Python No-Op Threading Fallback
Use Python's dummy_threading module as a no-op threading shim for platforms without thread support and Claude Code — dummy_threading Thread for the no-op thread class that executes its target function immediately in the calling thread rather than spawning a new OS thread making it a drop-in replacement for threading.Thread in environments where thread support was compiled out, dummy_threading Lock for the no-op lock class that always succeeds on acquire and is a no-op on release allowing code that uses threading.Lock to run on threadless interpreters, dummy_threading RLock for the no-op re-entrant lock that behaves identically to Lock on platforms without threading, dummy_threading Condition for the no-op condition variable that makes wait a no-op and notify and notify_all no-ops, dummy_threading Semaphore for the no-op semaphore whose acquire always succeeds immediately, dummy_threading Event for the no-op event whose wait returns True immediately, dummy_threading Timer for the no-op timer that runs its function inline after the interval in the calling thread, dummy_threading current_thread for returning a placeholder DummyThread object that represents the main thread in a threadless environment, dummy_threading active_count and enumerate for returning 1 and a single-item list on platforms without threads, and dummy_threading integration with threading and concurrent.futures and asyncio for building platform-portable libraries embedded extension modules and threadless CPython interpreters.
Claude Code for _thread: Python Low-Level Threading Primitives
Use Python's low-level threading module for lightweight concurrency with the _thread module and Claude Code — _thread start_new_thread for launching a new OS thread that calls a given function with a tuple of arguments and an optional keyword argument dict, _thread allocate_lock for creating a new primitive lock object that supports acquire and release for mutual exclusion, _thread allocate_lock acquire for blocking or non-blocking acquisition of a primitive lock with an optional timeout parameter, _thread allocate_lock release for releasing a held primitive lock, _thread allocate_lock locked for checking whether a lock is currently held, _thread get_ident for returning the thread identifier of the calling thread as a non-zero integer, _thread exit for raising SystemExit in the current thread to terminate it cleanly, _thread interrupt_main for raising a KeyboardInterrupt in the main thread from any other thread, _thread stack_size for getting or setting the default stack size in bytes for new threads, _thread RLock for an alias to the re-entrant lock available in the low-level module on some platforms, and _thread integration with threading and queue and ctypes and multiprocessing for building spinlocks multi-producer queues background I/O workers lightweight daemon threads signal routing helpers and thread-local storage patterns.
Claude Code for crypt: Python Unix Password Hashing
Hash and verify Unix passwords with Python's crypt module and Claude Code — crypt crypt for hashing a plaintext password using a salt and the system's default or specified crypt method returning the hashed password string in modular crypt format, crypt mksalt for generating a cryptographically random salt string for a given crypt method such as METHOD_SHA512 or METHOD_SHA256 or METHOD_MD5 or METHOD_CRYPT, crypt methods for the list of available hashing methods on the current platform ordered from strongest to weakest, crypt METHOD_SHA512 for the constant representing the SHA-512 based crypt method used as yescrypt or sha512crypt in Linux PAM, crypt METHOD_SHA256 for the SHA-256 based crypt method, crypt METHOD_MD5 for the MD5 based crypt method used in legacy systems, crypt METHOD_CRYPT for the traditional DES-based crypt method limited to 8 characters, crypt crypt with a full hash string as the salt parameter for password verification where passing the stored hash as the salt re-hashes the plaintext and allows comparison with the stored hash, and crypt integration with hmac and passlib and spwd and pwd and PAM for building Unix password validators login authenticators passwd file updaters password strength checkers and shadow file audit tools.
Claude Code for msilib: Python Windows Installer Package Creation
Build Windows Installer MSI packages with Python's msilib module and Claude Code — msilib OpenDatabase for opening an existing MSI database file for reading or writing, msilib CreateDatabase for creating a new MSI database file at a given path, msilib init_database for initializing a new MSI database with the required Windows Installer summary information and directory structure tables, msilib add_tables for populating the core MSI tables such as Component File Directory Feature and FeatureComponents, msilib schema for the module containing the standard MSI table schema definitions, msilib sequence for the module containing the standard MSI table names for the InstallUISequence and InstallExecuteSequence tables, msilib text for the module with display string constants for MsiString dialog properties, msilib Directory for the helper class that manages MSI Directory entries and builds the DirId parent-root-path chain, msilib Feature for the helper class that represents an MSI Feature with title description display and level attributes, msilib CAB for the cabinet file builder that compresses files into a CAB archive embedded in or attached to the MSI, msilib SummaryInformation for getting and setting the MSI summary stream properties such as Title Author Subject PackageCode and schema, and msilib integration with distutils and bdist-msi and ctypes and subprocess for building professional Windows software installers silent uninstallers upgrade packages per-machine and per-user installers and CI-generated MSI deployment packages.
Claude Code for spwd: Python Shadow Password Database
Access the Unix shadow password database with Python's spwd module and Claude Code — spwd getspnam for retrieving the shadow password entry for a specific username as an spwd struct containing the hashed password and password aging fields, spwd getspall for returning a list of all entries in the shadow password database as a list of spwd structs, spwd struct sp_namp for the login name attribute of a shadow password entry, spwd struct sp_pwdp for the encrypted hashed password attribute of a shadow password entry, spwd struct sp_lstchg for the date of the last password change expressed as days since the Unix epoch, spwd struct sp_min for the minimum number of days required between password changes, spwd struct sp_max for the maximum number of days a password remains valid before it must be changed, spwd struct sp_warn for the number of days before password expiry that the user is warned, spwd struct sp_inact for the number of days after password expiry before the account is disabled, spwd struct sp_expire for the absolute date expressed as days since the Unix epoch on which the account expires, spwd struct sp_flag for a reserved field for future use, and spwd integration with crypt and hashlib and pwd and subprocess and pam for building Unix password validators password age checkers account expiry monitors and shadow file auditors.
Claude Code for nis: Python NIS Network Information Service
Query NIS Yellow Pages maps on Unix networks with Python's nis module and Claude Code — nis maps for returning a list of all available NIS map names on the default NIS server or a specified NIS domain, nis match for looking up a key in a specified NIS map and returning the corresponding value string, nis cat for returning a dictionary of all key-value pairs in a specified NIS map as a Python dict, nis get_default_domain for returning the name of the default NIS domain as a string, nis error for the exception class raised by nis when a lookup fails or the NIS server is unreachable, nis match with a domain parameter for looking up a key in a NIS map on a non-default domain, nis cat with a domain parameter for retrieving the full contents of a NIS map from a non-default domain, and nis integration with pwd and grp and socket and subprocess and ldap3 for building NIS-to-LDAP migration tools network user enumeration scripts Unix user and group importers hostname-to-IP resolvers and NIS map audit utilities.
Claude Code for lib2to3: Python 2 to 3 Source Migration
Parse and transform Python 2 source code to Python 3 with the lib2to3 module and Claude Code — lib2to3 pygram for the grammar objects for Python 2 and Python 3 used to parse source into concrete syntax trees, lib2to3 pytree for the Node and Leaf classes that represent the concrete syntax tree with parent child and sibling navigation and type and value attributes, lib2to3 pytree Node for an interior tree node that holds child nodes representing grammar productions, lib2to3 pytree Leaf for a terminal tree node that holds a token value and its position in the source, lib2to3 pytree convert for the function that creates a Node or Leaf from a raw parse tree tuple, lib2to3 pgen2 driver Driver for parsing Python source strings or files into pytree syntax trees using a specified grammar, lib2to3 pgen2 driver Driver parse_string for parsing a Python source string into a concrete syntax tree, lib2to3 pgen2 driver Driver parse_file for parsing a Python source file into a concrete syntax tree, lib2to3 fixer_base BaseFix for the abstract base class that all 2to3 fixers inherit from with a pattern attribute and a transform method, lib2to3 refactor RefactoringTool for applying a set of named fixers to source files or strings with options for writing output or dry-run, and lib2to3 integration with tokenize and ast and autopep8 and bowler for building custom source transformers Python 2 compatibility auditors automated code migration scripts print statement converters and legacy codebase analysis tools.
Claude Code for asyncore: Python Async Socket Event Loop
Build event-driven socket applications with Python's asyncore module and Claude Code — asyncore dispatcher for the base class that wraps a socket with event callbacks including handle_read handle_write handle_connect handle_accept handle_close and handle_error, asyncore dispatcher create_socket for creating and registering a socket with the asyncore socket map, asyncore dispatcher connect for initiating a non-blocking TCP connection with handle_connect called on success, asyncore dispatcher listen for putting the socket into listen mode with handle_accept called when a new connection arrives, asyncore dispatcher send for buffering data to be sent and calling handle_write when the socket is writable, asyncore dispatcher recv for receiving up to a given number of bytes in handle_read calling handle_close on EOF, asyncore dispatcher readable and writable for controlling which events are polled by the event loop, asyncore loop for starting the event loop running for a given timeout per iteration and optional count, asyncore file_dispatcher for wrapping an existing file descriptor in the asyncore event system, asyncore loop use_poll parameter for using poll instead of select for better scalability on platforms with large file descriptor counts, and asyncore integration with asynchat and socket and ssl and threading for building non-blocking TCP clients connection pools port scanners logging aggregators and custom protocol dispatchers.
Claude Code for asynchat: Python Async Protocol Handler
Build line-oriented and fixed-length network protocol handlers with Python's asynchat module and Claude Code — asynchat async_chat for the base class that extends asyncore.dispatcher to provide push-based buffered output and a collect-incoming-data and found_terminator handler pair for assembling complete messages from a stream, asynchat async_chat set_terminator for configuring the message delimiter as either a byte string to match or an integer byte count for fixed-length framing or None to disable automatic fragmentation, asynchat async_chat collect_incoming_data for the callback invoked with each chunk of incoming bytes that arrives before the terminator is found and that the subclass must implement to buffer the data, asynchat async_chat found_terminator for the callback invoked when the configured terminator has been found in the input stream and that the subclass must implement to process each complete message, asynchat async_chat push for queueing a bytes object to be sent asynchronously in the background output buffer, asynchat async_chat push_with_producer for queueing a producer object that lazily generates output chunks when ready, asynchat async_chat close_when_done for scheduling the channel to close automatically once the output queue has been fully flushed, asynchat simple_producer for a producer that sends a single bytes object, and asynchat integration with asyncore and socket and select for building line-oriented protocol servers chat servers HTTP-like request parsers SMTP relay handlers custom TCP protocol state machines and streaming data pipelines.
Claude Code for binhex: Python BinHex 4.0 Encoding
Encode and decode files in the BinHex 4.0 format with Python's binhex module and Claude Code — binhex binhex for encoding a binary file into a BinHex 4.0 text file that combines the data fork and resource fork with a four-character type and creator code checksum and run-length compression suitable for transferring Macintosh files over email and text-only channels, binhex hexbin for decoding a BinHex 4.0 encoded file back to binary writing the data into an output file and discarding the resource fork, binhex Error for the exception class raised when encoding or decoding fails due to a corrupted checksum unsupported format version or malformed BinHex stream, binhex BinHex for the low-level encoder class that exposes the BinHex 4.0 protocol at the push level with methods for writing the header the data fork and the resource fork, binhex HexBin for the low-level decoder class that reads the colon-delimited base64 text and decompresses the run-length encoding and validates the CRC checksums, and binhex integration with base64 and binascii and io and struct and codecs for building Macintosh file archive tools legacy Mac email attachment handlers BinHex stream validators and cross-platform binary-to-text encoding pipelines.
Claude Code for tabnanny: Python Indentation Checker
Detect ambiguous indentation in Python source files with the tabnanny module and Claude Code — tabnanny check for recursively checking all Python source files in a directory tree for indentation inconsistencies raising NannyNag exceptions on any file with a line that mixes tabs and spaces in an ambiguous way, tabnanny check with a single filename argument for checking one Python file for ambiguous tab or space indentation, tabnanny NannyNag for the exception class raised by tabnanny check when a file contains a line with indentation that is ambiguous between tab-based and space-based indentation with attributes filename lineno and msg, tabnanny verbose for the module-level flag that controls whether tabnanny prints each file it processes to standard output when set to true, tabnanny filename_only for the module-level flag that when true causes tabnanny to only print the filename of files with problems rather than detailed line info, and tabnanny integration with tokenize and ast and py_compile and subprocess for building pre-commit indentation linters mixed-indentation auditors automated code style fixers Python file validators and CI indentation check scripts.
Claude Code for opcode: Python Bytecode Opcode Constants
Inspect and work with CPython bytecode using Python's opcode module and Claude Code — opcode opmap for the dictionary mapping opcode name strings to their numeric bytecode values, opcode opname for the list mapping numeric bytecode values back to their opcode name strings, opcode cmp_op for the sequence of comparison operator strings indexed by the argument to COMPARE_OP, opcode hasconst for the list of opcodes that use the co_consts tuple for their argument, opcode hasfree for opcodes that access free variables from a closure, opcode hasname for opcodes that use the co_names tuple as their argument, opcode hasjrel for opcodes with a relative jump target argument, opcode hasjabs for opcodes with an absolute jump target argument, opcode haslocal for opcodes that reference co_varnames local variables, opcode hascompare for opcodes using a comparison operator index argument, opcode stack_effect for computing the net stack depth change produced by a given opcode and optional argument, opcode HAVE_ARGUMENT for the threshold below which opcodes take no argument, opcode extended_arg for the opcode that prefixes multi-byte arguments, and opcode integration with dis and types.CodeType and compile and sys and bytecode for building bytecode analyzers opcode frequency profilers dead code detectors stack depth validators and Python-to-Python compilers.
Claude Code for winreg: Python Windows Registry Access
Read and write the Windows Registry with Python's winreg module and Claude Code — winreg OpenKey for opening a registry key handle by path under a root hive such as HKEY_LOCAL_MACHINE or HKEY_CURRENT_USER, winreg CreateKey for creating a new subkey or opening an existing one, winreg DeleteKey for deleting a subkey that has no subkeys of its own, winreg DeleteValue for removing a named value from a key, winreg QueryValue for reading the default unnamed value of a key as a string, winreg QueryValueEx for reading a named value and its data type from a registry key, winreg SetValueEx for writing a named value with a specific type such as REG_SZ REG_DWORD REG_BINARY REG_EXPAND_SZ or REG_MULTI_SZ into a registry key, winreg EnumKey for enumerating the subkey names of an open registry key by zero-based index, winreg EnumValue for enumerating the value entries of an open registry key by index returning name data and type, winreg QueryInfoKey for returning the number of subkeys number of values and last-write time of a registry key, winreg ConnectRegistry for connecting to a registry on a remote computer using a UNC machine name, winreg SaveKey for saving a registry key and all subkeys and values to a file, winreg REG_SZ REG_DWORD REG_BINARY REG_EXPAND_SZ REG_MULTI_SZ and other type constants, and winreg integration with os and subprocess and ctypes and platform for reading installed software paths environment variables startup programs application settings and Windows system configuration.
Claude Code for msvcrt: Python Windows Console and File Utilities
Access low-level Windows console I/O and file locking with Python's msvcrt module and Claude Code — msvcrt getch for reading a single keypress from the console without echoing it to the screen, msvcrt getwch for reading a single wide-character keypress without echo, msvcrt getche for reading a keypress and echoing it to the console, msvcrt kbhit for checking whether a keypress is waiting in the console input buffer without blocking, msvcrt putch for writing a single byte character to the console without a newline, msvcrt putwch for writing a single wide character to the console, msvcrt ungetch for pushing a byte back into the console input buffer so the next getch call returns it, msvcrt setmode for setting the translation mode of a file descriptor to O_TEXT or O_BINARY, msvcrt locking for locking or unlocking a range of bytes in an open file using LK_LOCK LK_NBLCK LK_UNLCK LK_NBRLCK and LK_RLCK constants, msvcrt get_osfhandle for obtaining the Windows HANDLE associated with a C runtime file descriptor, msvcrt open_osfhandle for wrapping a Windows HANDLE in a C runtime file descriptor with flags, and msvcrt integration with os and ctypes and subprocess and sys and threading for building Windows CLI menus keystroke-driven TUI apps non-blocking keyboard loops file-locking utilities and console progress spinners.
Claude Code for winsound: Python Windows Audio and Beep
Play beeps and WAV files on Windows with Python's winsound module and Claude Code — winsound Beep for playing a pure tone at a given frequency in Hz for a given duration in milliseconds synchronously using the Windows speaker, winsound PlaySound for playing audio from a WAV file filename or from a bytes object containing WAV data, winsound PlaySound flags parameter using SND_FILENAME to specify that the first argument is a file path, winsound PlaySound SND_ASYNC for playing sound asynchronously in a background thread without blocking the caller, winsound PlaySound SND_NODEFAULT for suppressing the default system beep when the specified sound cannot be played, winsound PlaySound SND_LOOP for looping a sound continuously until PlaySound is called with None, winsound PlaySound SND_NOWAIT for immediately failing rather than waiting if the sound driver is busy, winsound PlaySound SND_MEMORY for playing sound data passed as a bytes object rather than a filename, winsound MessageBeep for playing a system alert sound by event type such as MB_OK MB_ICONWARNING MB_ICONERROR MB_ICONQUESTION or MB_ICONASTERISK, winsound MB_OK for the default system beep constant, and winsound integration with subprocess and wave and tkinter for building Windows desktop alert systems progress notifications error sounds installer audio feedback and Windows application sound themes.
Claude Code for importlib.abc: Python Import System ABCs
Implement custom loaders and finders for Python's import system with the importlib.abc module and Claude Code — importlib abc Finder for the deprecated base class establishing the find_module interface, importlib abc MetaPathFinder for the abstract base class for sys.meta_path finders implementing find_spec to intercept any import by name, importlib abc PathEntryFinder for the abstract base class for sys.path_hooks finders implementing find_spec for entries on sys.path, importlib abc Loader for the base class for loaders implementing create_module and exec_module, importlib abc SourceLoader for the abstract base class for loaders that have Python source code implementing get_data get_filename and optionally path_stats for bytecode caching, importlib abc ResourceLoader for the deprecated loader ABC that provides get_data for resource access, importlib abc InspectLoader for the loader ABC that adds get_source is_package and get_code capabilities, importlib abc ExecutionLoader for the loader ABC adding get_filename, importlib abc FileLoader for the concrete ABC base providing a default load_module built on get_filename and get_data, and importlib abc integration with importlib machinery and importlib util and sys meta_path and sys path_hooks for building in-memory importers encrypted module loaders namespace packages database-backed modules and import auditing hooks.
Claude Code for stringprep: Python String Preparation Profiles
Prepare and validate Unicode strings for internet protocols with Python's stringprep module and Claude Code — stringprep in_table_c11 for checking if a character is in the STRINGPREP C.1.1 prohibited character table covering ASCII space, stringprep in_table_c12 for checking characters in C.1.2 covering non-ASCII space characters, stringprep in_table_c21 for ASCII control characters, stringprep in_table_c21_c22 for combining C.2.1 and C.2.2 control characters, stringprep in_table_c3 for private use characters, stringprep in_table_c4 for non-character code points, stringprep in_table_c5 for surrogate codes, stringprep in_table_c6 for inappropriate for plain text characters, stringprep in_table_c7 for inappropriate for canonical representation characters, stringprep in_table_c8 for change display properties or are deprecated characters, stringprep in_table_c9 for tagging characters, stringprep in_table_d1 for characters with bidirectional property RandAL, stringprep in_table_d2 for characters with bidirectional property L, stringprep map_table_b2 for case folding using Unicode NFKC equivalence, stringprep map_table_b3 for mapping to nothing certain characters that should be deleted, and stringprep integration with unicodedata and idna and saslprep for building SASL authentication string preparers LDAP distinguished name validators hostname normalizers and internet identifier validators.
Claude Code for uu: Python UUencoding Utilities
Encode and decode uuencoded data with Python's uu module and Claude Code — uu encode for converting a binary file to uuencoded ASCII text suitable for transmission over 7-bit channels with a begin header line containing the file mode and name and an end trailer, uu decode for converting uuencoded ASCII back to binary data reading the begin header to determine the output filename and mode, uu encode in_file parameter for accepting a readable file-like object opened in binary mode, uu encode out_file parameter for accepting a writable file-like object opened in text mode, uu encode name parameter for overriding the filename written into the begin header, uu encode mode parameter for specifying the octal file permission written into the begin header, uu encode backtick parameter for using backtick instead of space for zero-value bytes in Python 3.7 plus, uu decode in_file parameter for accepting a readable text file-like object containing uuencoded data, uu decode out_file parameter for accepting a writable binary file-like object for the decoded output, uu Error for the exception raised when the uuencoded input is malformed, and uu integration with base64 and binascii and email for building legacy archive readers email attachment decoders format converters and old-school USENET tool compatibility layers.
Claude Code for mailcap: Python MIME Type Capability Database
Look up viewer and handler programs for MIME types with Python's mailcap module and Claude Code — mailcap getcaps for reading all mailcap files on the system and returning a dict mapping MIME type strings to lists of capability dicts, mailcap findmatch for searching the capability database for a specific MIME type returning the best matching entry and a shell command string, mailcap findmatch key parameter for selecting the capability type such as view edit print compose x-textualize or test, mailcap subst for substituting filename and parameters into a mailcap command template expanding percent-s for the filename percent-t for the MIME type and percent-percent for a literal percent, mailcap MimeCaps type alias for the dict mapping MIME type strings returned by getcaps, mailcap lookup rules for how wildcards such as image and text work with fallback to the star-star entry, and mailcap integration with mimetypes and subprocess and shutil for building file preview launchers MIME type routers content-type-aware open handlers and media player selectors on UNIX systems.
Claude Code for urllib.error: Python URL Exception Types
Handle URL and HTTP errors from urllib with Python's urllib.error module and Claude Code — urllib error URLError for the base exception raised by urllib.request when a URL operation fails due to a network problem or unknown URL scheme with the reason attribute holding either an OSError or string, urllib error HTTPError for the subclass of URLError raised when an HTTP response code indicates an error with the code attribute for the numeric status code the reason string and the headers mapping, urllib error ContentTooShortError for the exception raised when urllib.request.urlretrieve downloads fewer bytes than expected with the content attribute holding the partial download, urllib error URLError reason for the attribute providing the underlying reason as an OS error or string for non-HTTP errors, urllib error HTTPError code for the HTTP status code integer such as 404 500 or 403, urllib error HTTPError headers for the http.client.HTTPMessage headers of the error response, urllib error HTTPError read for reading the response body of the error response which often contains a JSON error payload, and urllib error integration with urllib.request and http.client and requests for building robust HTTP clients retry logic error classifiers JSON error parsers and HTTP status code handlers.
Claude Code for tkinter: Python GUI Toolkit
Build desktop GUI applications with Python's tkinter module and Claude Code — tkinter Tk for the root window class that initializes the Tk GUI runtime and provides the mainloop event loop, tkinter Frame for the container widget used to group and organize other widgets, tkinter Label for displaying static text or images, tkinter Button for a clickable button widget with a command callback, tkinter Entry for a single-line text input field, tkinter Text for a multi-line editable text widget, tkinter Canvas for a drawing area that supports shapes lines images and custom event bindings, tkinter Listbox for a scrollable list of selectable items, tkinter Scrollbar for attaching scroll control to Text Listbox and Canvas widgets, tkinter Menu and Menubutton for creating drop-down and menu-bar menus, tkinter StringVar IntVar DoubleVar BooleanVar for observable variables that automatically update linked widgets, tkinter mainloop for entering the Tk event loop, tkinter grid pack and place for the three geometry managers that position widgets in the window, tkinter bind for attaching event handler callbacks to keyboard mouse and window events, tkinter ttk for the themed widget set that follows the native OS look and feel, and tkinter integration with tkinter messagebox tkinter filedialog tkinter simpledialog tkinter colorchooser and PIL ImageTk for building form applications data entry tools file browsers image viewers and admin dashboards.
Claude Code for xml.sax: Python SAX XML Parser
Process large XML files with Python's event-driven SAX parser and Claude Code — xml sax parse for parsing an XML source file or stream by invoking a ContentHandler for each SAX event, xml sax parseString for parsing XML from a bytes or string object, xml sax handler ContentHandler for the base class to subclass when handling SAX events with startElement endElement characters startDocument and endDocument methods, xml sax handler ContentHandler startElement for the handler method called when an opening tag is found with the element name and Attributes mapping, xml sax handler ContentHandler endElement for the handler method called when a closing tag is found, xml sax handler ContentHandler characters for the handler method called with a chunk of character data inside an element, xml sax handler ErrorHandler for the base class providing warning error and fatalError hooks, xml sax make_parser for creating a configurable XMLReader instance that can be used to parse incrementally, xml sax xmlreader InputSource for wrapping a file path URL or stream as a SAX input, xml sax handler feature_namespaces for the feature flag that enables namespace processing so startElementNS and endElementNS are called, and xml sax integration with xml etree ElementTree and lxml and defusedxml for building streaming large-file parsers element collectors path-based extractors namespace-aware processors and SAX-to-dict converters.
Claude Code for xml.dom.minidom: Python DOM XML Processing
Parse and build XML documents with Python's xml.dom.minidom module and Claude Code — xml dom minidom parse for loading an XML file into a DOM Document object, xml dom minidom parseString for parsing an XML string into a Document, xml dom minidom getDOMImplementation for obtaining the DOM implementation to create new documents programmatically, xml dom minidom Document createElement for creating a new Element node, xml dom minidom Document createTextNode for creating a text content node, xml dom minidom Document createComment for creating a comment node, xml dom minidom Document createCDATASection for creating a CDATA section node, xml dom minidom Document toxml for serializing the document to an XML string, xml dom minidom Document toprettyxml for serializing with indentation, xml dom minidom Element getAttribute for reading an attribute value, xml dom minidom Element setAttribute for setting an attribute, xml dom minidom Element getElementsByTagName for finding all descendant elements with a given tag, xml dom minidom Node appendChild for appending a child node, xml dom minidom Node removeChild for removing a child node, xml dom minidom NodeList for the list-like object returned by getElementsByTagName, and xml dom minidom integration with xml etree ElementTree and lxml and defusedxml for building config file parsers document transformers SOAP message builders namespace-aware processors and XML diff tools.
Claude Code for turtle: Python Turtle Graphics
Draw graphics and teach programming visually with Python's turtle module and Claude Code — turtle forward for moving the turtle forward by a given number of pixels, turtle backward for moving the turtle backward, turtle right for rotating the turtle clockwise by a given angle in degrees, turtle left for rotating the turtle counterclockwise, turtle goto for moving the turtle to an absolute position, turtle penup for lifting the pen so movement does not draw, turtle pendown for placing the pen so movement draws, turtle pencolor for setting the pen color as a named color hex string or RGB tuple, turtle fillcolor for setting the fill color, turtle begin_fill and end_fill for marking the start and end of a region to fill, turtle circle for drawing a circle or arc of given radius and extent, turtle speed for setting the turtle animation speed from 0 slowest to 10 fastest with 0 meaning no animation, turtle screensize for setting the canvas dimensions, turtle tracer for controlling update frequency for faster batch drawing, turtle done for entering the Tk event loop, turtle Screen for the singleton screen object with bgcolor title setup and listen, turtle Turtle for the class that creates an independent turtle instance for multi-turtle drawings, and turtle integration with tkinter and PIL and colorsys for creating fractal visualizations algorithmic art educational interactive demos and geometry explorers.
Claude Code for importlib.metadata: Python Distribution Metadata
Read installed package metadata and entry points with Python's importlib.metadata module and Claude Code — importlib metadata version for returning the version string of an installed distribution by package name, importlib metadata metadata for returning the email.message.Message object containing all distribution metadata fields such as Name Version Author Requires-Python and Classifier, importlib metadata requires for returning the list of dependency requirement strings for a distribution, importlib metadata packages_distributions for returning a dict mapping top-level import package names to the distribution names that provide them, importlib metadata distribution for returning the Distribution object for a package name, importlib metadata distributions for iterating over all installed Distribution objects, importlib metadata entry_points for returning a SelectableGroups object of all entry points filterable by group and name, importlib metadata files for returning the list of PackagePath objects representing all files belonging to a distribution, importlib metadata PackageNotFoundError for the exception raised when a distribution is not installed, and importlib metadata integration with packaging and pip and importlib resources for building dependency checkers version validators plugin registries audit tools and runtime environment reporters.
Claude Code for importlib.util: Python Import System Utilities
Dynamically load modules and inspect import machinery with Python's importlib.util module and Claude Code — importlib util spec_from_file_location for creating a ModuleSpec from a filesystem path allowing you to load any Python file as a module regardless of whether it is on sys.path, importlib util spec_from_loader for constructing a ModuleSpec from a loader instance, importlib util module_from_spec for creating a new module object from a ModuleSpec before executing it, importlib util find_spec for looking up the ModuleSpec for a named module without importing it, importlib util LazyLoader for a loader wrapper that defers executing a module's code until the first attribute access, importlib util source_from_cache for converting a bytecode cache path such as a dot-pyc file to the source path, importlib util cache_from_source for converting a source path to the expected bytecode cache path, importlib util decode_source for decoding source bytes to a string using the encoding declared in the source, importlib util source_hash for computing the hash of source bytes for use in hash-based pyc files, and importlib util integration with importlib abc and sys modules and importlib machinery for building plugin loaders dynamic module executors sandboxed import contexts and path-based module discovery tools.
Claude Code for unittest.mock: Python Mocking and Patching
Mock objects and patch dependencies in Python tests with the unittest.mock module and Claude Code — unittest mock Mock for the general-purpose mock object that records calls and allows setting return values and side effects, unittest mock MagicMock for the Mock subclass that pre-configures all magic dunder methods automatically, unittest mock patch for the decorator and context manager that temporarily replaces a named attribute with a mock during a test, unittest mock patch object for patching an attribute directly on a specific object rather than by dotted name string, unittest mock patch dict for patching entries in a dict or replacing the dict entirely, unittest mock call for the call recording object used to inspect positional and keyword arguments of recorded calls, unittest mock sentinel for a namespace providing unique singleton objects useful as default sentinel values, unittest mock ANY for the special object that compares equal to everything for flexible call assertions, unittest mock create_autospec for creating a mock whose interface is constrained to the spec of a real object preventing typos in attribute access, and unittest mock integration with pytest and pytest-mock and unittest TestCase for building isolated unit tests dependency injection helpers protocol-safe mocks and async mock patterns.
Claude Code for importlib.resources: Python Package Data Access
Access package data files and resources with Python's importlib.resources module and Claude Code — importlib resources files for returning a Traversable representing the resource directory of a package, importlib resources as_file for materializing a Traversable to a real filesystem path as a context manager, importlib resources open_binary for opening a package resource as a binary file object, importlib resources open_text for opening a package resource as a text file object with encoding, importlib resources read_binary for reading a package resource and returning bytes, importlib resources read_text for reading a package resource and returning a string, importlib resources path for the legacy context manager that returns a pathlib Path to the resource, importlib resources contents for listing the resource names in a package, importlib resources is_resource for checking whether a name is a file resource rather than a subdirectory, importlib resources Package and Anchor type aliases for annotating the first parameter which accepts module objects, module name strings, or Traversable instances, and importlib resources integration with pathlib and pkg_resources and importlib_resources backport for building installed package file loaders config readers embedded asset accessors and data bundle managers.
Claude Code for graphlib: Python Topological Sorting
Perform topological ordering of directed acyclic graphs with Python's graphlib module and Claude Code — graphlib TopologicalSorter for the class that accepts a dependency graph as a dict mapping nodes to their predecessors and computes a topological ordering, graphlib TopologicalSorter add for adding a node and its predecessors to the sorter after construction, graphlib TopologicalSorter prepare for locking the graph and computing the initial set of ready nodes, graphlib TopologicalSorter is_active for checking whether there are still nodes to process, graphlib TopologicalSorter get_ready for retrieving the batch of nodes with all predecessors already done, graphlib TopologicalSorter done for marking one or more nodes as complete so their dependents can become ready, graphlib TopologicalSorter static_order for returning a single iterator over all nodes in topological order without the parallel-ready API, graphlib CycleError for the exception raised when the graph contains a cycle, and graphlib integration with concurrent.futures and asyncio and networkx for building build systems task schedulers dependency resolvers parallel pipeline executors and import order analyzers.
Claude Code for zoneinfo: Python IANA Timezone Database
Work with IANA timezone data in Python with the zoneinfo module and Claude Code — zoneinfo ZoneInfo for the class that wraps an IANA timezone key like America/New_York and implements the tzinfo interface for use with datetime, zoneinfo ZoneInfo key for the string identifier of the timezone such as UTC Europe/London or Asia/Tokyo, zoneinfo ZoneInfo from_file for loading a timezone from a custom tzdata file-like object, zoneinfo ZoneInfo no_cache for creating a fresh ZoneInfo instance bypassing the module-level cache, zoneinfo ZoneInfo clear_cache for flushing all cached ZoneInfo instances, zoneinfo available_timezones for returning the set of all IANA timezone keys available on the current system, zoneinfo ZoneInfoNotFoundError for the exception raised when a timezone key is not found in the database, and zoneinfo integration with datetime and dateutil and backports-zoneinfo and tzdata for building timezone-aware scheduling systems UTC converters local time helpers DST-safe arithmetic and multi-region calendar tools.
Claude Code for html: Python HTML Escaping and Entity Utilities
Escape and unescape HTML safely with Python's html module and Claude Code — html escape for converting special characters ampersand less-than greater-than and double-quote to their HTML entity equivalents preventing XSS and injection, html unescape for converting HTML and XML character references back to their Unicode characters, html entities html5 for the dict mapping HTML5 named entity strings to their Unicode character sequences, html entities name2codepoint for the dict mapping entity name strings to their Unicode codepoint integers, html entities codepoint2name for the dict mapping codepoint integers to their canonical entity name strings, html escape quote parameter for controlling whether double-quote characters are also escaped, html unescape handling numeric references for decimal and hexadecimal character references like A and A as well as named references like & and <, and html integration with xml.sax.saxutils and markupsafe and bleach for building safe HTML renderers attribute serializers entity converters template helpers and XSS sanitizers.
Claude Code for code: Python Interactive Interpreter Utilities
Embed and extend Python's interactive interpreter with Python's code module and Claude Code — code interact for starting an interactive console session in the current process reading from stdin and writing to stdout, code InteractiveConsole for the class that manages a multi-line interactive session with push and resetbuffer and runsource, code InteractiveConsole push for feeding one line at a time to the interpreter returning True if more input is needed for a compound statement, code InteractiveConsole runcode for executing a code object in the console namespace, code InteractiveConsole runsource for compiling and running a source string returning the continuation status, code InteractiveConsole resetbuffer for clearing the accumulated multi-line input buffer, code InteractiveConsole interact for running a read-eval-print loop with configurable banner and exitmsg, code InteractiveInterpreter for the lower-level class without the input loop that only provides runsource and showsyntaxerror and showtraceback, code InteractiveInterpreter showsyntaxerror for printing a syntax error message to stderr, code InteractiveInterpreter showtraceback for printing the current exception traceback to stderr, code compile_command for checking whether a partial source string is complete or needs more input using the codeop module, and code integration with readline and rlcompleter and sys and io for building embedded REPLs in-process sandboxes notebook kernels and debug console helpers.
Claude Code for bdb: Python Debugger Base Infrastructure
Build custom Python debuggers and execution monitors with Python's bdb module and Claude Code — bdb Bdb for the base debugger class that implements the trace dispatch mechanism used by pdb and other Python debuggers, bdb Bdb set_trace for installing the debugger as the sys.settrace handler starting from the calling frame, bdb Bdb set_break for setting a breakpoint at a given filename and line number with optional count and condition, bdb Bdb clear_break for removing a previously set breakpoint, bdb Bdb set_step for entering single-step mode where the debugger stops at every line, bdb Bdb set_next for stepping over without entering the next called function, bdb Bdb set_return for running until the current function returns, bdb Bdb set_continue for resuming normal execution, bdb Bdb set_quit for stopping the debugger and terminating the traced program, bdb Bdb user_call for the hook called when the debugger enters a new frame, bdb Bdb user_line for the hook called on each new source line in step mode, bdb Bdb user_return for the hook called just before a function returns, bdb Bdb user_exception for the hook called when an exception propagates, bdb Breakpoint for the class representing an individual breakpoint entry, and bdb integration with sys.settrace and inspect and pdb for building execution recorders call tracers coverage instrumentation hooks and custom interactive debuggers.
Claude Code for optparse: Python Legacy Option Parser
Parse command-line options with Python's optparse module and Claude Code — optparse OptionParser for the main class that defines acceptable options and parses sys.argv, optparse OptionParser add_option for registering a command-line option with its short flag long flag type default action and help string, optparse OptionParser parse_args for parsing a list of arguments defaulting to sys.argv returning options namespace and remaining positional args, optparse OptionParser set_defaults for providing default values for any option, optparse OptionParser error for printing an error message and exiting, optparse OptionParser print_help for displaying the auto-generated usage and help text, optparse add_option action parameter supporting store store_true store_false store_const append count and callback actions, optparse add_option type parameter accepting string int float long complex choice, optparse add_option dest parameter for specifying the attribute name on the values namespace, optparse add_option metavar parameter for controlling how the value placeholder appears in help text, optparse OptionGroup for grouping related options under a heading in the help output, and optparse integration with sys and os and argparse for building maintenance scripts legacy CLI tools migration helpers and backward-compatible option parsers.
Claude Code for keyword: Python Keyword List and Identification
Identify Python keywords and soft keywords with Python's keyword module and Claude Code — keyword kwlist for the sorted list of all Python hard keyword strings such as if for while def class import return yield lambda async await with try except finally raise del pass break continue global nonlocal and or not in is as from True False None, keyword iskeyword for testing whether a string is a reserved Python hard keyword that cannot be used as an identifier, keyword softkwlist for the list of soft keyword strings that have special meaning only in certain syntactic positions such as match case type, keyword issoftkeyword for testing whether a string is a soft keyword, and keyword integration with token and tokenize and ast and inspect for building keyword-aware identifier validators source filtering tools safe variable name generators reserved name checkers code migration assistants and Python version compatibility analyzers.
Claude Code for token: Python Token Type Constants
Work with Python token type constants for lexical analysis with Python's token module and Claude Code — token NAME for the integer constant identifying identifier and keyword tokens, token NUMBER for the integer constant identifying numeric literal tokens, token STRING for the integer constant identifying string literal tokens, token OP for the integer constant identifying operator and delimiter tokens, token COMMENT for the integer constant identifying comment tokens produced by tokenize, token NL for the integer constant identifying non-logical newlines, token NEWLINE for the integer constant identifying logical statement-ending newlines, token INDENT for the integer constant identifying indent level increases, token DEDENT for the integer constant identifying indent level decreases, token ENDMARKER for the integer constant marking end of file, token ERRORTOKEN for the integer constant identifying unrecognized characters, token tok_name for the dict mapping token type integers to their string names such as NAME and NUMBER, token is_terminal for testing whether a grammar symbol integer is a terminal grammar node, token EXACT_TYPE_MAP for looking up the precise token subtype for single-character operators, and token integration with tokenize and ast and keyword for building source analyzers identifier extractors string literal finders and token stream processors.
Claude Code for profile: Python Deterministic Profiler
Profile Python function call times and counts with Python's profile module and Claude Code — profile Profile for the pure-Python deterministic profiling class that measures function call counts and cumulative time, profile Profile enable for starting the profiler to begin recording events, profile Profile disable for stopping the profiler, profile Profile create_stats for finalizing the profiling data and populating the internal stats dict, profile Profile run for profiling a code string with exec under the profiler, profile Profile runcall for profiling a single callable with its arguments under the profiler, profile Profile runctx for profiling a code string with explicit global and local namespace dicts, profile Profile print_stats for printing a human-readable profiling report sorted by the given key, profile Profile dump_stats for saving the profiling data to a file for later analysis with pstats, profile Profile snapshot_stats for exposing the raw stats dict before print_stats normalizes it, and profile integration with pstats and cProfile and io for building function hotspot finders report formatters call count auditors top-N slow call reporters and reproducible profiling harnesses.
Claude Code for trace: Python Execution Tracer and Coverage
Trace Python program execution line by line and measure statement coverage with Python's trace module and Claude Code — trace Trace for the class that records which lines and functions are executed, trace Trace count parameter for enabling per-line execution counting, trace Trace trace parameter for printing each line as it executes, trace Trace countfuncs parameter for recording whether each function was called at all, trace Trace countcallers parameter for tracking caller-callee relationships, trace Trace ignoremods parameter for a list of module names to exclude from tracing, trace Trace ignoredirs parameter for a list of directory prefixes to exclude, trace Trace runfunc for tracing execution of a single callable, trace Trace run for tracing execution of a code string under exec, trace Trace runctx for tracing execution with explicit global and local dicts, trace Trace results for retrieving the CoverageResults object with counts and callers, trace CoverageResults counts for the dict mapping filename-lineno pairs to execution counts, trace CoverageResults write_results for writing annotated source files and a coverage summary, trace CoverageResults write_results show_missing parameter for highlighting unexecuted lines, and trace integration with sys.settrace and coverage.py and pathlib for building statement coverage collectors execution tracers function call graphs and lightweight CI coverage reporters.
Claude Code for faulthandler: Python Crash Debug Dump
Enable low-level crash and fault tracebacks in Python with the faulthandler module and Claude Code — faulthandler enable for registering the fault handler that dumps Python tracebacks to stderr on SIGSEGV SIGFPE SIGABRT SIGBUS and SIGILL signals, faulthandler disable for removing the previously registered fault handler, faulthandler is_enabled for checking whether the fault handler is currently registered, faulthandler dump_traceback for immediately printing the current traceback of all threads to a file without waiting for a crash, faulthandler dump_traceback_later for scheduling an automatic traceback dump after a timeout in seconds, faulthandler cancel_dump_traceback_later for cancelling a previously scheduled dump, faulthandler register for registering a traceback dump on any arbitrary signal, faulthandler unregister for unregistering a previously registered signal handler, faulthandler dump_traceback file parameter for directing the traceback output to a file object or file descriptor instead of stderr, faulthandler dump_traceback all_threads parameter for controlling whether all threads or only the current thread are included in the dump, and faulthandler integration with signal and logging and subprocess for building crash reporters deadlock detectors timeout watchdogs and production process monitors.
Claude Code for ensurepip: Python pip Bootstrap Utility
Bootstrap pip into a Python installation or virtual environment with Python's ensurepip module and Claude Code — ensurepip bootstrap for installing or upgrading pip and setuptools into the current Python environment from the bundled wheel files, ensurepip bootstrap upgrade parameter for upgrading an already-present pip instead of skipping if pip is already installed, ensurepip bootstrap root parameter for installing into an alternative root directory for staged installs, ensurepip bootstrap user parameter for installing into the user site-packages directory, ensurepip bootstrap altinstall parameter for installing pip3 dot X instead of the unversioned pip and pip3 aliases, ensurepip version for returning the version string of the bundled pip wheel, ensurepip _bootstrap for the internal function that performs the actual wheel extraction and installation, and ensurepip integration with venv and subprocess and importlib for building pip-bootstrapped environment provisioners CI setup scripts embedded interpreter setups and offline-capable distribution bundles.
Claude Code for venv: Python Virtual Environment Creation
Create and manage isolated Python virtual environments programmatically with Python's venv module and Claude Code — venv create for creating a virtual environment at the given directory path, venv EnvBuilder for the class that orchestrates virtual environment creation and configuration, venv EnvBuilder system_site_packages parameter for controlling whether the env inherits the base interpreter's site-packages, venv EnvBuilder clear parameter for deleting the target directory before creating a fresh environment, venv EnvBuilder symlinks parameter for using symlinks to the base Python on POSIX instead of copying the interpreter, venv EnvBuilder upgrade parameter for upgrading an existing env to a newer Python, venv EnvBuilder with_pip parameter for bootstrapping pip into the virtual environment using ensurepip, venv EnvBuilder prompt parameter for the prefix shown in the shell prompt when the env is activated, venv EnvBuilder setup_python for the hook that installs the python binary, venv EnvBuilder setup_scripts for the hook that installs activate scripts, venv EnvBuilder post_setup for a user-overridable hook called after setup completes, venv EnvBuilder context for the SimpleNamespace describing the environment paths bin_path env_dir env_exe and cfg_path, and venv integration with subprocess and ensurepip and pathlib for building project scaffolders CI environment provisioners reproducible build runners and environment health checkers.
Claude Code for zipapp: Python Executable Zip Application Builder
Create self-contained executable Python zip archives with Python's zipapp module and Claude Code — zipapp create_archive for building an executable dot-pyz file from a source directory or an existing zip, zipapp create_archive source parameter for the source directory containing a __main__.py or an already-assembled zip file, zipapp create_archive target parameter for the output file path defaulting to the source name with a dot-pyz extension, zipapp create_archive interpreter parameter for the shebang line written as the first bytes of the archive such as /usr/bin/env python3, zipapp create_archive main parameter for the function to call formatted as pkg.module:function overriding the __main__.py entry point, zipapp create_archive filter parameter for a callable that decides which files in the source directory to include, zipapp create_archive compressed parameter for enabling DEFLATE compression of the archive contents, zipapp get_interpreter for reading the shebang line from an existing pyz archive, and zipapp integration with zipfile and runpy and subprocess for building single-file CLI tools deployment bundles lambda layers and self-extracting archives.
Claude Code for runpy: Python Module Execution as Scripts
Execute Python modules and packages as scripts with Python's runpy module and Claude Code — runpy run_module for executing a named module or package as a top-level script in the same way that python -m does, runpy run_path for executing a file path as a script without permanently modifying sys.path or sys.modules, runpy run_module mod_name parameter for the dotted module name to locate and run, runpy run_module run_name parameter for overriding the __name__ set in the executed module defaulting to __main__, runpy run_module alter_sys parameter for temporarily updating sys.argv zero and sys.modules and sys.path during execution, runpy run_module init_globals parameter for injecting extra names into the module namespace before execution, runpy run_path path_name parameter for the file path or directory or zip archive path to run, runpy run_path init_globals parameter for pre-populating the execution namespace, runpy run_module return value for the dict of the module namespace after execution including all globals defined by the script, and runpy integration with importlib and subprocess and sys for building in-process script runners isolated namespace executors plugin sandboxes and test harnesses.
Claude Code for modulefinder: Python Module Dependency Finder
Discover all Python modules required by a script with Python's modulefinder module and Claude Code — modulefinder ModuleFinder for the class that traces imports and builds a dependency graph for a Python script, modulefinder ModuleFinder run_script for running a script through the import tracer to collect all modules it directly or indirectly imports, modulefinder ModuleFinder modules for the dict mapping module names to Module objects after run_script completes, modulefinder ModuleFinder badmodules for the dict of modules that could not be found during tracing, modulefinder ModuleFinder any_missing for returning a list of module names that were imported but could not be located, modulefinder Module for the namedtuple-like object with __name__ __file__ and __path__ attributes describing one discovered module, modulefinder ModuleFinder report for printing a formatted summary of found and missing modules to stdout, modulefinder ModuleFinder path parameter for overriding the search path used when tracing imports instead of sys.path, and modulefinder integration with zipfile and py_compile and packaging for building dependency graphs freeze validators missing-module detectors and deployment manifests.
Claude Code for zipimport: Python Import from Zip Archives
Import Python modules and packages directly from zip archives with Python's zipimport module and Claude Code — zipimport zipimporter for the importer class that handles zip-based entries on sys.path, zipimport zipimporter find_module for the legacy finder method that returns self if a module is available in the zip, zipimport zipimporter find_spec for the modern importlib-compatible spec finder returning a ModuleSpec, zipimport zipimporter load_module for the legacy loader that executes and returns a module from the zip, zipimport zipimporter exec_module and create_module for the importlib loader protocol methods, zipimport zipimporter get_data for reading arbitrary bytes from a path inside the zip as if it were a file, zipimport zipimporter get_filename for returning the full archive-rooted path of a module source or bytecode file, zipimport zipimporter get_source for returning the source code string of a module inside the zip, zipimport zipimporter get_code for returning the code object of a module inside the zip, zipimport zipimporter is_package for testing whether a name is a package inside the zip, zipimport zipimporter archive for the path attribute giving the zip file path, and zipimport integration with sys.path and zipfile and importlib for building single-file app bundles resource readers zip-based plugin loaders and distribution validators.
Claude Code for marshal: Python Bytecode Serialization
Serialize and deserialize Python code objects and simple values with Python's marshal module and Claude Code — marshal dumps for converting a Python value to bytes, marshal loads for reconstructing a value from bytes, marshal dump for writing serialized bytes to a binary file object, marshal load for reading and reconstructing from a binary file object, marshal version for the integer constant controlling the on-disk bytecode format version, marshal supported types covering None bool int float complex str bytes bytearray tuple list set frozenset dict frozenset and code objects, marshal PyC header reading for parsing the magic number mtime and source-size fields that prefix every dot-pyc file, marshal code object introspection for accessing co_code co_consts co_names co_varnames co_filename co_firstlineno and co_flags on a types.CodeType returned by marshal.loads, and marshal integration with py_compile and importlib.util and dis for building bytecode readers pyc validators code object serializers and lightweight in-process caches.
Claude Code for errno: Python System Error Code Constants
Interpret and handle POSIX system error codes with Python's errno module and Claude Code — errno ENOENT for the error number indicating no such file or directory, errno EACCES for permission denied, errno EEXIST for file already exists, errno ENOTDIR for not a directory, errno EISDIR for is a directory, errno ENOTEMPTY for directory not empty, errno ETIMEDOUT for operation timed out, errno ECONNREFUSED for connection refused, errno EADDRINUSE for address already in use, errno EPIPE for broken pipe, errno EAGAIN and EWOULDBLOCK for resource temporarily unavailable used in non-blocking I/O, errno EINTR for interrupted system call, errno ENOMEM for out of memory, errno errorcode for the dict mapping error numbers to their symbolic name strings, errno strerror for formatting an error number as a human-readable message, and errno integration with os and socket and subprocess for building error-specific exception handlers retry logic network error classifiers and portable cross-platform error message formatters.
Claude Code for stat: Python File Status Flag Interpretation
Interpret os.stat() results and file mode bits with Python's stat module and Claude Code — stat S_ISREG for testing whether a mode value describes a regular file, stat S_ISDIR for testing whether a mode describes a directory, stat S_ISLNK for testing if a mode describes a symbolic link, stat S_ISSOCK for testing if a mode describes a socket, stat S_ISBLK and S_ISCHR for testing block and character device nodes, stat S_ISFIFO for testing named pipes, stat ST_MODE ST_SIZE ST_MTIME ST_ATIME ST_CTIME for the integer indices into os.stat_result, stat S_IRUSR S_IWUSR S_IXUSR and group and other permission bits for bitmasking file permissions, stat UF_NODUMP and SF_IMMUTABLE for BSD and macOS file flags, stat filemode for returning an ls-style permission string like drwxr-xr-x from a mode integer, stat S_IFMT for extracting the file type bits, stat S_IMODE for extracting the permission bits, and stat integration with os and pathlib and shutil for building permission checkers file type routers directory walkers and mode formatting utilities.
Claude Code for sched: Python Event Scheduler
Schedule timed callbacks in a single-threaded or multi-threaded Python program with Python's sched module and Claude Code — sched scheduler for the event scheduler class that queues and fires callbacks at absolute or relative times, sched scheduler enter for scheduling a callback to run after a delay in seconds, sched scheduler enterabs for scheduling a callback to run at an absolute time value, sched scheduler cancel for cancelling a previously scheduled event by its event handle, sched scheduler run for running all queued events in time order blocking until they complete, sched scheduler run blocking parameter for controlling whether run blocks or drains only events that are immediately ready, sched scheduler empty for checking whether the event queue is empty, sched scheduler queue for the read-only list of pending Event namedtuples sorted by time, sched scheduler timefunc for the callable used to get the current time defaulting to time.monotonic, sched scheduler delayfunc for the callable used to sleep for the required interval, and sched integration with time and threading and heapq for building single-threaded retry loops debounce helpers cron-style schedulers background heartbeats and deadline-based timeouts.
Claude Code for py_compile: Python Source File Compilation
Compile Python source files to bytecode with Python's py_compile module and Claude Code — py_compile compile for compiling a single Python source file to a dot-pyc bytecode file in the __pycache__ directory, py_compile PycInvalidationMode for the enum controlling how the interpreter detects stale bytecode using TIMESTAMP or CHECKED_HASH or UNCHECKED_HASH, py_compile PyCompileError for the exception raised when a syntax error or other compilation error occurs, py_compile compile source parameter for the path to the source dot-py file, py_compile compile cfile parameter for overriding the output dot-pyc file path, py_compile compile dfile parameter for the filename to embed in tracebacks instead of the real source path, py_compile compile optimize parameter for the optimization level zero one or two passed to compile, py_compile compile invalidation_mode parameter for controlling bytecode cache invalidation strategy, and py_compile integration with compileall and importlib and pathlib for building pre-compilation pipelines deploy validators syntax checkers and bytecode cache warmers.
Claude Code for builtins: Python Built-in Functions and Types
Access and extend Python's built-in namespace with the builtins module and Claude Code — builtins module for accessing all built-in names programmatically via the module object, builtins print for the built-in output function that can be replaced for custom logging or output redirection, builtins input for reading a line from stdin that can be replaced for scripted testing, builtins open for the built-in file opener that can be patched for virtual filesystems, builtins len for the built-in length function accessible as builtins.len, builtins type for creating new types dynamically at runtime, builtins isinstance and issubclass for runtime type checks, builtins getattr setattr hasattr delattr for dynamic attribute access, builtins vars and dir and id and hash for object inspection, builtins map filter zip enumerate sorted reversed for functional iteration tools, builtins repr and str and format for object serialization, builtins __import__ for the hook that controls how import statements load modules, and builtins integration with sys and ast and functools for building custom print hooks test stubs import interceptors and namespace introspection tools.
Claude Code for sys: Python Interpreter State and Control
Inspect and control the Python interpreter's runtime state with Python's sys module and Claude Code — sys argv for the list of command-line arguments passed to the script, sys exit for raising SystemExit to terminate the interpreter with an optional status code or error message, sys path for the list of directories the interpreter searches for modules, sys modules for the dict of all currently imported modules, sys stdin stdout stderr for the standard I/O stream objects, sys version and sys version_info for the Python version string and named tuple, sys platform for the operating system identifier string, sys executable for the path to the Python interpreter binary, sys getdefaultencoding for the default string encoding, sys getfilesystemencoding for the filesystem encoding, sys maxsize for the largest positive integer supported by the platform, sys byteorder for the native byte order little or big, sys getsizeof for the memory size of an object in bytes, sys getrecursionlimit and setrecursionlimit for the maximum recursion depth, sys exc_info for the current exception type value and traceback, sys settrace and setprofile for installing frame-level trace and profile hooks, and sys integration with os and io and traceback for building CLI argument processors stream redirectors import hooks version guards and memory profilers.
Claude Code for copyreg: Python Pickle State Registration
Control how objects are pickled and copied by registering constructor and reduce functions with Python's copyreg module and Claude Code — copyreg pickle for registering a custom reduce function for a type that tells pickle how to serialize instances, copyreg constructor for declaring a callable as a valid reconstruction function that pickle may call during unpickling, copyreg dispatch_table for the module-level dict mapping types to their reduce functions used by Pickler, copyreg _reconstructor for the default reconstruction callable used internally by pickle and copy, copyreg add_extension for registering a short numeric code for an object to reduce pickle size, copyreg remove_extension for unregistering an extension code, copyreg clear_extension_cache for clearing the extension lookup cache, and copyreg integration with pickle and copy and io and dataclasses for building version-tolerant serialization schemas backward-compatible pickle protocols extension registries C-extension type pickle support and custom deep-copy controls.
Claude Code for xml.etree.ElementTree: Python XML Parsing and Generation
Parse and generate XML documents with Python's xml.etree.ElementTree module and Claude Code — xml.etree.ElementTree parse for loading an XML file into an ElementTree, xml.etree.ElementTree fromstring for parsing an XML string into a root Element, xml.etree.ElementTree Element for the node class with tag text tail and attribute dict, xml.etree.ElementTree ElementTree for the document wrapper with write and find methods, xml.etree.ElementTree Element find for finding the first matching subelement by tag or XPath, xml.etree.ElementTree Element findall for returning a list of matching subelements, xml.etree.ElementTree Element findtext for returning the text content of the first matching element, xml.etree.ElementTree Element iter for recursively iterating all descendant elements, xml.etree.ElementTree tostring for serializing an Element to a bytes string, xml.etree.ElementTree indent for pretty-printing an Element tree in place, xml.etree.ElementTree SubElement for creating and appending a child element in one call, and xml.etree.ElementTree integration with io and pathlib and dataclasses for building config readers RSS parsers SOAP request builders sitemap generators and XML diff tools.
Claude Code for html.parser: Python HTML Parsing
Parse HTML documents by subclassing Python's HTMLParser with the html.parser module and Claude Code — html.parser HTMLParser for the base class whose handle methods are overridden to process HTML events, html.parser HTMLParser handle_starttag for receiving opening tags and their attribute lists, html.parser HTMLParser handle_endtag for receiving closing tags, html.parser HTMLParser handle_data for receiving text content between tags, html.parser HTMLParser handle_comment for receiving HTML comments, html.parser HTMLParser handle_entityref for receiving named character entity references, html.parser HTMLParser handle_charref for receiving numeric character references, html.parser HTMLParser handle_decl for receiving DOCTYPE declarations, html.parser HTMLParser feed for incrementally feeding HTML string chunks to the parser, html.parser HTMLParser reset for resetting parser state, html.parser HTMLParser convert_charrefs for controlling whether character references are converted to Unicode, and html.parser integration with urllib.request and re and collections for building link extractors text extractors table scrapers and meta tag readers.
Claude Code for webbrowser: Python Browser Launch and URL Opening
Open URLs in the user's web browser from Python scripts with Python's webbrowser module and Claude Code — webbrowser open for opening a URL in the default browser with optional new-window or new-tab control, webbrowser open_new for opening a URL in a new browser window, webbrowser open_new_tab for opening a URL as a new tab in the existing browser window, webbrowser get for retrieving a specific registered browser controller by name, webbrowser register for registering a custom browser controller under a given name, webbrowser BackgroundBrowser for a browser launched in a background process without waiting for it to exit, webbrowser GenericBrowser for a browser launched via a simple command with the URL appended, webbrowser BaseBrowser open for the interface all browser controller classes implement, webbrowser BROWSER environment variable for overriding which browser is selected by the module, and webbrowser integration with pathlib and urllib.parse and os for building help-link launchers documentation openers OAuth callback helpers file-to-browser viewers and local HTML preview servers.
Claude Code for tempfile: Python Temporary File and Directory Management
Create and manage secure temporary files and directories with Python's tempfile module and Claude Code — tempfile NamedTemporaryFile for a temporary file with a visible filesystem path that is deleted when closed, tempfile TemporaryFile for an anonymous temporary file with no directory entry that is automatically deleted, tempfile SpooledTemporaryFile for a temporary file that buffers in memory up to a size limit before spilling to disk, tempfile TemporaryDirectory for a temporary directory that is recursively deleted when the context manager exits, tempfile mkstemp for creating a named temporary file and returning a file descriptor and path without auto-deletion, tempfile mkdtemp for creating a temporary directory and returning its path without auto-deletion, tempfile gettempdir for returning the default temporary directory path, tempfile tempdir for overriding the default temporary directory, tempfile NamedTemporaryFile delete parameter for controlling whether the file is deleted on close, and tempfile integration with pathlib and shutil and contextlib for building atomic write helpers work-directory managers upload staging areas and test fixture factories.
Claude Code for atexit: Python Interpreter Shutdown Handlers
Register cleanup functions that run automatically when the Python interpreter exits with Python's atexit module and Claude Code — atexit register for registering a callable to be called at interpreter shutdown with optional positional and keyword arguments, atexit unregister for removing all registrations of a callable from the exit handler list, atexit _clear for removing all registered exit handlers, atexit _run_exitfuncs for calling all registered handlers immediately in LIFO order, atexit handlers for the callbacks that fire during normal interpreter shutdown including sys.exit calls but not os._exit or SIGKILL, atexit LIFO execution order so that the last registered handler runs first to match resource acquisition order, atexit exception handling where exceptions in handlers are printed to stderr and the remaining handlers continue, and atexit integration with tempfile and logging and multiprocessing and threading for building cleanup registrars resource finalizers log flushers lock releasers and temporary file removers.
Claude Code for contextvars: Python Context Variable Management
Manage context-local state in concurrent async and threaded code with Python's contextvars module and Claude Code — contextvars ContextVar for declaring a context-local variable with a name and optional default value, contextvars ContextVar get for retrieving the current value falling back to default or raising LookupError, contextvars ContextVar set for setting a value and returning a Token that can undo the change, contextvars ContextVar reset for restoring a ContextVar to its value before the matching set call using the Token, contextvars Token for the object returned by ContextVar.set that captures the prior value for rollback, contextvars copy_context for copying the current execution context as a Context snapshot, contextvars Context for the immutable mapping of ContextVar to value that can be run with Context.run, contextvars Context run for executing a callable in the context snapshot isolating any set calls from the caller, and contextvars integration with asyncio and threading and logging and decimal for building request-scoped storage middleware tracing systems per-task configuration and tenant-aware async handlers.
Claude Code for selectors: Python Cross-Platform I/O Multiplexing
Monitor multiple file descriptors efficiently across platforms with Python's selectors module and Claude Code — selectors DefaultSelector for automatically choosing the most efficient I/O multiplexer available on the current platform, selectors SelectSelector for the select-based fallback multiplexer available on all platforms, selectors EpollSelector for the Linux epoll-based multiplexer, selectors KqueueSelector for the BSD and macOS kqueue-based multiplexer, selectors PollSelector for the Linux poll-based multiplexer, selectors BaseSelector register for registering a file object for monitoring with an event mask and optional data attachment, selectors BaseSelector unregister for removing a file object from monitoring, selectors BaseSelector select for waiting up to a timeout for I/O events returning a list of ready SelectorKey objects and event masks, selectors BaseSelector modify for changing the event mask of a registered file object, selectors SelectorKey for the namedtuple of fileobj fd events and data returned by select and get_key, selectors EVENT_READ and EVENT_WRITE for the event mask constants, and selectors integration with socket and threading for building cross-platform echo servers callback-driven event loops non-blocking TCP connects and multiplexed client pools.
Claude Code for http.cookiejar: Python HTTP Client Cookie Management
Automatically manage HTTP cookies in client sessions with Python's http.cookiejar module and Claude Code — http.cookiejar CookieJar for an in-memory cookie store that automatically receives and sends cookies with urllib requests, http.cookiejar FileCookieJar for a persistent cookie store that can be saved to and loaded from a file, http.cookiejar MozillaCookieJar for reading and writing cookies in the Netscape Mozilla cookies.txt format, http.cookiejar LWPCookieJar for reading and writing cookies in the libwww Set-Cookie3 format, http.cookiejar DefaultCookiePolicy for the default accept-reject policy governing which cookies are stored and sent, http.cookiejar CookiePolicy for implementing custom cookie acceptance rules, http.cookiejar Cookie for a single stored cookie with all its attributes, http.cookiejar HTTPCookieProcessor for the urllib request handler that integrates a CookieJar with an OpenerDirector, and http.cookiejar integration with urllib.request and ssl and pathlib for building authenticated web scrapers session-persistent crawlers cookie-based login flows and browser cookie importers.
Claude Code for select: Python I/O Multiplexing
Monitor multiple file descriptors for I/O readiness with Python's select module and Claude Code — select select for waiting until one or more file descriptors become ready for reading writing or exceptional conditions, select poll for an efficient level-triggered I/O multiplexing object on Linux that avoids the fd-count limit of select, select epoll for the Linux epoll interface offering edge-triggered or level-triggered I/O notification for thousands of concurrent connections, select kqueue for the BSD and macOS kqueue interface for efficient event notification, select kevent for constructing kqueue event filter entries, select devpoll for the Solaris dev-poll interface, select select read-list and write-list and exceptional-list for the three lists of file-like objects or descriptors to monitor, select poll register and modify and unregister for managing the set of monitored descriptors, select poll poll for waiting up to a timeout milliseconds for events, select POLLIN POLLOUT POLLERR POLLHUP for poll event mask constants, and select integration with socket and threading and ssl for building echo servers multiplexed chat servers non-blocking I/O loops and event-driven pipelines.
Claude Code for secrets: Python Cryptographic Token Generator
Generate cryptographically secure random values with Python's secrets module and Claude Code — secrets token_bytes for generating a secure random byte string of the specified number of bytes suitable for tokens and keys, secrets token_hex for generating a secure random hex string of twice the specified number of characters, secrets token_urlsafe for generating a URL-safe base64-encoded secure random string suitable for session tokens and password reset links, secrets choice for choosing a cryptographically random element from a sequence, secrets randbelow for returning a random integer in the range from 0 to exclusive-n, secrets randbits for returning an integer with the specified number of random bits, secrets SystemRandom for a Random subclass that uses the OS cryptographic random source, secrets compare_digest for timing-safe string comparison, and secrets integration with hashlib and hmac and base64 and os.urandom for building API key generators session token systems password reset flows OTP generators and secure nonce producers.
Claude Code for hmac: Python HMAC Message Authentication
Compute and verify HMAC message authentication codes with Python's hmac module and Claude Code — hmac new for creating a new HMAC object with a key and optional message using a specified digest algorithm, hmac digest for computing an HMAC in a single call without creating an object, hmac compare_digest for comparing two digests in constant time to prevent timing attacks, hmac HMAC update for feeding additional data into an existing HMAC object, hmac HMAC digest for returning the raw bytes MAC, hmac HMAC hexdigest for returning the hex-encoded MAC string, hmac HMAC copy for cloning an HMAC object for parallel MAC computation, hmac HMAC block_size for the underlying hash's block size in bytes, hmac HMAC digest_size for the output MAC length in bytes, and hmac integration with hashlib and secrets and struct and time for building request signing middlewares webhook validators API key verifiers session cookie signers and tamper-proof token systems.
Claude Code for getpass: Python Secure Password Input
Prompt for passwords without echo and retrieve the current username with Python's getpass module and Claude Code — getpass getpass for prompting the user for a password on the terminal with echo disabled so the typed characters are not visible, getpass getuser for returning the login name of the current process owner from environment variables or the password database, getpass GetPassWarning for the warning emitted when echo cannot be disabled for the password prompt such as when reading from a pipe or non-interactive stream, getpass getpass prompt parameter for customizing the prompt string shown to the user, getpass getpass stream parameter for specifying an alternative stream for the prompt output such as sys.stderr, and getpass integration with crypt and hashlib and hmac and os for building terminal authentication prompts interactive credential collectors sudo-style privilege escalation helpers and CLI login flows.
Claude Code for getopt: Python C-Style Command Line Parser
Parse short and long command-line options with Python's getopt module and Claude Code — getopt getopt for parsing a list of arguments into option-value pairs using short option string syntax with colon for required arguments, getopt gnu_getopt for parsing options that may appear after positional arguments in any order, getopt GetoptError for the exception raised when an unrecognized option or missing required argument is encountered, getopt GetoptError msg for the human-readable error description, getopt GetoptError opt for the option string that caused the error, getopt short option format with colon suffix for required value and no suffix for flag, getopt long option format as a list of strings with equals suffix for required value, and getopt integration with sys.argv and os and subprocess for building CLI tools option processors subcommand dispatchers and legacy script adapters.
Claude Code for urllib.robotparser: Python robots.txt Parser
Parse and query robots.txt files with Python's urllib.robotparser module and Claude Code — urllib.robotparser RobotFileParser for creating a parser object that fetches and parses a robots.txt file, urllib.robotparser RobotFileParser set_url for setting the robots.txt URL before fetching, urllib.robotparser RobotFileParser read for fetching the robots.txt content over HTTP, urllib.robotparser RobotFileParser parse for parsing a robots.txt from a list of lines without fetching, urllib.robotparser RobotFileParser can_fetch for checking whether a given user-agent is allowed to access a given URL, urllib.robotparser RobotFileParser crawl_delay for returning the Crawl-delay value specified for a user-agent, urllib.robotparser RobotFileParser request_rate for returning the Request-rate value as a named tuple with requests and seconds, urllib.robotparser RobotFileParser modified for returning the last-modified time of the robots.txt fetch, urllib.robotparser RobotFileParser mtime for the fetched timestamp, and urllib.robotparser integration with urllib.request and logging and pathlib for building polite crawlers site scraper guards fetch policy validators and crawl rate limiters.
Claude Code for http.server: Python HTTP Development Server
Serve files and build custom HTTP handlers with Python's http.server module and Claude Code — http.server HTTPServer for creating a TCP socket server that dispatches HTTP requests, http.server ThreadingHTTPServer for handling each request in its own thread, http.server BaseHTTPRequestHandler for implementing custom GET POST PUT DELETE and other HTTP method handlers, http.server SimpleHTTPRequestHandler for serving static files and directory listings from the current directory, http.server BaseHTTPRequestHandler send_response for writing the status line, http.server BaseHTTPRequestHandler send_header for writing individual response headers, http.server BaseHTTPRequestHandler end_headers for finalizing the header section, http.server BaseHTTPRequestHandler wfile for the response body write buffer, http.server BaseHTTPRequestHandler rfile for reading the request body, http.server BaseHTTPRequestHandler path for the URL path, http.server BaseHTTPRequestHandler headers for the request headers dict, http.server BaseHTTPRequestHandler command for the HTTP method string, and http.server integration with socketserver and ssl and json and threading for building development servers JSON REST handlers file upload endpoints and test HTTP fixtures.
Claude Code for cmath: Python Complex Number Math
Perform mathematical operations on complex numbers with Python's cmath module and Claude Code — cmath phase for the phase angle of a complex number in radians, cmath polar for converting a complex number to polar form as a magnitude and phase tuple, cmath rect for converting polar form back to a complex number, cmath exp for the complex exponential, cmath log for the complex natural logarithm with optional base, cmath log10 for the complex base-10 logarithm, cmath sqrt for the complex square root, cmath sin cos tan for complex trigonometric functions, cmath asin acos atan for complex inverse trigonometric functions, cmath sinh cosh tanh for complex hyperbolic functions, cmath asinh acosh atanh for complex inverse hyperbolic functions, cmath isclose for comparing two complex numbers within a relative or absolute tolerance, cmath isinf isnan isfinite for testing complex special values, cmath pi tau e inf nan for mathematical constants, and cmath integration with math and numpy and struct for building phasor calculators signal processors impedance analyzers and complex root finders.
Claude Code for xmlrpc.server: Python XML-RPC Server
Build and serve XML-RPC APIs with Python's xmlrpc.server module and Claude Code — xmlrpc.server SimpleXMLRPCServer for creating a standalone HTTP server that dispatches XML-RPC method calls, xmlrpc.server SimpleXMLRPCServer register_function for registering a callable as an XML-RPC method with a custom name, xmlrpc.server SimpleXMLRPCServer register_instance for registering an object whose public methods become callable XML-RPC methods, xmlrpc.server SimpleXMLRPCServer register_introspection_functions for adding system.listMethods system.methodSignature and system.methodHelp introspection support, xmlrpc.server SimpleXMLRPCServer register_multicall_functions for enabling system.multicall batch request support, xmlrpc.server MultiPathXMLRPCServer for serving multiple XML-RPC endpoints at different URL paths in a single server, xmlrpc.server CGIXMLRPCRequestHandler for running an XML-RPC endpoint as a CGI script, xmlrpc.server SimpleXMLRPCRequestHandler rpc_paths for restricting which URL paths accept XML-RPC requests, and xmlrpc.server integration with xmlrpc.client and socketserver and threading for building REST-free RPC services calculator APIs test harnesses and multi-service XML-RPC routers.
Claude Code for http.cookies: Python HTTP Cookie Parser
Parse, build, and manage HTTP Set-Cookie and Cookie headers with Python's http.cookies module and Claude Code — http.cookies SimpleCookie for a dict-like container that parses and serializes HTTP cookie headers, http.cookies Morsel for a single cookie with its value and attributes including expires domain path secure httponly samesite max-age and comment, http.cookies SimpleCookie load for parsing a Set-Cookie or Cookie header string into the cookie jar, http.cookies SimpleCookie output for serializing all cookies as Set-Cookie header lines, http.cookies Morsel OutputString for serializing a single cookie including its attributes, http.cookies Morsel coded_value for the quoted and encoded cookie value safe for the wire, http.cookies Morsel key for the cookie name, http.cookies CookieError for exceptions raised when parsing malformed cookie strings, and http.cookies integration with http.server and urllib and datetime for building cookie readers Set-Cookie emitters session token managers and test cookie harnesses.
Claude Code for poplib: Python POP3 Email Retrieval
Download email messages from POP3 servers with Python's poplib module and Claude Code — poplib POP3 for opening a cleartext POP3 connection to a mail server, poplib POP3_SSL for opening a TLS-encrypted POP3 connection, poplib POP3 user and pass_ for authenticating with username and password credentials, poplib POP3 apop for authenticating with the APOP challenge-response mechanism, poplib POP3 stat for returning a tuple of message count and total mailbox size in bytes, poplib POP3 list for listing all messages with their sizes as a list of id size strings, poplib POP3 retr for retrieving a full message by number returning response header lines and octets, poplib POP3 top for retrieving only the headers and a specified number of body lines, poplib POP3 dele for marking a message for deletion to take effect on quit, poplib POP3 uidl for returning unique message identifiers that persist across sessions, poplib POP3 noop for sending a no-op keepalive, poplib POP3 rset for cancelling all pending deletions, poplib POP3 quit for committing deletions and closing the connection, and poplib integration with email and ssl and io for building mail downloaders duplicate detectors inbox monitors and message archive builders.
Claude Code for doctest: Python Documentation Testing
Run interactive Python examples embedded in docstrings with Python's doctest module and Claude Code — doctest testmod for running all docstring examples in a module and reporting failures, doctest testfile for running docstring examples embedded in a plain text file, doctest run_docstring_examples for running examples from a single docstring, doctest DocTestFinder for extracting DocTest objects from modules classes and functions, doctest DocTestRunner for executing a list of DocTest objects and collecting results, doctest DocTestSuite for creating a unittest.TestSuite from all doctests in a module, doctest DocFileSuite for creating a unittest.TestSuite from a text file containing doctests, doctest ELLIPSIS directive for matching variable output with three dots, doctest NORMALIZE_WHITESPACE directive for ignoring whitespace differences in expected output, doctest SKIP directive for skipping a specific example, doctest IGNORE_EXCEPTION_DETAIL for matching exception type without caring about the message, and doctest integration with unittest and pytest and pathlib for building embedded test suites example validators API contract checkers and living documentation verifiers.
Claude Code for pickletools: Python Pickle Bytecode Analyzer
Inspect and optimize pickle byte streams with Python's pickletools module and Claude Code — pickletools dis for disassembling a pickle byte stream into human-readable opcode annotations printed to stdout or a file, pickletools genops for generating a sequence of opcode name argument position tuples from a pickle byte stream without printing, pickletools optimize for removing redundant PUT opcodes from a pickle byte stream to reduce its size, pickletools read_uint1 and read_uint2 and read_int4 for reading little-endian integers from a binary stream at a given offset, pickletools opcodes for the complete list of PickleBuffer opcode descriptors with name code argument type docs and stack effect, and pickletools integration with pickle and io and struct for building pickle debuggers protocol analyzers size optimizers and serialization validators.
Claude Code for pyclbr: Python Class Browser
Inspect Python source files for class and function definitions with Python's pyclbr module and Claude Code — pyclbr readmodule for scanning a module by name and returning a dict of class names to Class objects, pyclbr readmodule_ex for scanning a module and returning both Class and Function objects, pyclbr Class for an object representing a class found in the source including name file module lineno and super attributes, pyclbr Function for an object representing a top-level function found in the source including name file module and lineno attributes, pyclbr Class methods for the dict of method names to line numbers within the class, pyclbr Class super for the list of base class names or pyclbr Class objects for inherited classes, pyclbr Class module for the module name where the class was found, pyclbr readmodule path parameter for specifying additional directories to search for the module source, and pyclbr integration with importlib and pathlib and ast for building class hierarchies method inventories documentation extractors and API surface scanners.
Claude Code for netrc: Python .netrc Credential Parser
Parse and use .netrc credential files with Python's netrc module and Claude Code — netrc netrc for reading the standard ~/.netrc file or a custom path returning a netrc object with all host credentials, netrc authenticators for looking up the login password and account for a given hostname returning a tuple, netrc hosts for the dictionary of all hostname entries mapping to login password and account tuples, netrc macros for the dictionary of ~/.netrc macro definitions, netrc NetrcParseError for errors encountered parsing a malformed netrc file, netrc machine token for entries that apply to a specific host, netrc default token for credentials that apply to any host not explicitly listed, netrc login token for the username, netrc password token for the credential secret, netrc account token for an optional secondary account identifier, and netrc integration with ftplib and urllib and httpx and ssh for building authenticated FTP clients credential loaders CI secret readers and multi-host authentication managers.
Claude Code for filecmp: Python File and Directory Comparison
Compare files and directory trees with Python's filecmp module and Claude Code — filecmp cmp for comparing two files by content or by signature metadata including size and modification time, filecmp cmpfiles for comparing a list of filenames across two directories returning a tuple of match differ and errors lists, filecmp dircmp for creating a directory comparison object that recursively compares two directory trees, filecmp dircmp left_only for the list of files only in the left directory, filecmp dircmp right_only for the list of files only in the right directory, filecmp dircmp common for the list of names present in both directories, filecmp dircmp same_files for files that are identical in both directories, filecmp dircmp diff_files for files that have different content in both directories, filecmp dircmp funny_files for files that could not be compared, filecmp dircmp subdirs for a dict of dircmp objects for common subdirectories, filecmp dircmp report for printing a human-readable comparison report, filecmp clear_cache for clearing the filecmp comparison cache, and filecmp integration with pathlib and hashlib and shutil for building directory synchronizers backup validators diff reporters and file deduplication tools.
Claude Code for fileinput: Python Multi-File Line Iterator
Iterate over lines from multiple files or stdin with Python's fileinput module and Claude Code — fileinput input for creating an iterator that transparently reads through multiple filenames or stdin as though they were a single stream, fileinput filename for getting the name of the file currently being read, fileinput fileno for getting the file descriptor of the current file, fileinput lineno for getting the cumulative line number across all files, fileinput filelineno for getting the line number within the current file only, fileinput isfirstline for checking whether the current line is the first line of a new file, fileinput isstdin for checking whether the current source is standard input, fileinput nextfile for skipping the remainder of the current file, fileinput close for closing the fileinput object and all open files, fileinput hook_compressed for transparently decompressing gzip and bzip2 files, fileinput hook_encoded for decoding files with a specified character encoding, fileinput FileInput inplace parameter for in-place file filtering by redirecting stdout to write back to the file, and fileinput integration with sys.argv and re and pathlib for building multi-file search tools sed-style in-place editors line number annotators and grep replacement utilities.
Claude Code for formatter: Python Abstract Formatter and Writer
Build document formatters and text layout engines with Python's formatter module and Claude Code — formatter AbstractFormatter for processing document events such as paragraph breaks line breaks horizontal rules indentation changes font changes and literal text emission, formatter AbstractWriter for the output backend that receives formatted content from an AbstractFormatter and writes to a destination, formatter NullFormatter for a no-op formatter that discards all events without output, formatter NullWriter for a no-op writer backend, formatter DumbWriter for a simple writer that outputs to a file-like object with basic formatting, formatter AbstractFormatter add_literal_data for emitting literal preformatted text, formatter AbstractFormatter add_flowing_data for adding flowing text that can be wrapped, formatter AbstractFormatter push_font and pop_font for changing font size style and color, formatter AbstractFormatter push_margin and pop_margin for indentation, formatter AbstractFormatter assert_line_data for ensuring current position, and formatter integration with html.parser and io for building text layout engines document renderers markup-to-text converters and structured text formatters.
Claude Code for cgi: Python CGI Script Support
Parse HTTP query strings and form data in CGI scripts with Python's cgi module and Claude Code — cgi FieldStorage for parsing multipart form data URL-encoded query strings and file uploads from stdin and environment variables, cgi FieldStorage getvalue for safely retrieving a field value by name with a default, cgi FieldStorage getlist for retrieving all values submitted for a multi-value field, cgi FieldStorage filename for accessing the uploaded filename of a file upload field, cgi FieldStorage file for accessing the file-like object of the uploaded file data, cgi parse_header for splitting a Content-Type or Content-Disposition header into value and parameter dictionary, cgi parse_multipart for low-level multipart MIME body parsing, cgi escape for HTML-escaping values in CGI output, cgi print_environ for debugging the CGI environment variables, and cgi integration with http.server and os.environ and io for building form parsers file upload handlers CGI test harnesses and query string decoders.
Claude Code for cgitb: Python CGI Traceback Handler
Generate rich HTML and text traceback reports with Python's cgitb module and Claude Code — cgitb enable for installing cgitb as the global exception handler so all unhandled exceptions produce detailed HTML tracebacks with source code context local variable values and the full exception chain, cgitb enable text parameter for switching to a plain-text traceback format instead of HTML, cgitb enable display parameter for controlling whether the traceback appears in the browser response, cgitb enable logdir parameter for writing each traceback to a dated file in a log directory, cgitb handler for calling cgitb as a sys.excepthook replacement, cgitb text for generating a detailed plain-text traceback string from an exc_info tuple, cgitb html for generating a complete HTML traceback page from an exc_info tuple, cgitb reset for writing a closing tag to reset the HTML output buffer, and cgitb integration with sys and traceback and inspect for building rich exception reporters development debug pages structured traceback loggers and CI failure annotators.
Claude Code for smtpd: Python SMTP Server
Build SMTP server sinks and relays with Python's smtpd module and Claude Code — smtpd SMTPServer for creating an asynchronous SMTP server that accepts incoming mail connections on a local address and port, smtpd SMTPServer process_message for overriding the message delivery callback to receive the peer address mail from envelope sender rcpt tos recipient list and data message bytes, smtpd DebuggingServer for a ready-made SMTP server that prints all received messages to stdout, smtpd PureProxy for a transparent SMTP proxy that forwards messages to an upstream relay, smtpd MailmanProxy for integrating received mail with Mailman mailing lists, smtpd asynchat for the underlying async I/O multiplexing, and smtpd integration with email and asyncio and logging for building local mail capture servers test SMTP sinks development mail interceptors forwarding relays and SMTP pipeline validators.
Claude Code for telnetlib: Python Telnet Client
Automate Telnet protocol connections with Python's telnetlib module and Claude Code — telnetlib Telnet for opening a TCP connection to a host on port 23 or a custom port with optional timeout, telnetlib Telnet read_until for blocking until a specific byte string appears in the input stream or until timeout, telnetlib Telnet read_all for reading all data until the connection is closed, telnetlib Telnet read_some for reading at least one byte without blocking, telnetlib Telnet read_very_eager for reading everything available in the buffer immediately, telnetlib Telnet write for sending bytes to the server with IAC escaping for Telnet protocol control characters, telnetlib Telnet expect for waiting for one of several regular expressions to match the incoming data, telnetlib Telnet interact for switching to interactive mode passing stdin to the connection, telnetlib Telnet set_option_negotiation_callback for handling Telnet option negotiation IAC WILL WONT DO DONT sequences, telnetlib IAC WILL WONT DO DONT SB SE NOP option constants, and telnetlib integration with re and time and socket for building automated login scripts CLI scrapers expect-style automation tools and legacy device configuration managers.
Claude Code for nntplib: Python NNTP Usenet Client
Connect to Usenet NNTP servers with Python's nntplib module and Claude Code — nntplib NNTP for connecting to a Usenet news server on port 119 with optional authentication, nntplib NNTP_SSL for connecting over TLS on port 563, nntplib list for retrieving the list of all newsgroups with article counts, nntplib group for selecting a newsgroup and getting its first last and article count, nntplib over for retrieving message overviews containing subject from date message-id references bytes lines, nntplib article for fetching a complete article with headers and body, nntplib head for fetching only the article headers, nntplib body for fetching only the article body, nntplib newnews for getting message IDs of articles posted since a given datetime, nntplib post for posting a new article, nntplib NNTPError for handling server error responses, nntplib GroupInfo and ArticleInfo named tuples, and nntplib integration with email and ssl and datetime for building newsgroup browsers article archivers subject line readers and Usenet feed processors.
Claude Code for pipes: Python Shell Pipeline Constructor
Build Unix shell command pipelines programmatically with Python's pipes module and Claude Code — pipes Template for creating a reusable pipeline template object that chains shell commands, pipes Template append for adding a shell command step to the pipeline with a flag specifying input and output modes such as source sink filter or tee, pipes Template prepend for inserting a command at the beginning of an existing template, pipes Template clone for copying a template to create a variant pipeline, pipes Template open for opening a pipeline for reading or writing as a file-like object, pipes Template debug flag for tracing the constructed shell command, pipes quote for safely quoting a filename for use in a shell command string to prevent injection, pipes STDIN and pipes STDOUT pseudo-file constants, and pipes integration with subprocess and shlex and os for building composable text processing pipelines filter chains multifile transformers and shell command constructors.
Claude Code for xdrlib: Python XDR Data Encoding
Encode and decode XDR (External Data Representation) binary data with Python's xdrlib module and Claude Code — xdrlib Packer for building XDR-encoded binary buffers by packing integers floats doubles opaque bytes strings booleans and unsigned integers, xdrlib Packer pack_int for encoding a signed 32-bit integer in big-endian XDR format, xdrlib Packer pack_uint for encoding an unsigned 32-bit integer, xdrlib Packer pack_hyper for encoding a signed 64-bit integer, xdrlib Packer pack_uhyper for encoding an unsigned 64-bit integer, xdrlib Packer pack_float for encoding a 32-bit IEEE 754 float, xdrlib Packer pack_double for encoding a 64-bit IEEE 754 double, xdrlib Packer pack_opaque for encoding fixed-length bytes with 4-byte alignment padding, xdrlib Packer pack_bytes for encoding variable-length bytes with a 4-byte length prefix, xdrlib Packer pack_string for encoding a variable-length string as UTF-8 bytes with length prefix, xdrlib Packer pack_list and pack_farray for encoding variable-length and fixed-length arrays, xdrlib Unpacker for reading XDR-encoded binary data back into Python types, and xdrlib integration with struct and socket and io for building NFS RPC message encoders DNS wire format tools distributed protocol buffers and cross-platform binary serializers.
Claude Code for audioop: Python Audio Signal Operations
Process raw PCM audio samples with Python's audioop module and Claude Code — audioop max for finding the maximum absolute sample value in a PCM buffer, audioop minmax for returning the minimum and maximum sample values simultaneously, audioop avg for computing the average of absolute sample values, audioop rms for computing the root mean square power level of a PCM buffer, audioop tomono for mixing a stereo interleaved buffer to mono with adjustable channel weights, audioop tostereo for duplicating a mono buffer into a stereo interleaved buffer, audioop lin2ulaw and audioop ulaw2lin for CCITT G.711 mu-law encode and decode, audioop lin2alaw and audioop alaw2lin for CCITT G.711 A-law encode and decode, audioop ratecv for sample rate conversion between arbitrary rates, audioop bias for adding a constant bias to each sample, audioop mul for multiplying each sample by a floating-point factor, audioop adpcm2lin and audioop lin2adpcm for Intel ADPCM codec, audioop add for adding two PCM buffers sample by sample, audioop cross for determining zero-crossing rate, and audioop integration with wave and sunau for building audio normalizers resampling pipelines codec converters stereo mixers and PCM signal analyzers.
Claude Code for chunk: Python IFF Chunk Parser
Parse IFF RIFF and AIFF chunk-based binary file formats with Python's chunk module and Claude Code — chunk Chunk for reading a single IFF chunk from a file-like object, chunk Chunk getname for getting the 4-byte chunk identifier such as RIFF fmt data LIST or FORM AIFF COMM SSND, chunk Chunk getsize for getting the data size of the chunk in bytes, chunk Chunk read for reading the chunk data bytes, chunk Chunk skip for advancing past the chunk without reading its data, chunk Chunk seek and chunk Chunk tell for seeking within the chunk data, chunk Chunk close for finishing the chunk, bigendian parameter for switching between RIFF little-endian and IFF AIFF big-endian byte order in chunk size fields, and chunk integration with struct and io and wave and aifc for building raw RIFF WAV parsers AIFF chunk inspectors IFF file analyzers custom chunk extractors and binary format debuggers.
Claude Code for aifc: Python AIFF and AIFF-C Audio Format
Read and write AIFF and AIFF-C audio files with Python's aifc module and Claude Code — aifc open for opening an AIFF or AIFF-C file for reading or writing returning an Aifc_read or Aifc_write object, aifc Aifc_read getnchannels for getting the number of audio channels, aifc Aifc_read getsampwidth for getting the number of bytes per audio sample, aifc Aifc_read getframerate for getting the sample rate in Hz, aifc Aifc_read getnframes for getting the total number of audio frames, aifc Aifc_read getcomptype for getting the AIFF-C compression type such as NONE sowt ulaw alaw or MARC, aifc Aifc_read readframes for reading a specified number of frames as raw bytes, aifc Aifc_write setnchannels setsampwidth setframerate for configuring the output AIFF or AIFF-C file parameters, aifc Aifc_write writeframes for writing PCM or compressed frames to the file, aifc Aifc_write setcomptype for setting AIFF-C compression, aifc Aifc_read getmarkers and Aifc_write setmark for reading and writing IFF marker annotations, and aifc integration with wave and struct for building AIFF to WAV converters Apple audio readers marker extractors and multi-format audio inspection pipelines.
Claude Code for sunau: Python Sun AU Audio Format
Read and write Sun AU and NeXT audio files with Python's sunau module and Claude Code — sunau open for opening an AU file for reading or writing returning an AU_read or AU_write object, sunau AU_read getnchannels for getting the number of audio channels, sunau AU_read getsampwidth for getting the number of bytes per audio sample, sunau AU_read getframerate for getting the audio sample rate in Hz, sunau AU_read getnframes for getting the total number of audio frames, sunau AU_read getcomptype for getting the compression type such as ULAW ALAW or NONE, sunau AU_read readframes for reading a specified number of frames as raw bytes, sunau AU_write setnchannels setsampwidth setframerate for configuring output parameters, sunau AU_write writeframes for writing PCM frames to the AU file, sunau AUDIO_FILE_ENCODING_ULAW_8 AUDIO_FILE_ENCODING_LINEAR_16 encoding constants, and sunau integration with wave and struct and array for building AU to WAV converters sample rate analyzers encoding format detectors and multi-format audio pipeline tools.
Claude Code for ossaudiodev: Python Linux OSS Audio Device
Access Linux OSS audio hardware directly with Python's ossaudiodev module and Claude Code — ossaudiodev open for opening a PCM audio device for playback or recording returning an audio device object, ossaudiodev openmixer for opening the mixer device for volume and channel control, ossaudiodev setfmt for setting the sample format to AFMT_S16_LE AFMT_U8 or other OSS format constants, ossaudiodev channels for setting the number of audio channels to 1 for mono or 2 for stereo, ossaudiodev speed for setting the sample rate in Hz such as 44100 or 48000, ossaudiodev write for writing raw PCM frames to the audio device for playback, ossaudiodev read for reading raw PCM frames from the audio device for recording, ossaudiodev close for closing the audio device, ossaudiodev getplayvol and setplayvol for reading and writing the playback volume via the mixer, ossaudiodev SOUND_MIXER_VOLUME SOUND_MIXER_PCM SOUND_MIXER_LINE constants, and ossaudiodev integration with wave and struct and array for building raw PCM playback pipelines audio capture recorders volume controllers and OSS hardware diagnostic tools.
Claude Code for syslog: Python Unix Syslog Interface
Write structured log messages to the Unix syslog facility with Python's syslog module and Claude Code — syslog openlog for setting the program identity string used as prefix in all subsequent log messages, syslog closelog for closing the current connection to the syslog daemon, syslog syslog for writing a message at a specific priority combining a facility and a severity level, syslog setlogmask for filtering which priority levels actually get delivered to syslogd, syslog LOG_EMERG LOG_ALERT LOG_CRIT LOG_ERR LOG_WARNING LOG_NOTICE LOG_INFO LOG_DEBUG severity constants from highest to lowest priority, syslog LOG_AUTH LOG_DAEMON LOG_KERN LOG_LOCAL0 through LOG_LOCAL7 LOG_MAIL LOG_SYSLOG LOG_USER facility constants, syslog LOG_PID LOG_CONS LOG_NDELAY LOG_NOWAIT LOG_PERROR option flags for openlog, and syslog integration with logging and os and signal for building structured daemon loggers systemd service loggers audit trail emitters and syslog priority routing pipelines.
Claude Code for posix: Python Direct POSIX Syscall Wrappers
Access POSIX operating system interfaces directly with Python's posix module and Claude Code — posix stat for reading file metadata including mode size mtime uid gid and inode, posix open for opening files with low-level flags like O_RDONLY O_WRONLY O_CREAT O_TRUNC O_NONBLOCK, posix read and posix write for unbuffered byte-level I/O on file descriptors, posix fork for creating child processes, posix execv and posix execve for replacing process image, posix getpid and posix getppid for process identification, posix getuid posix getgid posix geteuid posix getegid for user and group identity, posix getcwd and posix chdir for working directory, posix listdir and posix mkdir and posix rmdir and posix rename and posix unlink for filesystem operations, posix kill for sending signals, posix waitpid for reaping child processes, and posix integration with os and stat and signal for building low-level process management file descriptor pipelines and Unix syscall wrappers.
Claude Code for resource: Python Unix Resource Limits
Read and set Unix process resource limits with Python's resource module and Claude Code — resource getrlimit for reading the current soft and hard resource limits for a given resource type, resource setrlimit for setting new soft and hard limits when privileged, resource getrusage for reading process resource usage statistics such as user time system time memory and I/O operations, resource RLIMIT_AS for virtual address space, resource RLIMIT_CORE for core dump file size, resource RLIMIT_CPU for CPU time in seconds, resource RLIMIT_DATA for data segment size, resource RLIMIT_FSIZE for maximum file size, resource RLIMIT_NOFILE for maximum number of open file descriptors, resource RLIMIT_NPROC for maximum number of child processes, resource RLIMIT_RSS for resident set size, resource RLIMIT_STACK for stack size, resource RLIM_INFINITY for unlimited resource value, resource RUSAGE_SELF for current process usage, resource RUSAGE_CHILDREN for terminated child usage, and resource integration with os and signal and subprocess for sandboxing memory-limited workers CPU-time enforcement and resource usage profiling pipeline patterns.
Claude Code for pwd: Python Unix Password Database
Query Unix user entries with Python's pwd module and Claude Code — pwd getpwnam for looking up a user entry by username returning a struct_passwd named tuple, pwd getpwuid for looking up a user entry by numeric user ID, pwd getpwall for returning all user entries from the system password database, pwd struct_passwd named tuple with pw_name pw_passwd pw_uid pw_gid pw_gecos pw_dir and pw_shell fields, pwd KeyError when a username or UID is not found in the database, pwd integration with os and grp and pathlib for building user identity resolvers home directory locators privilege drop helpers and Unix user audit pipelines.
Claude Code for grp: Python Unix Group Database
Query Unix group entries with Python's grp module and Claude Code — grp getgrnam for looking up a group entry by name returning a struct_group named tuple, grp getgrgid for looking up a group entry by numeric group ID, grp getgrall for returning all group entries from the system group database, grp struct_group named tuple with gr_name gr_passwd gr_gid and gr_mem fields, grp KeyError when a group name or GID is not found in the database, grp integration with os and pwd and subprocess for building group membership checks permission validators privileged process guards and Unix user-group relationship pipelines.
Claude Code for fcntl: Python File Descriptor and File Control
Control Unix file descriptor properties and perform advisory file locking with Python's fcntl module and Claude Code — fcntl fcntl for manipulating file descriptor flags such as O_NONBLOCK FD_CLOEXEC and F_SETFL F_GETFL commands, fcntl ioctl for sending device-specific control commands to file descriptors, fcntl flock for applying simple advisory file locks using LOCK_SH LOCK_EX LOCK_UN and LOCK_NB, fcntl lockf for POSIX record-level byte-range locking using LOCK_SH LOCK_EX LOCK_UN F_SETLK F_GETLK, fcntl F_GETFL and F_SETFL for getting and setting the file status flags, fcntl F_GETFD and F_SETFD for getting and setting the file descriptor flags including FD_CLOEXEC, fcntl F_SETLKW for blocking until a lock is available, fcntl F_DUPFD for duplicating a file descriptor to a minimum number, and fcntl integration with os and struct and subprocess for Python non-blocking I/O file lock guards single-instance pid files and concurrent file access pipeline patterns.
Claude Code for tty: Python Terminal Mode Switching
Switch Unix terminal modes with Python's tty module and Claude Code — tty setraw for configuring a terminal file descriptor to raw mode with no line discipline and no echo, tty setcbreak for configuring cbreak mode that disables line discipline while keeping signal characters active, tty IFLAG OFLAG CFLAG LFLAG CC constants matching the termios attribute list indices, tty setraw modifying iflag oflag cflag lflag and cc in-place using termios.tcsetattr with TCSAFLUSH, tty setcbreak disabling only ICANON and ECHO while preserving ISIG for Ctrl-C and Ctrl-Z, tty setraw versus setcbreak for choosing between completely raw input and signal-aware cbreak input, and tty integration with termios sys stdin os.read and select for building Python single-keypress readers interactive shell prompts game input handlers and terminal-aware password prompts.
Claude Code for termios: Python Terminal Attribute Control
Read and write Unix terminal attributes with Python's termios module and Claude Code — termios tcgetattr for reading the current terminal settings as a list, termios tcsetattr for applying terminal settings with TCSANOW TCSADRAIN or TCSAFLUSH timing, termios tcsendbreak for sending a break condition on the terminal, termios tcflush for discarding buffered terminal data, termios tcflow for suspending or resuming terminal data flow, termios termios constants such as ECHO ECHONL ICANON ISIG IXON VMIN VTIME for controlling input echo line discipline and signal generation, termios cfgetispeed and cfsetispeed for reading and setting the input baud rate, termios cfgetospeed and cfsetospeed for the output baud rate, termios TCSANOW for immediate attribute change, termios TCSADRAIN for change after all output written, termios TCSAFLUSH for change after output written with input discarded, and termios integration with tty and pty and select and sys for Python raw mode password prompting terminal state save restore and serial port configuration pipeline patterns.
Claude Code for pty: Python Pseudo-Terminal I/O
Spawn processes in pseudo-terminals with Python's pty module and Claude Code — pty fork for forking the process with the child attached to a new pseudo-terminal, pty openpty for allocating a master and slave pseudo-terminal file descriptor pair, pty spawn for running a command in a pseudo-terminal with optional read and write callbacks, pty STDOUT_FILENO for using standard file descriptor constants, pty master and slave for the master file descriptor controlling the terminal and the slave fd used by the child process, pty integration with os and select and tty and termios for reading from and writing to a process as if in an interactive terminal session, raw mode and character echoing for controlling terminal behavior in pseudo-terminal I/O pipelines, and pty use in terminal multiplexers SSH wrappers pexpect-style automation and interactive process capture on Unix Linux and macOS.
Claude Code for sndhdr: Python Audio File Type Detection
Identify audio file formats by reading magic bytes with Python's sndhdr module and Claude Code — sndhdr what for detecting the audio type of a file path returning a SndHeaders named tuple, sndhdr whathdr for testing audio type against a bytes header already in memory, sndhdr SndHeaders named tuple with filetype sample_rate channels encoding_type sample_bits fields, sndhdr detecting aiff aifc au hcom sndr sndt voc wav 8svx sb ub ul formats, sndhdr tests list for extending detection to additional audio types, sndhdr deprecation in Python 3.11 and removal in Python 3.13, and sndhdr comparison with filetype and mutagen and soundfile for modern audio format detection and metadata reading pipeline patterns.
Claude Code for imghdr: Python Image Type Detection
Detect image file formats by reading magic bytes with Python's imghdr module and Claude Code — imghdr what for identifying the image type of a file path or bytes object, imghdr tests for the list of image type test functions that imghdr iterates to identify format, imghdr what filename parameter for reading bytes from a file path, imghdr what h parameter for testing against a bytes header already in memory, imghdr what f parameter for reading from a file-like object, imghdr what returning png jpeg gif tiff bmp webp rgbe xbm or None for unknown, custom imghdr test registration for extending detection to additional formats, imghdr deprecation in Python 3.11 and removal in Python 3.13, and imghdr alternatives including filetype and python-magic and PIL.Image.open for modern image format detection pipeline patterns.
Claude Code for colorsys: Python Color Space Conversion
Convert between RGB HLS HSV and YIQ color spaces with Python's colorsys module and Claude Code — colorsys rgb_to_hsv for converting red green blue to hue saturation value, colorsys hsv_to_rgb for converting hue saturation value back to red green blue, colorsys rgb_to_hls for converting red green blue to hue lightness saturation, colorsys hls_to_rgb for converting hue lightness saturation to red green blue, colorsys rgb_to_yiq for converting red green blue to the YIQ television color space, colorsys yiq_to_rgb for converting YIQ components back to red green blue, colorsys ONE_THIRD and ONE_SIXTH and TWO_THIRD constants used internally in the hue calculation, and colorsys integration with PIL Pillow and tkinter and matplotlib for Python color picker, palette generator, gradient builder, and image recoloring pipeline patterns.
Claude Code for wave: Python WAV Audio File Reading and Writing
Read and write WAV audio files with Python's wave module and Claude Code — wave open for opening a WAV file for reading or writing, wave Wave_read getnchannels for the number of audio channels, wave Wave_read getsampwidth for the sample width in bytes, wave Wave_read getframerate for the sample rate in samples per second, wave Wave_read getnframes for the total number of audio frames, wave Wave_read readframes for reading a specified number of audio frames as bytes, wave Wave_read getparams for returning a named tuple of all parameters, wave Wave_write setnchannels for setting the channel count before writing, wave Wave_write setsampwidth for setting the sample width, wave Wave_write setframerate for setting the sample rate, wave Wave_write writeframes for writing audio data bytes to the file, wave Wave_write setparams for setting all parameters at once from a named tuple, and wave integration with struct and array and io for Python audio synthesis, normalization, resampling, and signal pipeline patterns.
Claude Code for quopri: Python Quoted-Printable Encoding
Encode and decode quoted-printable email content with Python's quopri module and Claude Code — quopri encode for converting binary data to quoted-printable bytes for safe MIME transport, quopri decode for decoding quoted-printable bytes back to binary, quopri encodestring for encoding a bytes object using quoted-printable, quopri decodestring for decoding a quoted-printable bytes object, quopri encode header parameter for using the modified header encoding variant without soft line breaks, quopri encode quotetabs parameter for encoding tab characters and spaces with equal-sign escaping, quopri integration with email.mime and io and base64 for Python MIME message construction and content transfer encoding pipeline patterns, and quopri comparison with base64 for choosing between human-readable quoted-printable and compact base64 encoded email body parts.
Claude Code for mailbox: Python Email Mailbox Reading and Writing
Read and write email mailbox files with Python's mailbox module and Claude Code — mailbox Maildir for reading and writing Maildir-format mailboxes with subdirectory layout, mailbox mbox for reading and writing Unix mbox format single-file mailboxes, mailbox Babyl for Babyl RMAIL format mailboxes, mailbox MH for MH folder format mailboxes, mailbox MMDF for MMDF multi-message format mailboxes, mailbox Mailbox add for adding a message to a mailbox, mailbox Mailbox remove for deleting a message by key, mailbox Mailbox get for retrieving a message by key, mailbox Mailbox iterkeys for iterating all message keys, mailbox Mailbox items for iterating key-message pairs, mailbox Mailbox flush for writing changes to disk, mailbox Mailbox lock and unlock for exclusive access, mailbox MaildirMessage mboxMessage for format-specific message wrappers, mailbox Message with email.message.Message API for accessing headers and body, and mailbox integration with email.parser and pathlib and shutil for Python email archive reader batch processor and migration pipeline patterns.
Claude Code for rlcompleter: Python Tab Completion for the REPL
Add tab completion to Python interactive sessions with the rlcompleter module and Claude Code — rlcompleter Completer for the completion class that searches globals and builtins, rlcompleter Completer complete for returning the nth completion candidate for a text prefix, rlcompleter Completer attr_matches for completing attribute names after a dot, rlcompleter Completer global_matches for completing names from globals and builtins, rlcompleter Completer namespace parameter for passing a custom namespace dictionary to complete from, readline set_completer for registering the rlcompleter function with readline, readline parse_and_bind for binding the Tab key to the completion function, rlcompleter integration with readline and sys and dir and builtins for Python REPL attribute and global name tab completion, and rlcompleter use in code.InteractiveConsole and custom shells for context-sensitive method and keyword completion pipeline patterns.
Claude Code for codeop: Python Incomplete Code Detection
Detect incomplete Python statements for interactive interpreters with the codeop module and Claude Code — codeop compile_command for attempting to compile a source string and returning None for incomplete input that needs more lines, codeop CommandCompiler for a stateful compiler that tracks future statement imports across multiple compile calls, codeop compile_command symbol parameter for specifying single exec or eval compilation mode, codeop compile_command filename parameter for the filename shown in SyntaxError tracebacks, codeop CommandCompiler call for compiling a code object that accumulates future feature flags across the session, codeop integration with code.InteractiveConsole and code.InteractiveInterpreter for building Python REPL loops, and codeop use in readline-based shells and Jupyter-style notebook kernels for determining when a code cell is complete or requires additional input.
Claude Code for symtable: Python Symbol Table Analysis
Analyze Python symbol tables and scope information with the symtable module and Claude Code — symtable symtable for building a SymbolTable tree from source code, symtable SymbolTable get_name for the scope name, symtable SymbolTable get_type for the scope type function class or module, symtable SymbolTable get_symbols for listing all Symbol objects defined in the scope, symtable SymbolTable get_children for the nested scopes inside the current scope, symtable SymbolTable has_exec for detecting exec usage, symtable SymbolTable is_optimized for whether local variable lookups use LOAD_FAST, symtable SymbolTable lookup for finding a Symbol by name in the current scope, symtable Symbol get_name for the symbol name, symtable Symbol is_assigned is_referenced is_imported is_global is_local is_free is_parameter is_namespace for symbol attribute queries, symtable Function get_parameters for parameter names and get_locals get_globals get_frees get_cells for categorized name lists, and symtable integration with ast and compile and dis for Python static scope analysis and free variable detection pipeline patterns.
Claude Code for site: Python Site Configuration and sys.path Customization
Manage Python's site-packages, sys.path, and startup customization with the site module and Claude Code — site getsitepackages for returning the list of all global site-packages directories, site getusersitepackages for the user-specific site-packages directory, site getuserbase for the user base directory under which scripts and packages are installed, site addsitedir for adding a directory and its pth files to sys.path, site addpackage for processing a single pth file, site ENABLE_USER_SITE for the flag controlling whether user site-packages are active, site PREFIXES for the list of prefixes searched for site-packages, site main for re-running site initialization to pick up new pth files, site sys_path_contains for checking if a path is already in sys.path, site sitecustomize for the user-level startup hook executed during interpreter initialization, and site integration with sys and sysconfig and importlib for Python environment bootstrap path management and virtual environment detection pipeline patterns.
Claude Code for sysconfig: Python Build and Installation Paths
Query Python's build configuration and installation layout with the sysconfig module and Claude Code — sysconfig get_path for retrieving a named installation path such as stdlib purelib platlib scripts data or include, sysconfig get_paths for returning all installation paths as a dictionary, sysconfig get_config_var for reading a single build-time configuration variable such as EXT_SUFFIX SOABI or LDFLAGS, sysconfig get_config_vars for returning all Makefile and pyconfig.h build variables as a dictionary, sysconfig get_python_version for the major.minor version string, sysconfig get_platform for the platform tag used in wheel names, sysconfig get_scheme_names for listing all available installation scheme names, sysconfig get_default_scheme for the scheme name active in this interpreter, sysconfig is_python_build for detecting whether the interpreter is running from its build directory, sysconfig parse_config_h for parsing a pyconfig.h style file into a dictionary, and sysconfig integration with sys and platform and importlib.metadata for Python environment introspection and cross-platform build path resolution pipeline patterns.
Claude Code for linecache: Python Source Line Reading
Read source code lines by filename and line number with Python's linecache module and Claude Code — linecache getline for fetching a single source line from any Python file including zipimported modules, linecache getlines for retrieving all lines of a file as a list, linecache clearcache for freeing all cached file content from memory, linecache checkcache for invalidating stale cache entries when files have changed on disk, linecache updatecache for explicitly loading or refreshing a file into the cache, linecache lazycache for registering a module's source lines using its loader without reading the file, linecache cache dictionary for direct inspection of the internal filename-to-lines mapping, and linecache integration with traceback and pdb and tracemalloc and inspect for Python source annotation, error context display, and profiler line labeling pipeline patterns.
Claude Code for tracemalloc: Python Memory Allocation Tracing
Trace Python memory allocations with the tracemalloc module and Claude Code — tracemalloc start for beginning memory tracing with a configurable call stack depth, tracemalloc stop for ending memory tracing and freeing trace data, tracemalloc take_snapshot for capturing a Snapshot of all current allocations, tracemalloc get_traced_memory for reading the current and peak traced memory in bytes, tracemalloc get_tracemalloc_memory for the memory used by tracemalloc itself, tracemalloc clear_traces for resetting all allocation records without stopping tracing, tracemalloc Snapshot compare_to for diffing two snapshots to find new allocations, tracemalloc Snapshot statistics for aggregating allocation data by traceback filename or lineno, tracemalloc Snapshot filter_traces for excluding irrelevant tracebacks such as stdlib paths, tracemalloc StatisticDiff for the allocation diff entry with count size and count_diff and size_diff fields, tracemalloc Traceback for the per-allocation call stack, and tracemalloc integration with gc and sys and linecache for Python memory leak detection and object allocation analysis pipeline patterns.
Claude Code for pstats: Python Profile Statistics Analysis
Analyze cProfile profiling data with Python's pstats module and Claude Code — pstats Stats for loading and managing profiling data from cProfile or profile output, pstats Stats sort_stats for sorting profile data by cumulative tottime ncalls filename or pcalls, pstats Stats print_stats for displaying the top N hottest functions with optional limit and regex pattern, pstats Stats print_callers for showing which functions called each function in the profile, pstats Stats print_callees for showing which functions each function called, pstats Stats add for merging multiple profile runs into a single Stats object, pstats Stats dump_stats for writing the profile data to a file, pstats Stats strip_dirs for removing directory prefixes from filenames, pstats Stats get_stats_profile for returning a StatsProfile dataclass with structured data, pstats SortKey for the SortKey enum with cumulative time calls tottime filename and pcalls constants, and pstats integration with cProfile and io and pathlib for Python performance bottleneck analysis and function hotspot pipeline patterns.
Claude Code for compileall: Python Bytecode Compilation
Compile Python source files to bytecode with the compileall module and Claude Code — compileall compile_dir for recursively compiling all Python files in a directory tree to pyc bytecode, compileall compile_file for compiling a single Python source file to a pyc file, compileall compile_path for compiling all entries in sys.path, compileall compile_dir quiet parameter for suppressing output, compileall compile_dir force parameter for recompiling even when pyc is up to date, compileall compile_dir optimize parameter for selecting the optimization level 0 1 or 2, compileall compile_dir maxlevels for limiting recursion depth, compileall compile_dir ddir for overriding the source directory shown in error messages, compileall compile_dir workers for parallel compilation with multiple processes, compileall compile_dir invalidation_mode for selecting the source hash or timestamp pyc validation strategy, and compileall integration with py_compile and zipfile and pathlib for Python bytecode packaging and deployment pre-compilation pipeline patterns.
Claude Code for pkgutil: Python Package Utilities and Module Discovery
Discover modules and read package data with Python's pkgutil module and Claude Code — pkgutil iter_modules for listing available submodules of a package or all top-level modules, pkgutil walk_packages for recursively walking all submodules in a package tree, pkgutil get_loader for retrieving the loader for a named module, pkgutil find_loader for locating a module without importing it, pkgutil get_data for reading a binary resource file bundled inside a Python package, pkgutil extend_path for merging namespace packages from multiple directories, pkgutil ImpImporter and ImpLoader for legacy import machinery compatibility, pkgutil simplegeneric for a simple generic function dispatch decorator, pkgutil ModuleInfo named tuple returned by iter_modules with module_finder name and ispkg fields, and pkgutil integration with importlib and sys.path and os.path for Python namespace package discovery and plugin enumeration pipeline patterns.
Claude Code for importlib: Python Dynamic Import and Resource Access
Import modules dynamically and access package resources with Python's importlib module and Claude Code — importlib import_module for programmatically importing a module by name string, importlib reload for reloading an already-imported module to pick up source changes, importlib find_loader and util find_spec for locating a module without importing it, importlib util module_from_spec and spec_from_file_location for loading modules from arbitrary file paths, importlib util spec_from_loader for creating a module spec from a loader, importlib resources files and as_file and open_text and open_binary and read_text and read_binary for accessing files bundled inside Python packages, importlib resources path for a deprecated compatibility path context manager, importlib metadata version and packages_distributions and entry_points and requires for reading installed package metadata, importlib machinery SourceFileLoader and ModuleSpec for lower-level import machinery, and importlib integration with sys.modules and pathlib and pkgutil for Python plugin loader and package resource reader pipeline patterns.
Claude Code for curses: Python Terminal UI Programming
Build terminal user interfaces with Python's curses module and Claude Code — curses wrapper for safely initializing and cleaning up a curses application with automatic terminal restore, curses initscr for manual terminal initialization returning the stdscr window, curses newwin for creating a new window at a given position and size, curses Window addstr and addch for writing text and characters to a window, curses Window getch and getkey for reading keyboard input blocking or non-blocking, curses Window refresh and noutrefresh and doupdate for flushing window content to the terminal, curses Window box and border for drawing borders around a window, curses Window move and clear and erase for cursor positioning and clearing, curses Window getmaxyx for reading the current dimensions, curses color_pair and init_pair and start_color for terminal color support, curses curs_set for showing or hiding the cursor, curses noecho and echo and cbreak and nocbreak for input mode controls, curses Panel and new_panel for layered window management, and curses integration with threading for Python terminal dashboard and interactive TUI pipeline patterns.
Claude Code for cmd: Python Interactive Command Interpreter
Build interactive command-line shells with Python's cmd module and Claude Code — cmd Cmd for the base class providing a read-eval-print loop with do_ method dispatch and help_ documentation and complete_ tab completion hooks, cmd Cmd cmdloop for starting the interactive REPL with an optional intro banner, cmd Cmd onecmd for parsing and dispatching a single command string, cmd Cmd default for handling unrecognized commands, cmd Cmd emptyline for handling empty input lines, cmd Cmd precmd and postcmd for pre and post command hooks, cmd Cmd preloop and postloop for startup and teardown callbacks, cmd Cmd completedefault and completenames for completion routing, cmd Cmd identchars for setting the characters allowed in command names, cmd Cmd prompt for the input prompt string, cmd Cmd ruler and doc_leader and doc_header for help formatting, and cmd Cmd integration with readline and argparse and shlex for Python multi-command shell and CLI interpreter pipeline patterns.
Claude Code for readline: Python Interactive Line Editing
Add line editing, history, and tab completion to Python CLIs with the readline module and Claude Code — readline set_completer for registering a tab-completion callback function, readline parse_and_bind for binding readline key sequences such as tab complete and set editing-mode vi, readline read_history_file and write_history_file for persisting command history across sessions, readline get_history_length and set_history_length for controlling history size, readline get_current_history_length for the current session count, readline get_history_item for reading a specific history entry by index, readline clear_history for erasing all stored history, readline add_history for programmatically inserting a history entry, readline get_begidx and get_endidx for the cursor position in the completion buffer, readline get_line_buffer for reading the current input line during completion, readline set_pre_input_hook and set_startup_hook for pre-input callbacks, and readline integration with rlcompleter and input and pathlib and cmd for Python REPL history and tab-completion pipeline patterns.
Claude Code for plistlib: Python Property List Files
Read and write Apple property list files with Python's plistlib module and Claude Code — plistlib load for reading a binary or XML plist from a file object, plistlib loads for parsing plist bytes directly, plistlib dump for serializing a Python object to a plist file object, plistlib dumps for serializing a Python object to plist bytes, plistlib FMT_XML for the XML plist format constant, plistlib FMT_BINARY for the binary bplist00 format constant, plistlib UID for wrapping an unsigned integer as a plist UID type, plistlib InvalidFileException for errors raised when parsing fails, plistlib supported types mapping Python dict list tuple str int float bool bytes datetime and uid to plist equivalents, and plistlib integration with pathlib and xml and datetime for Python macOS configuration file reading and preferences file pipeline patterns.
Claude Code for dbm: Python Key-Value Database
Store and retrieve bytes by key with Python's dbm module and Claude Code — dbm open for opening a dbm database file with flag r w c or n and optional mode permissions, dbm ndbm and dbm dumb and dbm gnu for the three dbm backend implementations available on a platform, dbm whichdb for detecting the dbm implementation backing an existing database file, dbm error for the base exception class for all dbm errors, dbm Shelf underlying storage through shelve, dbm database keys for listing all stored keys, dbm setdefault for getting or initializing a key, dbm close for closing the database and flushing pending writes, dbm get for retrieving bytes with a default, and dbm integration with struct and json and msgpack and pathlib for Python persistent bytes store and binary key-value pipeline patterns.
Claude Code for shelve: Python Persistent Key-Value Store
Persist Python objects by key with the shelve module and Claude Code — shelve open for opening a persistent dictionary backed by dbm with optional flag and writeback parameters, shelve Shelf for the dict-like object returned by open supporting getitem setitem delitem keys values items len and contains, shelve writeback for enabling automatic sync of mutable values without re-assignment, shelve sync for manually flushing pending changes to disk, shelve close for closing the shelf and flushing all pending writes, shelve DbfilenameShelf for the concrete shelf class wrapping a dbm database file, shelve flag parameter r for read-only n for new empty c for create-or-open, shelve keys for listing all stored keys, shelve get for retrieving a value with a default, and shelve integration with pickle and pathlib and contextlib for Python persistent object cache and session storage pipeline patterns.
Claude Code for numbers: Python Numeric Abstract Base Classes
Use Python's numbers module abstract base classes with Claude Code — numbers Number for the root abstract base class of all numeric types, numbers Complex for numbers with real and imag and conjugate and abs and bool support, numbers Real for numbers with float conversion and math comparisons and floor and ceil and round and trunc, numbers Rational for numbers with numerator and denominator properties returning integers, numbers Integral for integers with bit-length and bit operations and int conversion, numbers register for registering existing numeric types as virtual subclasses of the hierarchy, isinstance with numbers.Number for duck-typed numeric type checking, and numbers integration with decimal and fractions and int and float and complex for Python numeric type checking and custom numeric type implementation pipeline patterns.
Claude Code for locale: Python Locale-Aware Formatting
Format numbers, currencies, and dates locale-aware with Python's locale module and Claude Code — locale setlocale for activating a locale category such as LC_ALL LC_NUMERIC LC_MONETARY LC_TIME LC_COLLATE and LC_CTYPE, locale getlocale for reading the active locale for a category, locale localeconv for retrieving the locale convention dictionary with decimal_point thousands_sep grouping currency_symbol and frac_digits, locale format_string for formatting a number with locale-aware separators, locale currency for formatting a monetary value with the locale symbol and grouping, locale str for converting a float to a locale-aware string, locale atof and atoi for parsing locale-formatted number strings back to float and int, locale strcoll for locale-aware string comparison, locale strxfrm for transforming a string for locale-aware sorting, locale normalize for mapping locale alias strings to proper locale names, locale getdefaultlocale for reading the system default locale, and locale integration with decimal and datetime and gettext for Python locale-aware formatting pipeline patterns.
Claude Code for gettext: Python Internationalization and Translation
Internationalize Python applications with the gettext module and Claude Code — gettext translation for loading a message catalog from a .mo file and returning a GNUTranslations object, gettext install for installing _() into builtins for global use, gettext bindtextdomain for setting the locale directory for a text domain, gettext textdomain for selecting the active text domain, gettext find for locating a .mo file for a given domain and language, gettext GNUTranslations for wrapping a compiled .mo message catalog with gettext and ngettext and pgettext methods, gettext NullTranslations for a no-op fallback when no catalog is found, gettext ngettext for plural-aware message lookup, gettext pgettext for context-disambiguation message lookup, gettext npgettext for plural context-disambiguated lookup, and gettext integration with Babel and locale and pathlib for Python i18n translation pipeline patterns.
Claude Code for tarfile: Python TAR Archive Creation and Extraction
Create and extract TAR archives with Python's tarfile module and Claude Code — tarfile open for opening a tar archive in read write or append mode with optional gzip bz2 or xz compression, tarfile add for adding a file or directory tree to an archive with optional filter and arcname, tarfile addfile for adding a TarInfo member with a file-like data object, tarfile extract for extracting a single member to a directory, tarfile extractall for extracting all members with optional filter and members list, tarfile getmembers for listing archive contents as TarInfo objects, tarfile getnames for listing member path names, tarfile TarInfo for inspecting and constructing archive member metadata including name size mtime mode uid gid type linkname, tarfile TarFile.add filter for stripping metadata during archive creation, tarfile is_tarfile for checking if a path is a valid tar archive, and tarfile integration with io and pathlib and gzip and bz2 and lzma for Python archive pipeline patterns.
Claude Code for bz2: Python BZip2 Compression
Compress and decompress data with Python's bz2 module and Claude Code — bz2 compress for one-shot in-memory bzip2 compression with compresslevel parameter, bz2 decompress for one-shot bzip2 decompression, bz2 open for opening a bzip2-compressed file for reading or writing in text or binary mode, bz2 BZ2File for creating a file-like object wrapping a bzip2 stream with mode and compresslevel, bz2 BZ2Compressor for stateful incremental compression with compress and flush methods, bz2 BZ2Decompressor for stateful incremental decompression with decompress method and eof and unused_data properties, bz2 BZ2Decompressor needs_input property for checking whether more input bytes are needed, and bz2 integration with io and tarfile and pathlib for Python BZip2 archive creation and streaming compression pipeline patterns.
Claude Code for lzma: Python LZMA/XZ Compression
Compress and decompress data with Python's lzma module and Claude Code — lzma compress for one-shot in-memory LZMA compression with format and preset and filters options, lzma decompress for one-shot LZMA decompression with memlimit and format, lzma open for opening an LZMA-compressed file for reading or writing in text or binary mode, lzma LZMAFile for creating a file-like object wrapping a compressed stream, lzma LZMACompressor for stateful incremental compression with compress and flush methods, lzma LZMADecompressor for stateful incremental decompression with decompress method, lzma FORMAT_XZ and FORMAT_ALONE and FORMAT_RAW for the three supported container formats, lzma CHECK_CRC32 and CHECK_CRC64 and CHECK_SHA256 for integrity check types in XZ format, lzma FILTER_LZMA2 and FILTER_DELTA and FILTER_X86 for multi-filter chain configuration, lzma MF_HC4 and MODE_FAST and MODE_NORMAL for encoder performance tuning, and lzma integration with io and tarfile and pathlib for Python XZ archive reading and streaming compression pipeline patterns.
Claude Code for codecs: Python Codec and Encoding Pipeline
Encode and decode text and binary data with Python's codecs module and Claude Code — codecs open for opening a file with an explicit text encoding and error handler, codecs encode and decode for applying codec transforms to strings or bytes, codecs lookup for retrieving a CodecInfo object for a named codec, codecs register for registering a custom search function for codec discovery, codecs CodecInfo for packaging encoder decoder streamreader and streamwriter into a codec object, codecs IncrementalEncoder and IncrementalDecoder for stateful streaming encoding and decoding, codecs BufferedIncrementalDecoder for byte-by-byte feed with internal buffering, codecs StreamReader and StreamWriter for wrapping file objects with codec layer, codecs getreader and getwriter and getencoder and getdecoder for factory shortcuts, codecs charmap_build for building a custom character mapping table, codecs BOM and BOM_UTF8 and BOM_UTF16 and BOM_UTF32 byte order mark constants, and codecs integration with io and base64 and binascii for Python text encoding and data transform pipeline patterns.
Claude Code for unicodedata: Python Unicode Character Properties
Query Unicode character properties with Python's unicodedata module and Claude Code — unicodedata name for retrieving the official Unicode name of a character, unicodedata lookup for finding a character by its Unicode name, unicodedata category for returning the two-letter Unicode general category of a character such as Lu Ll Nd Zs Cc and Ps, unicodedata bidirectional for the bidirectional class of a character, unicodedata combining for the canonical combining class as an integer, unicodedata east_asian_width for the East Asian display width of a character, unicodedata mirrored for checking if a character is mirrored in bidirectional text, unicodedata decomposition for the character decomposition mapping, unicodedata normalize for applying NFC NFD NFKC or NFKD normalization to strings, unicodedata is_normalized for checking normalization without normalizing, unicodedata digit and numeric and decimal for numeric value extraction, unicodedata unidata_version for the Unicode data version string, and unicodedata integration with str and re and unidecode for Python text normalization and character analysis pipeline patterns.
Claude Code for mimetypes: Python MIME Type Detection
Detect and map MIME types with Python's mimetypes module and Claude Code — mimetypes guess_type for inferring the MIME type and encoding from a file path or URL, mimetypes guess_extension for finding the canonical file extension for a MIME type, mimetypes guess_all_extensions for returning all known extensions for a MIME type, mimetypes add_type for registering a custom MIME type to extension mapping, mimetypes init for loading MIME types from a list of files or the system database, mimetypes read_mime_types for loading a single mime.types format file, mimetypes types_map and suffix_map and encodings_map for inspecting the database dictionaries, mimetypes common_types and inited for module state inspection, mimetypes MimeTypes class for creating isolated MIME type databases without affecting the global state, and mimetypes integration with pathlib and http.server and email and urllib for Python content-type detection and file serving pipeline patterns.
Claude Code for ctypes: Python C Library Bindings
Call C functions and access C data from Python with the ctypes module and Claude Code — ctypes CDLL and WinDLL and LibraryLoader for loading shared libraries, ctypes c_int c_char_p c_void_p c_double c_float c_bool and other fundamental C type mappings, ctypes Structure and Union and BigEndianStructure for defining C struct and union layouts, ctypes Array for creating fixed-length C arrays, ctypes POINTER and pointer and byref and addressof for C pointer operations, ctypes cast for reinterpreting a ctypes pointer as a different type, ctypes restype and argtypes for declaring function return type and argument types, ctypes create_string_buffer and create_unicode_buffer for mutable C string buffers, ctypes string_at and wstring_at for reading null-terminated C strings from addresses, ctypes memmove and memset and sizeof and alignment for low-level memory operations, ctypes windll and cdll and pythonapi for platform library access, and ctypes integration with struct and io and cffi for Python native code integration and performance pipeline patterns.
Claude Code for signal: Python Unix Signal Handling
Handle Unix signals in Python with the signal module and Claude Code — signal signal for registering a signal handler function for a signal number, signal getsignal for retrieving the current handler for a signal, signal SIG_DFL and SIG_IGN for restoring default behavior and ignoring signals, signal raise_signal for sending a signal to the current process, signal pause for suspending the process until any signal is received, signal alarm for scheduling a SIGALRM after a number of seconds, signal setitimer and getitimer for high-resolution interval timers with ITIMER_REAL and ITIMER_VIRTUAL and ITIMER_PROF, signal sigwait and sigwaitinfo and sigtimedwait for blocking on a set of signals in a POSIX-compliant thread, signal pthread_kill for sending a signal to a specific thread, signal Signals enumeration for named signal constants like SIGINT SIGTERM SIGCHLD SIGHUP SIGUSR1 SIGUSR2, signal strsignal for human-readable signal name strings, and signal integration with os and threading and contextlib for Python graceful shutdown and timeout and daemon lifecycle pipeline patterns.
Claude Code for wsgiref: Python WSGI Server and Utilities
Run and test WSGI web applications with Python's wsgiref module and Claude Code — wsgiref.simple_server make_server for creating a development HTTP server that serves any WSGI application, wsgiref.simple_server WSGIServer and WSGIRequestHandler for the WSGI-compliant server implementation, wsgiref.handlers SimpleHandler and BaseCGIHandler for writing WSGI responses to arbitrary streams, wsgiref.util FileWrapper for wrapping a file object in an iterable for efficient response streaming, wsgiref.util request_uri and application_uri and shift_path_info for URL reconstruction from environ, wsgiref.validate validator for wrapping a WSGI app and checking for specification compliance errors, wsgiref.headers Headers class for building and managing response header lists, wsgiref.environ_router for environ-based request routing, and wsgiref integration with http.server and io and threading for Python WSGI application testing and development server pipeline patterns.
Claude Code for socketserver: Python Network Server Framework
Build TCP and UDP servers with Python's socketserver module and Claude Code — socketserver TCPServer for creating a TCP server with address and request handler, socketserver UDPServer for creating a UDP datagram server, socketserver ThreadingMixIn for handling each connection in a new thread, socketserver ForkingMixIn for handling each connection in a new process, socketserver ThreadingTCPServer for a concurrent TCP server combining TCPServer and ThreadingMixIn, socketserver BaseRequestHandler for defining request handling with setup and handle and finish methods, socketserver StreamRequestHandler for TCP handlers with rfile and wfile file-like access, socketserver DatagramRequestHandler for UDP handlers with packet and socket access, socketserver BaseServer server_forever and shutdown for run loop management, socketserver BaseServer socket and server_address and allow_reuse_address for server configuration, and socketserver integration with ssl and http.server and threading for Python concurrent TCP and UDP server pipeline patterns.
Claude Code for xmlrpc.client: Python XML-RPC Client
Call remote procedures over XML-RPC with Python's xmlrpc.client module and Claude Code — xmlrpc.client ServerProxy for creating an XML-RPC client connected to a server URL, xmlrpc.client ServerProxy with allow_none and use_datetime and use_builtin_types for type marshalling options, xmlrpc.client MultiCall for batching multiple calls into a single HTTP request, xmlrpc.client Fault for catching server-side XML-RPC errors with faultCode and faultString, xmlrpc.client ProtocolError for catching HTTP-level transport errors with errcode and errmsg, xmlrpc.client Binary for wrapping bytes data in base64 XML-RPC encoding, xmlrpc.client DateTime for XML-RPC dateTime.iso8601 values, xmlrpc.client dumps and loads for serializing and deserializing XML-RPC payloads directly, xmlrpc.client ServerProxy system.listMethods and system.methodHelp and system.multicall for server introspection, and xmlrpc.client integration with ssl and urllib and http.client for Python XML-RPC RPC pipeline patterns.
Claude Code for ftplib: Python FTP File Transfer
Transfer files over FTP with Python's ftplib module and Claude Code — ftplib FTP for opening a plain FTP connection with host user and passwd, ftplib FTP_TLS for creating an encrypted FTPS connection with ssl context, ftplib FTP login for authenticating with username and password, ftplib FTP nlst and mlsd and mlst for listing directory contents and file metadata, ftplib FTP retrlines and retrbinary for downloading files as lines or raw bytes, ftplib FTP storlines and storbinary for uploading files as lines or raw bytes, ftplib FTP cwd and pwd and mkd and rmd and delete and rename for directory and file management, ftplib FTP size for getting file size, ftplib FTP quit and close for closing the connection, ftplib FTP set_pasv for passive mode control, ftplib FTP_TLS prot_p and prot_c for enabling and disabling data channel encryption, and ftplib integration with ssl and io and pathlib for Python FTP upload download and sync pipeline patterns.
Claude Code for imaplib: Python IMAP4 Email Retrieval
Read and manage email over IMAP4 with Python's imaplib module and Claude Code — imaplib IMAP4_SSL for creating a TLS-encrypted IMAP connection with host and port, imaplib IMAP4 for a plain IMAP connection, imaplib IMAP4 login and logout for authenticating and closing sessions, imaplib IMAP4 select for opening a mailbox folder, imaplib IMAP4 search for finding messages by criteria like ALL UNSEEN FROM TO SUBJECT and date ranges, imaplib IMAP4 fetch for retrieving message data by UID with envelope body header and flags, imaplib IMAP4 store for setting and clearing message flags like Seen Deleted Flagged, imaplib IMAP4 expunge for permanently removing deleted messages, imaplib IMAP4 copy and move for transferring messages between folders, imaplib IMAP4 create and delete and rename for folder management, imaplib IMAP4 idle for server-push new-message notification, and imaplib integration with email.parser and ssl for Python mailbox reader and inbox monitor pipeline patterns.
Claude Code for smtplib: Python SMTP Email Sending
Send email over SMTP with Python's smtplib module and Claude Code — smtplib SMTP for opening a plain SMTP connection with host and port, smtplib SMTP_SSL for creating a TLS-encrypted SMTP connection, smtplib SMTP ehlo and starttls for upgrading a plain connection to TLS with STARTTLS, smtplib SMTP login for authenticating with username and password, smtplib SMTP sendmail for sending raw RFC 5322 message bytes, smtplib SMTP send_message for sending an EmailMessage object directly, smtplib SMTP noop and quit and close for connection lifecycle, smtplib SMTP set_debuglevel for logging SMTP protocol exchanges, smtplib SMTPException and SMTPAuthenticationError and SMTPRecipientsRefused for error handling, smtplib SMTP connect and reconnect patterns for connection pooling, and smtplib integration with email.message and ssl and queue for Python SMTP sending pipeline patterns.
Claude Code for email: Python Email Message Composition
Build and parse email messages with Python's email module and Claude Code — email.message EmailMessage for creating MIME-correct messages with subject from to cc bcc and date headers, email.message EmailMessage set_content for setting plain text body, email.message EmailMessage add_alternative for adding HTML alternative and multipart support, email.message EmailMessage add_attachment for attaching files with content type and filename, email.mime.text MIMEText for legacy plain text and HTML message parts, email.mime.multipart MIMEMultipart for mixed and alternative and related multipart containers, email.mime.base MIMEBase with email.encoders encode_base64 for attaching binary files, email.headerregistry Address for structured name and addr-spec parsing, email.utils formataddr and parseaddr and formatdate and make_msgid for header formatting utilities, email.parser BytesParser and Parser for parsing raw RFC 5322 message bytes, email.policy EmailPolicy and default and SMTP and SMTPUTF8 and HTTP for output serialization policies, and email integration with smtplib and ssl for Python email composition and sending pipeline patterns.
Claude Code for urllib.request: Python URL Fetching
Fetch URLs and handle HTTP with Python's urllib.request module and Claude Code — urllib.request urlopen for opening a URL and returning a response object, urllib.request Request for constructing a request with URL method headers and data, urllib.request urlretrieve for downloading a file to disk with progress callback, urllib.request build_opener for creating a custom opener with handlers, urllib.request install_opener for setting the global opener used by urlopen, urllib.request HTTPBasicAuthHandler and HTTPDigestAuthHandler for authentication, urllib.request HTTPCookieProcessor for cookie jar integration, urllib.request ProxyHandler for routing requests through a proxy, urllib.request HTTPRedirectHandler for controlling redirect behavior, urllib.request BaseHandler and AbstractHTTPHandler for custom handler subclassing, urllib.error URLError and HTTPError for exception handling, and urllib.request integration with urllib.parse and ssl and http.cookiejar for Python HTTP fetching pipeline patterns.
Claude Code for http.client: Python HTTP/1.1 Connections
Make HTTP and HTTPS requests with Python's http.client module and Claude Code — http.client HTTPConnection for creating a plain HTTP connection with host and port, http.client HTTPSConnection for creating a TLS-encrypted HTTPS connection with ssl context and timeout, http.client HTTPConnection request for sending GET POST PUT DELETE and HEAD requests with headers and body, http.client HTTPResponse getresponse for reading status code reason headers and body, http.client HTTPResponse read and readline and readinto for streaming response bodies, http.client HTTPResponse getheaders and getheader for inspecting response headers, http.client HTTPConnection set_debuglevel for wire-level debug logging, http.client HTTPResponse status and reason and version for response metadata, http.client HTTPConnection connect and close for explicit connection management, http.client responses dict for status code name lookup, and http.client integration with ssl and json and urllib.parse for Python HTTP client pipeline patterns.
Claude Code for ssl: Python TLS/SSL Secure Connections
Add TLS encryption to Python socket connections with the ssl module and Claude Code — ssl create_default_context for creating a secure client SSL context with system CA verification, ssl SSLContext for creating server and client contexts with protocol and verify mode configuration, ssl SSLContext load_cert_chain for loading server certificate and private key, ssl SSLContext load_verify_locations for loading custom CA certificates, ssl SSLContext wrap_socket for upgrading a plain socket to TLS, ssl SSLContext connect for creating an already-wrapped SSL socket, ssl SSLSocket getpeercert for inspecting the server certificate, ssl match_hostname for verifying certificate common name and SAN fields, ssl PROTOCOL_TLS_CLIENT and PROTOCOL_TLS_SERVER for modern protocol constants, ssl OP_NO_SSLv2 and OP_NO_SSLv3 and OP_NO_TLSv1 option flags for disabling old protocols, ssl CERT_REQUIRED and CERT_OPTIONAL and CERT_NONE for peer verification modes, ssl get_default_verify_paths for system CA bundle location, ssl cert_time_to_seconds for certificate expiry parsing, and ssl integration with socket and http.client and smtplib for Python TLS client and server pipeline patterns.
Claude Code for socket: Python Low-Level Network I/O
Create TCP and UDP network connections with Python's socket module and Claude Code — socket socket for creating TCP and UDP client and server sockets, socket AF_INET and AF_INET6 and AF_UNIX for address family constants, socket SOCK_STREAM for TCP and SOCK_DGRAM for UDP and SOCK_RAW for raw sockets, socket connect and bind and listen and accept and send and recv and sendto and recvfrom for TCP and UDP operations, socket setsockopt and SO_REUSEADDR and SO_REUSEPORT and TCP_NODELAY for socket options, socket settimeout and setblocking and makefile for timeout and file-like access, socket getaddrinfo and gethostbyname and gethostname and getfqdn for DNS resolution, socket create_connection and create_server for high-level helpers, socket socketpair for creating connected socket pairs, socket fromfd and fileno for integrating with file descriptors, and socket integration with ssl and selectors and threading for Python TCP server and client pipeline patterns.
Claude Code for concurrent.futures: Python High-Level Concurrency
Run tasks concurrently with Python's concurrent.futures module and Claude Code — concurrent.futures ThreadPoolExecutor for I/O-bound parallel execution with worker threads, concurrent.futures ProcessPoolExecutor for CPU-bound parallel execution with worker processes, concurrent.futures submit for scheduling a callable and returning a Future, concurrent.futures map for parallel map with ordered results and timeout, concurrent.futures as_completed for processing futures in completion order, concurrent.futures Future result and exception and done and cancel methods for inspecting submitted work, concurrent.futures wait with ALL_COMPLETED and FIRST_COMPLETED and FIRST_EXCEPTION for bulk future waiting, concurrent.futures shutdown for graceful executor cleanup, concurrent.futures Executor as context manager for automatic shutdown, and concurrent.futures integration with asyncio and tqdm and retry for Python parallel task pipeline and work-stealing queue patterns.
Claude Code for cProfile: Python CPU Performance Profiling
Profile Python program performance with the cProfile module and Claude Code — cProfile run for profiling a code string and printing a report, cProfile Profile class for programmatic profiling with enable and disable and create_stats, cProfile Profile runcall for profiling a single function call, cProfile Profile dump_stats and load_stats for saving and loading profile data, pstats Stats class for analyzing and printing cProfile data, pstats Stats sort_stats with tottime and cumtime and ncalls and pcalls sort keys, pstats Stats print_stats with limit and pattern filtering, pstats Stats print_callers and print_callees for call graph analysis, pstats Stats strip_dirs for removing path prefixes from output, cProfile context manager pattern for scoped profiling, line_profiler and memory_profiler comparison, and cProfile integration with pstats and io and timeit for Python performance analysis and optimization pipelines.
Claude Code for pdb: Python Interactive Debugger
Debug Python programs interactively with the pdb module and Claude Code — pdb set_trace for inserting a breakpoint in source code, pdb breakpoint builtin for Python 3.7 and later breakpoint insertion, pdb run and runeval and runcall for starting the debugger on code strings and callables, pdb post_mortem for inspecting the traceback after an exception, pdb pm for re-entering post-mortem debugging of the last exception, pdb Pdb class for creating a customized debugger with stdin and stdout redirection, pdb commands n and s and c and r and l and ll and p and pp and w and u and d and b and cl and h for navigation and inspection, pdb condition and ignore and commands for conditional breakpoints and hit counts, pdb tbreak for one-time temporary breakpoints, pdb alias for creating custom debugger commands, and pdb integration with sys and traceback and logging for Python automated debugging and exception investigation pipelines.
Claude Code for unittest: Python Standard Test Framework
Write and run structured unit tests with Python's unittest module and Claude Code — unittest TestCase for defining test classes with setUp and tearDown and test methods, unittest TestCase assertion methods assertEqual and assertNotEqual and assertTrue and assertFalse and assertIsNone and assertIn and assertRaises and assertAlmostEqual and assertRegex and assertDictEqual and assertListEqual, unittest mock Mock and MagicMock and patch for replacing dependencies during tests, unittest mock patch as decorator and context manager for scoped mocking, unittest mock call_count and call_args and assert_called_once_with for verifying mock interactions, unittest TestSuite and TestLoader and TextTestRunner for programmatic test discovery and execution, unittest skip and skipIf and skipUnless and expectedFailure decorators for conditional test control, unittest subTest for parameterized assertions within a single test method, and unittest integration with coverage and argparse for Python test suite organization and CI pipeline testing.
Claude Code for timeit: Python Micro-Benchmark Utilities
Measure Python code performance with the timeit module and Claude Code — timeit timeit for timing a callable or code string over multiple repetitions, timeit repeat for running timeit multiple times to gather a sample distribution, timeit default_timer for selecting the best available clock, timeit Timer class for reusable benchmark objects with setup code and globals, timeit Timer timeit method for running the benchmark loop, timeit Timer repeat method for collecting multiple timing samples, timeit Timer autorange for automatically determining a suitable number of repetitions, timeit command-line interface with -n and -r and -s and -u flags, timeit best practice of taking the minimum of repeat() samples to filter background noise, and timeit integration with statistics and pprint and gc for Python performance measurement and comparison pipelines.
Claude Code for mmap: Python Memory-Mapped File I/O
Access large files efficiently with Python's mmap module and Claude Code — mmap mmap for creating memory-mapped file objects from file descriptors, mmap ACCESS_READ and ACCESS_WRITE and ACCESS_COPY for access mode constants, mmap mmap read and write and seek and tell and find and rfind for file-like byte operations on mapped memory, mmap mmap size and length for getting mapped region size, mmap mmap flush for writing changes back to disk, mmap mmap close for releasing the mapping, mmap mmap slice notation for byte-range access, mmap mmap move for in-place byte copying within the mapping, mmap mmap madvise for page prefetching and eviction hints on Unix, mmap ALLOCATIONGRANULARITY and PAGESIZE constants for alignment, mmap offset parameter for mapping a subrange of a file, and mmap integration with struct and re and pathlib for Python large-file processing and binary search pipelines.
Claude Code for binascii: Python Binary/ASCII Encoding Conversions
Convert between binary data and ASCII text representations with Python's binascii module and Claude Code — binascii hexlify for converting bytes to hex string, binascii unhexlify for converting hex string back to bytes, binascii b2a_base64 for encoding bytes to base64 with newline, binascii a2b_base64 for decoding base64 bytes, binascii b2a_hex and a2b_hex as aliases for hexlify and unhexlify, binascii crc32 for CRC-32 checksum calculation, binascii crc_hqx for CRC-CCITT checksum, binascii b2a_uu and a2b_uu for uu encoding, binascii b2a_qp and a2b_qp for quoted-printable encoding, binascii Error and Incomplete exception classes for conversion errors, binascii hexlify with sep and bytes_per_sep parameters for formatted hex output, and binascii integration with struct and hashlib and hmac for Python binary data encoding and checksum pipelines.
Claude Code for shlex: Python Shell Lexer and Quoting
Parse and quote shell command strings safely with Python's shlex module and Claude Code — shlex split for splitting a command string into a list of tokens respecting shell quoting, shlex quote for shell-escaping a single argument to prevent command injection, shlex join for reassembling a list of tokens back into a shell-safe command string, shlex shlex class for character-by-character tokenization with custom punctuation and wordchars and commenters and whitespace settings, shlex shlex posix mode for POSIX-compliant quoting behavior, shlex shlex source for file inclusion directives, shlex shlex read_token for reading one token at a time, shlex shlex error_leader for error message formatting, shlex shlex wordchars and whitespace_split for custom tokenization modes, and shlex integration with subprocess and pathlib and argparse for Python safe command construction and shell argument parsing pipelines.
Claude Code for glob: Python Filesystem Glob Pattern Matching
Find files matching Unix shell patterns with Python's glob module and Claude Code — glob glob for returning a list of paths matching a pattern with star and question mark and bracket wildcards, glob iglob for lazy iterator version of glob, glob escape for escaping special glob characters in literal path components, glob glob recursive option with double star for matching directories at any depth, glob iglob with root_dir and dir_fd parameters for specifying search roots without changing cwd, pathlib Path glob and rglob for object-oriented recursive pattern matching, glob pattern caching and performance for large directory trees, glob combining with fnmatch for two-stage filtering, glob include and exclude pattern stacking, and glob integration with os.path and pathlib and shutil for Python file discovery and batch processing pipelines.
Claude Code for fnmatch: Python Unix Shell Pattern Matching
Match filenames against Unix shell-style patterns with Python's fnmatch module and Claude Code — fnmatch fnmatch for case-sensitive or case-insensitive filename pattern matching against shell wildcards, fnmatch fnmatchcase for always case-sensitive matching, fnmatch filter for filtering a list of names against a pattern, fnmatch translate for converting a shell pattern to a compiled regular expression string, star wildcard for matching zero or more characters, question mark wildcard for matching exactly one character, bracket expressions for character set matching with negation, and fnmatch integration with os.listdir and pathlib and glob and re for Python filename filter and file selector pipelines.
Claude Code for difflib: Python Sequence Difference Utilities
Compare sequences and generate diffs with Python's difflib module and Claude Code — difflib SequenceMatcher for computing similarity ratios and matching blocks between two sequences, difflib SequenceMatcher ratio and quick_ratio and real_quick_ratio for fast similarity scoring, difflib SequenceMatcher get_matching_blocks for longest common subsequence blocks, difflib SequenceMatcher get_opcodes for edit operation sequences with equal and replace and insert and delete tags, difflib Differ for line-by-line diff with context markers, difflib unified_diff for generating unified diff patches, difflib context_diff for context diff output, difflib ndiff for character-level comparison with intra-line change markers, difflib HtmlDiff for HTML side-by-side diff tables, difflib get_close_matches for fuzzy string lookup from a list, difflib restore for recovering original sequences from Differ output, and difflib integration with io and pathlib for Python text comparison and patch generation pipelines.
Claude Code for reprlib: Python Abbreviated Object Representations
Generate abbreviated repr strings for large Python objects with the reprlib module and Claude Code — reprlib repr for size-limited string representations of any object, reprlib Repr class for configuring maximum lengths for lists and tuples and dicts and sets and frozensets and arrays and deques and strings and other sequences, reprlib Repr maxstring and maxlist and maxdict and maxset and maxfrozenset and maxdeque and maxarray and maxlong and maxother for per-type limits, reprlib Repr maxlevel for recursion depth control, reprlib Repr repr_str for custom type override, reprlib Repr repr1 for single-level dispatch, reprlib recursive_repr decorator for preventing infinite recursion in custom __repr__ methods, reprlib aRepr singleton for module-level shorthand, and reprlib integration with logging and dataclasses and pprint for Python safe object summarization and debug logging pipelines.
Claude Code for string: Python String Constants and Templates
Use Python's string module constants and templates with Claude Code — string ascii_letters and ascii_lowercase and ascii_uppercase for character set constants, string digits and hexdigits and octdigits for numeric character sets, string punctuation for punctuation characters, string printable and whitespace for broader character categories, string Template for safe variable substitution with dollar-sign placeholders, string Template substitute and safe_substitute for rendering with mapping or kwargs, string Template pattern and idpattern for custom template delimiter customization, string Formatter for custom str.format style formatting pipelines, string Formatter parse for iterating format string fields, string Formatter vformat and format_field for building table and report formatters, string capwords for capitalizing word sequences, and string integration with re and secrets and random for Python string generation and template rendering pipelines.
Claude Code for calendar: Python Calendar Utilities
Generate and manipulate calendars with Python's calendar module and Claude Code — calendar month for text month grids, calendar monthcalendar for nested week lists, calendar monthrange for first weekday and day count, calendar isleap for leap year detection, calendar leapdays for leap day count in range, calendar weekday for day-of-week integer, calendar weekheader for abbreviated weekday headers, calendar calendar for full year text grids, calendar HTMLCalendar for HTML month and year rendering, calendar TextCalendar for text month and year rendering, calendar setfirstweekday and firstweekday for locale weekday start, calendar timegm for UTC struct_time to epoch, calendar day_name and day_abbr for full and abbreviated day name sequences, calendar month_name and month_abbr for full and abbreviated month name sequences, and calendar integration with datetime and time for Python calendar generation and date utility pipelines.
Claude Code for time: Python Time Access and Conversion
Access and convert time values with Python's time module and Claude Code — time time for Unix epoch seconds as float, time time_ns for nanosecond precision epoch, time monotonic and monotonic_ns for elapsed time measurement immune to clock adjustments, time perf_counter and perf_counter_ns for high-resolution benchmarking, time process_time for CPU time excluding sleep, time sleep for blocking delay, time gmtime and localtime for struct_time from epoch, time mktime for struct_time back to epoch, time strftime for formatting struct_time to strings, time strptime for parsing time strings to struct_time, time asctime and ctime for human-readable time strings, time timezone and altzone and daylight and tzname for local timezone info, time clock_gettime and clock_settime and clock_getres for POSIX clocks, time get_clock_info for clock metadata, and time integration with datetime and calendar for Python time measurement and conversion pipelines.
Claude Code for types: Python Type Objects and Utilities
Inspect Python runtime type objects and create dynamic types with the types module and Claude Code — types FunctionType and LambdaType for function objects, types MethodType for bound methods, types CodeType for code objects, types ModuleType for module objects, types SimpleNamespace for attribute namespaces, types MappingProxyType for immutable dict views, types GeneratorType and CoroutineType and AsyncGeneratorType for generator and coroutine introspection, types TracebackType for traceback objects, types FrameType for frame objects, types BuiltinFunctionType for built-in function detection, types NoneType and EllipsisType and NotImplementedType for singleton type access, types DynamicClassAttribute for descriptor-based class attributes, types GenericAlias for parameterized generics, types UnionType for X or Y type hints, types new_class for dynamic class creation with metaclass, and types integration with inspect and dataclasses for Python runtime type inspection pipelines.
Claude Code for tokenize: Python Lexical Analysis
Tokenize Python source code for syntax analysis with the tokenize module and Claude Code — tokenize generate_tokens for tokenizing text streams with token number and string and start and end and line, tokenize tokenize for tokenizing binary streams, tokenize untokenize for round-tripping token sequences back to source, tokenize detect_encoding for detecting source file encoding, tokenize open for opening byte files with encoding detection, tokenize TokenInfo namedtuple with type and string and start and end and line, tokenize token types NAME and NUMBER and STRING and OP and COMMENT and NEWLINE and NL and INDENT and DEDENT and ENCODING and ENDMARKER and ERRORTOKEN, tokenize token module constants for type lookup, tokenize for comment extraction and string literal analysis, tokenize for linting whitespace and style analysis, tokenize for identifier renaming without full AST parsing, and tokenize integration with io.StringIO and ast for Python source token analysis pipelines.
Claude Code for dis: Python Bytecode Disassembly
Inspect Python bytecode and optimize code performance with the dis module and Claude Code — dis dis for printing bytecode disassembly of code objects and functions and methods, dis disassemble for disassembling to a text stream, dis get_instructions for iterating Instruction namedtuples, dis code_info for high-level code object summary, dis findlinestarts for mapping bytecode offsets to line numbers, dis findlabels for finding jump targets, dis stack_effect for computing instruction stack effects, dis Instruction namedtuple with opname and opcode and arg and argval and argrepr and offset and starts_line and is_jump_target, dis Bytecode class for structured iteration with first_line and exception_entries, dis HAVE_ARGUMENT constant for argument detection, dis opname and opmap for opcode name lookup, dis hasjabs and hasjrel and hasconst and hasname and haslocal for instruction category classification, and dis integration with compile and ast and types for Python bytecode analysis and performance investigation pipelines.
Claude Code for ast: Python Abstract Syntax Trees
Parse, inspect, and transform Python source code with the ast module and Claude Code — ast parse for converting source code strings to abstract syntax trees, ast dump for human-readable AST output, ast NodeVisitor for read-only tree traversal, ast NodeTransformer for in-place tree modification, ast fix_missing_locations for repairing location metadata after transformations, ast unparse for converting AST back to source code, ast literal_eval for safely evaluating literal expressions, ast walk for iterating all nodes without a visitor class, ast get_docstring for extracting docstrings, ast Module and FunctionDef and ClassDef and Assign and Call and Import nodes for structural analysis, ast Constant and Name and Attribute for leaf node inspection, ast comprehend for comprehension nodes, ast compile for compiling AST to code objects, and ast integration with inspect and tokenize for Python static analysis and code transformation pipelines.
Claude Code for fractions: Exact Rational Arithmetic in Python
Perform exact rational arithmetic with Python's fractions module and Claude Code — fractions Fraction for exact rational number representation, fractions Fraction from int and float and string and Decimal for construction, fractions Fraction numerator and denominator for accessing reduced form, fractions Fraction with limit_denominator for float approximation, fractions Fraction arithmetic with add and subtract and multiply and divide and power operators, fractions Fraction comparison operators for exact ordering, fractions Fraction with math module functions, fractions Fraction from_float and from_decimal class methods, fractions gcd via math.gcd for denominator reduction, fractions Fraction in mixed arithmetic with int and float, fractions Fraction as ratio representation, and fractions integration with decimal and statistics and math for Python exact rational computation and ratio pipelines.
Claude Code for random: Randomness in Python
Generate pseudo-random numbers and make random selections with Python's random module and Claude Code — random random for uniform floats between 0 and 1, random randint for random integers in inclusive range, random choice for random single selection, random choices for weighted random sampling with replacement, random sample for random sampling without replacement, random shuffle for in-place list randomization, random uniform for uniformly distributed floats in a range, random gauss and normalvariate for Gaussian distribution sampling, random expovariate for exponential distribution, random triangular for triangular distribution, random seed for reproducible random sequences, random Random class for independent generator instances, random SystemRandom for cryptographically strong randomness, secrets for cryptographically secure tokens and passwords, and random integration with itertools and dataclasses for Python simulation and testing pipelines.
Claude Code for math: Mathematical Functions in Python
Use Python's math module for precise numeric calculations and Claude Code — math sqrt and pow and exp and log for elementary functions, math floor and ceil and trunc for rounding, math factorial and comb and perm for combinatorics, math gcd and lcm for number theory, math sin and cos and tan and asin and acos and atan and atan2 for trigonometry, math degrees and radians for angle conversion, math hypot for Euclidean distance, math isclose for floating-point equality comparison, math isfinite and isinf and isnan for floating-point classification, math copysign and fabs for sign manipulation, math fsum for accurate floating-point summation, math prod for product of iterables, math log2 and log10 and log with base for logarithms, math modf and frexp and ldexp for decomposition, math pi and e and tau and inf and nan constants, math erf and erfc for error functions, math gamma and lgamma for gamma functions, and math integration with statistics and decimal for Python numerical computation pipelines.
Claude Code for zipfile: ZIP Archives in Python
Create, read, and extract ZIP archives with Python's zipfile module and Claude Code — zipfile ZipFile for reading and writing zip files, zipfile ZipFile with mode r and w and a and x for different access modes, zipfile ZipFile with compression ZIP_STORED and ZIP_DEFLATED and ZIP_BZIP2 and ZIP_LZMA, zipfile ZipFile namelist for listing contents, zipfile ZipFile infolist for ZipInfo metadata, zipfile ZipFile read and open for extracting files, zipfile ZipFile extract and extractall for file extraction with path filtering, zipfile ZipFile write and writestr for adding files and strings, zipfile ZipFile mkdir for creating directories in archives, zipfile ZipFile setpassword and open with pwd for password-protected archives, zipfile ZipFile testzip for integrity checking, zipfile Path for pathlib-like archive navigation, zipfile is_zipfile for format detection, zipfile BadZipFile for error handling, and zipfile integration with io.BytesIO and pathlib for Python zip archive manipulation pipelines.
Claude Code for gzip: Gzip Compression in Python
Read, write, and stream gzip files with Python's gzip module and Claude Code — gzip open for reading and writing gzip files with transparent decompression, gzip compress and decompress for one-shot in-memory compression, gzip GzipFile for low-level streaming access with mtime and filename control, gzip BadGzipFile for error handling on invalid gzip data, gzip compresslevel parameter for speed versus ratio trade-offs, gzip open with mode rb and wb and ab and rt and wt for binary and text gzip IO, gzip open with encoding and errors for text mode gzip files, gzip open with newline parameter for line ending control, gzip peek for lookahead without consuming data, gzip multiple member files handling, gzip mtime suppression for deterministic output, and gzip integration with io.BytesIO and tarfile and shutil for Python file compression and streaming pipelines.
Claude Code for zlib: Data Compression in Python
Compress and decompress bytes with Python's zlib module and Claude Code — zlib compress and decompress for one-shot deflate compression, zlib compressobj and decompressobj for streaming compression, zlib compress level parameter from 0 to 9 for speed versus ratio trade-offs, zlib Z_DEFAULT_COMPRESSION and Z_BEST_SPEED and Z_BEST_COMPRESSION constants, zlib Compress flush and copy for incremental encoding, zlib Decompress flush for incremental decoding, zlib crc32 for CRC-32 checksums, zlib adler32 for Adler-32 checksums, zlib Z_SYNC_FLUSH and Z_FULL_FLUSH and Z_FINISH flush modes, zlib wbits parameter for raw deflate versus zlib versus gzip format wrappers, zlib MAX_WBITS constant for window size, zlib DEF_MEM_LEVEL for memory level tuning, zlib error for compression errors, and zlib integration with io.BytesIO and socket and http for Python low-level compression pipelines.
Claude Code for platform: System Information in Python
Detect OS environment and hardware information with Python's platform module and Claude Code — platform system for operating system name, platform node for hostname, platform release for OS release version, platform version for detailed OS version string, platform machine for hardware architecture, platform processor for processor type, platform python_version and python_version_tuple for Python version, platform python_implementation for CPython vs PyPy vs Jython, platform uname for a named tuple of all system info, platform architecture for 32 vs 64 bit detection, platform system_alias for normalized OS name, platform mac_ver for macOS version detection, platform win32_ver for Windows version detection, platform linux_distribution alternatives for Linux distro detection, platform freedesktop_os_release for modern Linux distro info, and platform integration with sys and os for Python cross-platform compatibility and runtime environment detection pipelines.
Claude Code for gc: Garbage Collection in Python
Control Python's garbage collector and diagnose memory issues with the gc module and Claude Code — gc collect for forcing garbage collection cycles, gc disable and gc enable for controlling automatic collection, gc get_count for checking generation object counts, gc get_threshold and gc set_threshold for tuning GC thresholds, gc get_objects for listing all tracked objects, gc get_referrers and gc get_referents for reference graph traversal, gc is_tracked for checking object tracking status, gc isenabled for querying GC state, gc callbacks for pre and post collection hooks, gc freeze for immortalizing objects before fork, gc get_freeze_count for freeze count, gc DEBUG_LEAK and DEBUG_STATS and DEBUG_COLLECTABLE and DEBUG_UNCOLLECTABLE debug flags, finding reference cycles with gc.get_referrers, memory profiling with tracemalloc integration, and gc integration with weakref and tracemalloc for Python memory management and cycle detection pipelines.
Claude Code for traceback: Exception Tracebacks in Python
Extract, format, and handle Python exception tracebacks with the traceback module and Claude Code — traceback format_exc for getting the current exception traceback as a string, traceback print_exc for printing the current traceback to stderr, traceback format_exception for formatting exc_type and exc_value and exc_tb, traceback format_tb and extract_tb for processing raw traceback objects, traceback TracebackException for structured exception introspection, traceback StackSummary and FrameSummary for frame-level stack inspection, traceback walk_stack and walk_tb for iterator-based traversal, traceback print_stack for printing the current call stack, traceback format_list for formatting extracted stack frames, traceback chain for chained exception display with cause and context, traceback integration with logging and sentry and error reporters for Python structured exception handling and alerting pipelines.
Claude Code for warnings: Python Warning Control
Issue, filter, and manage Python warnings with the warnings module and Claude Code — warnings warn for emitting DeprecationWarning and UserWarning and RuntimeWarning and FutureWarning and PendingDeprecationWarning and ResourceWarning and SyntaxWarning, warnings filterwarnings and simplefilter for controlling which warnings appear, warnings catch_warnings context manager for temporarily modifying warning filters within a block, warnings warn_explicit for programmatic warning emission with file and line overrides, warnings resetwarnings for clearing all custom filters, warnings WarningMessage for warning introspection in tests, warnings stacklevel parameter for pointing warnings at the correct call site, warnings module flag -W for command-line filter control, deprecated function decorator pattern using functools.wraps and warnings.warn, and warnings integration with logging.captureWarnings and pytest for Python library deprecation and runtime alert pipelines.
Claude Code for queue: Thread-Safe Queues in Python
Coordinate concurrent work with Python's queue module and Claude Code — queue Queue for FIFO thread-safe queues, queue LifoQueue for stack-like LIFO queues, queue PriorityQueue for min-heap priority scheduling, queue SimpleQueue for lightweight lockless single-producer single-consumer queues, queue put and get and put_nowait and get_nowait for non-blocking operations, queue task_done and join for producer-consumer synchronization, queue maxsize for bounded queues with backpressure, queue Empty and Full exceptions for non-blocking error handling, queue with threading.Thread for worker pool patterns, queue with concurrent.futures for task result collection, asyncio.Queue and asyncio.PriorityQueue for async producer-consumer pipelines, and queue integration with logging and multiprocessing for Python thread-safe work dispatch pipelines.
Claude Code for array: Typed Arrays in Python
Work with compact typed numeric arrays using Python's array module and Claude Code — array array constructor with typecodes for signed and unsigned integers and floats, array typecode b for signed char and B for unsigned char and h for short and H for unsigned short and i for int and I for unsigned int and l for long and L for unsigned long and q for long long and Q for unsigned long long and f for float and d for double, array append and extend and insert and pop and remove for mutation, array fromfile and tofile for binary file IO, array frombytes and tobytes for bytes conversion, array fromlist and tolist for list interop, array buffer_info for address and count, array byteswap for endianness flipping, array typecodes constant for all valid codes, array with memoryview for zero-copy slicing, array integration with struct and io.BytesIO and numpy for Python binary numeric array pipelines.
Claude Code for pickle: Object Serialization in Python
Serialize and deserialize Python objects with the pickle module and Claude Code — pickle dumps and dump for serializing objects to bytes or files, pickle loads and load for deserializing from bytes or files, pickle protocol versions for controlling serialization format compatibility, pickle Pickler and Unpickler classes for stream-based serialization, pickle HIGHEST_PROTOCOL and DEFAULT_PROTOCOL constants, pickle reduce and reduce_ex and getstate and setstate for customizing pickling behavior, pickle persistent_id and persistent_load for external object references, pickle copyreg for registering constructors for extension types, pickle dispatch_table for per-class pickling overrides, pickle PicklingError and UnpicklingError for error handling, pickle with io.BytesIO for in-memory serialization, pickle security warnings and safe unpickling patterns, pickle deepcopy alternative for performance, and pickle integration with shelve and multiprocessing for Python object persistence pipelines.
Claude Code for pprint: Pretty-Printing in Python
Format complex Python data structures for readable output with the pprint module and Claude Code — pprint pprint for formatted console output with indentation and width control, pprint pformat for getting the pretty-printed string, pprint PrettyPrinter class for reusable formatting configuration, pprint isreadable for checking if a structure can be repr-ed, pprint isrecursive for detecting circular references, pprint pp shorthand for pprint with sort_dicts=False, pprint width and depth and indent and compact and sort_dicts parameters, pprint format for custom PrettyPrinter subclasses, nested dict and list and tuple and set formatting, pprint for dataclass debugging, custom repr integration with pprint, and pprint integration with logging and json.dumps and rich for Python structured data inspection pipelines.
Claude Code for operator: Functional Operators in Python
Use Python's operator module as first-class functions with Claude Code — operator itemgetter for extracting items from sequences and mappings, operator attrgetter for attribute access chains, operator methodcaller for calling methods by name, operator add and sub and mul and truediv and floordiv and mod and pow for arithmetic operators, operator neg and pos and abs and invert for unary operators, operator eq and ne and lt and le and gt and ge for comparison operators, operator and_ and or_ and xor and not_ and lshift and rshift for bitwise operators, operator contains and indexOf and countOf for sequence operators, operator setitem and delitem and getitem for item mutation, operator iadd and imul and isub for in-place operators, and operator integration with functools.reduce and sorted and itertools for Python functional programming pipelines.
Claude Code for inspect: Runtime Introspection in Python
Examine live Python objects at runtime with the inspect module and Claude Code — inspect getmembers and getmembers_static for listing object attributes and methods, inspect isfunction and ismethod and isclass and ismodule and isbuiltin for type predicates, inspect signature and Parameter and BoundArguments for callable signature introspection, inspect getsource and getsourcelines and getsourcefile for source code retrieval, inspect stack and currentframe and getframeinfo for call stack inspection, inspect getdoc and cleandoc for docstring extraction, inspect isasyncgenfunction and iscoroutinefunction and isgeneratorfunction for async and generator predicates, inspect getannotations for type annotation access, inspect classify_class_attrs for class attribute classification, inspect Traceback for structured stack frame data, and inspect integration with dataclasses and typing for Python reflection and code analysis pipelines.
Claude Code for weakref: Weak References in Python
Manage object lifetimes and avoid memory leaks with Python's weakref module and Claude Code — weakref ref for creating weak references to objects, weakref proxy for transparent weak reference proxies, weakref WeakValueDictionary for caches that release values automatically, weakref WeakKeyDictionary for associating data with objects without preventing garbage collection, weakref WeakSet for sets of weakly referenced objects, weakref finalize for cleanup callbacks on object destruction, weakref ref callback for notification when referent is garbage collected, weakref getweakrefcount and getweakrefs for introspection, weakref WeakMethod for bound method weak references, cache invalidation patterns using WeakValueDictionary, observer pattern with weak callbacks, and weakref integration with functools.lru_cache and dataclasses for Python object lifecycle and memory management pipelines.
Claude Code for copy: Object Copying in Python
Duplicate Python objects safely with the copy module and Claude Code — copy copy for shallow copying of lists dicts and objects, copy deepcopy for fully independent recursive copying, copy copy with __copy__ for custom shallow copy behavior, copy deepcopy with __deepcopy__ for custom deep copy behavior, copy deepcopy memo dict for handling circular references, copy copy of dataclasses for fast field-level duplication, shallow vs deep copy trade-offs for nested mutable containers, copy replace pattern for immutable-style dataclass updates, copy in undo-redo and event sourcing patterns, copy for safe configuration defaults, and copy integration with dataclasses and typing for Python immutable-style data mutation pipelines.
Claude Code for os and os.path: System Interface in Python
Interact with the operating system with Python's os module and Claude Code — os environ and getenv and putenv for environment variable access, os path join and basename and dirname and splitext for path manipulation, os path exists and isfile and isdir and islink for file type checks, os path getsize and getmtime and getatime for file metadata, os getcwd and chdir for working directory, os makedirs and mkdir for directory creation, os walk for recursive directory traversal, os listdir and scandir for directory listing, os stat for detailed file attributes, os rename and replace and remove and rmdir for file operations, os cpu_count and getpid and getppid for process information, os urandom for cryptographic random bytes, os symlink and readlink for symbolic links, and os integration with pathlib and subprocess for Python system automation pipelines.
Claude Code for ipaddress: IP Address Handling in Python
Parse and manipulate IP addresses and networks with Python's ipaddress module and Claude Code — ipaddress ip_address for creating IPv4Address and IPv6Address objects, ipaddress ip_network for creating IPv4Network and IPv6Network objects, ipaddress ip_interface for address-plus-prefix objects, ipaddress network_address and broadcast_address and netmask and prefixlen for network attributes, ipaddress hosts for iterating over usable host addresses, ipaddress supernet and subnets for network splitting and aggregation, ipaddress is_private and is_loopback and is_global and is_multicast for address classification, ipaddress overlaps and subnet_of and supernet_of for network containment checks, ipaddress collapsed_addresses for route summarization, ipaddress packed for binary address representation, and ipaddress integration with socket and dataclasses for Python network configuration and access control pipelines.
Claude Code for base64: Binary-to-Text Encoding in Python
Encode and decode binary data as ASCII text with Python's base64 module and Claude Code — base64 b64encode and b64decode for standard base64 encoding and decoding, base64 urlsafe_b64encode and urlsafe_b64decode for URL-safe encoding with dash and underscore instead of plus and slash, base64 b16encode and b16decode for hexadecimal encoding, base64 b32encode and b32decode for base32 RFC 4648 encoding, base64 b85encode and b85decode for compact ASCII encoding, base64 encodebytes and decodebytes for MIME line-wrapped encoding, base64 standard_b64encode for alternative alphabet, padding handling and validation, base64 data URI generation for inline images and files, and base64 integration with io.BytesIO and hashlib and secrets for Python binary encoding pipelines.
Claude Code for uuid: Unique Identifiers in Python
Generate and manage universally unique identifiers with Python's uuid module and Claude Code — uuid uuid4 for random UUID generation, uuid uuid1 for time-based UUIDs, uuid uuid3 and uuid5 for namespace-based deterministic UUIDs, uuid UUID class for parsing and formatting and comparison, uuid hex and bytes and int and urn attributes for different UUID representations, uuid NAMESPACE_DNS and NAMESPACE_URL and NAMESPACE_OID and NAMESPACE_X500 for standard namespaces, uuid is_safe for thread safety indication, uuid UUID version attribute for version checking, short UUID patterns using base64 and base58 encoding, UUID validation patterns, and uuid integration with dataclasses and SQLAlchemy and Pydantic for Python entity identity and distributed ID generation pipelines.
Claude Code for bisect: Binary Search in Python
Perform fast binary search and sorted list maintenance with Python's bisect module and Claude Code — bisect bisect_left for finding leftmost insertion point, bisect bisect_right for finding rightmost insertion point, bisect insort_left and insort_right for maintaining sorted lists, bisect bisect as alias for bisect_right, bisect key parameter for custom key functions, binary search patterns for finding exact values and ranges and nearest neighbors, step-function lookup with bisect, grade bucket mapping with bisect, range query patterns using bisect_left and bisect_right, bisect for IP range lookup and version comparison and schedule event lookup, and bisect integration with dataclasses and sortedcontainers for Python ordered data structure pipelines.
Claude Code for heapq: Priority Queues in Python
Implement efficient priority queues with Python's heapq module and Claude Code — heapq heappush and heappop for min-heap insertion and extraction, heapq heapify for converting lists into heaps in linear time, heapq heapreplace and heappushpop for efficient heap replacement, heapq nlargest and nsmallest for top-N selection without full sort, heapq merge for sorted-iterator merging, max-heap patterns using negation, heapq with tuples for prioritized task scheduling, heapq for Dijkstra shortest-path and A-star search implementation, heapq running median pattern with two heaps, and heapq integration with dataclasses and typing for Python priority queue and scheduling pipelines.
Claude Code for asyncio: Async I/O in Python
Write concurrent asynchronous programs with Python's asyncio module and Claude Code — asyncio run for top-level coroutine execution, asyncio create_task and gather and wait for concurrent task management, asyncio sleep and timeout and wait_for for time control, asyncio Queue and PriorityQueue for async producer-consumer pipelines, asyncio Event and Lock and Semaphore and Condition for async synchronization, asyncio StreamReader and StreamWriter for TCP networking, asyncio TaskGroup for structured concurrency, asyncio to_thread for running blocking code without blocking the event loop, asyncio as_completed for processing results as they arrive, asyncio shield for protecting tasks from cancellation, asyncio ensure_future and current_task and all_tasks for task introspection, and asyncio integration with aiohttp and dataclasses for Python concurrent I/O application pipelines.
Claude Code for struct: Binary Data Packing in Python
Pack and unpack binary data with Python's struct module and Claude Code — struct pack for converting Python values to bytes, struct unpack for parsing bytes back to Python values, struct pack_into and unpack_from for working with buffers at offsets, struct calcsize for computing format string byte sizes, struct Struct for reusable compiled format objects, struct format strings with byte order specifiers big-endian and little-endian and network and native, struct format characters for integers floats booleans chars padding and strings, struct iter_unpack for streaming binary record parsing, struct error for format and size mismatch exceptions, and struct integration with io.BytesIO and socket and dataclasses for Python binary protocol and file format parsing pipelines.
Claude Code for io: In-Memory Streams in Python
Work with in-memory byte and text streams with Python's io module and Claude Code — io StringIO for in-memory text buffers, io BytesIO for in-memory binary buffers, io TextIOWrapper for wrapping binary streams with text encoding, io BufferedReader and BufferedWriter for buffered I/O, io RawIOBase and IOBase for custom stream implementations, io getvalue for buffer contents retrieval, io seek and tell and truncate for stream position control, io readline and readlines for line-oriented reading, io SEEK_SET and SEEK_CUR and SEEK_END for seek whence constants, io open as a built-in replacement with mode and encoding and buffering parameters, io DEFAULT_BUFFER_SIZE for buffer tuning, and io integration with csv and json and zipfile for Python in-memory data processing pipelines.
Claude Code for configparser: INI File Configuration in Python
Read and write INI configuration files with Python's configparser module and Claude Code — configparser ConfigParser for section and key parsing, configparser read and read_string and read_dict for loading config from files strings and dicts, configparser get and getint and getfloat and getboolean for typed value access, configparser DEFAULT section for fallback values, configparser interpolation and BasicInterpolation and ExtendedInterpolation for variable substitution, configparser write for saving config files, configparser has_section and has_option for existence checks, configparser fallback for missing key defaults, configparser RawConfigParser for no-interpolation parsing, configparser items for section iteration, configparser converters for custom type coercion, and configparser integration with dataclasses and environment variables for Python layered configuration pipelines.
Claude Code for decimal: Exact Decimal Arithmetic in Python
Perform exact decimal arithmetic with Python's decimal module and Claude Code — decimal Decimal for arbitrary-precision fixed-point numbers, decimal getcontext and localcontext for precision and rounding mode control, decimal ROUND_HALF_UP and ROUND_HALF_EVEN and ROUND_DOWN for banking and financial rounding, decimal Decimal from string and integer and float conversion, decimal InvalidOperation and DivisionByZero and Overflow exceptions, decimal quantize for fixed decimal places, decimal to_integral_value for integer rounding, decimal as_tuple for sign and digit and exponent access, decimal compare and number_class for NaN and Infinity handling, and decimal integration with dataclasses and csv for Python financial calculation pipelines.
Claude Code for statistics: Descriptive Statistics in Python
Compute descriptive statistics with Python's statistics module and Claude Code — statistics mean and fmean for arithmetic averages, statistics median and median_low and median_high and median_grouped for central tendency, statistics mode and multimode for most frequent values, statistics stdev and variance for population dispersion, statistics pstdev and pvariance for population parameters, statistics geometric_mean and harmonic_mean for rate and ratio averages, statistics quantiles for percentile computation, statistics NormalDist for normal distribution modeling and z-scores and overlap and samples, statistics correlation and covariance and linear_regression for bivariate analysis, and statistics integration with dataclasses and CSV ingestion for Python data analysis pipelines.
Claude Code for urllib.parse: URL Parsing and Building in Python
Parse and construct URLs with Python's urllib.parse module and Claude Code — urllib.parse urlparse for splitting URLs into components, urllib.parse urljoin for resolving relative URLs, urllib.parse urlencode for query string encoding, urllib.parse parse_qs and parse_qsl for query string decoding, urllib.parse quote and quote_plus for percent encoding, urllib.parse unquote and unquote_plus for percent decoding, urllib.parse urlsplit and urlunsplit for 5-component URL manipulation, urllib.parse ParseResult and SplitResult named tuples for component access, urllib.parse urldefrag for fragment stripping, urllib.parse uses_netloc registry for scheme handling, and urllib.parse integration with dataclasses and requests for Python URL construction and routing pipelines.
Claude Code for shutil: File and Directory Operations in Python
Copy, move, and manage files with Python's shutil module and Claude Code — shutil copy and copy2 for file copying with metadata, shutil copytree for recursive directory copying, shutil move for file and directory relocation, shutil rmtree for recursive directory deletion, shutil make_archive and unpack_archive for zip and tar creation and extraction, shutil disk_usage for storage statistics, shutil which for executable path resolution, shutil get_terminal_size for console dimensions, shutil chown for file ownership changes, shutil ignore_patterns for selective copytree filtering, shutil SameFileError and Error for robust error handling, and shutil integration with pathlib and tempfile for Python file management pipelines.
Claude Code for sqlite3: Embedded Databases in Python
Work with embedded SQLite databases using Python's sqlite3 module and Claude Code — sqlite3 connect for database connections, sqlite3 cursor execute and executemany for queries, sqlite3 Row for dict-like row access, sqlite3 row_factory for custom row mapping, sqlite3 context manager transactions with commit and rollback, sqlite3 WAL mode for concurrent reads, sqlite3 placeholders for parameterized queries, sqlite3 create_function for custom SQL functions, sqlite3 in-memory databases for testing, sqlite3 backup for database copying, sqlite3 check_same_thread for multi-threaded access, sqlite3 detect_types and adapters and converters for custom Python types, and sqlite3 integration with dataclasses for typed query pipelines in Python embedded database application patterns.
Claude Code for hashlib: Hashing and HMAC in Python
Compute cryptographic hashes with hashlib and Claude Code — hashlib sha256 and sha512 and sha3_256 for secure digests, hashlib md5 for checksums, hashlib blake2b and blake2s for fast keyed hashing, hashlib new for algorithm-agnostic hashing, hashlib file_digest for streaming file hashing, hashlib pbkdf2_hmac for password key derivation, hashlib scrypt for memory-hard password hashing, hmac.new and hmac.compare_digest for HMAC-based message authentication, hashlib update for incremental hashing of large data, hashlib hexdigest and digest for bytes and hex output, hashlib algorithms_available for runtime capability check, secrets module for cryptographically secure random bytes, and hashlib integration with dataclasses and API signing for Python secure data integrity pipelines.
Claude Code for csv: CSV File Processing in Python
Read and write CSV files with Python's csv module and Claude Code — csv reader and writer for basic row iteration and writing, csv DictReader for header-mapped row access, csv DictWriter for dict-based row writing, csv Sniffer for automatic dialect detection, csv QUOTE_ALL and QUOTE_NONNUMERIC and QUOTE_NONE for quoting control, csv delimiter and quotechar and lineterminator dialect parameters, csv register_dialect for reusable format definitions, csv fieldnames and extrasaction for flexible header handling, streaming large CSV files with itertools and csv.reader, csv writing to StringIO for in-memory output, csv error handling for malformed rows, and csv integration with dataclasses and typing for typed row processing pipelines in Python data ingestion workflows.
Claude Code for datetime: Dates and Times in Python
Handle dates and times with Python's datetime module and Claude Code — datetime date and time and datetime for calendar and clock values, datetime timedelta for durations and arithmetic, datetime timezone and utc for timezone-aware datetimes, datetime strftime and strptime for formatting and parsing, datetime fromisoformat and isoformat for ISO 8601 round-trip, datetime replace for immutable date mutation, datetime combine for merging date and time objects, datetime astimezone for timezone conversion, calendar module for month calendars and weekday constants, zoneinfo for IANA timezone database lookups, datetime min and max and resolution for boundary values, and datetime integration with dataclasses and JSON for Python time-aware application pipelines.
Claude Code for abc: Abstract Base Classes in Python
Design extensible interfaces with abc and Claude Code — abc ABC for base class inheritance, abc abstractmethod for required method declarations, abc abstractclassmethod and abstractstaticmethod and abstractproperty for abstract class and static methods, abc ABCMeta for metaclass-based interface definition, abc register for virtual subclass registration, abc __subclasshook__ for custom isinstance behavior, abc get_cache_token for invalidating subclass checks, runtime_checkable Protocol comparison with ABC, mixin patterns using ABC for partial implementation sharing, abstract property patterns for required computed attributes, template method patterns with ABC and concrete steps, and abc integration with dataclasses and typing for Python interface-driven typed architecture pipelines.
Claude Code for json: JSON Serialization in Python
Serialize and deserialize data with Python's json module and Claude Code — json dumps for encoding Python objects to JSON strings, json loads for decoding JSON strings to Python objects, json dump and load for file I/O, json JSONEncoder for custom serialization of dataclasses and datetime and Decimal, json JSONDecoder and object_hook for custom deserialization, json indent and separators and sort_keys for formatting, json allow_nan for strict IEEE compliance, json parse_float and parse_int for numeric type control, json decoder parse_constant for extended constants, streaming JSON patterns for large files, json schema validation with jsonschema, and json integration with dataclasses and TypedDict for Python typed serialization pipelines.
Claude Code for re: Regular Expressions in Python
Match and transform text with Python's re module and Claude Code — re compile for pre-compiled patterns, re match and search and fullmatch for position-anchored matching, re findall and finditer for all-match extraction, re sub and subn for pattern substitution, re split for regex-based splitting, re groups and named groups with (?P<name>) for structured extraction, re lookahead and lookbehind with (?=...) and (?<=...) for zero-width assertions, re non-greedy quantifiers for minimal matching, re MULTILINE and DOTALL and IGNORECASE and VERBOSE flags, re escape for literal string matching, re Pattern object methods for compiled reuse, and re integration with dataclasses for typed extraction pipelines in Python text processing workflows.
Claude Code for typing: Python Type Annotations and Static Typing
Write type-safe Python with typing module and Claude Code — typing TypeVar and Generic for generic classes and functions, typing Protocol for structural subtyping, typing TypedDict for typed dict schemas, typing Literal for exact value types, typing Union and Optional and annotated types, typing overload for multiple signatures, typing cast and TYPE_CHECKING for type-check-only imports, typing NamedTuple for typed tuples, typing Callable for function type signatures, typing ClassVar and Final for class-level constants, typing get_type_hints for runtime type inspection, typing ParamSpec and Concatenate for decorator typing, typing TypeGuard for type narrowing, typing Self for fluent interfaces, and typing dataclass_transform for typed descriptor patterns in Python gradual static typing pipelines.
Claude Code for argparse: Command-Line Argument Parsing in Python
Build CLIs with argparse and Claude Code — argparse ArgumentParser for argument definition, argparse add_argument for positional and optional arguments, argparse type coercion and choices and default values, argparse nargs for multi-value arguments, argparse action store_true and append and count, argparse subparsers for git-style sub-commands, argparse ArgumentDefaultsHelpFormatter for auto-documenting defaults, argparse FileType for file argument handling, argparse mutually_exclusive_group and argument groups, argparse parse_known_args for partial parsing, argparse Namespace for structured argument access, argparse prog and description and epilog for rich help text, argparse prefix_chars and fromfile_prefix_chars for custom CLI conventions, and argparse integration with dataclasses and config systems for Python command-line application pipelines.
Claude Code for enum: Symbolic Constants and State Machines in Python
Define symbolic constants with enum and Claude Code — enum Enum for named constants, enum IntEnum for integer-compatible enums, enum StrEnum for string-compatible enums, enum Flag and IntFlag for bitmask combinations, enum auto for automatic value assignment, enum unique for duplicate-value prevention, enum member access by name and value, enum iteration and membership testing, enum _missing_ for lenient parsing, enum _ignore_ for private members, enum @property for computed attributes, enum mixin patterns for adding methods, enum aliases and pseudo-members, enum Enum.from_string patterns for parsing, and enum integration with dataclasses and Pydantic for Python typed constant and state machine modeling pipelines.
Claude Code for contextlib: Context Manager Utilities in Python
Build and compose context managers with contextlib and Claude Code — contextlib contextmanager for generator-based context managers, contextlib asynccontextmanager for async context managers, contextlib ExitStack for dynamic context manager composition, contextlib AsyncExitStack for async cleanup chains, contextlib suppress for safe exception suppression, contextlib redirect_stdout and redirect_stderr for output capture, contextlib closing for auto-close without context manager protocol, contextlib nullcontext for optional context managers, contextlib AbstractContextManager and AbstractAsyncContextManager for base classes, contextlib chdir for temporary directory change, contextlib aclosing for async resource cleanup, and with statement patterns for resource lifecycle management in Python safe resource handling pipelines.
Claude Code for itertools: Efficient Iterator Building Blocks
Compose lazy iterators with itertools and Claude Code — itertools chain for concatenating iterables, itertools islice for lazy slicing, itertools groupby for consecutive grouping, itertools product for Cartesian products, itertools permutations and combinations and combinations_with_replacement for combinatorics, itertools accumulate for running totals, itertools takewhile and dropwhile for predicate-based slicing, itertools cycle and repeat and count for infinite iterators, itertools compress and filterfalse for boolean masking, itertools starmap for multi-argument mapping, itertools zip_longest for uneven zipping, itertools tee for iterator copying, itertools pairwise for adjacent pairs, and itertools batched for fixed-size chunking in Python lazy data pipeline building.
Claude Code for functools: Higher-Order Functions in Python
Build reusable function utilities with functools and Claude Code — functools lru_cache for memoization, functools cached_property for lazy computed attributes, functools partial for argument binding, functools reduce for fold operations, functools wraps for preserving decorator metadata, functools total_ordering for comparison method generation, functools singledispatch for function overloading, functools cache for unbounded memoization, functools partialmethod for class method binding, functools cmp_to_key for legacy comparators, operator module with functools for pipeline composition, and functools combined with itertools for functional programming patterns in Python higher-order function and decorator pipelines.
Claude Code for collections: Specialized Container Types in Python
Use Python's collections module with Claude Code — collections Counter for frequency counting, collections defaultdict for auto-initialized dictionaries, collections deque for double-ended queues and sliding windows, collections OrderedDict for insertion-ordered mappings, collections namedtuple for lightweight named records, collections ChainMap for layered configuration lookups, collections UserDict and UserList and UserString for subclassing built-in types, Counter most_common and update and subtract for frequency analysis, deque maxlen for fixed-size sliding windows, deque appendleft and rotate for queue and ring-buffer operations, heapq with collections for priority queue patterns, and collections abc for structural interface checking in Python typed data structure pipelines.
Claude Code for threading: I/O-Bound Concurrency in Python
Parallelize I/O-bound work with threading and Claude Code — threading Thread for explicit thread creation, threading ThreadPoolExecutor for managed worker pools, threading Lock and RLock for mutual exclusion, threading Event for thread signaling, threading Condition for producer-consumer synchronization, threading Semaphore for rate limiting concurrent access, threading Timer for delayed execution, threading Barrier for rendezvous points, threading local for thread-local storage, threading daemon threads for background tasks, threading active_count and enumerate for thread inspection, concurrent.futures ThreadPoolExecutor with as_completed for future-based patterns, and threading queue Queue for safe inter-thread communication in Python I/O-parallel application pipelines.
Claude Code for dataclasses: Structured Data Classes in Python
Model data with Python dataclasses and Claude Code — dataclasses dataclass decorator for auto-generated init and repr, dataclasses field for default values and factories, dataclasses asdict and astuple for serialization, dataclasses replace for immutable updates, dataclasses frozen for immutable dataclasses, dataclasses post_init for validation, dataclasses InitVar for init-only parameters, dataclasses KW_ONLY for keyword-only fields, dataclasses slots for memory efficiency, dataclasses ClassVar for class-level variables, dataclasses fields for field introspection, dataclasses make_dataclass for dynamic class creation, inheritance patterns for hierarchical models, and dataclasses integration with JSON and pydantic for Python typed data modeling pipelines.
Claude Code for logging: Standard Logging in Python
Configure logging with Python's logging module and Claude Code — logging basicConfig for quick setup, logging getLogger for named loggers, logging FileHandler and RotatingFileHandler and TimedRotatingFileHandler for log files, logging StreamHandler for console output, logging Formatter for log message format, logging Filter for conditional log filtering, logging LogRecord for structured log fields, logging propagate and hierarchy for logger tree control, logging dictConfig for config-file-driven setup, logging captureWarnings for warnings integration, logging QueueHandler and QueueListener for async logging, logging contextvar for request-scoped context, and logging JSON formatter patterns for Python structured application logging pipelines.
Claude Code for pathlib: File System Paths in Python
Manage file paths with pathlib and Claude Code — pathlib Path for cross-platform path handling, pathlib Path open and read_text and write_text for file I/O, pathlib glob and rglob for file discovery, pathlib mkdir and rmdir and unlink for file system operations, pathlib stat and exists and is_file and is_dir for path inspection, pathlib parent and name and stem and suffix for path components, pathlib rename and replace for file moving, pathlib resolve for absolute path resolution, pathlib iterdir for directory listing, pathlib home and cwd for special paths, pathlib with_suffix and with_name for path mutation, pathlib symlink_to for symlink creation, and pathlib integration with os and shutil for Python cross-platform file system automation pipelines.
Claude Code for subprocess: Running System Commands in Python
Run shell commands with subprocess and Claude Code — subprocess run for simple command execution, subprocess Popen for live streaming output, subprocess check_output for capturing output, subprocess communicate for stdin input and stdout capture, subprocess PIPE for stream redirection, subprocess STDOUT for merging stderr into stdout, subprocess timeout for command time limits, subprocess env for environment variable injection, subprocess cwd for working directory, subprocess shell for shell string commands, subprocess CalledProcessError for error handling, subprocess check_call for exit-code assertions, and subprocess shlex split for safe argument parsing in Python shell automation and build scripting pipelines.
Claude Code for multiprocessing: CPU Parallelism in Python
Parallelize CPU-bound work with multiprocessing and Claude Code — multiprocessing Pool and map and starmap for parallel function calls, multiprocessing Process for explicit subprocess management, multiprocessing Queue and Pipe for inter-process communication, multiprocessing Manager for shared state, multiprocessing Pool apply_async and imap_unordered for async results, multiprocessing cpu_count for worker sizing, multiprocessing shared_memory for zero-copy data sharing, multiprocessing freeze_support for Windows packaging, concurrent.futures ProcessPoolExecutor for modern API, multiprocessing context spawn and fork and forkserver for platform control, and multiprocessing chunksize for large-iterable performance in Python CPU-parallel computing pipelines.
Claude Code for pytest: Testing Framework in Python
Write tests with pytest and Claude Code — pytest test functions and test classes for test organization, pytest fixtures for test setup and teardown, pytest parametrize for data-driven tests, pytest mark for test categorization, pytest conftest for shared fixtures, pytest monkeypatch for mocking, pytest tmp_path for temporary files, pytest capfd for output capture, pytest raises for exception testing, pytest approx for floating-point comparison, pytest ini and pyproject.toml for configuration, pytest coverage with pytest-cov for test coverage, pytest xdist for parallel test execution, and pytest fixture scope for session and module and class and function level in Python automated testing pipelines.
Claude Code for TensorFlow: Deep Learning Framework in Python
Build neural networks with TensorFlow and Claude Code — tensorflow keras Sequential for model building, tensorflow keras layers Dense and Conv2D and LSTM for layer types, tensorflow keras compile and fit and evaluate and predict for training pipeline, tensorflow keras callbacks EarlyStopping and ModelCheckpoint and TensorBoard for training control, tensorflow keras optimizers Adam and SGD for gradient descent, tensorflow keras losses and metrics for training objectives, tensorflow data Dataset and from_tensor_slices and map and batch and prefetch for data pipelines, tensorflow saved_model save and load for model serialization, tensorflow keras functional API for multi-input multi-output models, tensorflow keras regularizers and Dropout for regularization, tensorflow mixed precision for GPU training, and tensorflow lite converter for mobile deployment in Python deep learning model training pipelines.
Claude Code for Matplotlib: Data Visualization in Python
Create charts with Matplotlib and Claude Code — matplotlib pyplot for plot creation, matplotlib Figure and Axes for object-oriented plotting, matplotlib plot and scatter and bar and hist for chart types, matplotlib subplots for multi-panel figures, matplotlib xlabel and ylabel and title and legend for annotations, matplotlib savefig for PNG PDF SVG export, matplotlib colormap and colorbar for color scales, matplotlib imshow for image display, matplotlib errorbar for uncertainty visualization, matplotlib fill_between for area charts, matplotlib twin axes for dual y-axis, matplotlib style for theme switching, matplotlib animation for animated charts, and matplotlib integration with NumPy and pandas for Python scientific data visualization pipelines.
Claude Code for NumPy: Numerical Computing in Python
Accelerate numerical computing with NumPy and Claude Code — numpy array and ndarray for n-dimensional arrays, numpy zeros and ones and arange and linspace for array creation, numpy reshape and flatten and transpose for array manipulation, numpy dot and matmul for matrix multiplication, numpy sum and mean and std and min and max and argmax for reductions, numpy where for conditional selection, numpy concatenate and stack and split for array combination, numpy random for random number generation, numpy linalg for linear algebra operations, numpy broadcast rules for array operations, numpy vectorize for element-wise functions, numpy save and load for array serialization, and numpy integration with pandas and scikit-learn for Python scientific computing pipelines.
Claude Code for pandas: Data Analysis Library in Python
Analyze data with pandas and Claude Code — pandas DataFrame for tabular data, pandas read_csv and read_json and read_excel for data loading, pandas groupby for aggregation, pandas merge and join for combining DataFrames, pandas loc and iloc for selection, pandas apply and map for transformations, pandas pivot_table for reshaping, pandas fillna and dropna for missing data, pandas to_datetime for date parsing, pandas resample for time series resampling, pandas concat for stacking DataFrames, pandas value_counts for frequency analysis, pandas describe for summary statistics, and pandas to_csv and to_parquet for data export in Python tabular data analysis pipelines.
Claude Code for Flask: Lightweight Web Framework in Python
Build web applications with Flask and Claude Code — Flask route and methods for URL routing, Flask request for form data and JSON body parsing, Flask jsonify for JSON API responses, Flask Blueprint for application modular structure, Flask before_request and after_request for middleware hooks, Flask g for request context globals, Flask abort and HTTPException for error handling, Flask send_file and send_from_directory for file serving, Flask session for server-side sessions, Flask app factory pattern for application configuration, Flask-SQLAlchemy and Flask-Login integration patterns, and Flask testing with test_client for Python lightweight WSGI web application development.
Claude Code for requests: HTTP Client Library in Python
Make HTTP requests with requests and Claude Code — requests get and post and put and delete for REST API calls, requests Session for connection pooling and cookie persistence, requests auth for basic and bearer authentication, requests timeout and retries for resilient HTTP, requests stream for streaming downloads, requests hooks for request and response callbacks, requests PreparedRequest for request inspection, requests Response json and text and content for response parsing, requests HTTPAdapter for retry and backoff configuration, requests cert and verify for TLS configuration, requests multipart and form data for file uploads, and requests mock testing patterns for Python HTTP client automation and API integration pipelines.
Claude Code for filetype: File Type Detection from Bytes in Python
Detect file types with filetype and Claude Code — filetype guess for MIME type detection, filetype guess_mime for MIME string from bytes, filetype guess_extension for file extension detection, filetype is_image for image type checking, filetype is_video for video detection, filetype is_audio for audio file detection, filetype is_archive for compressed file detection, filetype is_document for document type checking, filetype Type for custom type matchers, filetype add_type for registering custom matchers, filetype match for multi-type matching, and filetype integration with file upload validation and content-type routing in Python magic bytes file identification pipelines.
Claude Code for asyncssh: Async SSH Client and Server in Python
Build SSH automations with asyncssh and Claude Code — asyncssh connect for async SSH client connections, asyncssh run for remote command execution, asyncssh SSHClient for event-driven client callbacks, asyncssh SSHServer and SSHServerSession for custom SSH servers, asyncssh start_server for server lifecycle, asyncssh SFTPClient for file transfer and directory listing, asyncssh get and put for file upload download, asyncssh forward_local_port for SSH tunneling, asyncssh SSHKnownHosts for known hosts verification, asyncssh read_private_key for key authentication, asyncssh SSHClientConnection for connection pooling, and asyncssh create_subprocess for remote process pipelines in Python async SSH automation and DevOps scripting.
Claude Code for tomllib: TOML Config Parsing in Python
Parse TOML configuration with tomllib and Claude Code — tomllib loads for parsing TOML strings, tomllib load for reading TOML files, tomllib TOMLDecodeError for parse error handling, tomllib with open binary mode for file loading, tomllib nested tables for hierarchical config, tomllib arrays and inline tables for data structures, tomllib datetime and date and time types for temporal values, tomllib integer and float and boolean types for scalar values, tomllib multi-line strings for long text values, toml write with tomli_w for serialization, tomllib environment overlay for config layering, and tomllib integration with pydantic and dataclasses for Python typed TOML configuration management pipelines.
Claude Code for urwid: Terminal UI Framework in Python
Build terminal UIs with urwid and Claude Code — urwid Text and Edit for text widgets, urwid Button and CheckBox and RadioButton for interactive controls, urwid Pile and Columns for layout composition, urwid ListBox for scrollable lists, urwid Frame for header footer body layout, urwid Padding and Filler for spacing, urwid AttrMap for color and style attributes, urwid MainLoop for event loop management, urwid connect_signal for widget signals, urwid ExitMainLoop for loop termination, urwid Canvas for custom drawing, urwid palette for color theme definition, urwid PopUpLauncher for overlay dialogs, and urwid integration with asyncio for Python terminal user interface dashboard and dialog application pipelines.
Claude Code for charset-normalizer: Encoding Detection in Python
Detect text encodings with charset-normalizer and Claude Code — charset_normalizer from_bytes for encoding detection, charset_normalizer from_path for file encoding analysis, charset_normalizer from_fp for stream detection, charset_normalizer Results best for top encoding match, charset_normalizer normalize for bytes to UTF-8 conversion, charset_normalizer encode and decode for safe text handling, charset_normalizer chaos for encoding disorder score, charset_normalizer coherence for language detection, charset_normalizer languages for detected language metadata, charset_normalizer is_large_sequence for file optimization, and charset_normalizer cli for command-line encoding detection in Python universal encoding detection text normalization pipelines.
Claude Code for PyLaTeX: LaTeX Document Generation in Python
Generate LaTeX documents with PyLaTeX and Claude Code — pylatex Document for PDF creation, pylatex Section and Subsection for document structure, pylatex Math and Equation for mathematical formulas, pylatex Tabular for table generation, pylatex Figure and SubFigure for image inclusion, pylatex TikZ and Axis for plotting, pylatex bold italic and underline for text formatting, pylatex Package for LaTeX package inclusion, pylatex generate_pdf for PDF compilation, pylatex NoEscape for raw LaTeX, pylatex MultiColumn and MultiRow for complex tables, pylatex VerticalSpace and HorizontalSpace for layout, and pylatex template classes for reusable report and thesis and invoice generation in Python automated PDF document pipelines.
Claude Code for boltons: Pure Python Utilities for Every Project
Enhance Python projects with boltons and Claude Code — boltons iterutils chunked and windowed for sequence operations, boltons iterutils remap for deep data transformation, boltons typeutils make_sentinel and is_type for type utilities, boltons strutils camel2under and slugify and strip_ansi for string processing, boltons fileutils atomic_save and iter_find_files for file operations, boltons cacheutils LRU and ThresholdCounter for caching, boltons timeutils parse_timedelta and decimal_clock for time utilities, boltons mathutils clamp and ceil_ceil for numeric helpers, boltons queueutils HeapQueue for priority queues, boltons statsutils mean and median for statistics, and boltons tbutils ExceptionInfo for exception formatting in Python utility programming.
Claude Code for inflect: English Language Inflection in Python
Handle English grammar with inflect and Claude Code — inflect plural for nouns and verbs, inflect singular_noun for singular detection, inflect plural_adj for adjective pluralization, inflect a and an for indefinite article selection, inflect number_to_words for integer to words conversion, inflect ordinal for ordinal numbers, inflect inflect_noun for number-aware noun forms, inflect compare and compare_nouns for plural equivalence, inflect join for English list joining with and or or, inflect present_participle for verb forms, inflect user_input_mode for case preservation, and inflect engine for configurable language rules in Python dynamic text generation UI labels and grammar-correct output pipelines.
Claude Code for construct: Binary Protocol Parsing in Python
Parse binary data with construct and Claude Code — construct Struct for binary record definitions, construct Int8sb Int16ub Int32ul for integer types, construct Bytes and GreedyBytes for raw byte fields, construct PascalString and CString for string parsing, construct Array and GreedyRange for repeated elements, construct Switch for conditional field selection, construct If and IfThenElse for conditional parsing, construct Computed and Rebuild for derived fields, construct Enum for named constants, construct BitStruct and Flag for bit-level parsing, construct Checksum for integrity checking, construct LazyBound for recursive structures, and construct build parse and sizeof for binary serialization in Python network protocol file format and embedded systems parsing pipelines.
Claude Code for sh: Shell Commands as Python Functions
Run shell commands with sh and Claude Code — sh Command for dynamic shell command invocation, sh git and sh ls and sh grep for common Unix commands as Python callables, sh _out for output capture, sh _err for stderr capture, sh _in for stdin piping, sh _bg for background process execution, sh _iter for streaming line-by-line output, sh _timeout for process timeout, sh _cwd for working directory, sh _env for environment variables, sh RunningCommand for process control, sh ErrorReturnCode for exit code handling, sh contrib for sudo and bash helpers, and sh command chaining and piping for Python subprocess automation shell scripting pipelines.
Claude Code for IceCream: Better Print Debugging in Python
Debug faster with IceCream and Claude Code — icecream ic for expression inspection with automatic context printing, icecream ic return value passthrough for inline debugging, icecream installLogging for Python logging integration, icecream includeContext for file and line number output, icecream prefix for custom output labels, icecream argToStringFunction for custom serialization, icecream disable and enable for conditional output, icecream configureOutput for redirecting output, icecream ic as context manager for temporary debugging, icecream format for structured output control, and icecream integration with rich and loguru for Python development print debugging inspection workflow tools.
Claude Code for funcy: Functional Programming Utilities in Python
Write cleaner Python with funcy and Claude Code — funcy compose and rcompose for function composition, funcy partial and curry for partial application, funcy memoize and memoize_plain for caching, funcy group_by and count_by for collection grouping, funcy flatten and chunks for sequence manipulation, funcy merge and project for dict operations, funcy first and last and nth for sequence access, funcy take and drop and take_while for lazy sequences, funcy retry for resilient function calls, funcy decorator and wraps for higher-order functions, funcy imap and ifilter for iterator pipelines, and funcy select_keys and omit for dict transformation in Python functional utilities data transformation pipelines.
Claude Code for returns: Type-Safe Functional Programming in Python
Write robust pipelines with returns and Claude Code — returns Result Success Failure for explicit error handling without exceptions, returns Maybe Some Nothing for optional value chaining, returns IO for side-effect isolation, returns Future for async computation containers, returns flow and pipe for function composition, returns pointfree map bind alt for container operations, returns safe and unsafe_perform_io for impure function lifting, returns curry for partial application, returns RequiresContext for dependency injection, returns Fold for container aggregation, and returns hypothesis strategies for property-based testing in Python type-safe monadic railway-oriented programming pipelines.
Claude Code for Shapely: Geometric Operations in Python
Compute geometry with Shapely and Claude Code — shapely Point LineString Polygon for geometric object creation, shapely contains within intersects for spatial predicates, shapely intersection union difference for set operations, shapely buffer for offset and dilation, shapely simplify for geometry generalization, shapely distance and length for measurements, shapely centroid bounds convex_hull for properties, shapely affinity for translate rotate scale transforms, shapely STRtree for spatial indexing, shapely unary_union for merging geometry collections, shapely from_wkt and to_wkt for WKT serialization, shapely from_geojson and mapping for GeoJSON integration, and shapely integration with Fiona GeoPandas and PostGIS for Python spatial analysis GIS pipelines.
Claude Code for pydub: Audio Manipulation in Python
Process audio with pydub and Claude Code — pydub AudioSegment from_file for loading WAV MP3 FLAC OGG audio, pydub AudioSegment export for saving to any format, pydub slicing and concatenation for audio editing, pydub overlay for mixing tracks, pydub fade_in and fade_out for smooth transitions, pydub apply_gain and normalize for volume control, pydub split_on_silence for voice activity detection, pydub effects low_pass_filter and high_pass_filter, pydub generators Sine and WhiteNoise for audio synthesis, pydub detect_leading_silence for trimming, and pydub from_mono_audiosegments for channel manipulation in Python audio processing trimming mixing normalization pipelines.
Claude Code for falcon: Fast Python REST API Framework
Build REST APIs with falcon and Claude Code — falcon App for WSGI ASGI application creation, falcon routing for URL dispatch with URI templates, falcon Request for query params headers and body access, falcon Response for status body and headers, falcon on_get on_post on_put on_delete for HTTP method responders, falcon before and after hooks for middleware, falcon middleware for cross-cutting concerns, falcon HTTPError and HTTPNotFound for error responses, falcon CORSMiddleware for cross-origin support, falcon media handlers for JSON and msgpack deserialization, falcon testing TestClient for unit tests, and falcon integration with uvicorn and gunicorn for Python high-performance REST API low-latency microservice pipelines.
Claude Code for arrow: Human-Friendly Datetime in Python
Handle dates and times with arrow and Claude Code — arrow now for current UTC datetime, arrow get for flexible parsing from strings ISO 8601 timestamps and epochs, arrow Arrow shift for relative date arithmetic, arrow format for locale-aware strftime output, arrow humanize for human-readable time differences, arrow span and span_range for datetime ranges, arrow floor and ceil for period truncation, arrow to for timezone conversion, arrow replace for immutable field updates, arrow fromtimestamp and timestamp for Unix epoch conversion, arrow between for range testing, and arrow factory functions for building datetimes in Python timezone-aware datetime parsing humanize formatting pipelines.
Claude Code for rapidfuzz: Fast Fuzzy String Matching in Python
Match fuzzy strings with rapidfuzz and Claude Code — rapidfuzz fuzz ratio for Levenshtein similarity, rapidfuzz fuzz partial_ratio for substring matching, rapidfuzz fuzz token_sort_ratio for word-order-insensitive comparison, rapidfuzz fuzz token_set_ratio for set-based matching, rapidfuzz process extractOne and extract for best-match lookup, rapidfuzz process cdist for pairwise distance matrices, rapidfuzz distance Levenshtein and DamerauLevenshtein for edit distance, rapidfuzz string_metric jaro_similarity for transposition-aware scoring, rapidfuzz scorer parameter for custom distance functions, rapidfuzz score_cutoff for threshold filtering, and rapidfuzz bulk matching for Python fuzzy deduplication name normalization and record linkage pipelines.
Claude Code for Bottle: Single-File Python Micro Web Framework
Build APIs with Bottle and Claude Code — bottle Bottle app for single-file web applications, bottle route decorator for URL mapping, bottle request for query params and form data and JSON body, bottle response and abort for HTTP responses, bottle template and jinja2 for HTML rendering, bottle static_file for file serving, bottle hook for before_request middleware, bottle BaseRequest cookies and auth for security, bottle redirect and HTTPError for flow control, bottle run with server adapters for wsgiref gevent and gunicorn, bottle reloader for development, and bottle PluginAPI for extensions in Python minimal single-file REST API development.
Claude Code for selenium: Browser Automation and Web Scraping in Python
Automate browsers with selenium and Claude Code — selenium WebDriver for Chrome Firefox and Edge control, selenium By for element location strategies, selenium WebDriverWait and expected_conditions for explicit waits, selenium ActionChains for mouse and keyboard interactions, selenium find_element and find_elements for DOM selection, selenium send_keys and click for form interaction, selenium execute_script for JavaScript execution, selenium get_screenshot_as_png for visual capture, selenium Options for headless and proxy configuration, selenium Select for dropdown handling, selenium Chrome DevTools Protocol for network interception, and selenium integration with pytest and page objects for Python browser testing and automation pipelines.
Claude Code for PyMuPDF: Fast PDF Text and Image Extraction in Python
Process PDFs with PyMuPDF and Claude Code — pymupdf fitz open for PDF document loading, pymupdf Page get_text for text extraction with json and blocks and dict formats, pymupdf Page get_images for embedded image access, pymupdf Pixmap for image rendering and PNG export, pymupdf Page search_for for text search and location, pymupdf Page get_links for hyperlink extraction, pymupdf Document insert_pdf for merging, pymupdf Page draw_rect and insert_text for annotation, pymupdf Document save and tobytes for output, pymupdf Table for tabular data extraction, pymupdf Story for reflow content, and pymupdf integration with OCR for Python fast PDF text image extraction pipelines.
Claude Code for parsel: CSS and XPath Web Scraping in Python
Extract web data with parsel and Claude Code — parsel Selector for HTML and XML document parsing, parsel css for CSS selector queries, parsel xpath for XPath expressions, parsel get and getall for text extraction, parsel attrib for attribute access, parsel re and re_first for regex extraction, parsel SelectorList for batch result operations, parsel follow and follow_all for link extraction, parsel jmespath for JSON data extraction, parsel response_text for full-document selectors, parsel nested selector chaining, and parsel integration with httpx and requests for Python CSS XPath web scraping data extraction pipelines.
Claude Code for gevent: Coroutine-Based Concurrency for Python
Accelerate I/O-bound Python with gevent and Claude Code — gevent monkey patching for transparent async I/O, gevent Greenlet for lightweight coroutine creation, gevent spawn and joinall for concurrent execution, gevent Pool for bounded parallel workers, gevent Queue for producer-consumer coordination, gevent Event and AsyncResult for synchronization, gevent Timeout for cancellable operations, gevent sleep for cooperative yielding, gevent socket for non-blocking network I/O, gevent hub for event loop access, gevent wsgi server for WSGI applications, and gevent integration with requests and urllib for Python cooperative multitasking pipelines.
Claude Code for python-pptx: Create PowerPoint Presentations in Python
Automate PowerPoint slides with python-pptx and Claude Code — pptx Presentation for creating and opening PPTX files, pptx slide_layouts for built-in slide designs, pptx add_slide and Slide for slide management, pptx TextFrame and Paragraph and Run for text formatting, pptx add_shape and add_picture for visual elements, pptx add_chart with ChartData for data visualizations, pptx Placeholder access for template-based content, pptx table add_table and Cell for data grids, pptx fill and line for shape styling, pptx slide_width and slide_height for dimensions, pptx save and BytesIO for file output, and pptx branded slide decks and automated report presentations in Python PowerPoint generation pipelines.
Claude Code for cloudpickle: Serialize Python Functions for Distributed Computing
Distribute Python functions with cloudpickle and Claude Code — cloudpickle dumps and loads for lambda and closure serialization, cloudpickle register_pickle_by_value for module-defined function portability, cloudpickle dumps protocol for version control, cloudpickle integration with concurrent.futures ProcessPoolExecutor, cloudpickle integration with Dask distributed delayed and scatter, cloudpickle integration with Ray remote functions, cloudpickle integration with multiprocessing Pool for lambda support, cloudpickle PicklingError for debugging non-serializable objects, cloudpickle with joblib for parallel function dispatch, and cloudpickle dynamic class and function pickling for Python distributed task pipeline serialization.
Claude Code for lxml: Fast XML and HTML Parsing in Python
Parse and build XML HTML with lxml and Claude Code — lxml etree parse and fromstring for XML document loading, lxml etree Element and SubElement for tree construction, lxml etree tostring for serialization, lxml etree XPath for node querying, lxml etree XSLT for stylesheet transforms, lxml etree XMLSchema for validation, lxml html parse and fromstring for HTML documents, lxml html tostring and clean for output, lxml cssselect for CSS selector queries, lxml objectify for data-binding XML, lxml iterparse for streaming large XML files, and lxml etree ElementMaker for fluent tree building in Python XML HTML processing pipelines.
Claude Code for python-docx: Create and Edit Word Documents in Python
Build Word documents with python-docx and Claude Code — docx Document for creating and opening Word files, docx add_paragraph and add_heading for text content, docx add_table and Cell for tabular data, docx Paragraph and Run for fine-grained text formatting, docx Font bold italic size and color for run styling, docx add_picture for image embedding, docx PageBreak and section properties for layout control, docx styles and numbered lists for consistent formatting, docx header and footer for page decoration, docx CoreProperties for document metadata, docx save for file output, and docx template documents for branded report generation in Python Word document automation pipelines.
Claude Code for dill: Extended Python Pickling and Serialization
Serialize complex Python objects with dill and Claude Code — dill dumps and loads for extended pickle serialization, dill pickle lambda and closure and class for objects stdlib pickle cannot handle, dill dump and load for file persistence, dill copy for deep copying via serialization, dill source for extracting object source code, dill detect for dependency analysis, dill session dump and load for full interpreter state persistence, dill settings for recursive pickling control, dill Pickler and Unpickler for custom serialization, dill compatibility with multiprocessing and concurrent.futures, and dill integration with joblib and pathos for Python distributed computing serialization pipelines.
Claude Code for line_profiler: Line-by-Line Python Performance Profiling
Find slow lines with line_profiler and Claude Code — line_profiler LineProfiler for function-level timing, line_profiler profile decorator for automatic line profiling, line_profiler kernprof CLI for script profiling, line_profiler add_function for manual registration, line_profiler print_stats for output formatting, line_profiler get_stats for programmatic result access, line_profiler rstats for sorted output, line_profiler dump_stats and load_stats for file persistence, line_profiler with pytest for test timing, line_profiler integration with Jupyter notebooks, and line_profiler TimeUnit for timing precision in Python hot path performance optimization.
Claude Code for kombu: Python Message Transport Abstraction Library
Route messages across brokers with kombu and Claude Code — kombu Connection for broker-agnostic connections, kombu Exchange for message routing with direct fanout and topic types, kombu Queue for message subscription, kombu Producer for publishing, kombu Consumer for callback-based consumption, kombu SimpleQueue for Redis and RabbitMQ backends, kombu BrokerConnection url for transport switching, kombu acks_late for reliable processing, kombu exchange bindings for multi-queue fanout, kombu Connection as_uri for connection inspection, kombu serialization with json and msgpack, and kombu integration with Celery and asyncio for Python multi-broker message transport pipelines.
Claude Code for uvloop: Fast asyncio Event Loop for Python
Accelerate async Python with uvloop and Claude Code — uvloop install as asyncio event loop policy for 2-4x performance improvement, uvloop EventLoopPolicy for global loop replacement, uvloop run for direct coroutine execution, uvloop integration with aiohttp for high-throughput HTTP servers, uvloop integration with FastAPI and uvicorn for ASGI performance, uvloop integration with asyncpg for fast PostgreSQL queries, uvloop loop benchmarking and profiling patterns, uvloop compatibility with asyncio streams and transports, uvloop with gunicorn worker for production async deployment, and uvloop loop policy with asyncio.run for drop-in event loop acceleration in Python async applications.
Claude Code for schedule: Simple Python Job Scheduling
Automate recurring tasks with schedule and Claude Code — schedule every for interval scheduling, schedule every day at for time-based jobs, schedule run_pending for the scheduler loop, schedule run_all for immediate execution, schedule cancel_job and clear for job removal, schedule tag for grouping jobs, schedule next_run for inspection, schedule idle_seconds for sleep optimization, schedule default_scheduler and custom Scheduler for multi-instance setups, schedule threading for background execution, schedule exception handling for resilient jobs, and schedule integration with Flask and FastAPI for Python cron-style periodic task automation.
Claude Code for aio-pika: Async RabbitMQ Client for Python
Connect to RabbitMQ with aio-pika and Claude Code — aio-pika connect_robust for resilient async RabbitMQ connections, aio-pika Channel and Exchange for message routing, aio-pika Queue and bind for subscription setup, aio-pika Message with DeliveryMode persistent for durable messages, aio-pika basic_ack and basic_nack for acknowledgement, aio-pika ExchangeType for direct fanout and topic routing, aio-pika IncomingMessage for consumer callbacks, aio-pika RobustConnection for automatic reconnect, aio-pika QueueIterator for async for message iteration, aio-pika deadletter exchange for failed message routing, and aio-pika integration with FastAPI asyncio lifespan for Python async RabbitMQ producer and consumer pipelines.
Claude Code for Quart: Async Flask Web Framework in Python
Build async web apps with Quart and Claude Code — quart Quart for async Flask-compatible application factory, quart route decorator for async view functions, quart request and jsonify for HTTP handling, quart Blueprint for modular routing, quart websocket for WebSocket endpoints, quart before_request and after_request for middleware, quart g and current_app for application context, quart render_template for Jinja2 HTML responses, quart make_response and Response for custom responses, quart testing with test_client and test_request_context, and quart hypercorn for ASGI production deployment in Python async web applications.
Claude Code for aiokafka: Async Kafka Producer and Consumer in Python
Stream events with aiokafka and Claude Code — aiokafka AIOKafkaProducer for async message publishing, aiokafka AIOKafkaConsumer for async message consumption, aiokafka send_and_wait for confirmed delivery, aiokafka consumer groups for parallel processing, aiokafka seek and commit_offsets for offset management, aiokafka TopicPartition for partition assignment, aiokafka key and value serializers for message encoding, aiokafka SSL context for secure Kafka connections, aiokafka batch send for high-throughput production, aiokafka consumer rebalance listener for partition events, and aiokafka integration with FastAPI and asyncio for Python event streaming pipelines.
Claude Code for pika: RabbitMQ AMQP Messaging in Python
Send and receive AMQP messages with pika and Claude Code — pika BlockingConnection for synchronous RabbitMQ, pika SelectConnection for async event-driven messaging, pika channel basic_publish for message production, pika basic_consume for consumer callbacks, pika queue_declare and exchange_declare for topology, pika basic_ack and basic_nack for message acknowledgement, pika DeliveryMode persistent for durable messages, pika RoutingKey and exchange types for message routing, pika heartbeat and connection_attempts for reliability, pika RabbitMQ TLS for secure connections, and pika integration with asyncio and threading for Python RabbitMQ producer and consumer pipelines.
Claude Code for RQ: Redis Queue Background Tasks in Python
Process background jobs with RQ and Claude Code — rq Queue for task queuing, rq Worker for job execution, rq job decorator for task definition, rq enqueue and enqueue_at and enqueue_in for scheduling, rq Retry for automatic job retry, rq job status and result for polling, rq Callback for success and failure handlers, rq connection for Redis backend, rq RQScheduler for periodic tasks, rq SimpleWorker for sync testing, rq Dashboard for job monitoring, and rq integration with Flask and FastAPI for Python background task processing systems.
Claude Code for SQLModel: SQLAlchemy and Pydantic ORM for FastAPI
Build type-safe databases with SQLModel and Claude Code — sqlmodel SQLModel for combining SQLAlchemy and Pydantic models, sqlmodel create_engine and create_db_and_tables for database setup, sqlmodel Session for CRUD operations, sqlmodel Field for column definitions with primary key and default and index, sqlmodel select and where for queries, sqlmodel Relationship for one-to-many and many-to-many associations, sqlmodel SQLModel with table equals True for table models, sqlmodel validation with Pydantic types, sqlmodel async engine and AsyncSession for async FastAPI database access, and sqlmodel integration with Alembic for migrations in Python FastAPI applications.
Claude Code for sqlite-utils: SQLite Database Toolkit in Python
Manage SQLite databases with sqlite-utils and Claude Code — sqlite-utils Database and Table for schema-free insertion, sqlite-utils insert and upsert for data loading, sqlite-utils create_table and transform for schema management, sqlite-utils search with FTS5 full-text search, sqlite-utils convert for column data transformation, sqlite-utils rows_where and pks_and_rows for querying, sqlite-utils index_foreign_keys and create_index for performance, sqlite-utils Memory for in-memory databases, sqlite-utils CLI for shell scripting, and sqlite-utils integration with pandas and httpx for Python SQLite data pipeline automation.
Claude Code for Fabric: Remote SSH Automation in Python
Automate remote servers with Fabric and Claude Code — fabric Connection for SSH session management, fabric run and sudo for remote command execution, fabric put and get for file transfer, fabric local for local command execution, fabric cd and prefix and env for execution context, fabric SerialGroup and ThreadedGroup for multi-host automation, fabric Config for SSH settings and connection pooling, fabric Responder for interactive prompt handling, fabric transfer for rsync-style file sync, fabric Connection with gateway for SSH jump hosts, and fabric integration with invoke tasks for Python deployment automation and remote server management.
Claude Code for tablib: Tabular Data Formats in Python
Export tabular data to multiple formats with tablib and Claude Code — tablib Dataset for in-memory table creation, tablib export for CSV and JSON and YAML and Excel and ODS and TSV formats, tablib import_set for loading data, tablib append and extend for dataset population, tablib headers for column names, tablib Databook for multi-sheet workbooks, tablib dynamic_col for computed columns, tablib filter for row filtering, tablib stack and wipe for dataset manipulation, tablib invalid_rows for data validation, and tablib integration with pandas and Django for Python multi-format data export pipelines.
Claude Code for XlsxWriter: Excel File Generation in Python
Generate Excel XLSX files with XlsxWriter and Claude Code — xlsxwriter Workbook and Worksheet for spreadsheet creation, xlsxwriter write and write_formula for cell data, xlsxwriter add_format for cell styling with bold and color and number format, xlsxwriter add_chart for bar and line and pie charts, xlsxwriter set_column and set_row for dimensions, xlsxwriter conditional_format for data bars and color scales, xlsxwriter merge_range for merged cells, xlsxwriter add_table for Excel Tables with autofilter, xlsxwriter freeze_panes for header rows, xlsxwriter BytesIO output for HTTP responses, and xlsxwriter integration with pandas and FastAPI for Python Excel report generation.
Claude Code for scalene: CPU and Memory Line-by-Line Profiler
Profile Python line-by-line with scalene and Claude Code — scalene Scalene for CPU and memory and GPU profiling, scalene profile decorator for function-level analysis, scalene web UI for interactive HTML reports, scalene cpu_percent and memory_usage for line attribution, scalene native for C extension profiling, scalene malloc_threshold for allocation filtering, scalene reduced_profile for fast summary, scalene profile_interval for sampling rate, scalene outfile for JSON export, scalene AI suggestions for automated performance recommendations, and scalene integration with pytest and CI for per-line Python performance regression detection.
Claude Code for py-spy: Sampling Profiler for Running Python Processes
Profile running Python processes with py-spy and Claude Code — py-spy top for live process monitoring, py-spy record for flamegraph generation without restart, py-spy dump for instant call stack snapshot, py-spy speedscope for timeline output, py-spy subprocesses for multi-process tracing, py-spy native for C extension profiling, py-spy rate for sampling frequency control, py-spy PyStacks for programmatic stack access, py-spy idle for including blocking call stacks, and py-spy integration with Docker and Kubernetes for zero-downtime Python production profiling.
Claude Code for viztracer: Python Execution Timeline Tracing
Trace Python execution timelines with viztracer and Claude Code — viztracer VizTracer for recording function call timelines, viztracer save and output_file for trace storage, viztracer report for HTML timeline viewer, viztracer log_var and log_attr for variable logging, viztracer add_instant and add_counter for custom trace events, viztracer filter_func for selective tracing, viztracer max_stack_depth and tracer_entries for trace size control, viztracer multiprocess and subprocess tracing, viztracer flamegraph for call aggregation, and viztracer integration with asyncio and pytest for Python performance investigation and timeline visualization.
Claude Code for pyinstrument: Python Call Stack Profiler
Profile Python performance with pyinstrument and Claude Code — pyinstrument Profiler for sampling call stacks, pyinstrument output and open_in_browser for flamegraphs, pyinstrument renderers for text and HTML and JSON output, pyinstrument interval for sampling rate control, pyinstrument async_mode for asyncio profiling, pyinstrument timeline for chronological call view, pyinstrument session for saving and comparing profiles, pyinstrument CLI for command-line profiling, pyinstrument middleware for FastAPI and Django request profiling, and pyinstrument pytest plugin for per-test call stack reports in Python applications.
Claude Code for memray: Memory Profiling in Python
Profile Python memory usage with memray and Claude Code — memray Tracker for recording allocations, memray flamegraph and table and tree for visualization, memray stats for peak memory and allocation counts, memray live for real-time monitoring, memray attach for profiling running processes, memray bin files for portable result storage, memray filter-allocations and native for C extension tracing, memray pytest plugin for per-test memory reporting, memray programmatic API for in-process profiling, and memray integration with asyncio for async memory leak detection in Python applications.
Claude Code for cairosvg: SVG to PNG and PDF Conversion in Python
Convert SVG to PNG, PDF, and PS with cairosvg and Claude Code — cairosvg svg2png for rasterizing SVG to PNG bytes, cairosvg svg2pdf for vector PDF output, cairosvg svg2ps for PostScript, cairosvg scale and dpi parameters for resolution control, cairosvg write_to for file output, cairosvg unsafe for external resource loading, cairosvg background_color for transparent SVG rendering, cairosvg output_width and output_height for size override, cairosvg url for remote SVG fetching, and cairosvg integration with svgwrite and Pillow and FastAPI for Python SVG rendering and image export pipelines.
Claude Code for pikepdf: PDF Manipulation in Python
Manipulate PDF files with pikepdf and Claude Code — pikepdf open and save for reading and writing PDFs, pikepdf pages for page access and reordering, pikepdf PdfImage for image extraction, pikepdf merge and split for combining and dividing documents, pikepdf encrypt and decrypt for PDF security, pikepdf metadata and docinfo for document properties, pikepdf stamp and watermark for page overlays, pikepdf compress and optimize for file size reduction, pikepdf Pdf.new for creating PDFs from scratch, pikepdf annotations for form fields and bookmarks, and pikepdf integration with Pillow and reportlab for Python PDF processing pipelines.
Claude Code for svgwrite: SVG Vector Graphics in Python
Generate SVG vector graphics with svgwrite and Claude Code — svgwrite Drawing for SVG document creation, svgwrite add for appending shapes, svgwrite rect and circle and line and polyline and polygon for geometric primitives, svgwrite text and tspan for typography, svgwrite path with d string for complex curves, svgwrite g for grouping and transforms, svgwrite linearGradient and radialGradient for fill effects, svgwrite defs and use for reusable elements, svgwrite viewBox and preserveAspectRatio for responsive SVG, svgwrite tostring and save for output, and svgwrite integration with FastAPI for dynamic SVG chart and badge generation in Python.
Claude Code for WeasyPrint: HTML and CSS to PDF in Python
Generate PDF documents from HTML and CSS with WeasyPrint and Claude Code — weasyprint HTML and CSS for document styling, weasyprint write_pdf for bytes output, weasyprint url_fetcher for asset loading, weasyprint @page CSS rules for margins and orientation and headers and footers, weasyprint base_url for relative asset resolution, weasyprint presentational_hints for inline HTML styles, weasyprint Font configuration for custom fonts, weasyprint string-set and running elements for repeating page headers, weasyprint Jinja2 integration for template-driven PDF generation, and weasyprint Flask and FastAPI response for PDF download endpoints.
Claude Code for fpdf2: Python PDF Generation
Generate PDF documents with fpdf2 and Claude Code — FPDF class for document creation, add_page and set_font for structure, cell and multi_cell for text blocks, image for embedding images, set_fill_color and set_text_color for styling, ln for line breaks, get_string_width for layout, header and footer override for templates, output to file or bytes, table generation with cell widths, HTML rendering with HTMLMixin, and fpdf2 integration with jinja2 templates Flask file responses and invoice generation.
Claude Code for websockets: Async WebSocket Server and Client in Python
Build real-time apps with websockets and Claude Code — websockets serve for WebSocket server, connect for WebSocket client, websockets send and recv for message exchange, websockets broadcast for fan-out to multiple connections, websockets websocket_connect and ConnectionClosed for lifecycle management, websockets ping and pong for keep-alive, websockets SSL context for secure WSS connections, websockets max_size and compression for performance tuning, websockets serve with authentication handler, and websockets integration with asyncio and FastAPI and JSON for real-time Python chat and notification systems.
Claude Code for Mako: Python Template Engine
Generate text with Mako templates and Claude Code — mako Template and TemplateLookup for rendering HTML and text, mako dollar-brace expression syntax for variable interpolation, mako percent control structures for if and for and while blocks, mako def blocks for reusable template functions, mako inheritance with base and child templates using inherits, mako include and namespace for template composition, mako filters and h and u and n escaping, mako render and render_unicode for string output, mako TemplateLookup with filesystem directories for template discovery, mako text blocks and comments, and mako integration with FastAPI and Pyramid and script generation for Python text pipeline automation.
Claude Code for pypika: SQL Query Builder in Python
Build SQL queries with pypika and Claude Code — pypika Query and Table for SELECT query construction, pypika where and join and group by and order by and limit for query clauses, pypika Field and Parameter and Criterion for conditions, pypika insert_into and update and delete for DML queries, pypika with_alias and subquery for nested SQL, pypika aggregate functions sum and count and avg and max and min, pypika full outer join and left join and right join for table joins, pypika Case and NullIf and Coalesce SQL expressions, pypika PostgreSQL and MySQL dialects, and pypika integration with aiopg and asyncpg and psycopg2 for Python database query generation.
Claude Code for jmespath: JSON Query Language in Python
Query JSON data with jmespath and Claude Code — jmespath.search for extracting nested values with JMESPath expressions, jmespath identifier and sub-expression and wildcard and filter projection, jmespath multi-select list and multi-select hash for reshaping output, jmespath pipe expressions for chained transformations, jmespath functions like keys and values and length and sort_by and min_by and max_by, jmespath escape and literal and flattenProjection, jmespath compile for reusing parsed expressions, jmespath custom functions with register_function, and jmespath integration with boto3 AWS API responses and REST API JSON parsing in Python.
Claude Code for aiocache: Async Caching in Python
Cache async Python code with aiocache and Claude Code — aiocache SimpleMemoryCache and RedisCache and MemcachedCache backends, aiocache cached decorator for async function memoization, aiocache multi_cached for list key caching, aiocache Cache.get and set and delete and exists for manual cache operations, aiocache TTL and namespace for cache key management, aiocache serializer with JsonSerializer and PickleSerializer and MsgPackSerializer, aiocache plugins for logging and timing, aiocache BaseCache for custom backend implementation, aiocache with FastAPI for response caching, and aiocache integration with aioredis and asyncio for high-performance Python async cache layers.
Claude Code for tinydb: Embedded JSON Database in Python
Store and query data with tinydb and Claude Code — tinydb TinyDB and Table for JSON document storage, tinydb insert and insert_multiple for adding records, tinydb search and where and Query for document querying, tinydb update and remove for document mutation, tinydb JSONStorage and MemoryStorage for backends, tinydb CachingMiddleware and SerializationMiddleware for performance and type support, tinydb upsert for insert-or-update, tinydb contains and count and all for collection queries, tinydb get for single document retrieval, and tinydb integration with pydantic and dataclasses for typed document storage in Python.
Claude Code for croniter: Cron Expression Parsing in Python
Parse and iterate cron schedules with croniter and Claude Code — croniter get_next and get_prev for next and previous run time, croniter from datetime for schedule generation, croniter with timezone using pytz for localized scheduling, croniter match for checking if a datetime matches a cron expression, croniter hash_expressions for consistent randomization, croniter get_current and set_current for cursor control, croniter with seconds for sub-minute scheduling, croniter expanding * and ? and L and W and hash for advanced cron syntax, croniter schedule_iter for lazy datetime generation, and croniter integration with APScheduler and Celery beat for production Python task scheduling.
Claude Code for sortedcontainers: Sorted Data Structures in Python
Use sorted data structures with sortedcontainers and Claude Code — SortedList for maintaining a sorted list with fast bisect insertion, SortedDict for a dict with keys always in sorted order, SortedSet for a set with sorted iteration, SortedList add and discard and bisect_left and bisect_right for position queries, SortedList irange and islice for range iteration, SortedDict peekitem and keys and values for ordered dict access, sortedcontainers key parameter for custom sort order, sortedcontainers update and pop and popitem for bulk operations, SortedKeyList for sorting by derived key function, and sortedcontainers integration with heapq and bisect for Python priority queue and leaderboard implementation.
Claude Code for more-itertools: Extended Iterator Tools in Python
Process sequences with more-itertools and Claude Code — more_itertools chunked and sliced for list splitting, batched and partition and divide for sequence grouping, more_itertools flatten and collapse for nested list flattening, more_itertools windowed and pairwise and triplewise for sliding windows, more_itertools groupby_transform and unique_everseen and unique_justseen for deduplication, more_itertools first and last and one and only for item extraction, more_itertools peekable and seekable and bucket for advanced iterators, more_itertools zip_equal and zip_broadcast for safe zipping, more_itertools roundrobin and interleave_longest for merging iterators, and more_itertools mark_ends and spy and prepend for iterator decoration in Python.
Claude Code for toolz: Functional Python Utilities
Write functional Python with toolz and Claude Code — toolz pipe and compose for function composition pipelines, toolz curry for partial function application, toolz thread_first and thread_last for Clojure-style threading, toolz groupby and countby and reduceby for data aggregation, toolz take and drop and partition_all and sliding_window for sequence processing, toolz merge and merge_with and valmap and keymap for dict transformation, toolz memoize for function result caching, toolz juxt for applying multiple functions simultaneously, toolz concat and interleave and interpose for sequence construction, and toolz integration with itertools and functools for high-performance functional Python pipelines.
Claude Code for schematics: Data Modeling and Validation in Python
Model and validate data with schematics and Claude Code — schematics Model for structured data class definition, StringType IntType FloatType ListType DictType for field types, schematics validate for model validation with exceptions, schematics to_primitive and to_native for serialization and deserialization, schematics Role for field visibility control, schematics PolyModelType for polymorphic nested models, schematics BaseType and validate_value for custom field types, schematics compound validators with ConversionError and ValidationError, schematics Model inheritance for reusable base schemas, and schematics integration with MongoDB and REST APIs for Python data modeling pipelines.
Claude Code for schema: Lightweight Data Validation in Python
Validate Python data with schema and Claude Code — schema Schema and Or and And validators for type-safe dict validation, schema Optional for optional keys, schema Use for type coercion, schema Regex for string pattern matching, schema Forbidden for disallowed keys, schema Literal for exact value checking, schema Schema validate and is_valid methods, schema error handling with SchemaError and SchemaUnexpectedTypeError, schema with FastAPI and Flask for request validation, schema nesting for recursive structure validation, and schema integration with dataclasses and JSON for configurable validation pipelines in Python.
Claude Code for voluptuous: Data Validation in Python
Validate Python data with voluptuous and Claude Code — voluptuous Schema for dict and list validation, voluptuous Required and Optional for key presence, voluptuous All and Any and And and Or validators for compound rules, voluptuous Range and Length and Clamp for numeric and string constraints, voluptuous Coerce for type coercion, voluptuous Invalid and MultipleInvalid for error handling, voluptuous extra ALLOW_EXTRA and REMOVE_EXTRA for unknown key handling, voluptuous humanize_errors for readable error messages, voluptuous SEQUENCE_OF and TUPLE_OF type validators, and voluptuous integration with Flask and FastAPI for request payload validation in Python.
Claude Code for python-benedict: Dict with Keypath Support in Python
Navigate nested dicts with python-benedict and Claude Code — benedict dict subclass with keypath dot notation access, benedict from_json and from_yaml and from_toml and from_xml for multi-format parsing, benedict get with default and keypath traversal, benedict merge for deep dict merging, benedict subset for extracting keys, benedict rename_keys and clean and filter_keys for transformation, benedict copy and deepcopy support, benedict from_base64 and from_csv for data ingestion, benedict to_json and to_yaml and to_toml output, and python-benedict integration with FastAPI and Pydantic for flexible config and response handling in Python.
Claude Code for glom: Nested Data Access in Python
Access and transform nested data with glom and Claude Code — glom.glom for deep path traversal, glom Spec and Path for nested key access, glom Coalesce for fallback chains, glom Assign for deep mutation, glom T for method chaining on nested values, glom Iter for nested list transformations, glom Merge for combining dicts, glom Match for schema validation with Check and Required, glom Auto for automatic restructuring, glom Fill for template-based extraction, and glom integration with dataclasses and Pydantic for structured data transformation in Python.
Claude Code for deepdiff: Deep Comparison and Diff in Python
Compare Python objects deeply with deepdiff and Claude Code — DeepDiff for nested dict and list comparison, deepdiff ignore_order for set-like list comparison, deepdiff exclude_paths and exclude_regex_paths for partial diffs, deepdiff significant_digits for float tolerance, deepdiff view flat for unified diff output, deepdiff Delta for applying and reversing diffs, deephash for content-based hashing, deepdiff grep for searching nested structures, deepdiff with custom operators for type-specific comparison, and deepdiff integration with pytest and unittest for data structure assertion in Python.
Claude Code for cbor2: CBOR Binary Format in Python
Encode data with CBOR using cbor2 and Claude Code — cbor2.dumps and loads for binary CBOR serialization, cbor2 with datetime UUID and decimal and Fraction native type support, cbor2 CBOREncoder with timezone and canonical options, cbor2 CBORDecoder with object_hook for custom type restoration, cbor2 indef_length_array and indef_length_map for streaming encoding, cbor2 shareable references for circular structure support, cbor2 tagging with CBORTag for typed extension values, cbor2 encode to file and decode from file, cbor2 COSE and diagnostic notation, and cbor2 integration with asyncio and msgpack for binary protocol comparison in Python.
Claude Code for orjson: Fast JSON Serialization in Python
Serialize JSON faster with orjson and Claude Code — orjson.dumps for high-performance JSON encoding, orjson.loads for fast JSON decoding, orjson with dataclass and pydantic model serialization, orjson OPT_INDENT_2 and OPT_SORT_KEYS and OPT_NON_STR_KEYS options, orjson with datetime UUID and numpy array serialization, orjson default parameter for custom type handling, orjson dumps returns bytes not string, orjson with FastAPI JSONResponse for fast API responses, orjson with Redis and Memcached for binary JSON caching, and orjson performance benchmarks versus json and ujson for Python API and data pipeline serialization.
Claude Code for msgpack: Fast Binary Serialization in Python
Serialize data with msgpack and Claude Code — msgpack.packb and unpackb for binary encoding, msgpack Packer and Unpacker for streaming serialization, msgpack with custom default and object_hook for type extensions, msgpack use_bin_type and raw for Python 3 bytes handling, msgpack fallback for pure Python mode, msgpack with Redis and ZeroMQ for binary message protocols, msgpack Unpacker feed for streaming incremental parsing, msgpack encode and decode performance benchmarks versus json, and msgpack integration with asyncio and aiofiles for binary file serialization in Python.
Claude Code for pyzmq: ZeroMQ Messaging in Python
Build distributed messaging systems with pyzmq and Claude Code — zmq.Context and Socket for ZeroMQ connection management, REQ REP pattern for request-reply messaging, PUB SUB for publish-subscribe fan-out, PUSH PULL for pipeline work distribution, DEALER ROUTER for async request routing, zmq.Poller for multiplexed socket I/O, pyzmq with asyncio using zmq.asyncio for non-blocking sockets, zmq SNDMORE multipart message framing, zmq high-water mark and LINGER and RCVTIMEO for socket configuration, and pyzmq integration with msgpack and JSON for serialized message protocols.
Claude Code for pexpect: Automate Interactive CLI Programs in Python
Automate interactive terminal programs with pexpect and Claude Code — pexpect.spawn for launching subprocesses, expect and sendline for conversation patterns, pexpect.run for one-shot command execution, pexpect with SSH and FTP and MySQL CLI for interactive session automation, timeout and TIMEOUT and EOF constants for expect error handling, pexpect logfile for capturing session output, pexpect with pxssh for SSH automation, before and after attributes for match context, pexpect interact for handing off to user, and pexpect integration with paramiko for Python SSH automation of interactive shell sessions.
Claude Code for aiofiles: Async File I/O in Python
Read and write files asynchronously with aiofiles and Claude Code — aiofiles.open for async file context manager, async read and write and readline and readlines for file operations, aiofiles with asyncio.gather for parallel file reading, aiofiles wrap for wrapping synchronous file objects, aiofiles tempfile for async temporary files, aiofiles os.path and os.stat for async filesystem operations, aiofiles with FastAPI and aiohttp for async file upload and download handlers, aiofiles for async log writers and file watchers, and aiofiles integration with asyncio.Queue for producer-consumer file pipelines.
Claude Code for sty: ANSI Styling for Python Terminals
Style terminal output with sty and Claude Code — sty fg and bg and ef and rs for foreground background effect and reset escape codes, sty RgbFg and RgbBg for 24-bit true color, sty with 256-color palette using fg.da_silva and color indices, ef.bold ef.italic ef.underline ef.blink for text effects, rs.all and rs.fg and rs.bg for selective reset, sty extending with custom colors and register_style, sty with contextlib and text wrapping for styled print functions, sty Style class for reusable style objects, and sty integration with print and io.StringIO for colored terminal output and logging in Python.
Claude Code for docopt: CLI from Docstring in Python
Build command-line interfaces with docopt and Claude Code — docopt parsing from docstring usage patterns, docopt with Options section for flags and defaults, docopt arguments and commands and options dict, docopt with required and optional argument groups, docopt repeating arguments with ellipsis, docopt with docopt-ng for Python 3 compatibility, docopt with schema library for argument validation, multi-command dispatch from docopt commands dict, docopt subcommand routing with dict.get, and docopt integration with logging and pathlib for Python CLI tools from usage docstrings.
Claude Code for Python Fire: Auto CLI from Python Functions
Generate CLI tools with Python Fire and Claude Code — fire.Fire for instant CLI from functions classes and modules, Fire with component argument for sub-commands from class methods, Fire separator for complex argument passing, Fire trace for debugging CLI dispatch, python-fire with dataclasses for typed CLI options, Fire with multiple commands using dict or class, fire.Fire with name parameter for help text, Python Fire serializer for custom output formatting, and python-fire integration with pydantic and argparse for auto-generated CLI interfaces from Python objects.
Claude Code for blessed: Terminal UI Toolkit in Python
Build terminal UIs with blessed and Claude Code — Terminal for display size and keyboard input, term.clear and term.home for screen management, term.move for cursor positioning, term.bold and term.color and term.on_color for styled text, term.inkey and cbreak for keyboard event handling, blessed with fullscreen and raw mode for interactive TUIs, Terminal.width and Terminal.height for responsive layouts, term.center and term.rjust for text alignment, blessed for progress bars and spinners and status lines, and blessed integration with threading for real-time terminal dashboard Python applications.
Claude Code for colorlog: Colored Python Logging
Add color to Python logging with colorlog and Claude Code — ColoredFormatter for ANSI-colored log levels, colorlog.getLogger and basicConfig for quick setup, log_colors dict for custom level-to-color mapping, secondary_log_colors for extra field coloring, colorlog StreamHandler and FileHandler combo for dual output, reset parameter for ANSI reset after each line, colorlog with dictConfig and fileConfig for production logging, colorlog LevelFormatter for per-level format strings, colorlog with structlog and loguru style, and colorlog integration with Django Flask and FastAPI for colored development server logs.
Claude Code for plotext: Terminal Charts and Plots in Python
Plot terminal charts with plotext and Claude Code — plotext scatter and plot for line and scatter charts, bar_chart and simple_bar for bar charts, hist for histogram distribution plots, plotext show and build and clear_figure for rendering, plotext date_form and xticks for axis label customization, multiple_plots with subplots for grid layouts, plotext image and gif for terminal image display, plotext theme for dark and clear and pro color themes, plotext with pandas and numpy for data plotting, and plotext integration with Typer and Click for Python CLI data visualization dashboards.
Claude Code for InquirerPy: Interactive CLI Prompts in Python
Build interactive CLI prompts with InquirerPy and Claude Code — inquirer.select for arrow-key menus, inquirer.checkbox for multi-select, inquirer.text and inquirer.password for input prompts, inquirer.number for numeric input, inquirer.filepath for path autocomplete, inquirer.confirm for yes-no questions, inquirer.fuzzy for fuzzy-searchable lists, InquirerPy with when and validate and filter for conditional and validated prompt flows, inquirer.rawlist for numbered list selection, and InquirerPy prompt() dict-driven multi-question forms for Python CLI wizards.
Claude Code for simple-term-menu: Interactive CLI Menus in Python
Build interactive terminal menus with simple-term-menu and Claude Code — TerminalMenu for single and multi-select menus, menu_cursor and menu_cursor_style for custom cursors, preview_command for file preview panel, multi_select for checkbox lists, show_search_hint for fuzzy filtering, accept_keys and quit_keys for keyboard customization, TerminalMenu title and menu_highlight_style, simple-term-menu with nested submenus, TerminalMenu show_multi_select_hint and multi_select_select_on_accept, and simple-term-menu integration with Click Typer and argparse for Python CLI navigation menus.
Claude Code for asciichartpy: Terminal Charts in Python
Plot terminal charts with asciichartpy and Claude Code — asciichartpy.plot for single series line charts, multiple series with color using plot and asciichartpy.colored, height and min_val and max_val for axis scaling, asciichartpy with deque for real-time scrolling charts, plot with format parameter for y-axis label formatting, asciichartpy pipeline for CPU and memory sparklines, multi-series overlay charts for metric comparison, asciichartpy with psutil for live system monitoring, histogram approximation with binned data, and asciichartpy integration with Click and Typer for Python CLI data visualization.
Claude Code for Enlighten: Terminal Progress Bars in Python
Display terminal progress bars with Enlighten and Claude Code — enlighten.get_manager for multi-bar terminal management, Counter for progress tracking, print_at and manager.print for clean output alongside progress bars, Bar format and series for custom progress appearances, SubCounter for segmented bars showing pass fail and skip totals, enlighten manager with nested bars for pipelines, enlighten Header and StatusBar for static status lines, manager.stop and counter.close for cleanup, enlighten with multiprocessing and threading for parallel progress, and Enlighten integration with logging and Flask Typer for Python CLI progress display.
Claude Code for yaspin: Python Terminal Spinner
Animate terminal spinners with yaspin and Claude Code — yaspin context manager for loading indicators, Spinners enum for 100-plus spinner styles, yaspin text and color and on_color customization, yaspin.ok and yaspin.fail for outcomes, yaspin write for printing lines without breaking animation, yaspin hidden for suppressing spinner output, sigmap for SIGINT and SIGTERM handling, yaspin side parameter for left or right spinner position, yaspin timer for elapsed time display, and yaspin integration with loguru and structlog for CLI progress logging in Python terminal applications.
Claude Code for Halo: Terminal Spinner in Python
Add terminal spinners with Halo and Claude Code — Halo spinner for CLI loading indicators, spinner parameter for dots clock earth moon and pong styles, text and color customization, halo.succeed halo.fail halo.warn halo.info for status outcomes, halo as context manager, Halo with indent for nested spinners, halo.stop_and_persist for custom final symbols, halo spinner for long-running subprocess and HTTP requests, halo with tqdm for spinner plus progress bar, and Halo integration with Click and Typer CLI frameworks for Python terminal tools.
Claude Code for pyfiglet: ASCII Art Text in Python
Generate ASCII art text with pyfiglet and Claude Code — pyfiglet.figlet_format for banner text, fonts_list for available fonts, Figlet class for reusable rendering, width parameter for terminal-width banners, justify for left right center alignment, pyfiglet with colorama and rich for colored ASCII art, figlet fonts slant banner big isometric3 and doom, pyfiglet for CLI tool headers and startup banners, and pyfiglet integration with rich.console for styled terminal output and click echo for CLI banners.
Claude Code for PrettyTable: ASCII Tables in Python
Format ASCII tables with PrettyTable and Claude Code — PrettyTable for terminal table output, add_row and add_rows for data insertion, field_names for column headers, align for per-column alignment, border and header visibility control, max_width for column truncation, sortby for sorting, reversesort for descending, get_string for filtered output, PrettyTable from_csv from_json and from_db_cursor, set_style with SINGLE_BORDER DOUBLE_BORDER MARKDOWN and ORGMODE presets, and PrettyTable integration with pandas and SQLite cursor for query result formatting.
Claude Code for OmegaConf: Hierarchical Config in Python
Manage hierarchical configuration with OmegaConf and Claude Code — OmegaConf.create for dict and structured config, OmegaConf.merge for config composition and override, OmegaConf.to_yaml and OmegaConf.to_container, DictConfig and ListConfig nodes, variable interpolation with dollar-brace syntax, MISSING sentinel for required fields, structured configs with dataclasses for type safety, OmegaConf.load for YAML file loading, readonly config freezing, OmegaConf.register_new_resolver for custom interpolation, and OmegaConf integration with Hydra for multi-run experiment configuration.
Claude Code for pydantic-settings: Python Settings Management
Manage application settings with pydantic-settings and Claude Code — BaseSettings for environment variable binding, model_config with env_file and env_prefix, nested settings models with model_validator, Secret types SecretStr for passwords and API keys, @model_validator for settings validation, pydantic-settings with dotenv files, pydantic-settings with AWS Secrets Manager and Vault providers, settings inheritance for dev staging prod environments, type coercion for bool int list from env strings, and pydantic-settings integration with FastAPI dependency injection.
Claude Code for Peewee: Lightweight Python ORM
Build database models with Peewee ORM and Claude Code — Model and fields CharField IntegerField ForeignKeyField DateTimeField JSONField, database-agnostic queries with select where order_by limit offset, Model.create and Model.save and Model.delete_instance, peewee with SQLite PostgreSQL and MySQL, Model.select with joins and prefetch_related, atomic and database.transaction context managers, Model.bulk_create and bulk_update for batch operations, peewee migrations with playhouse.migrate, and Peewee integration with Flask FastAPI and connection pooling via PooledSqliteDatabase.
Claude Code for sqlglot: SQL Parsing and Transpilation in Python
Parse and transpile SQL with sqlglot and Claude Code — sqlglot.parse_one for SQL AST parsing, sqlglot.transpile for dialect conversion between BigQuery Snowflake Spark DuckDB PostgreSQL MySQL SQLite, sqlglot.diff for SQL change detection, Expression tree traversal and transformation, sqlglot.optimizer.optimize for SQL query optimization, table and column extraction from queries, pretty-printing SQL with generator, sqlglot.errors.SqlglotError handling, and sqlglot integration with pandas and DuckDB for dialect-agnostic query pipelines.
Claude Code for aiosqlite: Async SQLite in Python
Use SQLite asynchronously with aiosqlite and Claude Code — aiosqlite.connect for async SQLite connection, Connection.execute for async parameterized queries, cursor fetchone fetchall fetchmany, Connection.executemany for batch inserts, aiosqlite row_factory with sqlite3.Row for column access by name, async context manager for transactions, aiosqlite.connect with FastAPI and asyncio for non-blocking database access, WAL mode for concurrent readers, aiosqlite with SQLAlchemy async session, and aiosqlite integration with pathlib for database path management.
Claude Code for psycopg3: Modern PostgreSQL Client for Python
Connect to PostgreSQL with psycopg3 and Claude Code — psycopg.connect for synchronous connections, AsyncConnection for async/await PostgreSQL, Connection.execute for parameterized queries, cursor fetchone fetchmany fetchall row_factory, ServerCursor for server-side cursors on large result sets, COPY for bulk data loading, Connection transaction context manager, pipeline mode for batching multiple queries, psycopg3 with asyncio FastAPI and SQLAlchemy, connection pooling with ConnectionPool and AsyncConnectionPool, and psycopg3 prepared statements and type adapters.
Claude Code for pybreaker: Circuit Breaker Pattern in Python
Implement the circuit breaker pattern with pybreaker and Claude Code — CircuitBreaker for wrapping unreliable external calls, CircuitBreakerState CLOSED OPEN HALF_OPEN states, fail_max threshold before opening, reset_timeout for half-open probing, CircuitBreakerError when circuit is open, listeners for state transition events, CircuitBreakerListener for logging and metrics, pybreaker with requests and httpx for HTTP circuit breaking, pybreaker for database connection breaking, thread-safe circuit state, and pybreaker integration with Redis for distributed circuit state.
Claude Code for limits: Rate Limiting in Python
Enforce rate limits in Python with the limits library and Claude Code — parse rate limit strings like 10 per minute and 100 per hour, MemoryStorage and RedisStorage backends, MovingWindowRateLimiter for sliding window limits, FixedWindowRateLimiter for fixed window counting, GCRA generic cell rate algorithm, test_hit for checking and consuming quota, get_window_stats for remaining quota, per-key rate limiting for API throttling, limits with Flask and FastAPI for route limiting, and limits integration with Redis for distributed multi-process rate limiting.
Claude Code for backoff: Retry with Exponential Backoff in Python
Retry failed functions with exponential backoff using backoff and Claude Code — backoff.on_exception decorator for retrying on specific exceptions, backoff.on_predicate for retrying based on return value, expo for exponential backoff, fibo for Fibonacci backoff, constant for fixed delay, max_tries and max_time for retry limits, jitter for randomized delay, on_backoff on_success and on_giveup callbacks, backoff with httpx aiohttp and requests HTTP retries, backoff for rate limit handling, and backoff integration with async functions.
Claude Code for portalocker: Cross-Platform File Locking
Lock files across platforms with portalocker and Claude Code — portalocker.lock for exclusive and shared LOCK_EX LOCK_SH locking, portalocker.unlock for releasing locks, LOCK_NB non-blocking flag for immediate failure, portalocker.Lock context manager class, portalocker.RLock for reentrant locking, portalocker.BoundedSemaphore for limiting concurrent access to N processes, portalocker.LockException and AlreadyLocked exception handling, portalocker for PID file patterns, and portalocker integration with multiprocessing and subprocess for cross-process resource coordination.
Claude Code for filelock: File Locking in Python
Coordinate file access with filelock and Claude Code — FileLock for cross-process mutual exclusion, SoftFileLock for NFS-compatible advisory locking, lock timeout parameter for non-blocking acquisition, is_locked property for status checks, lock context manager for automatic release, FileLock in multiprocessing pools for safe shared file writes, SoftFileLock with stale lock cleanup, lock across threads with threading primitives, filelock for database write coordination, and filelock integration with tempfile and pathlib for atomic file update patterns.
Claude Code for regex: Advanced Python Regular Expressions
Use the regex module for advanced Python pattern matching with Claude Code — regex.match regex.search regex.findall regex.sub with Unicode property escapes like \p{Letter} and \p{Script=Latin}, fuzzy matching with substitutions and deletions, overlapping matches with OVERLAPPED flag, possessive quantifiers and atomic groups for backtrack prevention, variable-length lookbehind assertions, VERSION1 for Python re compatibility layer, branch reset groups, and regex integration with pandas for vectorized text extraction and cleaning pipelines.
Claude Code for wcwidth: Unicode Display Width in Python
Measure Unicode character display widths with wcwidth and Claude Code — wcwidth for single character width, wcswidth for string display width, detecting wide CJK characters that occupy 2 columns, zero-width combining characters that occupy 0 columns, terminal table alignment with CJK text, ljust/rjust replacements for Unicode-safe column padding, wcwidth for progress bars with Unicode labels, wcswidth line truncation at exact column width, and wcwidth integration with rich and tabulate for Unicode-aware table formatting.
Claude Code for textwrap: Python Text Wrapping and Formatting
Wrap and format text with Python textwrap and Claude Code — textwrap.wrap for returning a list of wrapped lines, textwrap.fill for wrapped paragraph string, textwrap.indent for adding prefix to lines, textwrap.dedent for removing common leading whitespace, textwrap.shorten for truncating to a max length with ellipsis, TextWrapper class with width break_long_words break_on_hyphens initial_indent subsequent_indent and expand_tabs, wrapping docstrings for CLI help text, and textwrap integration with argparse terminal output and markdown rendering.
Claude Code for chardet: Character Encoding Detection in Python
Detect character encodings with chardet and Claude Code — chardet.detect for encoding and confidence detection, chardet.detect_all for ranked encoding candidates, UniversalDetector for streaming large files, chardet with open() for encoding-safe file reading, detect_and_decode for automatic decoding, batch file encoding detection, chardet confidence threshold for reliable detection, encoding normalization and alias mapping, chardet integration with requests for HTTP response decoding, and chardet pipeline for CSV import with unknown encodings.
Claude Code for Unidecode: Unicode to ASCII in Python
Transliterate Unicode text to ASCII with Unidecode and Claude Code — unidecode function for transliterating accented characters and CJK to ASCII, unidecode_expect_ascii for performance when input is mostly ASCII, unidecode_expect_nonascii for non-ASCII heavy content, per-character codepoint_string for debugging, Unidecode transliteration for German French Spanish Russian Arabic Japanese Korean Chinese, slug generation pipeline combining Unidecode with re.sub, romanization of names and addresses, and Unidecode integration with python-slugify and database normalization pipelines.
Claude Code for ftfy: Fix Unicode Text in Python
Repair mojibake and broken Unicode text with ftfy and Claude Code — ftfy.fix_text for automatic encoding repair, fix_encoding for mojibake correction, fix_line_breaks for mixed newline normalization, fix_surrogates for lone surrogate cleanup, fix_latin_ligatures for fi fl ligature expansion, explain_unicode for character analysis, fix_and_explain for annotated repair output, TextFixerConfig for selective fixes, fix_file for streaming large file repair, and ftfy integration with pandas for bulk text normalization pipelines.
Claude Code for python-slugify: Python URL Slug Generation
Generate URL-safe slugs from Unicode text with python-slugify and Claude Code — slugify function for converting titles to slugs, separator for custom delimiter, max_length for truncation, lowercase and strip options, allow_unicode for preserving non-ASCII characters, custom regex pattern for allowed characters, stopwords for removing common words, pre_process and post_process hooks, slugify with transliteration for Chinese Japanese Korean and Arabic text, and python-slugify integration with Django URLs Jinja2 templates and database slug fields.
Claude Code for tldextract: Python URL Domain Parsing
Extract domain components from URLs with tldextract and Claude Code — tldextract.extract for splitting subdomain domain and suffix, registered_domain for the effective second-level domain, TLDExtract with custom cache for offline use, include_psl_private_domains for Blogger GitHub Pages and co.uk handling, private_domains for custom TLD lists, extract from full URLs with scheme paths and query strings, batch URL processing for log analysis, and tldextract integration with urllib.parse and validators for URL normalization pipelines.
Claude Code for Pint: Python Physical Units and Quantities
Perform unit-aware arithmetic with Pint and Claude Code — UnitRegistry for unit definitions, Quantity for value-unit pairing, to() for unit conversion, ito() for in-place conversion, dimensionality for unit type checking, compatible_units for finding equivalent units, magnitude and units attributes, Quantity with numpy arrays for vectorized conversion, define for custom units, pint.Unit for unit-only objects, context manager for multi-step calculations, wraps decorator for unit-aware functions, and Pint integration with pandas and numpy for scientific data pipelines.
Claude Code for phonenumbers: Python Phone Number Parsing
Parse validate and format phone numbers with phonenumbers and Claude Code — phonenumbers.parse for number parsing with region hint, is_valid_number for validation, format_number with PhoneNumberFormat E164 NATIONAL and INTERNATIONAL, is_possible_number for quick validation, geocoder.description_for_number for geographic origin, carrier.name_for_number for carrier lookup, timezone.time_zones_for_number for timezone detection, phonenumbers.parse with country_code_for_region, normalize_dialing_digits_only for cleaning, and phonenumbers integration with pandas for bulk validation and with Jinja2 for display formatting.
Claude Code for num2words: Numbers to Words in Python
Convert numbers to words with num2words and Claude Code — num2words function for cardinal and ordinal conversion, to parameter for cardinal ordinal year currency and year formats, lang parameter for 40+ language support, num2words for invoice amount in words, ordinal conversion for 1st 2nd 3rd in English French German Spanish, currency amounts in words for check writing, year reading for historical dates, num2words with Jinja2 filters for template rendering, and num2words integration with fpdf2 humanize and formatting pipelines.
Claude Code for Babel: Python Internationalization and Localization
Internationalize Python applications with Babel and Claude Code — format_number and format_decimal for locale-aware numbers, format_currency for money display, format_date format_time and format_datetime for localized dates, format_timedelta for relative durations, Locale class for locale introspection, get_locale_identifier and parse_locale, gettext and lazy_gettext for translation strings, extract_messages and compile_catalog for message catalog workflow, plural forms with ngettext, Babel integration with Flask-Babel and Jinja2, and timezone localization with get_timezone and to_local_time.
Claude Code for dateparser: Natural Language Date Parsing
Parse natural language dates and times with dateparser and Claude Code — dateparser.parse for informal date strings, LANGUAGES setting for multilingual parsing, PREFER_DAY_OF_MONTH and PREFER_DATES_FROM settings for disambiguation, RETURN_TIME_AS_PERIOD for time-only input, TIMEZONE handling for localized parse, dateparser.search.search_dates for extracting dates from free text, dateparser with pytz for timezone-aware output, RELATIVE_BASE for anchoring relative dates, STRICT_PARSING to reject ambiguous input, and dateparser integration with pandas for bulk series parsing.
Claude Code for pdfplumber: Python PDF Table and Text Extraction
Extract structured data from PDFs with pdfplumber and Claude Code — open for loading PDFs, pages for iteration, extract_text with layout for precise positioning, extract_table and extract_tables for tabular data, crop for bounding box extraction, chars words lines and rects for element inspection, within_bbox for region extraction, debug visualizer for bounding boxes, extract_words with x_tolerance and y_tolerance, page.width and page.height for coordinate systems, and pdfplumber integration with pandas for table analysis and with pathlib for batch processing.
Claude Code for pypdf: Python PDF Reading and Writing
Read split merge and modify PDFs with pypdf and Claude Code — PdfReader for page text extraction, PdfWriter for building new PDFs, merge with PdfMerger, extract_text for text content, extract_images for embedded images, add_page and insert_page for document assembly, encrypt with owner and user passwords, metadata reading and writing, rotate and scale pages, page range slicing, pypdf with io.BytesIO for in-memory operations, watermarking by page overlay, and pypdf integration with Flask for PDF serving and with pathlib for batch processing.
Claude Code for qrcode: Python QR Code Generation
Generate QR codes with Python's qrcode library and Claude Code — qrcode.make for quick QR generation, QRCode class for full control, error correction levels L M Q H for redundancy, add_data and make for building codes, image_factory for output format selection, StyledPilImage for custom styling, save to PNG SVG or bytes, QR code with embedded logo image, fill_color and back_color for custom colors, size and border control with box_size and border, and qrcode integration with Flask Pillow and Jinja2 for web and CLI tools.
Claude Code for plumbum: Python Shell Scripting
Replace shell scripts with Python using plumbum and Claude Code — local machine commands with local[], remote machine commands with SshMachine, pipeline operator | for piping, redirection with >> and << operators, FG for foreground execution, BG for background processes, TEE for duplicating output, ProcessExecutionError for non-zero exit codes, bound commands with command[arg1, arg2], plumbum cli for argument parsing and switch decorator, and plumbum integration with paramiko for SSH and with invoke for task automation.
Claude Code for pyperclip: Python Clipboard Access
Read and write the system clipboard with pyperclip and Claude Code — pyperclip.copy for writing text to clipboard, pyperclip.paste for reading clipboard contents, PyperclipException for missing clipboard mechanism, waitForPaste for blocking until clipboard changes, determine_clipboard for backend detection, pyperclip on macOS Windows and Linux with pbcopy xclip xsel and xdotool, clipboard history patterns, clipboard-based CLI pipelines, pyperclip with argparse for copy-on-output, and pyperclip integration with rich click and terminal tools.
Claude Code for Lark: Python EBNF Parser Generator
Build full-featured parsers with Lark and Claude Code — Grammar class for EBNF grammar definition, Lark parser with earley and lalr algorithms, Transformer class for tree-to-value transformations, Tree and Token node inspection, parser.parse for input processing, inline_args transformer methods, Discard for filtering tokens, ambiguity handling with earley, import directives for shared grammar rules, lark-cython for C extension speedup, and Lark for building DSLs expression evaluators config readers and protocol parsers.
Claude Code for pyparsing: Python Parser Construction
Build text parsers with pyparsing and Claude Code — Word Keyword Literal Regex and Suppress for token primitives, And Or and ZeroOrMore for grammar composition, setResultsName and group for structuring parse results, ParseResults dict-like access, QuotedString for string literals, nestedExpr for recursive bracket matching, pyparsing_common for ints floats and identifiers, parseString and scanString for extraction, transformString for search-and-replace, ParserElement.enablePackrat for memoization, and pyparsing for expression parsers config file readers and DSL construction.
Claude Code for termcolor: Simple Python ANSI Colors
Add ANSI color codes to Python terminal output with termcolor and Claude Code — colored function for one-call text styling, cprint for direct colored printing, color and on_color and attrs parameters, COLORS and HIGHLIGHTS and ATTRIBUTES constants, termcolor with print and logging, bold underline blink reverse attrs combinations, colored with f-strings for inline styling, NO_COLOR environment variable support, cprint to stderr for error output, and termcolor integration with argparse click and unittest for styled CLI and test output.
Claude Code for colorama: Cross-Platform Terminal Colors
Add ANSI color codes to Python terminal output with colorama and Claude Code — init for Windows ANSI support, Fore and Back for text and background colors, Style for BRIGHT DIM and RESET_ALL, autoreset for per-print reset, LIGHTRED_EX and extended color constants, strip for CI environments, colorama with print statements and f-strings, combining Fore Back and Style for styled output, colorama with logging formatters for colored log levels, and colorama integration with click typer and rich for CLI tools.
Claude Code for Pygments: Python Syntax Highlighting
Highlight source code with Pygments and Claude Code — highlight function for one-shot rendering, get_lexer_by_name and guess_lexer for language detection, HtmlFormatter with linenos cssclass and style options, TerminalFormatter and Terminal256Formatter for ANSI output, get_all_styles for listing themes, pygments.highlight pipeline with lexer formatter and code, InlineHtmlFormatter for embedded CSS, RawTokenFormatter for token inspection, custom lexer subclassing RegexLexer, and Pygments integration with Flask Jinja2 bleach and CLI tools.
Claude Code for bleach: Python HTML Sanitization
Sanitize HTML and linkify text with bleach and Claude Code — bleach.clean for stripping unsafe tags and attributes, allowed_tags and allowed_attributes for whitelist configuration, strip vs strip_comments for handling disallowed content, bleach.linkify for automatic URL linkification, callbacks for customizing link attributes, bleach.sanitizer Cleaner class for reusable instances, markdown plus bleach pipeline for safe user content rendering, attribute callable for per-tag attribute filtering, and bleach integration with Jinja2 templates and Django for XSS prevention.
Claude Code for markdown: Python Markdown to HTML
Convert Markdown to HTML with Python's markdown library and Claude Code — markdown.markdown for basic conversion, extensions including tables fenced_code codehilite toc attr_list meta and nl2br, Extension API for custom preprocessors and postprocessors, Markdown class for stateful reuse, get_meta for YAML-style front matter extraction, safe_mode for untrusted input, output_format for HTML5, treeprocessors for AST manipulation, and markdown integration with Jinja2 templates Flask and static site generators.
Claude Code for python-dateutil: Date and Time Parsing
Parse and manipulate dates and times with python-dateutil and Claude Code — parser.parse for natural language date string parsing, relativedelta for calendar-aware date arithmetic, rrule for recurrence rules and RRULE strings, tz for timezone handling with gettz and tzutc, Easter for holiday calculation, relativedelta for adding months and years without overflow, dateutil.parser with dayfirst and yearfirst for locale-aware parsing, fuzzy parsing for extracting dates from text, and python-dateutil integration with datetime for business date calculations.
Claude Code for Jinja2: Python Template Engine
Render HTML and text templates with Jinja2 and Claude Code — Environment and FileSystemLoader for template discovery, render method for variable substitution, for loops and if conditionals in templates, filters including default join upper and custom filters, macros for reusable template fragments, template inheritance with extends and block, include for partial templates, globals for shared context, autoescape for XSS prevention, undefined for strict variable checking, and Jinja2 integration with FastAPI Flask and email generation.
Claude Code for humanize: Human-Readable Python Values
Format numbers dates and data sizes as human-readable text with humanize and Claude Code — naturalsize for byte formatting, intcomma and intword for large numbers, naturaltime for relative timestamps, naturalday and naturaldate for calendar dates, ordinal for 1st 2nd 3rd suffixes, apnumber for AP style numbers, fractional for fraction display, metric for SI prefixes, scientific for scientific notation, and humanize integration with Jinja2 templates and Django template filters for presentation-layer formatting.
Claude Code for alive-progress: Animated Python Progress Bars
Show animated progress bars in Python with alive-progress and Claude Code — alive_bar context manager for automatic progress tracking, manual mode with bar() call inside the context, title for labeling, total for count-known iteration, spinner and bar styles with built-in themes, stats and elapsed for live metrics display, force_tty for CI output, dual_line for two-line status display, receipt for completion summary, monitor and stats callbacks for custom metrics, and alive_progress integration with concurrent futures and pandas.
Claude Code for Dynaconf: Python Settings Management
Manage multi-environment application settings with Dynaconf and Claude Code — settings object for global configuration access, DYNACONF_ prefix for environment variable overrides, environments for dev/staging/prod layering, settings.toml and .secrets.toml for file-based config, from_env for environment switching, validators for type checking and required fields, options for merging lists and dicts across layers, box_settings for dot-notation access, Flask and Django extensions for framework integration, and Dynaconf testing with override_with and settings.configure.
Claude Code for python-decouple: Config from Environment
Separate configuration from code with python-decouple and Claude Code — config function for reading environment variables and .env files, cast parameter for type conversion to int bool and Csv, default values for optional settings, undefined for required settings that raise UndefinedValueError, Csv for comma-separated list parsing, Choices for validated options, RepositoryEnv for explicit .env file loading, AutoConfig for hierarchical discovery, and python-decouple integration with Django Flask and FastAPI settings modules.
Claude Code for questionary: Interactive Python CLI Prompts
Build interactive command-line prompts with questionary and Claude Code — text for freeform input, password for hidden input, confirm for yes/no questions, select for single-choice menus, checkbox for multi-select, autocomplete for fuzzy search, path for file path input, rawselect for numbered menus, ask and unsafe_ask for sync and exception-aware execution, default values, validation functions, instruction customization, style overrides with Style, and questionary integration with Click for rich interactive CLI applications.
Claude Code for Textual: Python TUI Framework
Build terminal user interfaces with Textual and Claude Code — App and Screen for application structure, Widget subclasses for custom UI components, compose method for layout declaration, on_mount for initialization, Button Label Input Header Footer and DataTable built-in widgets, reactive for state that triggers re-renders, watch_ methods for reactive observers, CSS-like styling with tcss files, on_button_pressed and on_input_submitted for events, push_screen and pop_screen for modal dialogs, ScrollableContainer for scrolling layouts, and Textual testing with App.run_test and pilot for automated UI testing.
Claude Code for tabulate: Python Table Formatting
Format tabular data as text tables with tabulate and Claude Code — tabulate function for list and dict input, tablefmt for output format selection including plain simple grid pipe github latex and html, headers parameter for column names, floatfmt and intfmt for number formatting, colalign for column alignment, showindex for row numbers, numalign for numeric sorting, tabulate with pandas DataFrame, missingval for None handling, and tabulate integration with Rich Console for color terminal output.
Claude Code for openpyxl: Python Excel Automation
Read and write Excel files with openpyxl and Claude Code — Workbook and Worksheet for creating xlsx files, load_workbook for reading existing files, cell value and data_types for reading data, iter_rows and iter_cols for efficient traversal, Font Fill PatternFill Alignment Border for cell formatting, number_format for dates and currency, merge_cells and unmerge_cells for spanning, chart objects including BarChart LineChart PieChart, data_only mode for reading formulas as values, freeze_panes for header rows, auto_filter for sortable tables, and openpyxl integration with pandas for DataFrame export.
Claude Code for PyInvoke: Python Task Runner
Automate build and deployment tasks with PyInvoke and Claude Code — @task decorator for defining runnable tasks, Context.run for shell command execution, task dependencies with pre and post hooks, namespace for task grouping, collection and add_collection for modular task libraries, invoke --list to discover tasks, invoke --help for task documentation, pty=True for interactive commands, watchers for prompts and interactive input, warn=True for non-fatal failures, and invoke integration with pytest coverage linting and deployment pipelines.
Claude Code for stamina: Production Retries in Python
Add safe production-ready retries to Python code with stamina and Claude Code — retry decorator for automatic retry with exponential backoff and jitter, Instrumented for OpenTelemetry and structlog integration, attempt and wait configuration, on parameter for exception filtering, timeout for total retry budget, retry_context for manual retry loops, stamp for low-level stats, and stamina integration with httpx tenacity and structlog for observable retry pipelines.
Claude Code for Paramiko: Python SSH and SFTP
Automate SSH connections and SFTP file transfers with Paramiko and Claude Code — SSHClient with AutoAddPolicy for host key management, connect with username and key_filename or password, exec_command for remote command execution, invoke_shell for interactive sessions, SFTPClient from transport for file upload and download, sftp.get and sftp.put for transfers, sftp.listdir_attr for directory listing, ProxyJump and ProxyCommand for bastion host tunneling, SSHConfig for reading ssh_config files, RSAKey and Ed25519Key for key generation, and paramiko integration with fabric for deployment automation.
Claude Code for joblib: Python Parallel Computing and Caching
Parallelize loops and cache expensive computations with joblib and Claude Code — Parallel and delayed for multiprocessing and threading backends, n_jobs=-1 for all CPUs, Memory for transparent disk-based function result caching, memory.cache decorator with ignore list for cache-key exclusion, batch_size for chunked parallel execution, verbose for progress reporting, prefer thread for GIL-releasing functions, loky backend for process isolation, dump and load for fast numpy array serialization, and joblib integration with scikit-learn pipelines.
Claude Code for DiskCache: Python Persistent Disk Caching
Cache Python objects persistently to disk with DiskCache and Claude Code — Cache for key-value storage backed by SQLite, FanoutCache for sharded concurrent writes, Deque for persistent queues, Index for sorted persistent dicts, memoize decorator for function result caching, expire for TTL-based eviction, tag-based group eviction, transact for atomic operations, statistics for hit-rate monitoring, size_limit for disk quota enforcement, and DiskCache integration with Flask and multiprocessing.
Claude Code for cachetools: Python In-Memory Caching
Cache function results and objects in memory with cachetools and Claude Code — LRUCache for least-recently-used eviction, TTLCache for time-to-live expiration, LFUCache for least-frequently-used, RRCache for random replacement, cached decorator for automatic function memoization, cachedmethod for instance method caching with a key function, custom key functions with hashkey and typedkey, cache maxsize and currsize for capacity monitoring, thread-safe access with RLock, and cachetools integration with API clients and database query caches.
Claude Code for Huey: Lightweight Python Task Queue
Run background tasks and scheduled jobs with Huey and Claude Code — @huey.task for async task dispatch, @huey.periodic_task with crontab for recurring jobs, RedisHuey and SqliteHuey for storage backends, task.schedule for delayed execution, result.get and AsyncResult for return values, revoke and restore for task cancellation, pipeline for chaining tasks, pre_execute and post_execute hooks for middleware, huey.immediate mode for testing, and Huey integration with Flask FastAPI and Django.
Claude Code for trio: Structured Concurrency in Python
Write async Python with structured concurrency guarantees using trio and Claude Code — trio.run for the event loop entry point, nurseries for task groups with automatic cancellation, trio.open_nursery for task spawning, cancel scopes with trio.move_on_after and trio.fail_after for timeouts, trio.sleep and checkpoint for cooperative scheduling, trio.open_memory_channel for producer-consumer pipelines, trio.to_thread.run_sync for blocking code, trio.from_thread.run for calling trio from threads, CapacityLimiter for concurrency control, trio.testing with trio.testing.MockClock and autojump, and pytest-trio for async test fixtures.
Claude Code for watchdog: Python File System Monitoring
Monitor file system changes in Python with watchdog and Claude Code — Observer and BaseEventHandler for event-driven file watching, FileSystemEventHandler subclass for on_created on_modified on_deleted on_moved callbacks, PatternMatchingEventHandler for glob-based filtering, RegexMatchingEventHandler for regex patterns, recursive directory watching, schedule and unschedule for dynamic watch management, debouncing rapid events, watchdog integration with threading for non-blocking observers, and file watcher patterns for auto-reload hot reload and file ingestion pipelines.
Claude Code for tqdm: Python Progress Bars
Add progress bars to Python loops and pipelines with tqdm and Claude Code — tqdm wrapper for iterables, trange for range loops, manual update with tqdm.update and tqdm.set_postfix, nested bars for multi-level loops, tqdm.pandas for DataFrame apply, tqdm.notebook for Jupyter, write method for logging without breaking bars, miniters and mininterval for high-throughput loops, disable flag for production, unit and unit_scale for bytes and custom units, and tqdm integration with concurrent.futures and asyncio.
Claude Code for APScheduler: Python Job Scheduling
Schedule recurring and one-shot jobs in Python with APScheduler and Claude Code — BackgroundScheduler and AsyncIOScheduler for embedding scheduling in applications, add_job with cron date and interval triggers, CronTrigger for calendar-based schedules, IntervalTrigger for fixed-rate jobs, DateTrigger for one-shot execution, job stores with SQLAlchemyJobStore and RedisJobStore for persistent scheduling, event listeners for job success and failure, coalesce and max_instances for overlap prevention, pause resume and remove for job lifecycle management, and APScheduler integration with FastAPI Flask and asyncio.
Claude Code for psutil: System and Process Monitoring in Python
Monitor system and process resources with psutil and Claude Code — cpu_percent cpu_count and cpu_freq for CPU metrics, virtual_memory and swap_memory for RAM usage, disk_usage disk_io_counters and disk_partitions for storage, net_io_counters and net_connections for network stats, Process for per-process CPU memory status and open files, process_iter for enumerating all processes, sensors_battery and sensors_temperatures for hardware, os.getpid for self-monitoring, and psutil integration with alerting and health-check endpoints.
Claude Code for polyfactory: Universal Python Test Data Factory
Generate typed test data from Pydantic models dataclasses and attrs classes with polyfactory and Claude Code — ModelFactory for Pydantic BaseModel, DataclassFactory for stdlib dataclasses, AttrsFactory for attrs classes, TypedDictFactory for TypedDict schemas, build and create for instance generation, batch for lists, coverage_mode for exhaustive Literal and Enum testing, FactoryField for field-level customization, __faker__ for Faker provider configuration, __set_as_default_factory__ for project-wide defaults, and pytest fixtures for clean test isolation.
Claude Code for pytest-benchmark: Python Performance Testing
Measure and track Python code performance with pytest-benchmark and Claude Code — benchmark fixture for timing code under test, rounds warmup_rounds and iterations for statistical accuracy, benchmark.pedantic for fine-grained control, compare benchmarks across runs with storage and compare modes, --benchmark-autosave and --benchmark-compare for CI regression detection, calibrate_timer and disable_gc for measurement precision, parametrize integration for comparing implementations, json and histogram output formats, and benchmark fixture in pytest fixtures for service-level timing.
Claude Code for Mimesis: Fast Fake Data Generation in Python
Generate realistic fake data at maximum speed with Mimesis and Claude Code — Generic provider combining Person Address Finance Internet Transport and Datetime providers, locale-aware generation for 30+ languages, Field and Fieldset for schema-driven batch generation, Schema for structured fake object factories, custom provider extension, seed for reproducible test data, and Mimesis integration with pytest fixtures and factory_boy for test data pipelines.
Claude Code for anyio: Async Framework Compatibility Layer
Write async Python code that runs on asyncio and trio with anyio and Claude Code — anyio.run for backend selection, TaskGroup for structured concurrency, anyio.sleep anyio.move_on_after and anyio.fail_after for cancellation, anyio.to_thread and anyio.from_thread for sync-async bridging, anyio.open_tcp_stream and anyio.create_tcp_listener for networking, MemoryObjectSendStream and MemoryObjectReceiveStream for in-process channels, Event Semaphore Lock and CapacityLimiter for synchronization, and pytest-anyio for backend-parametrized testing.
Claude Code for Click: Python CLI Framework
Build command-line interfaces with Click and Claude Code — @click.command and @click.group for command definition, @click.option and @click.argument for parameter handling, click.Path click.File click.Choice click.IntRange and click.DateTime for typed parameters, callback and is_eager for option interplay, pass_context and pass_obj for shared state, invoke_without_command and result_callback for group coordination, testing with CliRunner for output and exit code assertions, progressbar and echo for user feedback, and multi-command chaining with pipes.
Claude Code for structlog: Structured Logging in Python
Emit machine-readable structured logs with structlog and Claude Code — configure_once with processors pipeline for JSON output, BoundLogger and bind for request-scoped context, stdlib_logging integration to capture legacy loggers, AsyncBoundLogger for async frameworks, ConsoleRenderer for human-readable development output, JSONRenderer for production, contextvars ContextVar for automatic request context propagation, processors filter_by_level add_log_level add_logger_name TimeStamper format_exc_info and UnicodeDecoder, and testing with capture_logs for assertion-friendly log checking.
Claude Code for pytest-asyncio: Testing Async Python Code
Test async Python code with pytest-asyncio and Claude Code — @pytest.mark.asyncio for async test functions, asyncio_mode auto for whole-file async-by-default, async fixtures with pytest.fixture, event_loop_policy for uvloop integration, anyio backend switching between asyncio and trio, async context managers in tests, testing asyncio.Queue asyncio.Event and asyncio.Lock concurrency primitives, mocking coroutines with AsyncMock, timeout testing with asyncio.wait_for, and FastAPI async endpoint testing with httpx.AsyncClient.
Claude Code for VCR.py: Record and Replay HTTP in Tests
Record real HTTP interactions and replay them in tests with VCR.py and Claude Code — @vcr.use_cassette and with vcr.use_cassette for recording and replaying HTTP exchanges, cassette file storage in YAML and JSON formats, record modes none new_episodes all and once, request matching by URI method body and headers, filter_headers and filter_post_data for scrubbing secrets from cassettes, before_record_request and before_record_response hooks, pytest-recording integration for automatic cassette management, and VCRHTTPSConnection for HTTPS interception.
Claude Code for respx: Mock httpx in Python Tests
Mock httpx HTTP calls in Python tests with respx and Claude Code — respx.mock context manager and decorator for intercepting requests, route matching by method URL headers and content, side_effect for dynamic response generation, pass_through for real network calls in otherwise mocked tests, Router for reusable mock sets, assert patterns for verifying call counts and request content, async support with httpx.AsyncClient, and pytest fixture integration for clean test isolation.
Claude Code for beartype: Blazing-Fast Runtime Type Checking
Enforce type hints at maximum speed with beartype and Claude Code — @beartype for O(1) constant-time function argument and return type checking, beartype_this_package for whole-package instrumentation without decorators, BeartypeConf for strict lenient and performance tuning, is_bearable for safe type predicate checks, die_if_unbearable for inline assertions, BeartypeException for structured error reporting, numpy and pandas array dtype annotations, PEP 484 673 695 generic alias support, and beartype integration with pytest mypy and fastapi.
Claude Code for typeguard: Runtime Type Checking in Python
Enforce type hints at runtime with typeguard and Claude Code — @typechecked decorator for automatic function argument and return value validation, check_type for inline type assertions, CollectionCheckStrategy for deep container element checking, TypeCheckError for structured runtime type failures, suppress_type_checks context manager for performance-critical paths, install_import_hook for whole-module instrumentation, and integration with pytest and mypy for defence-in-depth type safety.
Claude Code for jsonschema: JSON Schema Validation in Python
Validate JSON and Python dicts against JSON Schema drafts with jsonschema and Claude Code — validate and Draft7Validator for schema enforcement, properties required type and additionalProperties keywords, format checkers for email uri date-time and ipv4, anyOf oneOf allOf not for compound schemas, if-then-else for conditional validation, definitions and ref for schema reuse, ValidationError and SchemaError for structured error handling, iter_errors for bulk error collection, RefResolver for external schema references, and jsonschema.protocols for custom type checkers.
Claude Code for Cerberus: Python Dict Validation
Validate Python dicts with Cerberus and Claude Code — Validator class with schema dicts for rule-based field validation, type string integer float boolean list dict datetime for type enforcement, required nullable allowed and forbidden for presence and value constraints, minlength maxlength min max for range checks, regex for pattern validation, coerce for automatic type conversion, dependencies for conditional field requirements, oneof anyof allof noneof for compound rules, valueschema and keyschema for dict entry validation, allow_unknown for extra field handling, and custom validation methods for business rules.
Claude Code for dacite: Dict to Dataclass Conversion
Convert plain dicts to Python dataclasses with dacite and Claude Code — from_dict for recursive nested dataclass construction, Config for type_hooks and cast settings, strict mode to reject unknown keys, forward_references for string annotations, Union type resolution, Optional field handling, data_key for dict key remapping, make_dataclass for dynamic class creation, and integration with JSON parsing and REST API deserialization workflows.
Claude Code for cattrs: Python Attrs and Dataclass Unstructuring
Convert Python objects to and from unstructured data with cattrs and Claude Code — Converter for structuring and unstructuring, structure and unstructure for dict and attrs Struct conversion, register_structure_hook and register_unstructure_hook for custom type handling, GenConverter for automatic dataclass and attrs support, override for per-field rename and omit, cattrs.preconf for JSON-ready converters with datetime and UUID support, disambiguate_union for tagged union structuring, and validation error collection with ClassValidationError.
Claude Code for msgspec: Ultra-Fast Python Serialization
Serialize and validate Python objects at maximum speed with msgspec and Claude Code — Struct for defining typed message schemas with automatic __init__ __repr__ and __eq__, json.encode and json.decode for zero-copy JSON serialization, msgpack.encode and msgpack.decode for binary MessagePack format, Meta for renaming fields encoding-width and frozen control, Convert for type coercion from plain dicts, Struct inheritance for schema composition, gc=False for non-GC structs in hot paths, EncodeError and DecodeError for structured error handling, Union and Literal types for discriminated unions, and custom encoder hooks for extending supported types.
Claude Code for attrs: Python Classes Without Boilerplate
Define concise Python classes with attrs and Claude Code — @define and @attrs decorators for automatic __init__ __repr__ __eq__ and __hash__ generation, field and attrib for custom field configuration, validators with instance_of in_ and custom callables, converters for automatic type conversion, Factory for mutable defaults, frozen for immutable value objects, slots for memory-efficient classes, evolve for functional updates, asdict and astuple for serialization, make_class for dynamic class creation, and attrs interoperability with Pydantic dataclasses and typing.
Claude Code for Marshmallow: Python Object Serialization
Serialize and validate Python objects with Marshmallow and Claude Code — Schema class for field definition and validation, fields.String Integer Float DateTime Nested List and Dict field types, validate module with Length Range OneOf Email URL and Regexp validators, post_load and pre_load decorators for deserialization hooks, dump and load for serialization and deserialization, many=True for list handling, Meta class for strict mode and unknown field handling, marshmallow-dataclass for dataclass integration, marshmallow-sqlalchemy for ORM-integrated schemas, nested schema references for related object serialization, Method fields for computed values, and validate_schema for nested object validation.
Claude Code for Pandera: DataFrame Validation
Validate pandas and Polars DataFrames with Pandera and Claude Code — DataFrameSchema and SchemaModel for column type and constraint definitions, Column with Check for value-level validation rules, check_types decorator for function-level schema enforcement, DataFrameModel with Field for class-based schema definitions, coerce for automatic type casting, nullable and required settings for optional columns, Index and MultiIndex validation, pa.Check built-in checks like isin between gt lt str_contains, custom Check lambdas for business rule validation, SchemaError and SchemaErrors for structured validation failure reporting, and hypothesis integration for property-based DataFrame testing.
Claude Code for Litestar: High-Performance Python API Framework
Build type-safe APIs with Litestar and Claude Code — get post put patch delete decorators with automatic OpenAPI documentation, Provide and Dependency injection system, DTOs for request and response serialization with Pydantic and dataclasses, Guard for route-level authorization, Middleware for cross-cutting concerns, Router for modular route organization, AbstractRepository and SQLAlchemyAsyncRepository for database access patterns, WebSocket handlers, EventListener for application events, and testing with AsyncTestClient for endpoint verification.
Claude Code for Strawberry: GraphQL in Python
Build GraphQL APIs with Strawberry and Claude Code — strawberry.type and strawberry.field for schema definition with type hints, strawberry.Schema for query mutation and subscription schema, strawberry.mutation and strawberry.subscription decorators, Info context for accessing request state and DataLoader, strawberry.ID and strawberry.scalars for custom scalar types, async resolvers for database queries, DataLoader for batching and caching N+1 queries, strawberry.experimental.pydantic for Pydantic model integration, permission classes for field-level authorization, strawberry.django and strawberry-fastapi for framework integration, and schema.execute_sync and AsyncGraphQLView for testing.
Claude Code for Starlette: Lightweight ASGI Framework
Build ASGI web applications with Starlette and Claude Code — Route and Mount for URL routing, Request and Response classes, JSONResponse HTMLResponse RedirectResponse and StreamingResponse for typed responses, Middleware for cross-cutting concerns, BackgroundTask for post-response work, StaticFiles and TemplatesResponse for serving assets, WebSocket support with WebSocket accept send and receive, TestClient for synchronous testing without running a server, on_startup and on_shutdown lifecycle events, AuthenticationMiddleware and SessionMiddleware, and routing groups with APIRouter.
Claude Code for Motor: Async MongoDB with Python
Query MongoDB asynchronously with Motor and Claude Code — AsyncIOMotorClient for connection and database setup, insert_one insert_many and bulk_write for writing documents, find find_one and find_one_and_update for querying, aggregate for pipeline-based analytics, create_index and IndexModel for performance and unique constraints, watch for change streams and real-time events, GridFS with AsyncIOMotorGridFSBucket for large file storage, session and start_session for multi-document transactions, count_documents and estimated_document_count for collection statistics, and motor integration with FastAPI lifespan for connection management.
Claude Code for asyncpg: Fast Async PostgreSQL Client
Query PostgreSQL asynchronously with asyncpg and Claude Code — asyncpg.connect and create_pool for connection and pool management, execute and fetch for running queries, fetchrow and fetchval for single-row and scalar results, executemany for batch inserts, prepared statements with connection.prepare for high-frequency queries, COPY protocol with copy_from_query and copy_to_table for bulk transfer, transaction context managers with isolation levels, add_listener for PostgreSQL LISTEN/NOTIFY, custom type codecs for UUID decimal datetime and JSON, connection pool lifecycle with min_max_size and max_inactive_connection_lifetime, and pool termination from FastAPI lifespan.
Claude Code for Beanie: Async MongoDB ODM
Build async MongoDB applications with Beanie and Claude Code — Document model definition with Pydantic BaseModel integration, init_beanie for connection and model registration, find and find_one for querying with typed filter expressions, insert and save for creating and updating documents, aggregate for MongoDB aggregation pipelines, Indexed and PydanticObjectId field types, Link and BackLink for document references, BeanieDocumentMeta for collection configuration, find_many with sort limit and skip for paginated queries, bulk_write for efficient batch operations, BulkWriter context manager for batched inserts and updates, and migration support with beanie-migrations.
Claude Code for Tortoise ORM: Async Python ORM
Build async database applications with Tortoise ORM and Claude Code — Model definition with Field types, ForeignKeyField and ManyToManyField for relationships, Tortoise.init for database connection and schema generation, generate_schema for table creation, Q objects for complex filter expressions, select_related and prefetch_related for eager loading, values and values_list for projection queries, annotate with Count Sum Avg for aggregation, transactions with in_transaction and atomic, Tortoise.generate_schema with safe=True for migrations, migrations with aerich for Django-style schema versioning, and TestCase and TruncationTestCase for isolated async testing.
Claude Code for arq: Async Redis Job Queues
Run async background jobs with arq and Claude Code — WorkerSettings class for job function registration and Redis connection configuration, enqueue_job for submitting tasks, job_timeout and max_tries for retry and timeout control, ctx dict for dependency injection in job functions, cron and on_startup on_shutdown hooks for scheduled and lifecycle tasks, ArqRedis connection pool for enqueueing from web apps, defer_by and run_at for delayed job scheduling, health_check_interval for liveness monitoring, and arq worker CLI for starting typed worker processes.
Claude Code for Dramatiq: Background Task Processing
Process background tasks with Dramatiq and Claude Code — @dramatiq.actor decorator for defining task functions, dramatiq.send for enqueuing tasks, RabbitmqBroker and RedisBroker for message broker configuration, Retries and TimeLimit middleware for retry logic and execution timeouts, pipeline and group for composing task workflows, actor.send_with_options for per-message TTL and priority, Results middleware for retrieving return values, periodiq for cron-scheduled Dramatiq actors, dramatiq-crontab for time-based scheduling, StubBroker for synchronous unit testing, and CLI worker startup with python -m dramatiq.
Claude Code for Pydantic: Data Validation and Settings
Validate data and manage settings with Pydantic and Claude Code — BaseModel for schema-validated data classes, Field for default values constraints and aliases, model_validator and field_validator for custom validation logic, model_dump and model_validate for serialization and parsing, ConfigDict for model configuration including strict mode and populate_by_name, BaseSettings for environment variable loading with dotenv support, discriminated unions for polymorphic parsing, computed_field for derived properties, nested model composition, RootModel for typed list and dict wrappers, TypeAdapter for validating without a model, and JSON schema generation with model_json_schema.
Claude Code for factory_boy: Test Object Factories
Generate test fixtures with factory_boy and Claude Code — Factory and DjangoModelFactory for ORM-integrated object creation, SubFactory for related object hierarchies, LazyAttribute and LazyFunction for computed fields, Sequence for unique incrementing values, RelatedFactory for reverse relationships, PostGenerationMethodCall for password hashing, Trait for toggling behavior presets, faker integration with Faker class, build vs create vs stub strategies, batch_create for bulk generation, use_in_tests pattern with pytest fixtures, and FactoryFloor for managing related factory state.
Claude Code for pytest-mock: Mocking in pytest Tests
Mock dependencies in pytest tests with pytest-mock and Claude Code — mocker fixture for MagicMock and patch, mocker.patch for replacing module-level functions and class methods, mocker.patch.object for patching specific object attributes, mocker.spy for wrapping real functions while tracking calls, mocker.stub for lightweight test doubles, assert_called_once_with and call_args_list for verifying mock interactions, side_effect for raising exceptions or returning sequences, return_value for controlling mock output, autospec=True for signature-preserving mocks, mocker.resetall and mocker.stopall for cleanup, and AsyncMock for async function mocking.
Claude Code for pre-commit: Automated Git Hook Management
Automate code quality with pre-commit and Claude Code — .pre-commit-config.yaml for hook configuration, pre-commit install for activating hooks on git commit, pre-commit run --all-files for CI and bulk fixes, rev pinning for reproducible hook versions, language and entry fields for custom hooks, pre-commit autoupdate for keeping hooks current, stages for commit commit-msg push and manual triggers, default_stages and always_run settings, exclude and files regex patterns for scoping hooks, trailing-whitespace end-of-file-fixer check-yaml check-json check-merge-conflict and detect-private-key built-in hooks, and pre-commit-ci for automatic PR fixes.
Claude Code for Ruff: Fast Python Linter and Formatter
Lint and format Python with Ruff and Claude Code — ruff check for linting with E/W/F/I/N/UP/B/S/C/PTH rule sets, ruff format for Black-compatible code formatting, --fix for auto-repair, --unsafe-fixes for aggressive fixes, per-file-ignores for excluding specific rules from test or migration files, noqa comments for inline suppression, pyproject.toml configuration with select extend-ignore line-length and target-version, ruff check --watch for continuous feedback, ruff rule EXXXX for rule documentation, isort-compatible import sorting with I rules, pyupgrade-compatible syntax modernization with UP rules, and pre-commit integration for zero-friction CI enforcement.
Claude Code for mypy: Static Type Checking in Python
Add static type checking to Python projects with mypy and Claude Code — mypy --strict for maximum type safety, --ignore-missing-imports for third-party packages, type: ignore comments for suppressing specific errors, py.typed marker files for library type exports, TypeVar and Generic for generic function and class typing, Protocol for structural subtyping, Literal types for value-constrained parameters, TypedDict for typed dict schemas, overload decorator for multiple call signatures, reveal_type for interactive debugging, mypy.ini and pyproject.toml configuration, dmypy for incremental daemon mode, and stub files for untyped third-party packages.
Claude Code for Bandit: Python Security Linting
Find security vulnerabilities with Bandit and Claude Code — bandit -r for recursive source scanning, severity and confidence levels HIGH MEDIUM LOW for filtering findings, -t B101 B201 B301 for test code selection, -i for skipping specific tests with inline noqa, bandit.yaml configuration file for project-level settings, assert_used B101 hardcoded_password B105 sql_injection B608 and subprocess_without_shell_equals_true B603 common security tests, bandit -f json for machine-readable CI output, bandit --exit-zero for non-blocking CI, integration with pre-commit hooks, baseline files with bandit-baseline for tracking known issues, and safestring and hashlib secure usage patterns.
Claude Code for Coverage.py: Test Coverage Measurement
Measure Python test coverage with Coverage.py and Claude Code — coverage run for executing tests with tracing, coverage report for terminal summary with missing lines, coverage html for browsable HTML reports, coverage xml for CI integration with Codecov and SonarQube, .coveragerc and pyproject.toml configuration for source omit and branch coverage, coverage combine for merging parallel test run data, coverage erase for resetting data, branch=True for condition coverage beyond line coverage, fail_under for enforcing minimum thresholds, pragma no cover comments for excluding specific lines, coverage annotate for annotated source files, and coverage json for machine-readable output.
Claude Code for Nox: Python Test Automation
Automate Python test environments with Nox and Claude Code — nox.session decorator for defining isolated test sessions, session.install for dependency management per session, session.run for executing commands, parametrize for matrix testing across Python versions, session.notify for triggering dependent sessions, reuse_venv for faster development iteration, noxfile.py configuration with nox.options for defaults, posargs for passing pytest flags through nox, session.chdir for working directory control, tags for grouping and filtering sessions, session.error for conditional failure, and nox --list --sessions --no-venv --reuse-existing-virtualenvs for CLI control.
Claude Code for responses: Mock HTTP Requests in Tests
Mock HTTP requests in Python tests with responses and Claude Code — @responses.activate decorator for intercepting requests, responses.add for registering GET POST PUT DELETE and PATCH mock responses, callback functions for dynamic responses, responses.add_passthrough for real HTTP pass-through, json body params headers and status for response configuration, responses.calls for inspecting intercepted requests, RequestsMock context manager for scoped mocking, match_querystring for URL query parameter matching, responses.matchers request_body_matcher json_params_matcher and query_param_matcher for request body validation, stream responses for chunked downloads, and responses.reset for clearing registered mocks.
Claude Code for Freezegun: Freeze Time in Tests
Control time in Python tests with Freezegun and Claude Code — @freeze_time decorator for pinning datetime.datetime.now and date.today, freeze_time context manager for block-level time control, tick=True for real-time advancement from a frozen start, move_to for shifting frozen time within a test, freeze_time with string ISO 8601 and datetime objects for setting the frozen moment, ignore parameter for excluding specific modules from time freezing, auto_tick_seconds for automatic time advancement, freezegun.api.FakeDatetime for type-checking frozen datetimes, and compatibility with time.time time.localtime time.gmtime time.strftime and uuid.uuid1 for comprehensive time surface coverage.
Claude Code for Faker: Realistic Test Data Generation
Generate realistic test data with Faker and Claude Code — Faker with locale for localized names addresses and phone numbers, faker.name fake.first_name and fake.last_name for person data, fake.address fake.city fake.country and fake.postcode for location data, fake.email fake.url fake.ipv4 and fake.uuid4 for internet and identifier fields, fake.date_of_birth fake.date_this_decade and fake.date_time_between for temporal data, fake.text fake.sentence fake.paragraph and fake.words for text generation, fake.credit_card_number fake.iban and fake.currency_code for financial data, fake.company fake.job and fake.catch_phrase for business data, Faker providers for custom domain data, factory_boy integration for Django and SQLAlchemy model factories, and seed for reproducible test data.
Claude Code for Locust: Load Testing in Python
Load test web services with Locust and Claude Code — HttpUser with host and wait_time for simulated users, @task decorator with weights for task distribution, TaskSet for grouped user behavior flows, on_start and on_stop hooks for session setup, between and constant wait times for think time simulation, locust.event hooks for custom reporting, FastHttpUser for high-throughput testing, LoadTestShape for custom load ramp profiles, locust-plugins for additional protocols and behaviors, locust --headless and --csv for CI integration, locust --processes for distributed multi-worker runs, catch_response context manager for custom success and failure assertions, and locust.stats for programmatic results access.
Claude Code for Hypothesis: Property-Based Testing
Write property-based tests with Hypothesis and Claude Code — @given decorator with st.integers st.text st.lists st.floats and st.dictionaries for test data generation, @settings for controlling Hypothesis runtime options like max_examples deadline and suppress_health_check, assume for filtering invalid inputs, @example for explicit edge cases, st.composite for custom strategy composition, st.builds for dataclass and object construction, st.one_of for union types, st.from_type for type-annotated strategies, st.recursive for nested data, find for debugging failing examples, and hypothesis.extra.pandas and hypothesis.extra.numpy for array and DataFrame testing.
Claude Code for Tenacity: Python Retry Logic
Add resilient retry logic with Tenacity and Claude Code — @retry decorator with stop stop_after_attempt and stop_after_delay for retry limits, wait wait_fixed wait_random wait_exponential and wait_exponential_jitter for back-off strategies, retry retry_if_exception_type retry_if_result and retry_if_not_result for conditional retry, before_sleep callbacks for logging retry attempts, reraise=True for re-raising the original exception, Retrying context manager for programmatic retry control, AsyncRetrying for async coroutine retry, tenacity.TryAgain for manual retry signaling, and RetryError for exhausted attempt handling.
Claude Code for TorchMetrics: ML Evaluation Metrics
Evaluate machine learning models with TorchMetrics and Claude Code — torchmetrics.Accuracy BinaryAccuracy MulticlassAccuracy and MultilabelAccuracy for classification, torchmetrics.Precision Recall F1Score and AUROC for binary and multiclass evaluation, torchmetrics.MeanSquaredError MeanAbsoluteError and R2Score for regression, torchmetrics.MeanAveragePrecision and IntersectionOverUnion for object detection, torchmetrics.BLEUScore ROUGEScore and BERTScore for NLP, MetricCollection for tracking multiple metrics simultaneously, metric.update compute and reset for stateful accumulation, torchmetrics.wrappers.BootStrapper for confidence intervals, and torchmetrics.functional for stateless batch computation.
Claude Code for Pendulum: Datetime Made Easy
Handle dates and times with Pendulum and Claude Code — pendulum.now pendulum.today pendulum.parse and pendulum.instance for datetime creation, timezone-aware datetimes with pendulum.timezone and in_timezone for safe conversions, add and subtract with fluent interface for date arithmetic, diff and diff_for_humans for human-readable duration display, period for date ranges and iteration, duration for precise interval arithmetic, format and to_iso8601_string for consistent serialization, start_of and end_of for period boundaries, between and is_between for range checks, pendulum.set_test_now for deterministic testing, and pendulum.travel for time travel in tests.
Claude Code for Zarr: Chunked N-D Array Storage
Store and access large N-dimensional arrays with Zarr and Claude Code — zarr.open_array and zarr.open_group for local and cloud array I/O, zarr.zeros ones empty and open with chunks dtype and compressor for array creation, DirectoryStore FSStore S3Store and GCSStore for storage backends, Blosc LZ4 Zstd and GZip compressors for compression configuration, zarr.hierarchy Group with subgroups and arrays for hierarchical storage, array slicing and partial I/O for out-of-core access, zarr.consolidate_metadata and zarr.open_consolidated for fast cloud reads, rechunking and copying with zarr.copy and zarr.copy_store, attributes dict for metadata storage, and zarr.BlockIndex for advanced chunk selection.
Claude Code for einops: Tensor Reshape Operations
Manipulate tensors with einops and Claude Code — rearrange for reshape transpose flatten and unflatten with named axes, reduce for mean sum max and min along named dimensions, repeat for broadcasting expansion along new axes, einops.asnumpy and pack unpack for batching heterogeneous shapes, EinMix layer for learnable projections with named dimensions, einops.layers.torch Rearrange and Reduce as PyTorch modules, pattern syntax with parentheses for merge and split axes, and compatibility with NumPy PyTorch TensorFlow JAX and CuPy arrays.
Claude Code for Albumentations: Fast Image Augmentation
Build image augmentation pipelines with Albumentations and Claude Code — A.Compose for sequential transform pipelines with bboxes and keypoints, A.HorizontalFlip A.VerticalFlip A.RandomRotate90 and A.Transpose for geometric flips, A.ShiftScaleRotate A.Affine and A.ElasticTransform for spatial deformations, A.RandomCrop A.CenterCrop A.RandomResizedCrop and A.PadIfNeeded for crop and pad operations, A.RandomBrightnessContrast A.HueSaturationValue A.ColorJitter and A.CLAHE for color and brightness augmentation, A.GaussNoise A.GaussianBlur A.MotionBlur and A.Defocus for noise and blur, A.CoarseDropout A.GridDropout and A.Cutout for occlusion augmentation, A.Normalize and ToTensorV2 for tensor conversion, A.BboxParams and A.KeypointParams for coordinate-aware augmentation, and A.ReplayCompose for deterministic replay.
Claude Code for Loguru: Modern Python Logging
Implement structured logging with Loguru and Claude Code — logger.add for sink configuration with rotation retention and compression, logger.debug info warning error critical and exception for log levels, logger.bind for contextual field injection, logger.opt for lazy evaluation depth and exception control, logger.catch decorator and context manager for automatic exception logging, format strings with color markup and structured fields, serialize=True for JSON log output, intercept_handler for capturing stdlib logging, filter functions for per-sink log routing, Loguru record dict for custom formatters, and enqueue=True for non-blocking async-safe logging.
Claude Code for xarray: N-D Labeled Arrays
Work with N-dimensional labeled arrays using xarray and Claude Code — xr.DataArray with dims coords and attrs for labeled array creation, xr.Dataset for multi-variable collections, sel and isel for label-based and integer indexing, where and fillna for masking and gap filling, groupby resample and rolling for aggregations, xr.open_dataset and xr.open_mfdataset for NetCDF and Zarr I/O, to_netcdf and to_zarr for writing, interp and interp_like for interpolation, xr.apply_ufunc for vectorized operations, xr.concat merge and combine_by_coords for combining datasets, stack unstack and transpose for reshaping, coarsen for block reductions, and xarray-datatree for hierarchical datasets.
Claude Code for Alembic: Database Schema Migrations
Manage database schema migrations with Alembic and Claude Code — alembic init and env.py configuration for migration environment setup, alembic revision --autogenerate for automatic migration detection from SQLAlchemy models, upgrade and downgrade functions with op.create_table op.add_column op.drop_column op.alter_column and op.create_index for schema changes, alembic upgrade head and downgrade base for applying migrations, bulk_insert and execute for data migrations, alembic current history and stamp for tracking migration state, branch_labels and depends_on for migration graph management, context.configure with compare_type and render_as_batch for SQLite compatibility, and run_migrations_online versus run_migrations_offline for live and script-based execution.
Claude Code for boto3: AWS SDK for Python
Interact with AWS services using boto3 and Claude Code — boto3.client and boto3.resource for service connections with session and credentials, S3 upload_file download_file put_object get_object list_objects_v2 copy and generate_presigned_url for object storage, DynamoDB Table put_item get_item query scan batch_writer and update_item for NoSQL operations, Lambda invoke for serverless function calls, SQS send_message receive_message delete_message and Queue for message queuing, SNS publish for notifications, SSM get_parameter for secrets management, STS assume_role for cross-account access, Bedrock Runtime invoke_model for LLM inference, S3 Transfer with TransferConfig for multipart uploads, and botocore ClientError for AWS exception handling.
Claude Code for Rich: Beautiful Terminal Output
Build beautiful terminal applications with Rich and Claude Code — rich.print with markup and emoji for colored formatted output, Console with highlight and log for structured logging, Table with add_column add_row and border styles for terminal tables, Progress with SpinnerColumn BarColumn and TimeElapsedColumn for progress indicators, Panel Text Markdown and Syntax for formatted content blocks, Live and Layout for dynamic dashboard rendering, Tree for hierarchical data display, Columns for side-by-side output, Traceback for beautiful exception formatting, Inspect for interactive object inspection, Theme and Style for custom color schemes, and rich.logging RichHandler for pretty log output.
Claude Code for Typer: Modern Python CLI Framework
Build command-line interfaces with Typer and Claude Code — typer.Typer app and app.command for multi-command CLI apps, typer.Option and typer.Argument with type hints for automatic parameter parsing, typer.echo typer.secho and typer.style for colored terminal output, typer.confirm typer.prompt and typer.progressbar for interactive input, typer.Exit and typer.Abort for controlled exit codes, callback=True for subcommand groups, app.add_typer for nested subcommand trees, typer.testing.CliRunner for unit testing CLI commands, typer.launch for opening URLs and files, rich integration for formatted output, completion install for shell autocompletion in bash zsh and fish, and typer.main.get_command for Click interoperability.
Claude Code for aiohttp: Async HTTP Client and Server
Build async HTTP applications with aiohttp and Claude Code — aiohttp.ClientSession with connector and timeout for async HTTP client, get post put patch delete and request methods with json params headers and ssl, aiohttp.web Application router add_get add_post add_route for HTTP server, Request response json and text for handler I/O, aiohttp.web.run_app and AppRunner for server lifecycle, TCPConnector with limit and keepalive_timeout for connection pooling, aiohttp.ClientTimeout for fine-grained timeout control, middleware with web.middleware decorator for cross-cutting concerns, WebSocket support with ws_connect and WebSocketResponse, aiohttp.web.static for serving files, aiohttp.ClientSession with auth BasicAuth and headers for API authentication, and aiohttp_retry RetryClient for automatic retry with exponential backoff.
Claude Code for imbalanced-learn: Class Imbalance Handling
Handle class imbalance with imbalanced-learn and Claude Code — RandomOverSampler SMOTE ADASYN and BorderlineSMOTE for oversampling minority classes, RandomUnderSampler TomekLinks ClusterCentroids and EditedNearestNeighbours for undersampling majority classes, SMOTEENN and SMOTETomek for combined over and undersampling, imblearn Pipeline for imbalanced-aware scikit-learn pipelines, BalancedRandomForestClassifier and EasyEnsembleClassifier for ensemble methods with resampling, sampling_strategy parameter for targeting specific class ratios, imblearn make_pipeline for safe composition with preprocessing, and metrics precision_recall_fscore_support with zero_division for imbalanced evaluation.
Claude Code for CatBoost: Gradient Boosting for Categorical Data
Build gradient boosting models with CatBoost and Claude Code — CatBoostClassifier and CatBoostRegressor for supervised learning, cat_features parameter for native categorical column support without encoding, Pool object for efficient data containers with feature names and weights, early_stopping_rounds and eval_set for overfitting prevention, plot_tree and get_feature_importance for model interpretation, SHAP values via get_feature_importance with type EFstrType.ShapValues, CatBoostRanker for learning-to-rank, GPU training with task_type=GPU, Optuna integration for hyperparameter search, cv for cross-validation, CatBoost model serialization with save_model and load_model, and virtual ensembles for uncertainty estimation.
Claude Code for httpx: Modern Async HTTP Client
Build HTTP clients with httpx and Claude Code — httpx.Client and AsyncClient for sync and async HTTP with connection pooling, httpx.get post put patch delete and request for all HTTP methods, auth BasicAuth BearerAuth DigestAuth and custom Auth for authentication, httpx.Timeout and Limits for fine-grained timeout and connection control, Response text json content and stream for response handling, httpx.Event hooks for request and response logging, follow_redirects verify cert and proxies for transport options, httpx.MockTransport and httpx_mock for testing, httpx.HTTPStatusError and RequestError for error handling, streaming with response.aiter_bytes and aiter_lines for large responses, and httpx.AsyncHTTPTransport with retries for resilient async clients.
Claude Code for Pillow: Python Image Processing
Process images with Pillow and Claude Code — Image.open Image.new Image.fromarray and Image.save for I/O, Image.resize Image.crop Image.rotate and Image.transpose for geometric transforms, ImageFilter.BLUR GaussianBlur UnsharpMask and FIND_EDGES for convolution filters, ImageEnhance Contrast Brightness Color and Sharpness for adjustment, ImageDraw draw rectangle ellipse polygon line and text for annotations, ImageFont truetype for custom font rendering, Image.convert for mode conversion between RGB RGBA L grayscale and CMYK, Image.composite Image.blend and Image.alpha_composite for compositing, ImageOps autocontrast equalize solarize and fit for automatic adjustments, ImageSequence Iterator for animated GIF processing, and image.getdata putdata and numpy interop for pixel-level manipulation.
Claude Code for Scrapy: Web Scraping at Scale
Build production web scrapers with Scrapy and Claude Code — Spider and CrawlSpider with start_urls and parse methods, scrapy.http Request and Response with callback and errback, css and xpath selectors with SelectorList get getall and re, Item and ItemLoader with input_output processors, scrapy.pipelines for item processing deduplication and database storage, settings CONCURRENT_REQUESTS DOWNLOAD_DELAY ROBOTSTXT_OBEY and AUTOTHROTTLE, scrapy.extensions for stats monitoring, DownloadMiddleware for custom headers user-agent rotation and proxy support, Splash and scrapy-playwright for JavaScript rendering, scrapy.exporters for JSON JSONL CSV and XML output, scrapy crawl command with -o and -s flags, and Scrapy Cloud or Scrapyd for deployment.
Claude Code for SQLAlchemy: Python ORM and SQL Toolkit
Build database-backed applications with SQLAlchemy and Claude Code — DeclarativeBase and mapped_column for ORM model definitions, relationship and ForeignKey for associations, Session sessionmaker and scoped_session for unit-of-work transactions, select update delete and insert for Core SQL expression queries, AsyncSession and create_async_engine for async SQLAlchemy 2.0, with_loader_options selectinload joinedload and lazyload for relationship loading strategies, Query API with filter_by filter order_by limit and offset, Index UniqueConstraint and CheckConstraint for database constraints, event listeners for audit logging, Alembic autogenerate for schema migrations, connection pooling with QueuePool and NullPool, and bulk insert_mappings for high-throughput writes.
Claude Code for PyArrow: Columnar Data Processing
Process columnar data efficiently with PyArrow and Claude Code — pyarrow.Table from_pandas to_pandas from_batches and schema for tabular data, pyarrow.Array chunked_array and RecordBatch for columnar containers, pyarrow.compute module with filter cast add subtract and sort_indices for vectorized operations, pyarrow.parquet read_table write_table and ParquetDataset for Parquet I/O with predicate pushdown, pyarrow.csv read_csv and write_csv for fast CSV parsing, pyarrow.ipc RecordBatchStreamReader and write_to_ipc_stream for Arrow IPC format, pyarrow.fs S3FileSystem GCSFileSystem and LocalFileSystem for cloud storage access, pyarrow.dataset dataset and Scanner for partition-aware large dataset scanning, pyarrow.flight FlightClient for high-performance gRPC data transport, and pyarrow.plasma for shared-memory object store.
Claude Code for Altair: Declarative Statistical Visualization
Build declarative visualizations with Altair and Claude Code — alt.Chart with mark_point mark_line mark_bar mark_area and mark_circle for chart types, alt.X alt.Y alt.Color alt.Size and alt.Tooltip for channel encodings, shorthand syntax x='field:Q' for quantitative O for ordinal N for nominal and T for temporal, alt.condition for interactive conditional highlighting, selection_point and selection_interval for interactive brushing, transform_filter transform_aggregate transform_bin transform_fold and transform_calculate for data transforms, facet column and row for small multiples, hconcat and vconcat and layer for chart composition, alt.Chart.resolve_scale for shared and independent axis scales, and chart.save for JSON Vega-Lite spec export.
Claude Code for SymPy: Symbolic Mathematics
Perform symbolic mathematics with SymPy and Claude Code — sympy.symbols and Function for symbolic variable declaration, sympy.expand factor simplify and cancel for algebraic manipulation, sympy.diff and Derivative for symbolic differentiation, sympy.integrate and Integral for symbolic integration, sympy.solve and solveset for equation solving, sympy.limit for limit computation, sympy.series for Taylor and Laurent series expansion, sympy.Matrix with det inv eigenvals and eigenvects for symbolic linear algebra, sympy.ode.dsolve for differential equations, sympy.stats Normal Bernoulli and E for probability, sympy.latex for LaTeX rendering, sympy.lambdify for converting expressions to NumPy functions, and sympy.assumptions with assume for conditional simplification.
Claude Code for Seaborn: Statistical Data Visualization
Build statistical visualizations with Seaborn and Claude Code — seaborn.scatterplot relplot and pairplot for relationship plots, seaborn.histplot kdeplot and displot for distribution visualization, seaborn.boxplot violinplot and stripplot for categorical distributions, seaborn.heatmap with annot and cmap for matrix visualization, seaborn.lineplot with ci and estimator for time series with confidence bands, seaborn.lmplot and regplot for regression visualization, seaborn.FacetGrid and catplot for multi-panel conditional plots, seaborn.jointplot for bivariate distributions, seaborn.clustermap for hierarchical clustering heatmaps, seaborn.set_theme set_style and set_palette for global styling, and seaborn.objects interface for layered grammar-of-graphics style composition.
Claude Code for Dask: Parallel and Out-of-Core Computing
Scale Python data pipelines with Dask and Claude Code — dask.dataframe from_pandas read_csv read_parquet and map_partitions for parallel DataFrames, dask.array from_array from_delayed and blockwise for chunked NumPy arrays, dask.bag from_sequence from_delayed and map filter fold for parallel collections, dask.delayed decorator for custom task graphs, Client and LocalCluster for distributed scheduling, dask.compute for concurrent execution, persist for keeping data in cluster memory, dask.diagnostics ProgressBar and visualize for task graph inspection, futures interface for real-time task submission, and dask.config for scheduler and memory limit configuration.
Claude Code for CuPy: GPU-Accelerated Array Computing
Accelerate NumPy workloads on GPU with CuPy and Claude Code — cupy.array and cupy.asarray for host-to-device transfer, cupy.asnumpy and get method for device-to-host, cupy.zeros ones linspace arange and random for GPU array creation, cupy.dot matmul einsum for GPU BLAS operations, cupy.linalg.solve svd eigh and lstsq for GPU linear algebra, cupy.fft.fft ifft rfft and rfftfreq for GPU FFT, cupy.sparse csr_matrix and spsolve for GPU sparse linear algebra, cupy.ElementwiseKernel and RawKernel for custom CUDA kernels, cupy.ReductionKernel for custom reductions, cupy.cuda.Stream for asynchronous execution, cupy.cuda.MemoryPool for memory management, and cupyx.scipy.ndimage gaussian_filter and label for GPU image processing.
Claude Code for Plotly: Interactive Data Visualization
Build interactive data visualizations with Plotly and Claude Code — plotly.express px.scatter px.line px.bar px.histogram px.box and px.choropleth for high-level charts, go.Figure and go.Scatter go.Bar go.Heatmap go.Candlestick and go.Surface for graph objects, fig.update_layout and fig.update_traces for styling, make_subplots for multi-panel dashboards, facet_col and facet_row for small multiples, animation_frame for animated charts, hover_data and custom_data for rich tooltips, color_continuous_scale and color_discrete_map for color control, Dash integration for interactive web applications, fig.write_html and fig.write_image for export, and plotly.io renderers for Jupyter and standalone HTML.
Claude Code for Numba: JIT Compilation for Python
Accelerate Python with Numba JIT and Claude Code — numba.jit and njit decorators for CPU loop acceleration with nopython mode, numba.vectorize and guvectorize for NumPy ufunc creation, numba.cuda.jit for GPU kernel programming with thread block grid configuration, numba.prange for automatic parallel loops, numba.typed.List and Dict for Numba-compatible containers, numba.jit cache parameter for disk-caching compiled code, ahead-of-time compilation with numba.pycc, float32 float64 int32 type annotations for explicit signature dispatch, stencil decorator for neighborhood operations, numba.objmode for falling back to Python objects in JIT code, and Numba FastMath and parallel target for maximum performance.
Claude Code for SciPy: Scientific Computing
Build scientific computing pipelines with SciPy and Claude Code — scipy.optimize minimize and curve_fit and linprog and differential_evolution for optimization, scipy.signal filtfilt butter and spectrogram and find_peaks for signal processing, scipy.stats norm t chi2 kstest ttest_ind mannwhitneyu and pearsonr for statistics and hypothesis testing, scipy.sparse csr_matrix csc_matrix and spsolve for sparse linear algebra, scipy.linalg lstsq svd and solve_banded for dense linear systems, scipy.interpolate CubicSpline interp1d and griddata for interpolation, scipy.ndimage gaussian_filter median_filter and label for image processing, scipy.fft fft ifft rfft and fftfreq for Fourier transforms, and scipy.spatial KDTree cKDTree distance_matrix and ConvexHull for spatial algorithms.
Claude Code for PyMC: Probabilistic Programming
Build Bayesian models with PyMC and Claude Code — PyMC model context manager with pm.Model, prior distributions pm.Normal pm.Exponential pm.Beta pm.Dirichlet pm.HalfNormal pm.StudentT, pm.Deterministic for derived quantities, pm.sample with NUTS sampler and target_accept and draws and chains parameters, pm.sample_prior_predictive and pm.sample_posterior_predictive for predictive checks, ArviZ az.summary az.plot_trace and az.plot_posterior for posterior analysis, hierarchical models with plate notation and coords, Linear regression Logistic regression and GLM models, pm.Data for out-of-sample predictions, Gaussian process with pm.gp.Marginal, mixture models with pm.Categorical and Dirichlet process, and ADVI mean-field variational inference with pm.fit.
Claude Code for SHAP: Model Explainability
Build model explainability with SHAP and Claude Code — shap.TreeExplainer for XGBoost LightGBM RandomForest and tree ensembles, shap.LinearExplainer for linear models, shap.DeepExplainer for neural networks, shap.KernelExplainer as model-agnostic fallback, shap_values arrays with feature contribution signs, shap.summary_plot beeswarm for global importance, shap.waterfall_plot for single prediction explanation, shap.force_plot for interactive JavaScript visualization, shap.dependence_plot for feature interaction effects, shap.bar_plot for mean absolute SHAP importances, shap.Explanation object with values base_values and data, shap.maskers.Independent and Partition for data sampling, and TreeExplainer with tree_path_dependent for exact SHAP computation.
Claude Code for NetworkX: Graph Analysis and Network Science
Build graph analysis pipelines with NetworkX and Claude Code — nx.Graph DiGraph MultiGraph and MultiDiGraph creation, add_node add_edge and add_edges_from for graph construction, shortest_path and shortest_path_length and all_shortest_paths with Dijkstra and Bellman-Ford algorithms, degree_centrality betweenness_centrality closeness_centrality and eigenvector_centrality for node importance, PageRank and HITS for link analysis, community detection with greedy_modularity_communities and louvain_communities, connected_components and strongly_connected_components, minimum_spanning_tree and maximum_flow and min_cut, graph generators erdos_renyi_graph barabasi_albert_graph and watts_strogatz_graph, drawing with matplotlib, and reading GML GraphML and edgelist formats.
Claude Code for statsmodels: Statistical Modeling and Econometrics
Build statistical models with statsmodels and Claude Code — OLS and WLS and GLS linear regression with RobustCovariance HC3 standard errors, Logit Probit and MNLogit for discrete choice models, ARIMA and SARIMA and SARIMAX for time series with pmdarima auto_arima, ExponentialSmoothing Holt-Winters for seasonal forecasting, VAR vector autoregression for multivariate time series, acf and pacf for autocorrelation analysis, adfuller and kpss for stationarity tests, OLS summary with R-squared F-statistic t-tests p-values and confidence intervals, GLM with Poisson Binomial and Negative Binomial families, quantile regression QuantReg for heteroscedastic data, and statsmodels formula API smf for R-style model specification.
Claude Code for Prophet: Time Series Forecasting
Build time series forecasting models with Meta Prophet and Claude Code — Prophet model with seasonality_mode additive and multiplicative, ds and y DataFrame format for fitting, make_future_dataframe for forecast horizon, predict returning yhat yhat_lower yhat_upper, add_country_holidays for automatic holiday effects, add_seasonality for custom Fourier order periods, add_regressor for external regressors, changepoint_prior_scale for trend flexibility tuning, seasonality_prior_scale for seasonality strength, plot and plot_components for visualization, cross_validation and performance_metrics from prophet.diagnostics for backtesting, parameter tuning with grid search over changepoint and seasonality scales, and Prophet with uncertainty_samples for confidence intervals.
Claude Code for Gensim: Topic Modeling and Word Embeddings
Build topic models and word embeddings with Gensim and Claude Code — gensim.corpora.Dictionary for vocabulary building with filter_extremes, doc2bow for bag-of-words conversion, LdaModel with num_topics passes and alpha and eta parameters, LdaMulticore for parallel training, CoherenceModel with c_v measure for optimal topic count selection, Word2Vec with sg CBOW skip-gram and vector_size window min_count parameters, KeyedVectors most_similar doesnt_match and similarity methods, FastText for subword embeddings handling OOV words, Doc2Vec with TaggedDocument for document similarity, gensim.models.TfidfModel for TF-IDF weighting, LsiModel for latent semantic indexing, and similarities.MatrixSimilarity for document retrieval.
Claude Code for scikit-learn: Classical Machine Learning
Build complete machine learning pipelines with scikit-learn and Claude Code — sklearn Pipeline and ColumnTransformer for preprocessing chaining, StandardScaler MinMaxScaler and RobustScaler for numeric features, OneHotEncoder and OrdinalEncoder for categoricals, SimpleImputer and KNNImputer for missing values, RandomForestClassifier GradientBoostingClassifier SVM and LogisticRegression estimators, cross_val_score and GridSearchCV and RandomizedSearchCV and HalvingRandomSearchCV for model selection, SMOTE via imblearn for imbalanced data, FeatureUnion for parallel preprocessing branches, SelectFromModel and RFECV for feature selection, classification_report confusion_matrix and roc_auc_score metrics, and joblib for parallel cross-validation and model persistence.
Claude Code for LightGBM: Fast Gradient Boosting
Build fast gradient boosting models with LightGBM and Claude Code — lgb.Dataset for efficient data format with label weight and categorical_feature parameters, lgb.train with params dict for learning_rate num_leaves max_depth min_data_in_leaf lambda_l1 lambda_l2 and feature_fraction, LGBMClassifier and LGBMRegressor scikit-learn API, early stopping with valid_sets and callbacks lgb.early_stopping and lgb.log_evaluation, lgb.cv for cross-validation with stratified folds, feature importance with feature_importances_ gain and split types, SHAP integration with tree_explainer, categorical feature handling without encoding, lightgbm.train with custom objective and eval functions, model save and load with save_model and load_model, and Optuna integration with LightGBMTuner.
Claude Code for XGBoost: Gradient Boosting for Structured Data
Build high-performance gradient boosting models with XGBoost and Claude Code — xgb.DMatrix for efficient data format with label and weight parameters, xgb.train with params dict for tree booster eta max_depth subsample colsample_bytree and num_round, XGBClassifier and XGBRegressor scikit-learn API with fit predict and predict_proba, early stopping with eval_set and early_stopping_rounds, xgb.cv for cross-validation with nfold and stratified, feature importance with get_score gain weight and cover importance types, SHAP integration for model explainability, GPU acceleration with device parameter, custom objective functions and eval metrics, model save and load with save_model and load_model, and hyperparameter tuning with Optuna.
Claude Code for spaCy: Industrial-Strength NLP
Build production NLP pipelines with spaCy and Claude Code — spacy.load for en_core_web_sm and en_core_web_trf transformer model loading, nlp.pipe for batch processing, Doc tokens with text lemma pos tag dep is_stop, Span entities with label start end, EntityRecognizer and Tagger training with example updates, custom pipeline components with nlp.add_pipe and Language.component decorator, displacy for entity and dependency visualization, Matcher and PhraseMatcher for rule-based pattern matching, EntityRuler for dictionary gazetteers, DocBin for binary serialization, training loop with nlp.update and example Examples list and SGD optimizer, spacy train CLI with config.cfg, textcat multi-label text classification, and spacy.blank for building custom language models from scratch.
Claude Code for FAISS: Fast Approximate Nearest Neighbor Search
Build billion-scale vector search with FAISS and Claude Code — faiss.IndexFlatL2 and IndexFlatIP for exact search, IndexIVFFlat and IndexIVFPQ for approximate search with nlist and nprobe parameters, faiss.normalize_L2 for cosine similarity, IndexHNSWFlat for graph-based ANN with M and efConstruction parameters, IndexIDMap for custom document IDs, faiss.write_index and read_index for persistence, GPU acceleration with faiss.index_cpu_to_gpu and StandardGpuResources, index.train for IVF index training on representative vectors, index.add and search and add_with_ids methods, IndexPQ and IndexScalarQuantizer for memory-efficient compression, and index factory string syntax for composite index creation.
Claude Code for Sentence Transformers: Semantic Embeddings
Build semantic search and NLP embeddings with Sentence Transformers and Claude Code — SentenceTransformer model loading with all-MiniLM-L6-v2 all-mpnet-base-v2 and multilingual models, model.encode for single and batch sentence embedding, semantic similarity with cosine_similarity and util.pytorch_cos_sim, semantic search with util.semantic_search for top-k retrieval, cross-encoder CrossEncoder for re-ranking, paraphrase detection with paraphrase-MiniLM models, bi-encoder dual encoder architecture for fast retrieval, model.encode with normalize_embeddings show_progress_bar and batch_size parameters, SentenceTransformerTrainer for fine-tuning with MultipleNegativesRankingLoss and CosineSimilarityLoss, InputExample dataset format, and semantic textual similarity benchmarks.
Claude Code for LLaVA: Visual Language Models
Build vision-language applications with LLaVA and Claude Code — LLaVA 1.5 and LLaVA-Next and LLaVA-OneVision multimodal model loading with transformers AutoModelForVision2Seq and LlavaNextProcessor, image_to_text pipeline for single image QA, multi-image and multi-turn visual conversation, LlavaNextForConditionalGeneration with generate method and streamer, pixel_values and input_ids and attention_mask inputs, chat templates with apply_chat_template for instruction following, visual instruction following for detailed image description chart reading and OCR, Moondream for lightweight edge inference, and Hugging Face transformers pipeline API for vision-language tasks.
Claude Code for SAM2: Segment Anything Model 2
Segment any object with Meta SAM2 and Claude Code — SAM2ImagePredictor for point box and mask prompted image segmentation, SAM2VideoPredictor for video object segmentation with object tracking across frames, build_sam2 and build_sam2_video_predictor for model loading with sam2.1_hiera small base plus and large checkpoints, set_image for image conditioning, predict with point_coords and point_labels for positive and negative prompt points, box prompt with box parameter for XYXY coordinates, get_state and add_new_points_or_box for video state management, propagate_in_video for forward and backward tracking, automatic mask generation with SAM2AutomaticMaskGenerator, and mask filtering by area and stability score.
Claude Code for OpenCLIP: Open-Source CLIP for Vision-Language
Build vision-language models with OpenCLIP and Claude Code — open_clip.create_model_and_transforms for ViT-B-32 ViT-L-14 and EVA02 model loading, open_clip.tokenize for text encoding, model.encode_image and model.encode_text for joint embedding extraction, cosine similarity for zero-shot image classification, zero-shot transfer with CIFAR and ImageNet template prompts, open_clip.list_pretrained for available pretrained checkpoints, image-text retrieval with similarity matrices, fine-tuning CLIP with contrastive loss, CoCa model for captioning, and LAION pretrained weights for state-of-the-art zero-shot performance.
Claude Code for Ultralytics YOLO: Object Detection and Tracking
Detect track and segment objects with Ultralytics YOLO and Claude Code — YOLO model loading with YOLOv8 and YOLOv11 variants n s m l x sizes, model.predict for inference with conf and iou threshold parameters, model.train for custom dataset fine-tuning with YAML config, model.val for mAP evaluation, model.export to ONNX TensorRT CoreML and TFLite formats, Results object with boxes masks keypoints and class names, obb for oriented bounding boxes, model.track for multi-object tracking with ByteTrack and BotSort, pose estimation with keypoints, instance segmentation with masks, image and video and stream inference modes, and batch training optimization.
Claude Code for timm: PyTorch Image Models
Build vision models with timm and Claude Code — timm.create_model for loading pretrained ViT EfficientNet ConvNeXt Swin Transformer ResNet and 1000 plus models, timm.list_models for model discovery with name filtering, get_pretrained_cfg and pretrained_cfg_for_model for architecture metadata, in_chans num_classes global_pool and features_only parameters for customization, timm.data.create_transform and create_dataset for dataset loading, mixup and cutmix augmentation with Mixup class, automatic augmentation with AutoAugment and RandAugment, model feature extraction with forward_features, register_notrace_module decorator, and timm.optim for AdamW LAMB and Lion optimizers.
Claude Code for Librosa: Audio Analysis and Music Processing
Analyze audio and music with Librosa and Claude Code — librosa.load for audio file loading with resampling, librosa.feature for MFCC Mel Spectrogram chroma zero crossing rate spectral centroid and spectral rolloff extraction, librosa.beat for tempo detection and beat tracking, librosa.onset for onset detection and strength, librosa.effects for time stretching pitch shifting and harmonic percussive separation, librosa.segment for recurrence matrix and structure analysis, librosa.display for spectrogram and waveform plotting, librosa.decompose for NMF source separation, librosa.util for frame blocking and normalization, and music information retrieval features for genre classification and music recommendation.
Claude Code for AudioCraft: AI Music and Audio Generation
Generate music and audio with Meta AudioCraft and Claude Code — MusicGen for text-to-music generation with small medium large and stereo model sizes, AudioGen for text-to-sound-effects generation, EnCodec for neural audio compression and token encoding, MusicGen single and continuation modes, audiocraft.models.MusicGen load_pretrained for model loading, set_generation_params for duration temperature top_k and cfg_coef guidance, generate and generate_with_chroma for melody conditioning, audio_write for saving generated WAV files, batch generation with list of text prompts, stereo and mono output selection, and AudioCraft model serving with GPU acceleration.
Claude Code for TorchAudio: Audio Processing with PyTorch
Process audio with TorchAudio and Claude Code — torchaudio.load and torchaudio.save for WAV MP3 FLAC file I/O, torchaudio.transforms for MelSpectrogram MFCC and Spectrogram and AmplitudeToDB feature extraction, torchaudio.functional for resample and highpass_biquad and lowpass_biquad and deemphasis filters, torchaudio.datasets for SPEECHCOMMANDS LibriSpeech and VCTK loading, data augmentation with TimeStretch FrequencyMasking TimeMasking AddNoise and RoomImpulseResponse, torchaudio.pipelines for Wav2Vec2 and HuBERT and RNNT pretrained models, Tacotron2 and HiFiGAN for TTS synthesis, and speech_recognition pipeline for end-to-end ASR.
Claude Code for PyAnnote: Speaker Diarization
Perform speaker diarization with PyAnnote Audio and Claude Code — pyannote.audio Pipeline for speaker diarization with HuggingFace pretrained models, SPEAKER_00 and SPEAKER_01 labels with start and end timestamps, voice activity detection with VoiceActivityDetection pipeline, speaker verification with SpeakerVerification and score threshold, speaker segmentation with SpeakerSegmentation pipeline, overlap detection for simultaneous speakers, inference Inference class for sliding window processing, Speaker embedding extraction with PretrainedSpeakerEmbedding, pyannote RTTM format output, minimum speakers and maximum speakers constraints, and integration with WhisperX and torchaudio for transcription with speaker labels.
Claude Code for SpeechBrain: Speech Processing Toolkit
Build speech processing systems with SpeechBrain and Claude Code — EncoderClassifier for speaker verification and language identification, SepformerSeparation for speech separation and enhancement, ECAPA-TDNN speaker embeddings with x-vectors, SpeechBrain pretrained interfaces with from_hparams, Brain class with train and evaluate methods for custom model training, speechbrain.pretrained.interfaces for ASR TTS and speaker recognition, Encoder for speech feature extraction, Stage enum for training validation testing, custom YAML hyperparameter files, torchaudio integration for audio loading, and SpeechBrain dataio pipeline for data loading.
Claude Code for Whisper: OpenAI Speech Recognition
Transcribe audio with OpenAI Whisper and Claude Code — whisper.load_model for tiny base small medium large model variants, model.transcribe for audio file transcription with language and task parameters, word-level timestamps with word_timestamps True, translate task for transcription into English, temperature and beam size and best of decoding parameters, initial_prompt for domain vocabulary, whisper.DecodingOptions for advanced control, faster-whisper with WhisperModel and compute type int8 for CPU inference, WhisperX for word-level alignment and speaker diarization, and OpenAI Whisper API endpoint for cloud transcription.
Claude Code for TGI: Text Generation Inference Server
Deploy production LLM servers with Hugging Face Text Generation Inference and Claude Code — TGI Docker container with model HF_MODEL_ID and NUM_SHARD for multi-GPU tensor parallelism, OpenAI-compatible chat completions API endpoint, streaming with Server-Sent Events, InferenceClient and AsyncInferenceClient for Python calls, continuous batching with MAX_BATCH_PREFILL_TOKENS and MAX_TOTAL_TOKENS, GPTQ and AWQ and EETQ quantization flags, LoRA adapter loading with LORA_ADAPTERS, flash attention with USE_FLASH_ATTENTION, speculative decoding with SPECULATIVE_MODEL, grammar-constrained generation with JSON schema and regex, and Prometheus metrics at slash metrics endpoint.
Claude Code for OpenVINO: Intel AI Inference Optimization
Optimize AI inference on Intel hardware with OpenVINO and Claude Code — openvino.Core for model loading and device selection, convert_model for ONNX and PyTorch and TensorFlow model conversion, compile_model for device-specific optimization with CPU GPU NPU targets, INT8 quantization with nncf post-training quantization, ov.CompiledModel infer method and AsyncInferQueue for non-blocking inference, ov.Tensor for input and output data, AUTO device plugin for automatic hardware selection, throughput and latency performance hints, model caching with cache_dir, GenAI pipeline for LLM inference on Intel hardware, and optimum-intel for Hugging Face model optimization.
Claude Code for CTranslate2: Fast Inference for Transformers
Run fast transformer inference with CTranslate2 and Claude Code — ctranslate2.convert_model for converting Hugging Face and OpenNMT and Marian models to CTranslate2 format, Translator for sequence-to-sequence translation with beam search, Generator for causal language model text generation, Encoder for BERT-style feature extraction, int8 and int16 and float16 quantization for CPU and GPU, inter_threads and intra_threads for multi-threaded inference, AsyncTranslator for non-blocking inference, batched translation with max_batch_size and max_input_length, compute_type auto selection, CUDA device selection, and Whisper transcription with WhisperModel and faster-whisper integration.
Claude Code for LMDeploy: Efficient LLM Deployment
Deploy LLMs efficiently with LMDeploy and Claude Code — TurboMind inference engine with PagedAttention and continuous batching, lmdeploy convert for model weight conversion and quantization, lmdeploy chat for CLI inference, lmdeploy serve api_server for OpenAI-compatible REST API, pipeline API with LLM class for Python inference, W4A16 and W8A8 INT8 and KV int8 quantization modes, AWQ quantization with lmdeploy lite auto_awq, tensor parallelism across multiple GPUs, VisionConfig for vision language models, EngineConfig and GenerationConfig for inference tuning, and TurbomindEngineConfig max_batch_size and cache_max_entry_count for memory optimization.
Claude Code for SGLang: Structured Generation Language
Accelerate LLM inference with SGLang and Claude Code — sgl.function decorator for SGLang programs, sgl.gen for constrained generation with regex and JSON schema and choices, sgl.image for multimodal vision inputs, sgl.select for parallel branching, fork and join for concurrent generation streams, Runtime with model path and tensor parallel size for multi-GPU serving, sgl.set_default_backend for local and remote backends, pipeline parallelism and continuous batching for throughput, RadixAttention KV cache prefix sharing for speed, speculative decoding configuration, and OpenAI-compatible REST endpoint.
Claude Code for TruLens: RAG Evaluation and Tracing
Evaluate and trace RAG applications with TruLens and Claude Code — TruChain and TruLlama and TruBasicApp instrumentation wrappers for LangChain LlamaIndex and custom apps, Feedback functions with provider relevance and groundedness and coherence for automated LLM-as-judge scoring, tru.get_leaderboard for comparing app versions, TruLens dashboard at localhost 8501 for trace visualization, with tru_recorder context manager for capturing inputs and outputs and feedback scores, OpenAI and Hugging Face provider for feedback computation, record-level and aggregate metrics, RAG triad of context relevance and groundedness and answer relevance for complete RAG quality measurement, and session.reset_database for clean experiment runs.
Claude Code for DeepEval: LLM Unit Testing Framework
Unit test LLM applications with DeepEval and Claude Code — assert_test and evaluate for running LLM test cases, LLMTestCase with input output expected_output and retrieval_context fields, AnswerRelevancyMetric and FaithfulnessMetric and ContextualPrecisionMetric and ContextualRecallMetric and HallucinationMetric for RAG evaluation, GEval for custom criteria evaluation with natural language rubrics, pytest integration with deepeval decorator and parametrize for CI pipelines, EvaluationDataset from CSV and HuggingFace datasets, BaseMetric for custom metric implementation, conversation testing with ConversationalTestCase and TurnParams, and Confident AI cloud dashboard for test run tracking.
Claude Code for RAGAS: RAG Pipeline Evaluation
Evaluate RAG pipelines with RAGAS and Claude Code — faithfulness metric measuring answer groundedness in retrieved context, answer relevancy measuring response relevance to the question, context precision and context recall measuring retrieval quality, answer correctness comparing against ground truth, EvaluationDataset with SingleTurnSample for batch evaluation, evaluate function with metrics list and LLM judge configuration, RunConfig for retry and timeout settings, RAGAS testset generation with TestsetGenerator for synthetic QA pairs from documents, and integration with LangChain LlamaIndex and Haystack pipelines.
Claude Code for Arize Phoenix: LLM Evaluation and Tracing
Evaluate and trace LLM applications with Arize Phoenix and Claude Code — phoenix.trace for OpenAI and Anthropic and LangChain auto-instrumentation, SpanKind CHAIN RETRIEVER LLM EMBEDDING for trace categorization, px.Client for querying traces and spans, llm_classify and llm_eval_binary for automated LLM-as-judge evaluation, RAGEvaluator with RelevanceEvaluator and HallucinationEvaluator for retrieval-augmented generation quality, Phoenix datasets for organizing evaluation runs, PromptTemplate evaluation with context and response columns, batch evaluation with run_evals, and Phoenix UI for trace visualization and span exploration.
Claude Code for Outlines: Guaranteed Structured LLM Outputs
Generate guaranteed structured outputs from local LLMs with Outlines and Claude Code — outlines.generate.json for JSON schema-constrained generation, outlines.generate.regex for regular expression-constrained text, outlines.generate.choice for multiple choice classification, outlines.generate.text for unconstrained generation, Pydantic BaseModel and JSON Schema integration with outlines.generate.json, outlines.models.transformers for local Hugging Face model loading, outlines.models.vllm and outlines.models.llamacpp for inference backends, token-level constrained decoding without post-processing or retries, and FSM-based finite state machine grammar for structured outputs.
Claude Code for LiteLLM: Universal LLM Gateway
Call any LLM with one API using LiteLLM and Claude Code — litellm.completion with provider prefix routing for OpenAI Anthropic Gemini Cohere Mistral and 100 plus LLM providers, LiteLLM proxy server for centralized API key management and rate limiting, load balancing with Router across multiple models and providers, budget and rate limit enforcement with budget_manager, fallback chains with fallbacks parameter for reliability, streaming responses with stream true and delta content, async completion with acompletion, cost tracking with completion_cost and get_cost_summary, model aliases and virtual keys for enterprise routing, and OpenAI-compatible proxy endpoint for drop-in replacement.
Claude Code for Instructor: Structured LLM Outputs
Extract structured data from LLMs with Instructor and Claude Code — instructor.from_anthropic and instructor.from_openai for patching clients with structured output support, Pydantic BaseModel schemas for response validation, Field with description and constraints for LLM guidance, Literal and Enum for classification, nested models for complex hierarchies, retry logic with max_retries and ValidationContext, streaming partial models with create_partial, batch extraction with Iterable for list responses, async extraction with from_anthropic async client, mode selection with Mode.JSON and Mode.TOOLS and Mode.ANTHROPIC_TOOLS, and TypeScript Zod schema integration with instructor-js.
Claude Code for Langfuse: LLM Observability and Tracing
Observe and debug LLM applications with Langfuse and Claude Code — Langfuse Python SDK with langfuse.trace and langfuse.span for distributed tracing, langfuse.generation for token usage and cost tracking, decorator-based tracing with observe decorator, LangChain integration via CallbackHandler, LlamaIndex integration via LlamaIndexCallbackHandler, prompt management with langfuse.get_prompt for versioned prompts, datasets and evaluation runs for systematic LLM testing, user and session tracking for production analytics, score API for custom evaluation metrics, and Langfuse self-hosted Docker deployment with NEXTAUTH_SECRET and DATABASE_URL configuration.
Claude Code for PyTorch Lightning: Scalable Model Training
Train PyTorch models at scale with Lightning and Claude Code — LightningModule with training_step validation_step configure_optimizers and forward for model encapsulation, LightningDataModule with setup train_dataloader and val_dataloader for data pipelines, Trainer with accelerator devices strategy max_epochs gradient_clip_val and precision for hardware-agnostic training, Callbacks with ModelCheckpoint EarlyStopping LearningRateMonitor and custom hooks, Lightning Fabric for fine-grained control without full LightningModule, multi-GPU DDP and FSDP strategies, mixed precision with precision 16-mixed and bf16-mixed, logging with TensorBoardLogger WandbLogger and CSVLogger, and LightningCLI for YAML-driven experiment configuration.
Claude Code for Chainlit: LLM Chat Applications
Build production LLM chat apps with Chainlit and Claude Code — cl.on_message for handling incoming messages, cl.Message with content and elements for rich responses, cl.Step for multi-step agent reasoning display, cl.Action with callback for interactive buttons, cl.user_session for per-user state storage, cl.on_chat_start for session initialization and welcome messages, cl.File cl.Image cl.Text cl.Pdf elements for rich content, streaming responses with cl.Message.stream_token, authentication with cl.oauth_callback and cl.password_auth_callback, LangChain and LlamaIndex callback integration with ChainlitCallbackHandler, and Chainlit config.toml for branding and feature configuration.
Claude Code for Streamlit: Data Apps and ML Dashboards
Build data apps with Streamlit and Claude Code — st.write st.dataframe st.plotly_chart st.altair_chart for data visualization, st.sidebar for navigation controls, st.session_state for persistent state across reruns, st.cache_data and st.cache_resource for expensive computation caching, st.chat_message and st.chat_input for chatbot UIs, st.file_uploader for CSV and image upload, st.columns and st.tabs for layout, st.form with st.form_submit_button for batch inputs, st.spinner and st.progress for user feedback, st.experimental_rerun for programmatic reruns, multi-page apps with pages directory and st.navigation, and Streamlit Community Cloud deployment.
Claude Code for Gradio: ML Demo UIs in Minutes
Build ML demo interfaces with Gradio and Claude Code — gr.Interface for zero-boilerplate function wrapping with input and output component auto-detection, gr.Blocks for multi-component layout with Row Column Tab and Accordion, gr.ChatInterface for LLM chatbot UIs with message history, gr.Image gr.Audio gr.Video gr.File gr.Dataframe and gr.Plot components, gr.State for session-persistent state, streaming outputs with gr.update and yield, event listeners with btn.click and textbox.submit and change, Gradio API for programmatic access with client.predict, HuggingFace Spaces deployment, and custom CSS theming with gr.themes.
Claude Code for Diffusers: Stable Diffusion and Image Generation
Generate and fine-tune diffusion models with HuggingFace Diffusers and Claude Code — StableDiffusionPipeline and StableDiffusionXLPipeline for text-to-image generation, StableDiffusionImg2ImgPipeline and StableDiffusionInpaintPipeline for image editing, ControlNetModel with ControlNetPipeline for pose and depth conditioned generation, DreamBooth fine-tuning with DreamBoothTrainer, LoRA adapter training for SDXL with train_dreambooth_lora_sdxl, UNet2DConditionModel and DDPMScheduler for custom diffusion loops, scheduler swapping with EulerAncestralDiscreteScheduler and DPMSolverMultistepScheduler, memory optimization with enable_attention_slicing enable_sequential_cpu_offload and enable_xformers_memory_efficient_attention, FLUX pipeline for state-of-the-art generation, and TypeScript inference client for diffusion API endpoints.
Claude Code for NVIDIA NeMo: Speech and NLP Models
Build speech and NLP models with NVIDIA NeMo and Claude Code — NeMo ASR with EncDecCTCModelBPE and EncDecRNNTBPEModel for automatic speech recognition, NeMo TTS with FastPitch and HifiGan for text-to-speech synthesis, NLP with MegatronGPTModel and MegatronT5Model for LLM training and fine-tuning, Hydra configuration with DictConfig and OmegaConf for experiment management, NeMo data manifests for audio transcription pairs, CTC decoder with Beam CTC decoder and language model, RNNT transducer architecture, NeMo model restoration from ngc and HuggingFace, NeMo logging with exp_manager and Weights and Biases integration, and distributed training with PyTorch Lightning and Megatron parallelism.
Claude Code for Apple MLX: LLM Inference on Apple Silicon
Run and fine-tune LLMs on Apple Silicon with MLX and Claude Code — mlx.core arrays with unified CPU and GPU memory, mlx.nn module definitions with Linear Conv2d Embedding MultiHeadAttention and LayerNorm, mlx.optimizers SGD Adam and AdamW, mlx.core.grad and value_and_grad for automatic differentiation, mlx.core.compile for graph compilation, mlx-lm for Llama Mistral Phi Gemma inference and fine-tuning with LoRA, mlx.core.metal for GPU stream management, quantization with mlx.core.quantize for 4-bit and 8-bit weights, convert_weights from PyTorch to MLX safetensors format, and mlx-lm generate command for local Apple Silicon inference.
Claude Code for TensorRT: GPU Inference Optimization
Optimize model inference with TensorRT and Claude Code — TensorRT engine building from ONNX with trt.Builder and trt.NetworkDefinitionCreationFlag EXPLICIT_BATCH, IBuilderConfig with fp16 and int8 precision modes, INT8 calibration with IInt8EntropyCalibrator2, trt.Runtime engine deserialization and IExecutionContext for inference, dynamic shapes with optimization profiles and set_input_shape, Polygraphy for engine inspection and comparison, torch2trt and TensorRT Python API for direct PyTorch model conversion, TensorRT plugin for custom layer registration, batch inference with CUDA streams, and ONNX export with dynamic axes for variable batch size.
Claude Code for JAX and Flax: Functional ML on TPUs
Train neural networks with JAX and Flax and Claude Code — jax.grad and jax.jit and jax.vmap for automatic differentiation and JIT compilation and vectorization, jax.pmap for multi-device data parallelism across TPU pods, Flax NNX and Linen module definitions with nn.Dense nn.Conv and nn.MultiHeadDotProductAttention, Flax train state with optax optimizers, jax.numpy as drop-in NumPy replacement, lax.scan for memory-efficient recurrence and lax.fori_loop for device loops, JAX random key splitting with jax.random.PRNGKey and jax.random.split, sharding with PartitionSpec and mesh and shard_map for tensor parallelism, and NNX graph tracing for stateful training loops.
Claude Code for Triton: Custom GPU Kernels in Python
Write custom GPU kernels with Triton and Claude Code — triton.jit decorator for JIT-compiled GPU programs, tl.program_id and tl.load and tl.store for block-parallel memory access, tl.dot for tensor core matrix multiplication, tl.arange and tl.where for masked loads, Triton autotuner with triton.autotune and triton.Config for optimal block sizes, online softmax fused kernel, layer normalization kernel with tl.sum tl.sqrt, fused attention kernel replacing Flash Attention, debugging with tl.debug_barrier and triton.testing.assert_close, and benchmarking with triton.testing.Benchmark for latency and GBps throughput comparison.
Claude Code for Flash Attention: Fast Transformer Training
Speed up transformer training with Flash Attention and Claude Code — flash_attn_func and flash_attn_varlen_func for fused attention kernels, FlashAttention2 integration with HuggingFace Transformers via attn_implementation flash_attention_2, memory-efficient attention without O(n²) intermediate activations, Flash Attention 3 for H100 GPUs with fp8 support, positional encoding with ALiBi and RoPE via flash_attn_with_kvcache, causal attention mask with causal true parameter, packed variable-length sequences with cu_seqlens, sliding window attention with window_size, Triton flash attention implementation, and installation requirements for CUDA 11.6 and PyTorch 2.0.
Claude Code for Axolotl: Config-Driven LLM Fine-Tuning
Fine-tune LLMs with Axolotl and Claude Code — YAML config-driven training with base_model and model_type and tokenizer_type, LoRA and QLoRA adapter configuration with adapter and lora_r and lora_alpha, dataset format support for alpaca and sharegpt and completion and instruction and chat_template, DeepSpeed and FSDP integration via deepspeed config path, Flash Attention 2 with flash_attention true, gradient checkpointing and gradient accumulation, Axolotl preprocessing with push_dataset_to_hub, multi-dataset mixing with dataset weights, sample packing for efficient sequence utilization, and CLI commands for train preprocess merge-lora and inference.
Claude Code for Unsloth: 2x Faster LLM Fine-Tuning
Fine-tune LLMs 2x faster with Unsloth and Claude Code — FastLanguageModel.from_pretrained for loading Llama Mistral Phi Gemma with 4-bit quantization, get_peft_model with LoRA rank and target modules, UnslothTrainer and SFTTrainer with UnslothTrainingArguments for memory-efficient training, chat template application with get_chat_template for Llama-3 ChatML Alpaca Zephyr templates, dataset formatting with standardize_sharegpt and apply_chat_template, Unsloth gradient checkpointing with 30% less memory, saving model as GGUF for Ollama and llama.cpp with quantization methods q4_k_m and q8_0, and pushing fine-tuned adapters to HuggingFace Hub.
Claude Code for DeepSpeed: Distributed LLM Training
Train large language models at scale with DeepSpeed and Claude Code — ZeRO optimizer stages 0 through 3 for memory partitioning across GPUs, ds_config.json with zero_optimization and optimizer and scheduler and fp16 settings, deepspeed.initialize for wrapping model and optimizer, HuggingFace Trainer integration via TrainingArguments deepspeed parameter, Accelerate DeepSpeedPlugin for multi-GPU training loops, pipeline parallelism with PipelineModule, gradient checkpointing for activation memory reduction, offload_optimizer and offload_param to CPU or NVMe, deepspeed launch CLI for multi-node training, and mixed precision bf16 and fp16 training.
Claude Code for TRL: RLHF and SFT for LLM Training
Train and align LLMs with TRL and Claude Code — SFTTrainer for supervised fine-tuning with instruction datasets and chat templates, RewardTrainer for training reward models on preference pairs, PPOTrainer for reinforcement learning from human feedback with reference model, DPOTrainer for direct preference optimization without RL, ORPOTrainer for odds ratio preference optimization, PEFT and LoRA integration for memory-efficient training, Gaudi and multi-GPU support, TRL dataset formatting utilities for chosen and rejected pairs, and training configuration with SFTConfig and DPOConfig.
Claude Code for PEFT and LoRA: Efficient LLM Fine-Tuning
Fine-tune large language models efficiently with PEFT and LoRA and Claude Code — LoraConfig for rank and alpha and target modules configuration, get_peft_model for wrapping HuggingFace models with LoRA adapters, QLoRA with BitsAndBytesConfig for 4-bit quantized fine-tuning, prompt tuning and prefix tuning with PeftConfig, merging LoRA weights back into the base model, saving and loading adapter weights, training with HuggingFace Trainer and SFTTrainer, gradient checkpointing for memory efficiency, and TypeScript inference client for fine-tuned models.
Claude Code for Cleanlab: Data Quality for ML
Fix data quality issues with Cleanlab and Claude Code — Cleanlab find_label_issues for detecting mislabeled training data in classification datasets, get_label_quality_scores for per-sample quality rankings, Datalab for comprehensive data issue detection including outliers near-duplicates and data drift, cleanlab.filter for removing low-quality samples, Cleanlab Studio for no-code data curation, integration with scikit-learn PyTorch and HuggingFace for model-based label error detection, confident learning theory for noisy label correction, and TypeScript REST API for Cleanlab Studio project management.
Claude Code for Argilla: NLP and LLM Data Annotation
Annotate NLP and LLM data with Argilla and Claude Code — Argilla dataset creation with FeedbackDataset and Settings for LLM preference labeling and text classification and named entity recognition, record ingestion with Record and TextField and RatingQuestion and LabelQuestion, annotator workflows with Suggestions from model pre-labels, Argilla Python SDK v2 for datasets and records management, filtering and querying annotated records, exporting to HuggingFace datasets for fine-tuning, Argilla Cloud and self-hosted Docker setup, and TypeScript REST client for record management.
Claude Code for Roboflow: Computer Vision Dataset Management
Build computer vision pipelines with Roboflow and Claude Code — Roboflow Python SDK for dataset access and augmentation, workspace and project management with roboflow.workspace and project.version, image preprocessing and augmentation pipelines with flip rotate crop resize and mosaic, YOLOv8 and YOLOv11 training with ultralytics from Roboflow datasets, custom model deployment to Roboflow Hosted API and edge devices, active learning with add_images and train workflows, dataset export in YOLO COCO Pascal VOC and TensorFlow formats, and TypeScript inference client for Roboflow Hosted API predictions.
Claude Code for Label Studio: Data Labeling and Annotation
Annotate data for ML with Label Studio and Claude Code — Label Studio setup with Docker and Python SDK, project creation with labeling configuration XML for text classification image segmentation and NER named entity recognition, task import from JSON CSV and cloud storage S3, annotation export in JSON and YOLO and COCO formats, Label Studio ML backend for pre-labeling with model predictions, webhook integration for annotation complete events, active learning loop with model predictions and human review, and TypeScript REST API client for project and task management.
Claude Code for ClearML: Open-Source MLOps Platform
Manage the full ML lifecycle with ClearML and Claude Code — Task for experiment tracking with automatic parameter and metric capture, clearml.Logger for manual metric and image and artifact logging, Dataset for data versioning and lineage with get_or_create and upload and finalize, ClearML Pipelines with PipelineDecorator for step-based ML workflows, Model for central model registry with published versions and tags, HPO with HyperParameterOptimizer using Optuna and RandomSearch strategies, clearml-agent for distributed task execution on cloud and on-prem, and TypeScript API for querying experiments.
Claude Code for Comet ML: Experiment Tracking and Model Registry
Track ML experiments with Comet ML and Claude Code — comet_ml Experiment for run initialization with workspace and project, log_parameters and log_metric and log_metrics for hyperparameter and metric logging, log_model for artifact registration, confusion matrices and ROC curves with log_confusion_matrix and log_curve, dataset hashing with log_dataset_hash, Comet Optimizer for hyperparameter sweeps with Bayesian and grid search, Model Registry with register_model and production stage transitions, Comet LLM for LLM prompt and chain tracing, and TypeScript REST client for querying experiments.
Claude Code for Neptune.ai: ML Experiment Tracking
Track ML experiments with Neptune.ai and Claude Code — neptune.init_run for experiment initialization with tags and description, run tracking with log_metric and log_params and log_artifact, series logging for training curves, Neptune model registry with ModelVersion for production model management, integration with scikit-learn PyTorch LightGBM XGBoost and HuggingFace, custom metadata namespaces with Neptune Struct, artifact versioning with file hashes, run comparison queries with the Neptune Python client, and TypeScript REST API for embedding Neptune in dashboards.
Claude Code for whylogs: Data Logging and Profiling
Profile and monitor data with whylogs and Claude Code — whylogs DatasetProfile for statistical profiling of pandas DataFrames and images and text, column statistics with count distinct min max mean standard deviation and quantiles, constraint checks for data validation, whylogs Logger for continuous streaming logging, WhyLabs integration for cloud-based monitoring and alerting, drift detection with profile comparison, custom metrics and resolvers, segment profiling by categorical feature, and TypeScript profile reader for JSON profile files.
Claude Code for Metaflow: AWS ML Workflow Orchestration
Build scalable ML workflows with Metaflow and Claude Code — Metaflow FlowSpec with @step decorators for defining ML pipeline steps, @batch and @resources for AWS Batch cloud execution, @kubernetes for Kubernetes execution, @conda and @pypi for per-step dependency isolation, @retry and @timeout for fault tolerance, @catch for error handling, @parallel for fan-out execution, foreach for dynamic parameter sweeps, artifacts for automatic data versioning, and card decorators for rich step visualization and model cards.
Claude Code for Evidently: ML Model Monitoring
Monitor ML models and data quality with Evidently and Claude Code — Evidently Report for data drift and target drift and data quality analysis, Test Suites with TestSuite and individual tests for pass fail thresholds, column mapping for regression and classification and ranking tasks, Evidently monitoring panels and snapshots for continuous production monitoring, integration with MLflow for artifact storage, Grafana and Prometheus metrics export, custom tests and metrics with Python, and TypeScript REST API for embedding reports in dashboards.
Claude Code for ZenML: Production ML Pipelines
Build production ML pipelines with ZenML and Claude Code — ZenML steps with @step decorator for typed inputs and outputs, ZenML pipelines with @pipeline decorator connecting steps, artifact versioning and lineage tracking, stack components for orchestrators and artifact stores and model deployers, ZenML Stack with local Airflow Kubeflow and SageMaker orchestrators, Model Control Plane for model registration and deployment, ZenML Server for team collaboration, integration with MLflow and W&B and BentoML, and YAML configuration for cloud stacks.
Claude Code for DVC: Data Version Control for ML
Version control ML data and models with DVC and Claude Code — dvc init and dvc add for tracking large data files in Git, dvc remote for S3 GCS Azure Blob storage, dvc push and dvc pull for syncing data, DVC pipelines with dvc.yaml stage definitions for reproducible ML workflows, dvc repro for re-running changed pipeline stages, dvc params and dvc metrics for experiment comparison, dvc exp run for iterating experiments, DVCLive for real-time metric logging, and CI/CD integration with GitHub Actions for data validation.
Claude Code for Optuna: Hyperparameter Optimization
Optimize ML hyperparameters with Optuna and Claude Code — Optuna Study with TPE and CmaEs and Random samplers for objective function optimization, trial suggest methods for float int categorical parameters, pruning with MedianPruner and HyperbandPruner for early stopping, parallel optimization with multiprocessing and distributed storage backends, Optuna Dashboard for visualization, integration with scikit-learn PyTorch LightGBM XGBoost and HuggingFace Trainer, optuna-integration callbacks, MLflow and W&B logging, and best params extraction and model retraining.
Claude Code for Weights & Biases: ML Experiment Tracking
Track ML experiments with Weights and Biases and Claude Code — wandb.init for run initialization with config and tags, wandb.log for metrics and plots and media, wandb.Artifact for dataset and model versioning, W&B Sweeps for distributed hyperparameter search with Bayesian and grid and random strategies, W&B Tables for comparing predictions and data, custom charts with wandb.plot, callbacks for PyTorch and TensorFlow and HuggingFace and sklearn, W&B Launch for running jobs on cloud compute, and TypeScript API client for querying run results.
Claude Code for Azure Machine Learning: ML Platform on Azure
Train and deploy ML models with Azure Machine Learning and Claude Code — Azure ML workspace and compute clusters for training jobs, Environment and ScriptRunConfig for custom containers, MLflow autolog integration for experiment tracking, Model Registry for versioned model management, Online Endpoint and Batch Endpoint for inference, Azure ML Pipelines with PipelineJob, Managed Online Endpoint for real-time prediction with traffic splitting, Azure ML CLI v2 YAML job specs, Feature Store for feature engineering, and Python SDK v2 with TypeScript REST client.
Claude Code for Vertex AI: Google Cloud ML Platform
Train and deploy ML models with Google Vertex AI and Claude Code — Vertex AI Workbench and Custom Training jobs with pre-built containers, Model Registry for versioned model management, Vertex AI Endpoints for online prediction with autoscaling, Batch Prediction jobs for offline scoring, Vertex AI Pipelines with Kubeflow Pipelines SDK, Vertex Feature Store for online and batch feature serving, Model Evaluation and Explainability, Vertex AI Model Garden for foundation models, and Python Vertex AI SDK with TypeScript prediction client.
Claude Code for AWS SageMaker: ML Model Training and Deployment
Train and deploy ML models with AWS SageMaker and Claude Code — SageMaker Estimator for training jobs with custom containers and built-in algorithms, SageMaker Model and Endpoint for real-time inference, Batch Transform for offline scoring, SageMaker Pipelines for ML workflow orchestration, Model Registry for versioned model approval, SageMaker Feature Store for online and offline feature retrieval, A/B testing with production variants, autoscaling endpoint policies, and Boto3 and SageMaker Python SDK patterns.
Claude Code for KServe: Kubernetes-Native Model Serving
Deploy ML models on Kubernetes with KServe and Claude Code — InferenceService CRD for declarative model deployment, KServe predictor specs for sklearn TensorFlow PyTorch ONNX XGBoost and custom transformers, canary rollouts with traffic splitting, KServe Transformer for pre and post processing, explainability with AlibiExplainer, serverless autoscaling with Knative, multi-model serving with ModelMesh, monitoring with Prometheus metrics, and Python SDK for programmatic InferenceService management.
Claude Code for TorchServe: PyTorch Model Serving
Serve PyTorch models with TorchServe and Claude Code — TorchServe model archiver for packaging PyTorch models with handlers, BaseHandler and custom handler classes for preprocessing and inference and postprocessing, torchserve CLI for starting and managing the server, Management API and Inference API REST endpoints, batch inference configuration, model versioning and A/B testing with traffic splitting, TorchServe on Docker and Kubernetes, metrics collection with Prometheus, and TypeScript client for TorchServe inference endpoints.
Claude Code for Ray Serve: Distributed ML Model Serving
Scale ML inference with Ray Serve and Claude Code — Ray Serve deployment decorator for actor-based scaling, DeploymentHandle for model composition and multi-model pipelines, serve.ingress for FastAPI integration, fractional GPU allocation across replicas, traffic splitting for A/B testing and canary deployments, autoscaling with target_num_ongoing_requests_per_replica, ServeConfig and RayService for Kubernetes deployment, and TypeScript client for calling Ray Serve endpoints.
Claude Code for BentoML: ML Model Serving and Deployment
Serve ML models with BentoML and Claude Code — BentoML Service class with input and output schemas, runners for CPU and GPU model inference, Bentos for packaging models with dependencies, BentoML Cloud and Kubernetes deployment, multi-model pipelines with multiple runners, async batch inference, HTTP and gRPC endpoints, model store for versioned model artifacts, adaptive batching for throughput optimization, and TypeScript client for calling BentoML services.
Claude Code for Recce: dbt Model Review and Diff Tool
Review dbt model changes with Recce and Claude Code — Recce CI for comparing dbt production vs pull request environments, row count diffs and schema diffs and value diffs between environments, Recce Cloud for collaborative review in GitHub pull requests, recce run command for automated checks, Recce preset checks for query diffs and profile diffs and row count checks, GitHub Actions integration for automated Recce validation, Recce Python SDK for custom check logic, and best practices for dbt CI/CD with data impact review.
Claude Code for Elementary Data: dbt Data Observability
Add data observability to dbt with Elementary and Claude Code — Elementary dbt package for anomaly detection and schema changes and volume monitoring, elementary_tests for column anomalies and freshness and distribution checks, Elementary CLI for generating reports, Elementary Cloud for centralized observability, Slack alerts for data issues, Python SDK for querying Elementary tables, custom monitors with dbt macros, and automated data quality alerts in CI/CD dbt pipelines.
Claude Code for Soda: Data Quality Checks as Code
Validate data quality with Soda and Claude Code — Soda checks YAML with SodaCL check language, numeric and freshness and validity and schema checks, Soda Cloud for centralized results and notifications, Soda Core Python library for programmatic check execution, warehouse connections for BigQuery Snowflake Postgres DuckDB, Soda scan command and Python scan API, anomaly detection checks, custom SQL checks, Soda actions for Slack and PagerDuty alerts, and CI/CD pipeline data quality gates.
Claude Code for Observable Framework: Data Apps with JavaScript
Build interactive data applications with Observable Framework and Claude Code — Observable Markdown pages with reactive JavaScript cells, Plot for data visualization, DuckDB WASM for SQL in the browser, data loaders with Node.js Python R for server-side data fetching, FileAttachment API for CSV and JSON and Parquet, live reload development server, deploying to Observable Cloud and Netlify, inputs for interactivity, and TypeScript data loaders with type-safe output.
Claude Code for Lightdash: Open Source BI on dbt Models
Build BI dashboards with Lightdash and Claude Code — Lightdash YAML metrics defined in dbt schema.yml alongside models, dimensions and metrics with filters, custom dimensions with sql expressions, dashboards and saved charts via Lightdash API, Lightdash CLI for validating metric definitions, embedding charts with SSO tokens, Lightdash Cloud vs self-hosted Docker deployment, REST API for programmatic chart creation, and Next.js embed integration with Lightdash iframes.
Claude Code for Cube: Semantic Layer and Headless BI
Build semantic layers with Cube and Claude Code — Cube data models with measures and dimensions and segments, joins and relationship types, pre-aggregations for query acceleration, REST API and GraphQL API for frontend analytics, Cube Store for pre-aggregation caching, multi-tenancy with row-level security and tenant contexts, computed measures with SQL expressions, drill-through and sub-queries, Cube SQL interface for BI tools, and Next.js embedded analytics with Cube JavaScript client.
Claude Code for Evidence: Data Apps with Markdown and SQL
Build data applications with Evidence and Claude Code — Evidence Markdown pages with embedded SQL queries, component library with Charts and DataTable and Value and BigValue, connecting to DuckDB Snowflake BigQuery Postgres and CSV sources, source queries in YAML, parameterized pages with URL params, templated pages for dynamic routes, partials for reusable components, Evidence deployment to Netlify and Vercel, custom themes and layouts, and expression syntax with template literals in Markdown.
Claude Code for SQLMesh: Next-Generation SQL Transformation
Build SQL transformation pipelines with SQLMesh and Claude Code — SQLMesh models with grain and partitioning and incremental_by_unique_key strategies, Python models for complex transformations, audit and test assertions, semantic layer with metrics and dimensions, virtual environments for safe schema promotion, plan and apply workflow for CI/CD, SQLGlot transpilation between dialects, dbt compatibility mode for migration, state management with SQLMesh Hub, and TypeScript client for SQLMesh Cloud API.
Claude Code for dlt: Python Data Load Tool for ELT Pipelines
Build ELT pipelines with dlt (data load tool) and Claude Code — dlt pipeline with source and resource decorators, REST API source with pagination and authentication, incremental loading with cursor fields and merge write disposition, schema inference and evolution, destinations for BigQuery Snowflake DuckDB Postgres Redshift, transformers for nested data, pipeline state management, dlt hub for community sources, normalizer configuration and column hints, and GitHub Actions pipeline automation.
Claude Code for DataHub: Data Catalog and Metadata Management
Build data catalogs with DataHub and Claude Code — DataHub Python SDK for emitting metadata with MetadataChangeProposalWrapper and DatasetProperties and SchemaMetadata, lineage emission with DataJobInputOutput and UpstreamLineage, REST API for search and entity retrieval, DataHub Recipes for connector-based ingestion of Postgres and Snowflake and dbt and Glue, custom properties and tags and glossary terms, ownership assignment, GraphQL API for metadata queries, and automated metadata pipeline with Python emitter.
Claude Code for Trino: Distributed SQL Query Engine
Query data lakes with Trino and Claude Code — Trino Python client with trino.dbapi and trino.auth, catalog and schema configuration for Hive and Iceberg and Delta and S3 connectors, federated queries across PostgreSQL and MySQL and Kafka and Elasticsearch, JDBC connection strings, Trino REST API for query submission and status polling, performance tuning with cost-based optimizer and partition pruning and predicate pushdown, SQL on S3 with Hive connector, and Next.js analytics backend with Trino query client.
Claude Code for Feast: Feature Store for Machine Learning
Build ML feature stores with Feast and Claude Code — Feast feature definitions with FeatureView and Entity and FeatureService, online store for low-latency serving with Redis or DynamoDB, offline store for historical training data with BigQuery S3 Parquet, materialization to sync batch features online, point-in-time correct joins for training datasets, Python SDK for get_online_features and get_historical_features, feast apply for registry deployment, streaming feature ingestion with PushSource, and FastAPI serving endpoint for real-time feature retrieval.
Claude Code for Apache Arrow: In-Memory Columnar Data Processing
Process columnar data with Apache Arrow and Claude Code — PyArrow Table and RecordBatch for zero-copy in-memory operations, Arrow IPC format for fast serialization, Parquet read and write with PyArrow, compute functions for vectorized operations, Arrow Flight for high-speed data transfer, DataFusion SQL engine on Arrow data, Polars integration via Arrow, schema definition and casting, chunked arrays and memory pooling, and Node.js Arrow JS for analytics in TypeScript.
Claude Code for Delta Lake: ACID Transactions on Data Lakes
Build lakehouse tables with Delta Lake and Claude Code — delta-rs Python and Rust library for ACID writes and reads, DeltaTable for reading snapshots and time travel, write_deltalake for Parquet-based ACID writes, Change Data Feed for CDC pipelines, Z-order clustering for query optimization, OPTIMIZE and VACUUM operations, schema enforcement and evolution, Databricks Delta Live Tables, merge for upserts, and Next.js REST API backed by delta-rs for analytics.
Claude Code for Apache Iceberg: Open Table Format for Data Lakes
Build lakehouse architectures with Apache Iceberg and Claude Code — Iceberg table format with hidden partitioning and partition evolution, PyIceberg Python client for reading and writing Iceberg tables, time travel queries with snapshot IDs and timestamps, schema evolution with add and rename and drop columns, catalog integration with AWS Glue and REST and Hive, S3 and GCS and ADLS storage backends, Spark and DuckDB integration, Z-order optimization, and compaction for small file management.
Claude Code for Great Expectations: Data Quality Validation
Validate data quality with Great Expectations and Claude Code — Expectation Suites and DataContext setup, built-in expectations for column values and nulls and uniqueness and distributions, custom Expectations with column_map_condition, Checkpoints for pipeline integration, Data Docs for HTML validation reports, Pandas and Spark DataFrames as batches, SQLAlchemy datasource for database validation, Fluent configuration API, and automated data quality gates in CI/CD pipelines.
Claude Code for Redpanda: Kafka-Compatible Event Streaming
Build event streaming with Redpanda and Claude Code — Redpanda as Kafka-compatible broker with no ZooKeeper and lower latency, KafkaJS producer and consumer connecting to Redpanda, Redpanda Console for topic management, Schema Registry for Avro and JSON Schema, rpk CLI for topic and consumer group management, Redpanda Connect for data pipelines, Wasm transform functions, and Next.js producer connecting to self-hosted or Redpanda Cloud.
Claude Code for VictoriaMetrics: High-Performance Metrics Storage
Store and query metrics with VictoriaMetrics and Claude Code — VictoriaMetrics remote write endpoint as Prometheus drop-in, MetricsQL extensions beyond PromQL, vminsert and vmselect and vmstorage cluster architecture, victorialogs for log storage, vmagent for lightweight scraping and relabeling, vmauth for metrics proxying, retention policies and downsampling configuration, vmctl for data migration, and Node.js prom-client with VictoriaMetrics remote write.
Claude Code for Airbyte: ELT Data Integration and Connectors
Build data integration pipelines with Airbyte and Claude Code — Airbyte API for programmatic connection management, custom Python connectors with Source and Stream classes, incremental sync with cursor fields, full refresh vs incremental sync modes, destination loading patterns, Airbyte CDK for connector development, connection scheduling, Airbyte Cloud vs self-hosted OSS, PyAirbyte for embedded ELT in Python scripts, and Next.js integration with Airbyte Platform API.
Claude Code for Dagster: Data Pipeline Orchestration
Orchestrate data pipelines with Dagster and Claude Code — asset-based pipelines with @asset and AssetExecutionContext, multi-asset transformations, IOManagers for custom storage, Resources for database and API connections, Schedules and Sensors for triggering, Partitions for incremental processing, asset lineage and metadata, Definitions assembly, dbt integration with load_assets_from_dbt_project, embedded ELT patterns, and TypeScript REST client for Dagster run API.
Claude Code for InfluxDB: Time Series Data and IoT Metrics
Store and query time series data with InfluxDB and Claude Code — InfluxDB v3 client with write and query APIs, line protocol format for high-throughput writes, Flux query language for time series analysis, SQL queries in InfluxDB v3, bucket management, downsampling with continuous queries, retention policies, telegraf agent configuration, and Next.js time series API with InfluxDB write and query client.
Claude Code for OpenTelemetry: Distributed Tracing and Observability
Build distributed tracing with OpenTelemetry and Claude Code — NodeSDK with multiple exporters, trace.getTracer for manual spans, context propagation with context.with and trace.setSpan, semantic conventions for HTTP and DB attributes, W3C traceparent header propagation, baggage API, metrics with metrics.getMeter Counter and Histogram and ObservableGauge, OTel Collector configuration, OTLP export to Jaeger and Grafana Tempo and Honeycomb, and Next.js instrumentation.ts setup.
Claude Code for Grafana and Prometheus: Metrics and Observability
Build observability stacks with Grafana and Prometheus and Claude Code — prom-client Node.js metrics with Counter and Gauge and Histogram and Summary, custom metrics endpoint, Grafana Dashboard JSON provisioning, Grafana Loki structured logging with pino-loki transport, alert rules with PromQL, recording rules, Alertmanager routes and receivers, remote write to Grafana Cloud, and Next.js metrics instrumentation with prom-client.
Claude Code for Retool: Internal Tools and Admin Panels
Build internal tools with Retool and Claude Code — Retool API for programmatic resource creation, Retool Workflows for backend automation with steps and triggers, Retool DB for lightweight PostgreSQL, custom components with Retool SDK and useRetoolState, REST API queries and SQL queries in Retool, transformers for data transformation in JavaScript, environment variables for staging and production, Retool Mobile for native apps, and connecting Claude Code backends to Retool frontends.
Claude Code for Metabase: Embedded Analytics and Dashboards
Embed analytics with Metabase and Claude Code — Metabase Embedding SDK with MetabaseProvider and StaticQuestion and InteractiveQuestion, JWT signed embedding tokens with secret key, public sharing links, Metabase API for questions and dashboards and collections, programmatic question creation with card API, database connection management, custom themes with theme overrides, React component embedding, and Next.js embedded analytics dashboard with Metabase SDK.
Claude Code for RabbitMQ: Message Queues and Work Queues
Build message queue systems with RabbitMQ and Claude Code — amqplib connection and channel setup, direct and fanout and topic and headers exchange types, durable queues and persistent messages, acknowledgments and nack for error handling, prefetch for consumer concurrency control, dead letter exchanges, delayed message plugin, RPC pattern with correlationId and replyTo, publisher confirms for guaranteed delivery, AMQP over TLS, and Next.js background job processor with RabbitMQ.
Claude Code for Apache Kafka: Event Streaming at Scale
Build event streaming pipelines with Apache Kafka and Claude Code — KafkaJS producer and consumer setup, message serialization with Avro and JSON Schema, consumer groups and partition assignment, exactly-once semantics with idempotent producer, manual offset management, dead letter queues, Kafka Streams equivalent with KafkaJS transforms, Schema Registry integration, SSL and SASL authentication, Confluent Cloud connection, and Next.js Kafka producer for real-time event publishing.
Claude Code for MotherDuck: Serverless DuckDB in the Cloud
Run analytical SQL with MotherDuck and DuckDB and Claude Code — MotherDuck connection with motherduck token, DuckDB WASM in the browser, in-process OLAP queries on Parquet and CSV and JSON files, window functions and aggregations, httpfs extension for reading remote files, attach MotherDuck cloud database for serverless persistence, sharing databases via md share, DuckDB Node.js binding, and Next.js analytics API powered by MotherDuck.
Claude Code for PlanetScale: Serverless MySQL with Branching
Build scalable apps with PlanetScale and Claude Code — PlanetScale serverless driver with @planetscale/database for edge-compatible SQL, Prisma with PlanetScale provider, schema deploy requests for safe migrations, database branching for development and preview environments, connection string setup, PlanetScale bulk import, Drizzle ORM with MySQL2 dialect, non-blocking schema changes, and Next.js edge-compatible data fetching with PlanetScale.
Claude Code for Xata: Serverless Database with Search and AI
Build apps with Xata and Claude Code — Xata client init with xata.config.ts, typed table operations with getRecord and create and update and delete, searching with search and summarize, vector search for semantic similarity, AI ask feature with natural language queries over your data, branch-based schema migrations, file attachments, filtering with filter and sort and pagination, and Next.js full-stack app with Xata typed client.
Claude Code for CockroachDB: Distributed SQL at Global Scale
Build globally distributed apps with CockroachDB and Claude Code — CockroachDB Serverless connection with DATABASE_URL, Prisma ORM with CockroachDB provider, multi-region tables with REGIONAL BY ROW, global tables for reference data, locality-optimized searches, node-postgres pg client with SSL, database migrations with cockroach sql, CRDB-specific SQL features like UPSERT and ON CONFLICT, changefeeds for CDC, and Next.js multi-region app with CockroachDB.
Claude Code for Render: Zero-Ops Cloud Hosting
Deploy web services and databases with Render and Claude Code — render.yaml Infrastructure as Code for web services and databases, automatic deploys from GitHub, environment variables and secret files, Render Postgres and Redis managed databases, private services for internal APIs, background workers, cron jobs with schedule, health checks and zero-downtime deploys, preview environments per PR, custom domains with automatic TLS, disk persistent storage, and Next.js deployment to Render.
Claude Code for LogRocket: Session Replay and Frontend Monitoring
Add session replay and frontend monitoring with LogRocket and Claude Code — LogRocket.init with appID and options, identify for user context, track for custom events, Redux middleware for state capture, log for custom developer notes, network request recording, privacy controls with shouldSanitizeURL and redactedRequestHeaders, LogRocket React plugin, performance monitoring with getSessionURL for support workflows, and Next.js App Router LogRocket integration.
Claude Code for OpenReplay: Open-Source Session Replay
Add self-hosted session replay with OpenReplay and Claude Code — OpenReplay Tracker init with projectKey, setUserID and setMetadata for user context, event method for custom events, issue tracking with OpenReplay issue tracker, network request recording with network plugin, Redux and Zustand state inspection plugins, performance monitoring plugin, Assist plugin for co-browsing, React error boundary integration, and Next.js App Router OpenReplay setup with privacy controls.
Claude Code for Amplitude: Behavioral Analytics and Experiments
Add behavioral product analytics with Amplitude and Claude Code — Amplitude browser SDK init with amplitude.init, setUserId and setUserProperties for identity, track events with amplitude.track, revenue tracking with Revenue object, Session Replay plugin, Amplitude Experiment for A/B testing with fetch and variant, group analytics for B2B SaaS, user property operations with Identify object, server-side Node.js SDK, and Next.js Amplitude provider with automatic page views.
Claude Code for Mixpanel: Product Analytics and Funnels
Add product analytics with Mixpanel and Claude Code — Mixpanel browser init with token, mixpanel.identify and mixpanel.people.set for user profiles, mixpanel.track for events with properties, mixpanel.time_event for duration tracking, mixpanel.track_links and track_forms for automatic DOM tracking, server-side Node.js Mixpanel with mixpanel.track and mixpanel.people.increment, group analytics for B2B, super properties with mixpanel.register, and Next.js Mixpanel analytics provider.
Claude Code for Segment: Customer Data Platform and Event Tracking
Build a customer data pipeline with Segment and Claude Code — Segment Analytics.js browser init with write key, identify calls with user traits, track events with properties, page calls for SPA routing, group calls for accounts, Segment Node.js SDK for server-side events, TypeScript typed analytics with analytics-next, destination filters and transformations, Segment Protocols for schema validation, Connections for sending data to warehouses and tools, and Next.js analytics middleware.
Claude Code for Highlight.io: Full-Stack Session Replay and Error Monitoring
Add session replay and error monitoring with Highlight.io and Claude Code — H.init for frontend setup, H.identify for user context, H.track for custom events, H.consumeError for manual error capture, backend Node.js SDK with Highlight.init and H.runWithHeaders, OpenTelemetry-based distributed tracing, React error boundary integration, Next.js API route instrumentation, privacy controls for masking sensitive fields, and network request recording.
Claude Code for Railway: Instant Cloud Deployments
Deploy full-stack apps instantly with Railway and Claude Code — Railway CLI init and deploy, railway.toml for build and start commands, environment variables and shared variables, Railway Postgres and Redis provisioning, private networking between services, deploy from GitHub with automatic deploys on push, PR preview environments, multi-service projects with inter-service communication, health checks and restart policies, Railway Crons for scheduled jobs, and Next.js full-stack deploy to Railway.
Claude Code for Fly.io: Deploy Anywhere with Anycast
Deploy full-stack apps globally with Fly.io and Claude Code — fly launch for app initialization, Dockerfile-based deployments, fly.toml configuration with services and health checks, fly deploy for zero-downtime rolling updates, Fly Machines API for dynamic VM provisioning, Fly Volumes for persistent storage, Fly Postgres managed database, private networking with .internal DNS, secrets management with fly secrets set, multi-region deployment, and Next.js deployment to Fly.io with fly deploy.
Claude Code for Modal: Serverless GPU Python Functions
Run GPU workloads with Modal and Claude Code — Modal App and Image setup, @app.function decorator with gpu and memory and timeout, modal.run for local execution, web_endpoint for HTTPS API deployment, periodic scheduling with @app.cron, remote function calls with .remote and .map.aio for parallel execution, model weights caching with modal.Volume, custom Docker images with pip installs, FastAPI integration with @app.asgi_app, and Claude Code as Python orchestrator for Modal GPU inference.
Claude Code for Axiom: Serverless Observability and Log Analytics
Add structured logging and observability with Axiom and Claude Code — Axiom SDK init with dataset ingestion, ingest JSON events, query with APL Axiom Processing Language, time-series aggregations and filters, tail logs in real time, OpenTelemetry tracing with Axiom exporter, Next.js logging middleware with Axiom, structured log contexts with trace IDs, Vercel Log Drain integration, and Axiom CLI for local development.
Claude Code for Cloudflare AI: Workers AI and AI Gateway
Run AI models at the edge with Cloudflare Workers AI and Claude Code — Workers AI binding with env.AI.run, text generation with Llama models, text embeddings with BGE models, image classification and object detection, speech recognition with Whisper, image generation, AI Gateway for caching and rate limiting and provider routing, streaming responses with ReadableStream, and Next.js edge API route powered by Cloudflare Workers AI.
Claude Code for Tinybird: Real-Time Analytics APIs
Build real-time analytics APIs with Tinybird and Claude Code — Tinybird REST API for data ingestion with Events API, Pipes for SQL transformation chains, publishing API endpoints from Pipes, query parameters for dynamic filtering, materialized views for pre-aggregation, Kafka connector for streaming data, dbt integration, Tinybird CLI for version-controlled development, and Next.js real-time analytics dashboard powered by Tinybird API endpoints.
Claude Code for Typesense: Open-Source Instant Search
Add sub-millisecond instant search with Typesense and Claude Code — Typesense SDK init, schema creation with fields and facets, import documents, search with query_by and filter_by and sort_by and facet_by, typo tolerance and prefix search, multi-search for simultaneous queries, geo search with coordinates, curations for pinning results, synonyms and stopwords, Typesense InstantSearch adapter with react-instantsearch, and Next.js Typesense search API route.
Claude Code for PartyKit: Real-Time Multiplayer Backends
Build multiplayer apps with PartyKit and Claude Code — PartyServer class with onConnect onMessage onClose lifecycle, room-based broadcasting with party.broadcast, connection state with party.storage set and get, PartySocket client WebSocket with reconnection, React usePartySocket hook, presence tracking with join and leave events, cursor sharing, collaborative document sync with Y.js and PartyKit provider, and Next.js multiplayer chat room with PartyKit.
Claude Code for Upstash: Serverless Redis and Kafka
Add serverless Redis and Kafka with Upstash and Claude Code — Upstash Redis SDK with get set del expire hset hgetall, Redis.fromEnv() for Vercel and Netlify auto-config, rate limiting with Ratelimit and slidingWindow and fixedWindow, QStash message queue with publishJSON and schedules and callbacks, Kafka producer and consumer with upstash-kafka, atomic pipelines and transactions, pub/sub with subscribe and publish, sorted sets for leaderboards, and Next.js edge-compatible caching with Redis.
Claude Code for AssemblyAI: Audio Intelligence and LeMUR
Transcribe and analyze audio with AssemblyAI and Claude Code — AssemblyAI SDK init, transcribe from URL and file upload, LeMUR for LLM questions over audio, speaker diarization with speaker_labels, sentiment analysis and entity detection, chapter summaries, PII redaction, content safety and profanity filtering, auto highlights, custom vocabulary, streaming real-time transcription with WebSocket, and Next.js transcription API route.
Claude Code for React Flow: Interactive Node-Based UIs
Build node graphs and workflow editors with React Flow and Claude Code — ReactFlow component with nodes and edges, useNodesState and useEdgesState hooks, custom node types with Handle for connection points, addEdge for connecting nodes, useReactFlow for programmatic pan and zoom and fitView, MiniMap and Controls and Background, NodeToolbar and NodeResizer, edge types straight and step and bezier, markers and animated edges, onConnect callback, and dagre auto-layout.
Claude Code for Meilisearch: Instant Search with Typo Tolerance
Add instant search with Meilisearch and Claude Code — MeiliSearch SDK init, index.search with filters and facets, addDocuments and updateSettings for searchableAttributes and filterableAttributes, typo tolerance and ranking rules, react-instantsearch with InstantSearch and SearchBox and Hits, multi-index federated search, geosearch with _geo filter, attribute highlighting, synonyms, stop words, and Next.js search API route.
Claude Code for Together AI: Open Models at Scale
Run open-source LLMs with Together AI and Claude Code — Together SDK init with OpenAI-compatible API, inference with Llama-3.3-70B and DeepSeek-R1, streaming completions with async iteration, function calling and tools, vision models with image inputs, embeddings with BAAI/bge-large-en-v1.5, Together Inference as an OpenAI drop-in replacement, serverless and dedicated endpoints, file uploads for fine-tuning, and batch inference for throughput.
Claude Code for Deepgram: Real-Time Speech-to-Text
Transcribe audio with Deepgram and Claude Code — Deepgram SDK init, prerecorded transcription from URL and buffer, live streaming transcription with WebSocket and ListenLiveClient, Nova-3 model for accuracy, language detection, diarization for multi-speaker, punctuation and smart formatting, utterances for sentence boundaries, paragraphs for structured output, callback URL for async transcription, summarization and topic detection features, and Next.js WebSocket transcription endpoint.
Claude Code for ElevenLabs: AI Text-to-Speech and Voice Cloning
Add AI voice synthesis with ElevenLabs and Claude Code — ElevenLabs SDK init, text_to_speech.convert with voice ID and model, streaming TTS with text_to_speech.stream, list voices and voice metadata, voice cloning with voice.add from audio sample, speech_to_speech for voice conversion, multilingual models, conversation AI with convai, text to sound effects, voice design, and Next.js audio streaming route.
Claude Code for Replicate: Run AI Models via API
Run thousands of open-source AI models with Replicate and Claude Code — Replicate SDK init, run Stable Diffusion XL for image generation, run Meta Llama for text generation, polling and streaming output, webhook callbacks, deployments for faster cold starts, fine-tuning with training runs, model versions and version pinning, multi-modal models for image captioning, music generation, and video models, and Next.js image generation API route.
Claude Code for Cohere: Embeddings and Reranking
Build enterprise search with Cohere and Claude Code — Cohere SDK init, chat with command-r-plus, streaming with EventStream, embed texts with embed-english-v3.0 for semantic search, rerank results with rerank-english-v3.0, classify text with classify endpoint, tokenize and detokenize, RAG with documents parameter, tool use with tools and tool_results, and Next.js hybrid search pipeline with Cohere reranking.
Claude Code for Mistral AI: European LLM APIs
Build AI applications with Mistral AI and Claude Code — Mistral SDK init, chat completions with mistral-large-latest and mistral-small, streaming responses with async iteration, function calling with tool definitions, JSON mode with response_format, Codestral for code generation and fill-in-the-middle, Mistral embeddings with mistral-embed model, pixtral-large for vision tasks, safe_prompt for content filtering, and Next.js streaming API route.
Claude Code for Groq: Ultra-Fast LLM Inference
Build fast AI applications with Groq and Claude Code — Groq SDK init with API key, chat completions with llama-3.3-70b-versatile and mixtral-8x7b models, streaming completions with async iteration, tool calling with function definitions, structured output with JSON mode, Groq audio transcription with whisper-large-v3, system prompts and few-shot examples, temperature and max_tokens configuration, rate limit handling, and Next.js streaming API route.
Claude Code for Google Genkit: Firebase AI Flows
Build AI-powered applications with Google Genkit and Claude Code — genkit.defineFlow for type-safe AI pipelines, ai.generate with model selection, definePrompt for reusable prompts with Handlebars templates, dotprompt for file-based prompts, defineRetriever for RAG document retrieval, defineTool for function calling, Gemini and OpenAI model adapters, streamFlow for streaming responses, tracing with Firebase Genkit UI, and Next.js server action integration.
Claude Code for MSW: Mock Service Worker API Mocking
Mock HTTP APIs in tests and development with MSW and Claude Code — setupWorker for browser service worker, setupServer for Node.js tests, http.get and http.post request handlers, HttpResponse for realistic responses, passthrough for proxying live APIs, network error simulation, delay for latency simulation, once for single-use handlers, resetHandlers for test isolation, graphql handler for GraphQL mocking, and Vitest and Jest integration setup.
Claude Code for Chroma: Embedded Vector Store for AI Apps
Build AI memory with Chroma and Claude Code — ChromaDB client init in persistent and ephemeral modes, collection creation with embedding function, add documents with ids and metadata, query by text or vector with n_results, where and where_document filters for metadata and content queries, update and delete by id, collection.peek() for inspection, OpenAI and Cohere embedding functions, and chroma-js TypeScript client for Next.js RAG pipelines.
Claude Code for Weaviate: Open-Source Vector Search
Build semantic search with Weaviate and Claude Code — WeaviateClient init with REST and gRPC, collection schema creation with vectorizer config, object insertion with auto-vectorization, nearText hybrid search combining BM25 and vectors, nearVector for direct embedding queries, where filter for metadata, multi-tenancy with tenant management, cross-references between collections, generative search with generate.singlePrompt, batchInsert for bulk ingestion, and Docker Compose local setup.
Claude Code for Pinecone: Vector Database for AI Search
Build AI-powered semantic search with Pinecone and Claude Code — Pinecone client init with API key, index creation with dimension and metric, upsert vectors with metadata, query by vector similarity with top-k, namespace-based multitenancy, metadata filter expressions, fetch by ID, deleteMany by metadata filter, hybrid search with sparse vectors, index stats, and Next.js semantic search API route with OpenAI embeddings.
Claude Code for Chart.js Advanced: Custom Plugins and Mixed Charts
Advanced Chart.js patterns with Claude Code — chart.register() for tree-shaking, mixed chart types combining bar and line, custom plugin API with beforeDraw and afterDatasetsDraw hooks, ScriptableContext for computed colors, ChartDataLabels plugin for value labels, chartjs-plugin-zoom for pan and zoom, custom gradient fills via ctx.createLinearGradient, ChartJS annotation plugin for threshold lines, streaming data with chartjs-plugin-streaming, and react-chartjs-2 with useRef and chart instance.
Claude Code for Nivo: Rich SVG and Canvas Charts
Build rich data visualizations with Nivo and Claude Code — ResponsiveLine and ResponsiveBar for adaptive charts, ResponsiveHeatMap for matrix data, ResponsiveTreeMap for hierarchal data, ResponsiveSunburst for nested proportions, ResponsiveChord for relationship diagrams, ResponsiveCalendar for activity heat maps, ResponsiveNetwork for force graphs, NivoTheme for consistent styling, tooltip customization with sliceTooltip, and motion config for spring animations.
Claude Code for Victory Charts: React Native and Web Charts
Build cross-platform charts with Victory and Claude Code — VictoryChart, VictoryLine, VictoryBar, and VictoryScatter for web and React Native, VictoryPie for donut charts, VictoryArea for stacked areas, VictoryAxis for custom axes, VictoryTooltip and VictoryVoronoiContainer for hover tooltips, VictoryBrushContainer for range selection, VictoryZoomContainer for pan and zoom, VictoryLegend for series labels, custom theme with VictoryTheme, and VictoryStack for grouped bars.
Claude Code for Luxon: Modern Date and Time Handling
Handle dates and times with Luxon and Claude Code — DateTime.now() and DateTime.fromISO(), DateTime.fromFormat() with custom parsing tokens, plus() and minus() for duration math, diff() between two DateTimes, startOf() and endOf() for range boundaries, setLocale() for locale-aware formatting, toRelative() for relative time strings, toISO() and toFormat() for output, Interval for date ranges, Duration for exact amounts, IANAZone for timezone conversion, and Settings.defaultLocale.
Claude Code for i18next: React Internationalization
Add i18n to React with i18next and react-i18next — i18n.init with resources and lng, useTranslation hook for t() function, Trans component for JSX interpolation, I18nextProvider for React tree, language detector with i18next-browser-languagedetector, namespace splitting for lazy loading, pluralization with count, date/number formatting with i18next-chained-backend, interpolation escape, changeLanguage for runtime switching, and TypeScript type-safe translation keys.
Claude Code for CodeMirror 6: Modular Code Editor
Build lightweight code editors with CodeMirror 6 and Claude Code — EditorState with extensions array, EditorView for DOM integration, @codemirror/lang-javascript and @codemirror/lang-python language packs, @codemirror/theme-one-dark for theming, keymap.of for custom keybindings, Decoration API for custom highlighting, StateEffect and StateField for custom state extensions, autocompletion with CompletionSource, linting with setDiagnostics, and React wrapper component with useCodeMirror hook.
Claude Code for Monaco Editor: VS Code in the Browser
Embed VS Code's Monaco Editor with Claude Code — @monaco-editor/react Editor component, language and theme configuration, controlled value with onChange, editor.addAction for custom commands, IStandaloneCodeEditor instance via onMount, registerCompletionItemProvider for custom autocomplete, addExtraLib for TypeScript type definitions, editor.layout for responsive resize, DiffEditor for side-by-side comparison, multi-model support, and custom language syntax highlighting.
Claude Code for TanStack Virtual: Headless Virtualization
Virtualize any layout with TanStack Virtual and Claude Code — useVirtualizer for vertical and horizontal lists, dynamic measurement with measureElement callback, VirtualItem with key and start/size for custom positioning, overscan for scroll smoothness, estimateSize for variable heights, bidirectional infinite scroll with prepend support, window-based virtualization with useWindowVirtualizer, sticky headers with stickyIndices, and React Native support.
Claude Code for react-window: Virtualized Lists and Grids
Virtualize large lists and grids with react-window and Claude Code — FixedSizeList for uniform-height rows, VariableSizeList with itemSize callback for dynamic heights, FixedSizeGrid for spreadsheet layouts, AutoSizer for responsive containers, InfiniteLoader for paginated data fetching, areEqual with React.memo for row memoization, useRef with scrollToItem for programmatic scrolling, onItemsRendered for visible range tracking, and custom scroll restoration.
Claude Code for D3.js Advanced: Custom Data Visualizations
Advanced D3.js patterns with Claude Code — d3-selection for DOM manipulation, d3-scale for linear/ordinal/time/log scales, d3-axis for axes with custom ticks, d3-shape for area/line/arc/pie generators, d3-hierarchy for treemap and pack layouts, d3-force for network simulation, d3-zoom for pan and zoom behavior, d3-brush for range selection, d3-transition for animated updates, React integration with useD3 hook, and responsive SVG with ResizeObserver.
Claude Code for Leaflet: Open-Source Interactive Maps
Build interactive maps with Leaflet and react-leaflet — MapContainer and TileLayer setup, Marker and Popup components, CircleMarker and Polygon shapes, LayerGroup and LayersControl for toggleable overlay groups, GeoJSON layer for feature collections, custom DivIcon markers, useMap hook for imperative control, markercluster plugin, Leaflet.draw for shape editing, fitBounds and flyTo camera control, and OpenStreetMap tile integration.
Claude Code for Mapbox: Interactive Maps with React
Build interactive maps with Mapbox GL JS and Claude Code — react-map-gl Provider and Map component, Marker and Popup components, useMap hook for programmatic control, cluster layers with Supercluster, heatmap layer source, GeoJSON layer types, flyTo and fitBounds camera animations, custom map styles, MapboxGeocoder for address search, draw tools with MapboxDraw, user location tracking, and mobile-optimized touch gestures.
Claude Code for Tiptap Advanced: Custom Extensions and Collaboration
Advanced Tiptap patterns with Claude Code — custom Node extensions with NodeViewWrapper, custom Mark extensions for inline decorations, commands API for custom slash commands, suggestion plugin for @mention and /command menus, Yjs collaboration with HocuspocusProvider, AI autocomplete with streaming, custom toolbar with BubbleMenu and FloatingMenu, image upload extension, export to Markdown and HTML, and advanced key binding.
Claude Code for Recharts Advanced: Custom Charts and Tooltips
Advanced Recharts patterns with Claude Code — custom tooltip components with TooltipProps, custom dot rendering on LineChart, custom label with LabelList, ComposedChart with multiple series, ReferenceArea and ReferenceLine overlays, ResponsiveContainer sizing, Brush for time range selection, custom Legend, gradient fills with linearGradient defs, animated chart transitions, and real-time chart updates with streaming data.
Claude Code for Bun: Fast JavaScript Runtime and Toolkit
Build with Bun and Claude Code — Bun.serve for HTTP servers, Bun.file for fast file I/O, Bun.$ for shell commands, Bun.sql for SQLite and PostgreSQL, Bun.build for bundling, bun:test for testing, Bun.hash for hashing, bun.lock for deterministic installs, bun run for package.json scripts, hot reloading with --hot, bun init for project scaffolding, and compatibility with Node.js modules.
Claude Code for TanStack Form: Type-Safe Form Management
Build type-safe forms with TanStack Form and Claude Code — useForm with defaultValues and validators, Field component with onChange and onBlur validation, z.object Zod validator adapter, async server-side validators, form.Subscribe for reactive derived state, arrays with field.pushValue and field.removeValue, nested objects with dot-notation fields, form.handleSubmit with type-safe values, and React Native support.
Claude Code for Nuxt Advanced: Server Routes, Composables, and Layers
Advanced Nuxt 3 patterns with Claude Code — server routes with defineEventHandler, H3 utilities for request parsing, useFetch and useAsyncData for data fetching, useNuxtApp and useState for global state, Nuxt layers for shared base configuration, composables with auto-import, nitro plugins for server startup, server-side middleware, route rules with ISR and SWR, and Nuxt module development.
Claude Code for Zod Advanced: Runtime Validation Patterns
Advanced Zod patterns with Claude Code — z.discriminatedUnion for tagged variants, z.transform for data transformation, z.preprocess for coercion, z.superRefine for async cross-field validation, z.lazy for recursive schemas, branded types with z.brand, z.infer for type extraction, custom error maps, metadata with .describe(), schema composition with .merge() and .extend(), and environment variable validation with z.object.
Claude Code for Jotai Advanced: Atomic State Management Patterns
Advanced Jotai patterns with Claude Code — atomWithStorage for persistence, atomWithQuery for async data fetching, derived atoms with get-set patterns, atomWithReset for resettable state, atomFamily for parameterized atoms, loadable for suspense-free async, selectAtom for fine-grained subscriptions, abortable async with onMount, DevTools integration, and combining atoms for complex state machines.
Claude Code for Express.js Advanced: Patterns for Production APIs
Advanced Express.js patterns with Claude Code — typed request handlers with RequestHandler generics, async error handling middleware, Zod validation middleware factory, rate limiting with express-rate-limit and Redis store, helmet security middleware, compression, dependency injection with tsyringe, file upload with multer and S3, pagination utilities, JWT middleware, and structured logging with pino.
Claude Code for KeystoneJS: Node.js CMS and App Framework
Build full-stack apps with KeystoneJS and Claude Code — config with lists, fields.text and fields.relationship for schema definition, access control with isAuthenticated and isAdmin functions, hooks with beforeOperation and afterOperation, GraphQL API auto-generation from schema, AdminUI for content management, session with statelessSessions, Prisma adapter for database, file storage with images and files fields, and custom REST endpoints.
Claude Code for Hono Advanced: Edge-First Web Framework Patterns
Advanced Hono patterns with Claude Code — Hono RPC with hc typed client, factory createFactory for reusable middleware, validator middleware with Zod, streaming responses with streamText and streamSSE, WebSocket upgrader with upgradeWebSocket, Cloudflare Workers bindings with c.env, D1 database access, KV namespace, R2 bucket, middleware composition with compose, testing with app.request, and monorepo sharing of Hono RPC types.
Claude Code for TypeGraphQL: Decorator-Based GraphQL in TypeScript
Build GraphQL APIs with TypeGraphQL and Claude Code — @ObjectType and @Field decorators, @Resolver with @Query and @Mutation, @InputType for mutation arguments, @Authorized for authentication guards, buildSchema to generate executable schema, Ctx context injection, DataLoader integration with @FieldResolver, class-validator decorators for input validation, middleware with MiddlewareFn, and GraphQL Yoga or Apollo Server integration.
Claude Code for Orval: OpenAPI Code Generator for React Apps
Generate typed API clients with Orval and Claude Code — orval.config.ts with input and output settings, React Query hooks generator, Axios client generation, Zod schema generation from OpenAPI, MSW mock handlers for testing, Fetch client output, custom mutator for auth headers, multiple target files from one spec, watch mode for regeneration, and NestJS HTTP module integration.
Claude Code for Pothos: Code-First GraphQL Schema Builder
Build GraphQL APIs with Pothos and Claude Code — SchemaBuilder with plugins, builder.objectType and builder.queryField for type-safe schema definition, Drizzle plugin for ORM integration, Prisma plugin for prisma model types, relay plugin for cursor pagination, smart union and interface types, builder.mutationField with input types, context typing, error handling plugin with typed errors, and schema-first code generation patterns.
Claude Code for Elysia.js: Fast Bun-Native HTTP Framework
Build fast APIs with Elysia.js and Claude Code — Elysia app setup with .use plugins, .get/.post/.put/.delete route methods, schema validation with Elysia types and t schema, .derive for request context, .guard for authentication middleware, Eden Treaty client for end-to-end type safety, swagger plugin for OpenAPI docs, bearer plugin for JWT auth, cookie plugin, lifecycle hooks with onRequest and afterHandle, and Bun.serve for deployment.
Claude Code for ts-rest: Type-Safe API Contracts Without Code Generation
Build type-safe REST APIs with ts-rest and Claude Code — initContract for defining API contracts, c.router for nested routes, c.query for GET endpoints, c.mutation for POST/PUT/PATCH/DELETE, path parameters with colon syntax, Zod schemas for body and response validation, @ts-rest/next for Next.js App Router integration, @ts-rest/react-query for typed useQuery and useMutation hooks, fetchApi client, and server-side completion enforcement.
Claude Code for Ghost: Headless Publishing Platform
Build content sites with Ghost and Claude Code — Ghost Content API with @tryghost/content-api, getPosts and getPost queries, author and tag filtering, primary_author and tags expansion, featured posts, reading time, custom integrations via Admin API, memberstack for subscriptions, Next.js ISR with revalidate, image CDN with feature_image, custom excerpt and meta description, and Ghost webhooks for post.published events.
Claude Code for Vonage: SMS, Voice, and Verify API
Send SMS and make calls with Vonage and Claude Code — Vonage SDK initialization with @vonage/server-sdk, SMS.send for text messages, Verify.start and Verify.check for OTP verification, Voice.createOutboundCall with NCCO actions, vonage-node-sdk Messages API for WhatsApp and MMS, webhook signature verification with verifySignature, balance check, delivery receipt webhooks, and inbound SMS handling.
Claude Code for Pusher: Realtime WebSocket Channels
Add realtime features with Pusher Channels and Claude Code — PusherServer for server-side event publishing, PusherClient for browser subscriptions, channel.bind for event listeners, presence channels with member tracking, private channels with auth endpoints, trigger and triggerBatch for publishing, pusher-js for browser, Next.js auth endpoint for channel authorization, typing indicators, live cursors, and HTTP webhooks for channel lifecycle events.
Claude Code for Knock: Developer Notification Platform
Send notifications with Knock and Claude Code — Knock SDK initialization with @knocklabs/node, notify and notifyBatch for workflow triggering, user identification with identify, workflow editor with multi-channel steps, in-app feed with @knocklabs/react-notification-feed, feed filtering with KnockFeedProvider, preferences API for per-user channel control, tenant-based multi-tenancy for SaaS, and schedule-based recurring notifications.
Claude Code for Zodios: Type-Safe HTTP Client with Zod Validation
Build type-safe API clients with Zodios and Claude Code — makeApi with endpoint definitions, Zod schemas for request and response validation, parametric paths with path parameters, query params and body schemas, makeErrors for typed error responses, apiClient with axios under the hood, zodios React Query hooks with useQuery and useMutation, ZodiosRouter for Express server endpoints, and API contract sharing between client and server.
Claude Code for Daily.co: Video Calls with React
Build video calls with Daily.co and Claude Code — DailyProvider and useDaily hook, useLocalParticipant and useParticipantIds for participant state, useVideoTrack and useAudioTrack for media tracks, DailyVideo component for rendering video, createRoom and createMeetingToken REST API, CallObject with join/leave, useDevices for camera/mic selection, useScreenShare for screen sharing, and recording with startRecording.
Claude Code for Keystatic: File-Based CMS for Next.js and Astro
Build content management with Keystatic and Claude Code — Keystatic config with collection and singleton, fields.text/richText/image/select/date, Next.js App Router integration with createNextApiHandler, local and GitHub storage modes, markdoc and mdx content output, content reader API with reader.collections and reader.singletons, live editing with keystatic/ui, and CloudImage with Cloudinary.
Claude Code for openapi-ts: Generate TypeScript from OpenAPI Specs
Generate TypeScript API clients from OpenAPI with openapi-ts and Claude Code — @hey-api/openapi-ts for client generation, fetch-based clients with TypeScript types, request and response models, plugin system with @hey-api/client-fetch and @hey-api/client-axios, type-safe request builders, error types from OpenAPI schemas, Zod validators from openapi-zod-client, MSW mock handlers from openapi-msw, and CI/CD integration with npx openapi-ts.
Claude Code for Novu: Open-Source Notification Infrastructure
Send notifications with Novu and Claude Code — Novu SDK initialization with @novu/node, trigger and triggerBulk for workflow execution, subscriber creation and management, in-app notification center with @novu/notification-center, step types (email, SMS, push, in-app, chat), workflow editor, digest step for batching, delay step for sequences, subscriber preferences, and self-hosted Docker deployment.
Claude Code for Polar: Open-Source Developer Sales Platform
Monetize developer tools with Polar and Claude Code — Polar SDK initialization, checkout session creation with products and prices, subscription management with getSubscription, webhook handling with validateEvent for subscription.created and order.created, benefits delivery for GitHub stars and Discord roles, Next.js App Router integration, customer portal with generatePortalUrl, and TypeScript SDK with @polar-sh/sdk.
Claude Code for QStash: Serverless Message Queue and Scheduler
Queue jobs with QStash and Claude Code — Client.publishJSON for enqueuing tasks, URL-based delivery to HTTP endpoints, delay and notBefore for scheduling, @upstash/qstash Receiver for webhook signature verification, retries and deadLetterQueue, cron-based schedules with Schedules.create, batch publishing, Next.js Route Handler integration, FIFO queues with deduplication IDs, and callback URLs for job completion.
Claude Code for Medusa: Open-Source E-Commerce Backend
Build e-commerce with Medusa and Claude Code — @medusajs/js-sdk for storefront API, listProducts and retrieveProduct queries, addToCart and createCart, createPaymentCollection for Stripe checkout, registerCustomer and login authentication, Medusa modules for custom logic, Next.js storefront integration, uploadFile for product media, listOrders for customer history, and webhook event handling for order fulfillment.
Claude Code for Storyblok: Visual CMS with React Components
Build with Storyblok and Claude Code — StoryblokClient and useStoryblok hook, getStory and getStories API calls, dynamic component rendering with StoryblokComponent, content types and nested blocks, Next.js App Router integration, ISR with revalidate, live preview with Bridge initialization, rich text rendering with renderRichText, image transformations via CDN URL parameters, and TypeScript types from Storyblok CLI.
Claude Code for Directus: Open-Source Headless CMS and Data Platform
Manage content with Directus and Claude Code — Directus SDK initialization with createDirectus and rest(), readItems and readItem for collection queries, createItem and updateItem mutations, authentication with staticToken and email/password, file uploads to Directus Files, filter operators for relational queries, realtime subscriptions with WebSocket, custom extensions for hooks and endpoints, and self-hosted Docker deployment.
Claude Code for Lemon Squeezy: Merchant of Record Payments
Add payments with Lemon Squeezy and Claude Code — createCheckout for custom checkout links, getSubscription and updateSubscription, webhook handling with X-Signature validation, LemonSqueezy JS SDK initialization, subscription_created and subscription_updated events, license keys with validateLicense, customer portal URL generation, variant and product management, order retrieval, and TypeScript types with @lemonsqueezy/lemonsqueezy.js.
Claude Code for Agora: Ultra-Low Latency RTC and Live Streaming
Build real-time audio and video with Agora and Claude Code — AgoraRTC.createClient with live and rtc modes, createMicrophoneAudioTrack and createCameraVideoTrack, client.join with channel and token, publish and subscribe tracks, user-published and user-unpublished events, screen sharing with createScreenVideoTrack, network quality callbacks, cloud recording with Agora Cloud Recording REST API, token server with RtcTokenBuilder, and React integration with agora-rtc-react.
Claude Code for Stripe Subscriptions: Recurring Billing Patterns
Implement Stripe subscription billing with Claude Code — stripe.subscriptions.create and retrieve, Price objects with recurring intervals, customer portal with billing portal sessions, trial periods with trial_end, proration with subscription_update, plan upgrades and downgrades, invoice.payment_succeeded and customer.subscription.deleted webhooks, metered billing with usageRecords, cancellation with cancel_at_period_end, and subscription items.
Claude Code for Twilio: SMS, Voice, and Verify API
Add communications with Twilio and Claude Code — twilio.messages.create for SMS, twilio.calls.create for voice calls, Verify API with verifications.create and verificationChecks.create for OTP, webhook signature validation with validateRequest, Conversation API for two-way messaging, phone number provisioning with availablePhoneNumbers, status callbacks, bulk SMS with messaging services, and TypeScript with twilio SDK types.
Claude Code for Lucia: Database-Backed Session Authentication
Implement authentication with Lucia and Claude Code — Lucia initialization with database adapter, createSession and invalidateSession, validateRequestCookie for Next.js App Router, getSession middleware, sessionCookieName and createBlankSessionCookie, Drizzle and Prisma adapters, multi-device session management, GitHub OAuth with Arctic, password hashing with Argon2, and session expiry with idle timeout.
Claude Code for Socket.IO: Real-Time Bidirectional Communication
Build real-time features with Socket.IO and Claude Code — io.on connection and socket.on event handlers, rooms with socket.join and io.to(room).emit, namespaces, socket.emit and io.emit broadcasting, acknowledgements with callbacks, socket.data for auth state, middleware with io.use, Redis adapter for horizontal scaling with @socket.io/redis-adapter, Next.js API route integration, typed events with TypeScript generics, and client-side reconnection.
Claude Code for SWR: React Hooks for Data Fetching
Fetch and cache data with SWR and Claude Code — useSWR with key and fetcher, global SWRConfig with fetcher and error handling, conditional fetching with null key, useSWRMutation for POST/PUT/DELETE, optimistic updates with mutate, revalidation on focus and interval, SWR infinite for pagination, dependent queries, preloading with preload(), useSWRImmutable for static data, TypeScript generic types, and error retry configuration.
Claude Code for Passport.js: Node.js Authentication Middleware
Implement authentication with Passport.js and Claude Code — passport.use() with LocalStrategy and JwtStrategy, passport.authenticate() middleware, session serialization with serializeUser/deserializeUser, express-session integration, OAuth2 with GitHub and Google strategies, req.user type augmentation, requireAuth middleware, logout with req.logout(), and username/password login with bcrypt verification.
Claude Code for RTK Query: Data Fetching with Redux Toolkit
Fetch and cache server data with RTK Query and Claude Code — createApi with baseQuery and endpoints, useGetQuery and useMutation hooks, providesTags and invalidatesTags for cache invalidation, transformResponse for data shaping, optimistic updates with onQueryStarted, polling with pollingInterval, prefetching, selective tag invalidation, code splitting with injectEndpoints, and integration with Redux DevTools for request inspection.
Claude Code for Pinia: The Intuitive Vue Store
Manage Vue 3 state with Pinia and Claude Code — defineStore with setup function and options API, state, getters, and actions, storeToRefs for reactive destructuring, useStore() composition, cross-store dependencies, $patch for batch updates, $reset for state reset, $subscribe for state watchers, $onAction for action logging, Pinia plugin for persistence with localStorage, DevTools integration, and server-side rendering hydration.
Claude Code for Recoil: Facebook's Atom-Based State Management
Manage React state with Recoil and Claude Code — atom() for primitive state, selector() for derived state with get, useRecoilState and useRecoilValue hooks, RecoilRoot provider, atomFamily and selectorFamily for parameterized atoms, async selectors with Suspense, atomEffects for localStorage persistence, useRecoilCallback for transactional updates, waitForAll and waitForNone for concurrent data loading, and Snapshots for debugging.
Claude Code for Anime.js: Lightweight JavaScript Animation Engine
Animate DOM elements with Anime.js and Claude Code — anime() with targets, properties, duration, easing, and delay, timeline with anime.timeline() for sequenced animations, staggering with anime.stagger(), SVG path drawing with strokeDashoffset, color and transform animations, loop and direction control, callbacks onBegin/onUpdate/onComplete, seeking with animation.seek(), anime.set() for instant transforms, and morphing paths.
Claude Code for Fabric.js: Feature-Rich Canvas Editing
Build canvas editors with Fabric.js and Claude Code — Canvas initialization with fabric.Canvas, IObjects (Rect/Circle/Triangle/Polygon/Path/Image/Text/IText/Textbox), object serialization with toJSON/loadFromJSON, drawing mode with isDrawingMode and freeDrawingBrush, selection events on:selected, group and ungroup with fabric.Group, SVG import with loadSVGFromString, image filters like Grayscale and Brightness, toDataURL for PNG export, object snapping, and history with undo/redo.
Claude Code for Lottie: JSON-Based Vector Animations
Play Lottie animations in React with Claude Code — DotLottie and Lottie Web player setup, LottiePlayer React component, lottie-react useRef controls, play/pause/stop/setSpeed/goToAndPlay, autoplay and loop control, event listeners for complete and loopComplete, dynamic segment playback, animation theming with theme expressions, React Native with lottie-react-native, and loading from URL vs bundled JSON.
Claude Code for iron-session: Encrypted Cookie Sessions
Implement encrypted cookie sessions with iron-session and Claude Code — getIronSession with session options, SessionData interface for typed sessions, Next.js App Router and Pages Router patterns, session.save and session.destroy, withIronSessionSsr and withIronSessionApiRoute wrappers, password rotation with multiple passwords, CSRF protection with nonce, cart and auth session patterns, and Cloudflare Workers edge compatibility.
Claude Code for PixiJS: High-Performance 2D WebGL Rendering
Build high-performance 2D graphics with PixiJS and Claude Code — Application setup with WebGL/WebGPU auto-detection, Container and DisplayObject hierarchy, Sprite from textures, Graphics for procedural shapes, Text and BitmapText, Ticker for game loops, InteractionManager for pointer events, Assets loader with progress, particle systems with ParticleContainer, Filters for visual effects, RenderTexture for off-screen rendering, and React integration with @pixi/react.
Claude Code for react-spring: Physics-Based UI Animations
Animate React UIs with react-spring and Claude Code — useSpring for single value animation, useSprings for lists, useTrail for staggered entrances, useTransition for mount/unmount animations, animated.div and animated components, config presets (gentle/wobbly/stiff/slow), spring interpolation, drag gestures with @use-gesture/react, parallax scrolling with useParallax, and chained animations with useChain.
Claude Code for LiveKit: Real-Time Video and Audio
Build video conferencing with LiveKit and Claude Code — LiveKitRoom provider, useParticipants and useTracks hooks, VideoTrack and AudioTrack rendering, room connection with access tokens, LocalParticipant camera and microphone controls, RoomEvent listeners, screen sharing, useRoomContext, data channel messaging, transcription integration, and self-hosted deployment with livekit-server.
Claude Code for Konva: 2D Canvas Graphics and Interactions
Build interactive 2D canvas applications with Konva and Claude Code — Stage and Layer architecture, Shape nodes (Rect/Circle/Text/Image/Line), Transformer for selection and resizing, drag-and-drop with draggable, event handling on shapes, animation with Tween, react-konva integration, exportToDataURL for image export, Group for composite shapes, hit detection, and multi-select with Transformer.
Claude Code for jose: JWT Signing and Verification in JavaScript
Sign and verify JWTs with jose and Claude Code — SignJWT for creating tokens with claims, jwtVerify for validation, JWTExpired and JWTInvalid error handling, createRemoteJWKSet for JWKS endpoint verification, HS256 with symmetric secrets and RS256 with key pairs, token rotation with jti claims, cookie-based session tokens, API key signing, and Next.js Edge Runtime compatibility.
Claude Code for PapaParse: CSV Parsing and Generation
Parse and generate CSV files with PapaParse and Claude Code — Papa.parse for string and file parsing, streaming large files with step callbacks, header row detection, type inference with dynamicTyping, unparse for CSV generation from arrays and objects, error handling with malformed data, worker thread parsing, Node.js stream integration, browser file input parsing, and TypeScript typed results.
Claude Code for UploadThing: Type-Safe File Uploads for Next.js
Add file uploads with UploadThing and Claude Code — createUploadthing router with middleware and onUploadComplete, UploadButton and UploadDropzone React components, generateReactHelpers for custom upload UI, file size and type validation, image and video uploaders, access control with middleware auth check, client-side progress tracking, UTApi for file management and deletion, and Next.js App Router integration.
Claude Code for Sharp: High-Performance Node.js Image Processing
Process images efficiently with Sharp and Claude Code — resize with fit strategies, format conversion to webp/avif/jpeg/png, quality optimization, composite for watermarks, blur and sharpen operations, metadata extraction, pipeline chaining, responsive image generation with multiple sizes, thumbnail creation, image rotation and flip, and Next.js image optimization API route.
Claude Code for ExcelJS: Excel Spreadsheet Generation
Generate Excel files with ExcelJS and Claude Code — Workbook and Worksheet creation, cell values and data types, column width and row height, number formatting and alignment, cell borders and fill colors, formula cells, merging cells, adding images, auto-fit columns, freeze panes, data validation, chart creation, and streaming large files with stream.xlsx.
Claude Code for pdf-lib: PDF Generation in Pure JavaScript
Generate and modify PDFs with pdf-lib and Claude Code — PDFDocument.create and load, addPage with page sizing, drawText with font embedding, drawRectangle and drawLine for shapes, embed images with embedPng/embedJpeg, form field creation with addTextField and addCheckBox, page numbering with index and count, password protection with encryption options, merging PDFs with copyPages, and Node.js stream output.
Claude Code for next-intl: Internationalization for Next.js
Internationalize Next.js apps with next-intl and Claude Code — locale routing with createNavigation, useTranslations hook, useFormatter for dates/numbers/lists, message catalog JSON structure, pluralization with ICU syntax, rich text with tags in messages, locale detection middleware, localePrefix strategies, async server component translations, and TypeScript message typing.
Claude Code for pgvector: Semantic Search with PostgreSQL
Build semantic search with pgvector and Claude Code — vector column types, cosine similarity and L2 distance operators, HNSW and IVFFlat index creation, embedding generation with OpenAI or local models, hybrid search combining full-text and vector similarity, Prisma raw queries for vector operations, nearest neighbor lookup with <=> operator, and RAG document retrieval patterns.
Claude Code for WorkOS: Enterprise SSO and Directory Sync
Add enterprise authentication with WorkOS and Claude Code — AuthKit hosted UI, SSO with getSSOUrl and handleCallback, Directory Sync webhooks for SCIM provisioning, User Management API, impersonation for support, magic auth and OTP, organization management, role assignment, portal links for admin self-service, withAuth middleware, and Next.js App Router integration.
Claude Code for Stripe Checkout: Payment Link and Hosted Pages
Accept payments with Stripe Checkout and Claude Code — Session creation with line_items and mode, success_url and cancel_url redirect flow, hosted and embedded checkout modes, customer_email prefill, metadata for order tracking, subscription mode with price IDs, allow_promotion_codes, tax_id_collection, billing_address_collection, webhook checkout.session.completed handling, and checkout session retrieval.
Claude Code for OpenAI Assistants API: Persistent AI Threads
Build AI assistants with the OpenAI Assistants API and Claude Code — Assistant creation with tools and instructions, Thread and Message management, Run lifecycle with polling and streaming, Code Interpreter for data analysis, File Search with vector stores, function calling tools, streaming run events with runStream, tool call handling patterns, and assistant playground integration.
Claude Code for Yjs: Real-Time Collaborative Editing
Build collaborative features with Yjs and Claude Code — Y.Doc shared document, Y.Map and Y.Array CRDT types, WebsocketProvider and WebRTCProvider for sync, Awareness for user cursors and presence, Undo manager, binding to TipTap and Lexical editors, y-indexeddb for offline persistence, encoding/decoding updates with Y.encodeStateAsUpdate, and conflict-free merging across peers.
Claude Code for Nanostores: Tiny Framework-Agnostic State
Manage shared state with Nanostores and Claude Code — atom for primitive values, map for objects with setKey, computed for derived state, deepMap for nested objects, onMount/onSet lifecycle hooks, persistent for localStorage sync, @nanostores/react useStore hook, @nanostores/vue and @nanostores/svelte adapters, batching updates, and async stores with loading states.
Claude Code for Million.js: React Performance Optimization
Optimize React rendering with Million.js and Claude Code — block() HOC for virtual DOM bypass, For component for fast list rendering, million/compiler Babel and Vite plugin for automatic optimization, automatic mode with rules for compatible components, aiDiff for large DOM tree comparison, Slot for dynamic content in blocks, and profiling patterns to identify block candidates.
Claude Code for CASL: Isomorphic Authorization for JavaScript
Implement role-based and attribute-based permissions with CASL and Claude Code — AbilityBuilder and defineAbility for permission rules, can and cannot checks, subject helper for type detection, ForcedSubject for attribute permissions, React useAbility hook, ability.update for dynamic permissions, packRules and unpackRules for JWT storage, MongoDB-style conditions, Prisma query integration, and Next.js middleware guards.
Claude Code for Clerk: Authentication and User Management
Add authentication with Clerk and Claude Code — ClerkProvider setup, SignIn and SignUp components, useUser and useAuth hooks, clerkMiddleware for route protection, currentUser in Server Components, auth().protect() in Server Actions, UserButton component, OrganizationSwitcher for multi-tenancy, Clerk webhooks for database sync, custom claims with publicMetadata, and JWT templates.
Claude Code for Algolia: Instant Search and Index Management
Implement search with Algolia and Claude Code — algoliasearch client setup, index.saveObjects for indexing, InstantSearch React with SearchBox and Hits, Configure widget for query rules, useSearchBox and useHits hooks, faceted filtering with RefinementList, pagination with Pagination widget, custom hit components with Highlight, geo-search, index settings for searchable attributes and ranking, and webhook-based re-indexing.
Claude Code for Conform: Type-Safe Forms for Remix and Next.js
Build type-safe forms with Conform and Claude Code — useForm and getFieldsetProps for form structure, getInputProps for field binding, server-side parseWithZod validation, intent buttons for multi-action forms, nested fieldsets, file uploads, useFormMetadata for dynamic forms, error handling with field.errors, and Remix action integration with conform's submission protocol.
Claude Code for Lexical: Meta's Rich Text Editor Framework
Build rich text editors with Lexical and Claude Code — LexicalComposer setup with InitialConfigType, RichTextPlugin with ContentEditable, HistoryPlugin for undo/redo, OnChangePlugin for state capture, custom nodes with NodeKey and serialization, EditorState persistence with JSON, toolbar with formatting commands, AutoLink and HashTag plugins, Markdown transforms, and collaboration with Yjs.
Claude Code for GSAP: Professional Web Animations
Build professional animations with GSAP and Claude Code — gsap.to and gsap.from tweens, Timeline for sequenced animations, ScrollTrigger for scroll-driven effects, useGSAP React hook for cleanup, stagger for list animations, morphSVG for shape tweening, Draggable for drag interactions, SplitText for text animations, easing functions, and performance patterns with will-change.
Claude Code for Valtio: Proxy-Based State Management
Manage React state with Valtio and Claude Code — proxy state creation, useSnapshot for reactive reads, subscribe for external subscriptions, computed values with derive, devtools integration, proxyWithComputed, nested object mutation, async actions, proxySet and proxyMap for collections, and vanilla store usage without React.
Claude Code for fp-ts: Functional Programming in TypeScript
Apply functional programming patterns with fp-ts and Claude Code — Option for nullable values with some/none/fold, Either for typed errors with right/left/chain, pipe and flow composition, TaskEither for async error handling, IO for side effects, Reader for dependency injection, sequence and traverse for collections, and do-notation with bind.
Claude Code for Better Auth: Full-Stack Authentication Library
Implement authentication with Better Auth and Claude Code — server setup with betterAuth, client setup with createAuthClient, email/password signIn and signUp, OAuth providers with socialProvider, session management, user role middleware, TypeScript inference, Next.js App Router integration, database adapters, forgot password and email verification flows, and organization multi-tenancy plugin.
Claude Code for CSS Modules: Scoped Styles in React
Write scoped component styles with CSS Modules and Claude Code — module.css file imports and className references, composes for style inheritance, :global for global selectors, TypeScript type generation with typescript-plugin-css-modules, CSS custom properties with modules, Vite and Next.js integration, clsx/cn for conditional classes, animation keyframes in modules, and media query patterns.
Claude Code for Storybook Advanced: Interaction Testing and Addons
Build robust component libraries with Storybook and Claude Code — play functions with userEvent and canvas queries for interaction testing, args and argTypes for controls, decorators for context providers, composeStories for unit test integration, storiesOf migration to CSF3, Storybook Test component testing via @storybook/test, a11y addon setup, viewport addon, and autodocs with JSDoc extraction.
Claude Code for BullMQ: Background Job Processing with Redis
Process background jobs with BullMQ and Claude Code — Queue and Worker setup with Redis connection, job.add with data and opts, Worker process function with typed job data, repeatable jobs with cron pattern, job priorities, retries with backoff, error handling and failed job events, QueueEvents for monitoring, FlowProducer for job chains, rate limiting workers, and Bull Board for job dashboard.
Claude Code for Kysely: Type-Safe SQL Query Builder
Build type-safe SQL queries with Kysely and Claude Code — database interface type definitions, selectFrom with select and where, insertInto returning, updateTable set, deleteFrom, joins with innerJoin/leftJoin, transactions, raw SQL with sql template tag, migrations with FileMigrationProvider, CamelCasePlugin, Postgres/SQLite/MySQL dialect setup, and subqueries.
Claude Code for Cloudflare KV: Edge Key-Value Storage
Store and retrieve data at the edge with Cloudflare KV and Claude Code — KV binding setup in wrangler.toml, get/put/delete operations with TypeScript, JSON serialization with expirationTtl, list with prefix and cursor, Workers integration in Hono routes, Next.js on Cloudflare Pages with KV in middleware and edge functions, caching patterns, rate limiting with atomic counters, and feature flag storage.
Claude Code for Resend: Transactional Email with React
Send transactional email with Resend and Claude Code — Resend client with API key, send with from/to/subject/react prop, React Email components with Html/Head/Body/Container/Section/Text/Button/Img, email template design with inline styles, batch sending, domain verification setup, webhook for delivery events, email preview in development, and attachment handling.
Claude Code for Stripe Webhooks: Event Processing Patterns
Process Stripe webhooks reliably with Claude Code — constructEvent signature verification, idempotency with event ID deduplication, handling checkout.session.completed and payment_intent.succeeded, subscription lifecycle events customer.subscription.updated/deleted, refund processing with charge.refunded, webhook retry handling with 200 responses, Stripe CLI for local testing, and database event logging.
Claude Code for React Query DevTools and Debugging Patterns
Debug TanStack Query with DevTools and Claude Code — ReactQueryDevtools setup, query state inspection, cache inspection with useQueryClient, custom logger configuration, onError callbacks for error boundaries, query key debugging with QueryClientProvider, persisting cache with createSyncStoragePersister, dehydrate/hydrate for SSR debugging, and custom DevTools overlay with query monitoring hooks.
Claude Code for React PDF: Generate PDFs with React Components
Generate PDFs with React and Claude Code — @react-pdf/renderer with Document/Page/View/Text/Image, StyleSheet.create for typed styles, PDFDownloadLink for browser downloads, PDFViewer for inline preview, renderToStream for server-side generation in Node.js API routes, custom fonts with Font.register, page breaks with break prop, dynamic tables from data arrays, and Cloudflare Worker streaming.
Claude Code for Ably: Real-Time Messaging and Pub/Sub
Build real-time features with Ably and Claude Code — Realtime client setup with auth tokens, channel.publish for sending messages, channel.subscribe for receiving, presence with enter/leave/get, channel history, connection state management, token auth with server-side TokenRequest, React hooks with ably/react, multiplayer cursors, live order status updates, and Ably CLI for testing.
Claude Code for Prisma Extensions: Custom Queries and Middleware
Extend Prisma Client with Prisma Extensions and Claude Code — $extends with model and query components, custom model methods, result transformations with $allModels, query middleware for soft delete and multi-tenancy, computed fields on result type, client-level $on event hooks, row-level security with RLS extensions, custom pagination helpers, and audit trail extension patterns.
Claude Code for Contentful: Headless CMS Integration
Integrate Contentful headless CMS with Claude Code — createClient with accessToken and space, getEntries with content_type and include depth, getEntry by ID, TypeScript code generation with cf-content-types-generator, Next.js App Router with ISR revalidation, rich text rendering with documentToReactComponents, Asset URL resolution, Preview API for draft content, and webhook revalidation for live updates.
Claude Code for Sentry: Error Monitoring and Performance Tracing
Monitor errors and performance with Sentry and Claude Code — Sentry.init with DSN and environment, captureException and captureMessage, withScope and setContext for enrichment, user identification, breadcrumbs, Next.js and Node.js SDK setup, performance tracing with startSpan, sampling rates, source maps for readable stack traces, session replay, and custom integrations with beforeSend filtering.
Claude Code for D3.js: Custom Data Visualizations
Build custom data visualizations with D3.js and Claude Code — scales with scaleLinear/scaleBand/scaleTime, axes with d3.axisBottom/axisLeft, path generators for line and area charts, d3.arc for pie and donut charts, d3.force for network graphs, d3.zoom for pan/zoom, brush for range selection, React + D3 useD3 hook pattern, and responsive SVG with viewBox and transitions.
Claude Code for React Three Fiber: 3D Scenes in React
Build 3D web applications with React Three Fiber and Claude Code — Canvas setup with camera and lighting, mesh with geometry and material primitives, useFrame for animation loop, useThree for renderer and camera access, drei helpers OrbitControls/Environment/Text/Html, GLTF model loading with useGLTF, physics with @react-three/rapier, raycasting for interaction, and post-processing effects.
Claude Code for date-fns: Modern Date Utilities for JavaScript
Format, parse, and manipulate dates with date-fns and Claude Code — format with token patterns, parse with parseISO and parse, differenceInDays/Hours/Minutes, addDays/subMonths/startOfWeek, isBefore/isAfter/isWithinInterval, formatDistance for relative times, date-fns-tz for timezone-aware formatting, eachDayOfInterval for date ranges, and locale-aware formatting with date-fns/locale.
Claude Code for MobX: Observable State for React
Manage reactive state with MobX and Claude Code — makeObservable with observable/action/computed annotations, makeAutoObservable for automatic inference, observer HOC and useLocalObservable for React integration, reaction and autorun for side effects, flow for async actions, runInAction for async state updates, MobX-State-Tree typed models, and strict mode for enforced action discipline.
Claude Code for Immer: Immutable State with Mutable Syntax
Write immutable state updates with Immer and Claude Code — produce for draft mutations, useImmer and useImmerReducer React hooks, structural sharing and frozen output, patches for undo/redo with applyPatches, createDraft and finishDraft for manual control, Immer with Redux Toolkit createSlice (built-in), curried producers for reusable updaters, and recipe functions for nested state.
Claude Code for React Aria: Accessible Headless UI Components
Build fully accessible React components with React Aria and Claude Code — useButton and useFocusRing for interactive elements, useSelect and ListBox for accessible dropdowns, useDialog and useModal for overlays, useDatePicker and useCalendar for date inputs, useTable with sorting and selection, useComboBox for autocomplete, AriaProvider for SSR, and internationalization with useLocale.
Claude Code for neverthrow: Type-Safe Error Handling in TypeScript
Eliminate thrown exceptions with neverthrow and Claude Code — Result and ResultAsync types, ok/err constructors, map/mapErr/andThen chaining, fromThrowable and fromPromise wrappers, combine for multiple results, match for exhaustive handling, ResultAsync for async pipelines, and domain-specific error unions replacing try/catch with typed error flows.
Claude Code for Remeda: Type-Safe Utility Library for TypeScript
Transform data safely with Remeda and Claude Code — pipe for function composition, map/filter/groupBy/sortBy with type inference, purry functions for data-first and data-last styles, lazy evaluation with createLazyInvocable, object utilities pick/omit/mapValues/mergeDeep, string helpers, type guard predicates isDefined/isString/isNonNullish, and partial application patterns.
Claude Code for PostHog: Product Analytics and Feature Flags
Track user behavior and ship features safely with PostHog and Claude Code — posthog-js initialization, capture events with properties, identify users, feature flags with useFeatureFlagEnabled, A/B tests with getFeatureFlagPayload, session recordings, group analytics, autocapture configuration, server-side tracking with posthog-node, and privacy controls with opt-out.
Claude Code for dnd kit: Drag and Drop in React
Build drag and drop interfaces with dnd kit and Claude Code — DndContext and droppable/draggable hooks, SortableContext with vertical and horizontal lists, useSortable for sortable items, drag overlay with DragOverlay for visual feedback, keyboard accessibility, collision detection strategies, and multi-container drag between kanban columns.
Claude Code for Recharts: Composable Charts in React
Build data visualizations with Recharts and Claude Code — LineChart with CartesianGrid and Tooltip, BarChart with stacked and grouped bars, AreaChart with gradients, PieChart with labels, ResponsiveContainer for fluid sizing, custom tooltips with payload access, reference lines and reference areas, recharts themes with stroke colors, and real-time charts with rolling data windows.
Claude Code for Framer Motion: React Animations and Transitions
Build fluid UI animations with Framer Motion and Claude Code — motion components with animate and variants, gesture animations with whileHover and whileTap, AnimatePresence for mount/unmount transitions, layout animations with layoutId for shared element transitions, useSpring and useTransform for scroll-driven animations, and stagger children with orchestration.
Claude Code for Jotai: Atomic State Management for React
Build fine-grained React state with Jotai and Claude Code — primitive atoms, derived atoms with read and write, async atoms with Suspense, atomWithStorage for persistence, atomWithReducer for event-driven state, atomFamily for keyed instances, DevTools integration, React Query integration with atomWithQuery, and server-side rendering with createStore.
Claude Code for Liveblocks: Real-Time Collaboration in React
Add multiplayer collaboration to apps with Liveblocks and Claude Code — storage with LiveList, LiveMap, and LiveObject, presence for cursors and avatars, useMyPresence and useOthers hooks, useStorage and useMutation for shared state, conflict-free CRDT sync, room lifecycle, undo/redo with useHistory, and Next.js App Router integration with server-side auth.
Claude Code for ElectricSQL: Local-First Sync for SQLite and PostgreSQL
Build offline-first apps with ElectricSQL and Claude Code — Electric sync service connecting PostgreSQL to client SQLite, Shape subscriptions for partial data sync, useShape React hook for reactive queries, conflict-free sync with CRDT guarantees, local writes with optimistic updates synced to Postgres, PGlite in-browser SQLite, and deployment with Electric Cloud.
Claude Code for XState: State Machines and Statecharts
Model application logic with XState and Claude Code — createMachine with states and transitions, guards and actions, invoke for async services in the machine, parallel states, history states, useMachine in React, useSelector for derived state, XState Inspector for visualization, and actor model with spawn and sendTo for component communication.
Claude Code for ts-pattern: Exhaustive Pattern Matching in TypeScript
Write expressive TypeScript with ts-pattern and Claude Code — match expressions with when conditions, discriminated unions with P.union and P.instanceOf, nested pattern matching, guard functions with P.when, exhaustive type checking to prevent missing cases, select to extract matched values, and integration with Express handlers and React state reducers.
Claude Code for TanStack Query Advanced: Optimistic Updates, Infinite Scroll, and Mutations
Master server state with TanStack Query and Claude Code — optimistic updates with onMutate and rollback, infinite scroll with useInfiniteQuery, prefetching with queryClient.prefetchQuery, dependent queries, query invalidation strategies, suspense mode, background refetching with stale-while-revalidate, offline support, and devtools integration.
Claude Code for Pino: Structured JSON Logging for Node.js
Add production-ready logging to Node.js with Pino and Claude Code — structured JSON output with child loggers, pino-http middleware for request logging, redact for PII masking, pino-pretty for development, log levels with level configuration, async transport with pino/file destination, Fastify integration, and correlation IDs for distributed tracing.
Claude Code for Tiptap: Rich Text Editor with Extensions
Build rich text editing with Tiptap and Claude Code — StarterKit with Heading, Bold, and Link, custom extensions with Node and Mark, collaboration with Hocuspocus and Y.js, slash commands with suggestion API, image upload with ImageExtension, floating toolbar with BubbleMenu, JSON and HTML serialization, and Next.js and React integration.
Claude Code for MDX: Rich Content with React Components in Markdown
Build interactive documentation and blogs with MDX and Claude Code — MDX syntax combining Markdown and JSX, custom components with mdxComponents map, frontmatter with gray-matter, Next.js App Router with next-mdx-remote, Astro MDX integration, Contentlayer type-safe content, code syntax highlighting with rehype-pretty-code, and custom remark and rehype plugins.
Claude Code for Expo Router: File-Based Navigation in React Native
Build React Native apps with Expo Router and Claude Code — file-based routing with app/ directory, Stack and Tabs layout configuration, dynamic routes with [id] params, typed navigation with useLocalSearchParams and useRouter, Expo SDK integration, authentication flow with protected routes, deep links and universal links, and EAS Build for CI deployment.
Claude Code for Drizzle ORM Advanced: Relations, Migrations, and Multi-Tenant
Master Drizzle ORM with Claude Code — relations API with one-to-many and many-to-many, query builder with with nested relations, custom types with jsonb and enum, migration workflows with drizzle-kit generate and migrate, multi-tenant row-level isolation with RLS, connection pooling with pg and Neon serverless, and type-safe complex query composition.
Claude Code for Sanity Studio: Headless CMS with GROQ Queries
Build content-driven applications with Sanity Studio and Claude Code — schema definitions with defineType and defineField, document and array types, portable text with custom marks, GROQ queries with projections and joins, GROQ subscriptions for live preview, image URL builder with @sanity/image-url, Next.js App Router integration with sanity/react, and webhook revalidation.
Claude Code for Capacitor: Native Mobile Apps from Web Projects
Build native iOS and Android apps with Capacitor and Claude Code — Capacitor CLI to add native platforms, core plugins for Camera, Filesystem, Geolocation, and Notifications, custom native plugins with Swift and Kotlin, live reload during development, App capacitor.config.ts configuration, deep links, Ionic Framework integration, and deployment to App Store and Play Store.
Claude Code for Oxlint: Ultrafast JavaScript Linter in Rust
Lint JavaScript and TypeScript at Rust speed with Oxlint and Claude Code — oxlint CLI, eslint-plugin-oxlint for compatibility layer, configuration with oxlintrc.json, fix mode, custom rule categories, integration with CI workflows, ESLint migration, pre-commit hooks with lint-staged, and performance benchmarks replacing ESLint in large codebases.
Claude Code for esbuild: Ultrafast JavaScript Bundler and Transformer
Bundle and transform JavaScript with esbuild and Claude Code — build API with entryPoints and bundle options, transform API for single-file transforms, plugins with onResolve and onLoad hooks, code splitting with chunkNames, CSS bundling, watch mode with rebuild, metafile analysis, and integration as a Vite alternative for library builds.
Claude Code for Vitest Advanced: Mocking, Coverage, and Workspace Config
Write fast TypeScript tests with Vitest and Claude Code — vi.mock and vi.spyOn for module mocking, vi.fn for function mocks, fake timers with vi.useFakeTimers, snapshot testing, coverage with v8 and istanbul, workspace config for monorepos, browser mode with Playwright, inline snapshots, and test.each for parameterized tests.
Claude Code for Testing Library Advanced: Async, Context, and Integration Patterns
Write robust React tests with Testing Library and Claude Code — userEvent for realistic interactions, waitFor and findBy for async UI, msw integration for API mocking, renderWithProviders helper for context, custom queries, accessibility testing with jest-axe, component testing with Vitest and JSDOM, and integration test patterns for forms and routing.
Claude Code for shadcn/ui Advanced: Theming, Custom Components, and Forms
Build production-grade UIs with shadcn/ui and Claude Code — CSS variable theming with HSL tokens, extending base components with cva variants, React Hook Form with shadcn Form primitive, compound component patterns, Dialog and Sheet with controlled state, Combobox with search, DataTable with TanStack Table, and custom registry components.
Claude Code for Valibot: Lightweight Runtime Schema Validation
Validate data at runtime with Valibot and Claude Code — schema composition with object, string, number, array, and union, pipe for chained transforms and refinements, parse and safeParse with detailed issue reporting, TypeScript type inference with InferOutput, integration with React Hook Form and Hono, and bundle-size comparison with Zod.
Claude Code for Payload CMS: Headless CMS with TypeScript
Build content-driven applications with Payload CMS and Claude Code — collection and global definitions, field types with validation, access control functions, hooks for business logic, local API for server-side queries, REST and GraphQL auto-generation, custom components, and Next.js integration with the Payload provider.
Claude Code for GraphQL Yoga: Server, Schema, and Subscriptions
Build GraphQL APIs with GraphQL Yoga and Claude Code — schema-first with type-defs and resolvers, code-first with Pothos, subscriptions over SSE, persisted queries, error handling with GraphQLError, context injection, Shield authorization, and deployment to Cloudflare Workers and Next.js API routes.
Claude Code for React Email: Transactional Email Templates in React
Build email templates with React Email and Claude Code — Email component with Section, Row, Column, Button, and Text primitives, render() to HTML and plain text, preview server with react-email CLI, Resend and SendGrid integration, inline styles from Tailwind, dynamic template props, and email client compatibility testing.
Claude Code for Kysely: Type-Safe SQL Query Builder
Write type-safe SQL with Kysely and Claude Code — Database type inference from schema, selectFrom and insertInto query builders, joins with LeftJoin and InnerJoin, migrations with Kysely Migrator, transaction API, raw SQL with sql template tag, Codegen from existing databases, and PostgreSQL/MySQL/SQLite dialect setup.
Claude Code for Hono: Ultrafast Web Framework for Edge and Node.js
Build edge-native web applications with Hono and Claude Code — routing with method chaining, middleware for auth and CORS, Zod OpenAPI validator, RPC client with type inference, JSX rendering for server components, Hono Islands for interactive pages, deployment to Cloudflare Workers, Vercel Edge, and Deno Deploy.
Claude Code for TanStack Router: Type-Safe Routing with File-Based Routes
Build type-safe React applications with TanStack Router and Claude Code — file-based routing with createFileRoute, loaders for data fetching with useLoaderData, search param validation with Zod, nested layouts, authenticated route guards, pending states with Suspense, and router DevTools integration.
Claude Code for Zustand Advanced: Slices, Middleware, and Persist
Build scalable React state with Zustand and Claude Code — slice pattern for modular stores, immer middleware for immutable updates, persist middleware with storage adapters, devtools integration, subscribeWithSelector for derived state, shallow equality selectors, TypeScript generics, and testing stores with act.
Claude Code for tRPC v11: End-to-End Type-Safe APIs
Build fully type-safe APIs with tRPC v11 and Claude Code — router with query and mutation procedures, Zod input validation, context with authentication, middleware for auth guards, React Query integration with useSuspenseQuery, error handling with TRPCError, and subscriptions with server-sent events.
Claude Code for Vite Plugins: Custom Build Transforms and Dev Server Extensions
Write custom Vite plugins with Claude Code — plugin hooks resolveId/load/transform for code transforms, configureServer for dev middleware, handleHotUpdate for HMR, virtual modules pattern, rollup plugin hooks compatibility, environment-specific plugins, and testing plugins with vitest.
Claude Code for SST Ion: Full-Stack Apps on AWS with Infrastructure as TypeScript
Build and deploy full-stack AWS applications with SST Ion and Claude Code — sst.config.ts with AWS resources, Function and API constructs, live Lambda dev with sst dev, Secret management, SvelteKit and Next.js site deployment, RDS and DynamoDB bindings, and resource linking for type-safe environment variables.
Claude Code for Biome: Fast Linting and Formatting for JavaScript
Configure Biome for fast JavaScript and TypeScript linting and formatting with Claude Code — biome.json configuration, lint rules with recommended and all profiles, safe and unsafe fix modes, format options for indent and quotes, CI integration with --ci flag, migrate from ESLint and Prettier, and VS Code extension setup.
Claude Code for Supabase Advanced: Vector Search, Edge Functions, and RLS
Build production Supabase applications with Claude Code — pgvector for semantic search with embedding storage, advanced Row Level Security policies with security definer functions, Supabase Edge Functions with Deno, Realtime channel subscriptions with filters, pg_cron for scheduled jobs, and custom database webhooks.
Claude Code for Cloudflare R2: S3-Compatible Object Storage at the Edge
Build with Cloudflare R2 and Claude Code — R2 bucket binding in Workers, multipart uploads for large files, pre-signed URLs for direct browser uploads, R2 event notifications, Workers KV for metadata, S3-compatible client with aws4fetch, public bucket CDN configuration, and signed URL generation.
Claude Code for Elixir Nx and Axon: Machine Learning in Elixir
Build machine learning pipelines in Elixir with Nx and Axon and Claude Code — Nx tensors with defn JIT compilation, EXLA for GPU acceleration, Axon neural network definition and training, Bumblebee for HuggingFace model inference, Nx.Serving for concurrent batched predictions, and Explorer DataFrames for data manipulation.
Claude Code for Partytown: Third-Party Scripts Off the Main Thread
Move third-party scripts to a web worker with Partytown and Claude Code — Partytown configuration for Analytics, Tag Manager, and Intercom, forward event configuration, reverse proxy setup for same-origin script serving, Next.js and Astro integration, debugging with logCalls, and measuring main thread relief.
Claude Code for Astro DB: Type-Safe SQL in Astro with LibSQL
Build data-driven Astro sites with Astro DB and Claude Code — db/config.ts table definitions with column types, seed files for local development, db.select/insert/update queries, Drizzle ORM integration, Astro Actions for type-safe form mutations, remote database setup on Astro Studio, and migration workflow.
Claude Code for Nx: Monorepo Build System with Caching and Generators
Manage large monorepos with Nx and Claude Code — project graph for dependency analysis, affected commands to run only changed projects, computation caching with Nx Cloud, custom generators with @nx/devkit, task pipelines, module federation for micro-frontends, and publishable library configuration.
Claude Code for Lit: Web Components with Reactive Properties
Build framework-agnostic web components with Lit and Claude Code — LitElement with @property and @state decorators, reactive update lifecycle, html template literals with directives, css tagged templates, shadow DOM, slots and composition, custom events, and publishing to npm for cross-framework reuse.
Claude Code for Bun: HTTP Server, File I/O, and SQLite
Build fast server applications with Bun and Claude Code — Bun.serve() HTTP server with WebSocket support, Bun.file() streaming responses, bun:sqlite for zero-dependency SQLite, Bun's test runner with expect matchers, worker threads with Bun.Worker, and hot module reloading in dev.
Claude Code for Angular Signals: Fine-Grained Reactivity and Zoneless Apps
Build reactive Angular applications with signals and Claude Code — signal, computed, and effect primitives, toSignal and toObservable for RxJS interop, input() and output() signal-based component APIs, resource() for async data loading, deferrable views, and zoneless change detection configuration.
Claude Code for PocketBase: Self-Hosted Backend with Collections and Auth
Build self-hosted backends with PocketBase and Claude Code — JavaScript SDK CRUD operations, collection schema design, real-time subscriptions, file uploads, custom API rules with filter syntax, extend with Go hooks, and deploy PocketBase as a single binary.
Claude Code for Deno KV: Built-In Key-Value Store and Queue
Build persistent Deno applications with Deno KV and Claude Code — atomic transactions with check/set/delete, secondary indexes, list with prefix scanning, KV queues with enqueue/listenQueue, Deno Deploy global replication, watch for real-time subscriptions, and testing with in-memory KV.
Claude Code for Inngest: Durable Functions and Event-Driven Workflows
Build reliable serverless workflows with Inngest and Claude Code — inngest.createFunction with steps, step.run for retryable units, step.sleep and step.waitForEvent for delays and human approval, event-driven fan-out with sendEvent, rate limiting, and local dev with the Inngest Dev Server.
Claude Code for React Native New Architecture: JSI, Fabric, and TurboModules
Build high-performance React Native apps with the New Architecture and Claude Code — JSI synchronous native calls, TurboModules with NativeModule spec files, Fabric renderer with concurrent features, Codegen type generation, Reanimated 3 worklets, and bridgeless mode configuration.
Claude Code for Neon: Serverless PostgreSQL with Branching and Autoscaling
Build serverless applications with Neon PostgreSQL and Claude Code — @neondatabase/serverless HTTP driver for edge/serverless, database branching for preview environments, Drizzle ORM integration, connection pooling with PgBouncer, point-in-time restore, and Neon autoscaling configuration.
Claude Code for Trigger.dev: Background Jobs and Event-Driven Workflows
Build reliable background jobs with Trigger.dev v3 and Claude Code — task definitions with retry and timeout, scheduled cron tasks, event-driven triggers, batch processing with concurrency limits, waitForEvent for human-in-the-loop, and local dev with the Trigger.dev CLI.
Claude Code for Svelte 5: Runes, Snippets, and Fine-Grained Reactivity
Build reactive Svelte 5 applications with Claude Code — $state and $derived runes, $effect for side effects, $props for component contracts, snippets for reusable templates, event attributes replacing on:event, and SvelteKit actions with enhanced form handling.
Claude Code for Turso: Edge SQLite with libSQL and Global Replication
Build edge-native applications with Turso and Claude Code — libSQL client with embedded replicas, schema migrations with turso db shell, Drizzle ORM integration, multi-tenant database-per-tenant architecture, edge function deployment, and branching for preview environments.
Claude Code for Effect-TS: Type-Safe Effects and Error Handling
Build robust TypeScript applications with Effect and Claude Code — Effect<Success, Error, Requirements> type, pipe composition, Effect.gen with yield*, Layer for dependency injection, Schema for runtime validation, Stream for async sequences, and Fiber for concurrency.
Claude Code for Knative: Serverless Workloads on Kubernetes
Run serverless workloads on Kubernetes with Knative and Claude Code — Knative Serving with auto-scaling to zero, traffic splitting for canary deployments, Knative Eventing with brokers and triggers, CloudEvents, Kafka event sources, and kn CLI workflows.
Claude Code for Convex: Real-Time Backend-as-a-Service with TypeScript
Build reactive full-stack apps with Convex and Claude Code — schema.ts with validators, query/mutation/action functions, useQuery and useMutation React hooks, real-time subscriptions, file storage, scheduled functions, and Convex Auth.
Claude Code for Loki and Grafana: Centralized Logging and Dashboards as Code
Build production observability with Grafana Loki and Claude Code — structured JSON logging, LogQL queries with label matchers and regex, Grafana dashboard JSON with panels and variables, alerting rules, Promtail agent config, and Helm deployment for Kubernetes.
Claude Code for FastHTML: Python-First Web Apps Without JavaScript Frameworks
Build modern web apps with FastHTML and Claude Code — components as Python functions, HTMX for server-driven interactivity, zero-build frontend, Starlette under the hood, FT (FastTag) element builders, form handling, and deployment to any ASGI host.
Claude Code for OpenCV: Computer Vision Pipelines and Image Processing
Build production computer vision systems with OpenCV and Claude Code — image preprocessing pipelines, object detection with YOLO, face detection, contour analysis, video stream processing, camera calibration, and integration with PyTorch and ONNX inference.
Claude Code for AutoGen: Conversational Multi-Agent Workflows
Build self-organizing AI agent systems with Microsoft AutoGen and Claude Code — AssistantAgent and UserProxyAgent, GroupChat with custom speaker selection, nested chats for sub-workflows, code execution sandboxing, tool registration, and human-in-the-loop patterns.
Claude Code for Qwik: Resumable Applications with Zero JavaScript Hydration
Build instant-loading apps with Qwik and Claude Code — resumability vs hydration, component$() with useSignal and useStore, server$ functions, lazy loading with useTask$, QwikCity routing with loaders and actions, and Partytown for third-party scripts.
Claude Code for Swift Concurrency: Async/Await, Actors, and Structured Concurrency
Write safe concurrent Swift with Claude Code — async/await with Task and TaskGroup, actor isolation for data safety, AsyncStream and AsyncSequence, Sendable protocol, MainActor for UI updates, Swift 6 strict concurrency checking, and SwiftUI async data loading.
Claude Code for Elixir LiveView: Real-Time Server-Rendered UIs
Build real-time web apps with Phoenix LiveView and Claude Code — LiveView mount/handle_event/handle_info lifecycle, LiveComponent for reusable state, PubSub for multi-user updates, streams for large lists, form handling with changesets, and JS hooks for client interop.
Claude Code for Databricks: Unified Lakehouse with Delta Lake and MLflow
Build production data platforms with Databricks and Claude Code — Delta Lake ACID transactions with merge/upsert, Unity Catalog for governance, structured streaming with Auto Loader, MLflow Model Registry, Feature Store, and Databricks Asset Bundles for CI/CD.
Claude Code for Apache Beam: Unified Batch and Streaming Pipelines
Build portable data pipelines with Apache Beam and Claude Code — PCollections with transforms, ParDo and DoFn for element processing, windowing for streaming data, side inputs, Dataflow runner deployment, and pipeline testing with TestPipeline.
Claude Code for Mojo: Python Superset with Systems-Level Performance
Write AI infrastructure code with Mojo and Claude Code — fn vs def functions, struct vs class, SIMD vectorization with DType, parametric types with alias, memory management with owned/borrowed/inout, and Python interop via PythonObject.
Claude Code for Haystack: Production RAG Pipelines and Document AI
Build production document AI with Haystack and Claude Code — Pipeline with component composition, DocumentStore with Elasticsearch and Weaviate, BM25 hybrid retrieval, extractive and generative QA, custom components, and REST API deployment.
Claude Code for Julia: High-Performance Data Science and Scientific Computing
Write fast data science code with Julia and Claude Code — multiple dispatch, DataFrames.jl for tabular data, Flux.jl for machine learning, DifferentialEquations.jl for simulation, Pluto.jl reactive notebooks, and Pkg.jl project environments.
Claude Code for Haskell: Pure Functional Programming and Type System Mastery
Write robust Haskell programs with Claude Code — algebraic data types, typeclasses with instances, Monad and Functor composition, IO and State monads, servant for type-safe web APIs, QuickCheck property testing, and Cabal/Stack project setup.
Claude Code for Crystal: Ruby-Like Syntax with C-Level Performance
Write fast, type-safe programs with Crystal and Claude Code — static typing with type inference, fibers and channels for concurrency, C bindings with lib/fun, HTTP::Server for web services, Spec testing framework, and shards package management.
Claude Code for CrewAI: Multi-Agent Workflows with Role-Based Orchestration
Build autonomous multi-agent systems with CrewAI and Claude Code — Crew with Agent and Task definitions, sequential and hierarchical process flows, tool use with custom tools and LangChain integrations, memory with RAG, and async agent execution.
Claude Code for Weights & Biases: Experiment Tracking and Hyperparameter Sweeps
Track ML experiments with W&B and Claude Code — wandb.init with config, log_artifact for datasets and models, Sweeps with Bayesian optimization, Tables for prediction analysis, and integration with PyTorch, Hugging Face Trainer, and Lightning.
Claude Code for ONNX: Cross-Platform Model Export and Optimized Inference
Deploy ML models anywhere with ONNX and Claude Code — export PyTorch and Hugging Face models to ONNX format, optimize with ONNX Runtime graph optimizations, quantize INT8 for CPU inference, run with ORT in Python/C++/Node.js, and benchmark latency.
Claude Code for DSPy: Declarative LLM Programs That Optimize Themselves
Build self-improving LLM pipelines with DSPy and Claude Code — ChainOfThought modules, Retrieve for RAG, compiled optimizers with BootstrapFewShot and MIPRO, assertions for output constraints, typed predictors with Pydantic, and MLflow integration.
Claude Code for Hugging Face Transformers: Fine-Tuning, Datasets, and Inference
Deploy production ML pipelines with Hugging Face and Claude Code — AutoModelForSequenceClassification with LoRA/PEFT, Trainer API with compute_metrics, Datasets with map/filter transforms, pipeline() for inference, Hub push_to_hub, and BitsAndBytes quantization.
Claude Code for Flutter Advanced: State Management, Riverpod, and Performance
Build production Flutter apps with Claude Code — Riverpod 2 with AsyncNotifier, go_router for type-safe navigation, Hive and Isar for local storage, platform channels for native APIs, Flutter test and integration testing, and performance profiling.
Claude Code for OpenAI Advanced: Assistants API, Batch, and Fine-Tuning
Leverage OpenAI's full API with Claude Code — Assistants API with file search and code interpreter, Batch API for cost-efficient bulk inference, fine-tuning with DPO, structured outputs with response_format, and Realtime API for voice.
Claude Code for Zig: Systems Programming Without Hidden Control Flow
Write reliable systems code with Zig and Claude Code — comptime generics, error handling with error unions, allocator-aware data structures, C interop with cImport, build.zig configuration, and cross-compilation to WASM and embedded targets.
Claude Code for tRPC Subscriptions: Real-Time Type-Safe APIs
Build real-time applications with tRPC subscriptions and Claude Code — WebSocket subscriptions with server-sent events, Next.js App Router integration, React Query with tRPC, input validation with Zod, and subscription authentication patterns.
Claude Code for SolidJS Advanced: Fine-Grained Reactivity and SolidStart
Build ultra-fast UIs with SolidJS and Claude Code — fine-grained reactivity with createSignal and createMemo, stores with createStore, SolidStart server functions, routing with file-based conventions, and Suspense for async data loading.
Claude Code for Neo4j: Graph Databases and Cypher Queries
Model and query graph data with Neo4j and Claude Code — Cypher query patterns, relationship traversal, graph algorithms with GDS, recommendation engines, fraud detection patterns, and Python/Node.js driver integration.
Claude Code for MLflow: Experiment Tracking and Model Registry
Track ML experiments with MLflow and Claude Code — run logging with autolog, custom metrics, artifact storage, model registry with staging/production transitions, MLflow Projects for reproducibility, and serving models with MLflow Serving.
Claude Code for Remix Advanced: Loaders, Actions, and Nested Routing
Master Remix with Claude Code — nested route layouts, loader data with TypeScript, action mutations with optimistic UI, file uploads with Cloudflare R2, error boundaries, resource routes, and full-stack form handling.
Claude Code for Astro Advanced: Content Collections, View Transitions, and Islands
Build blazing-fast content sites with Astro and Claude Code — content collections with Zod schemas, view transitions API, server islands, image optimization, middleware, and deploying to Vercel, Cloudflare, and Netlify.
Claude Code for Crossplane: Kubernetes-Native Infrastructure
Build cloud infrastructure with Crossplane and Claude Code — Composite Resource Definitions, Compositions, managed resources, provider configuration, XRDs for self-service APIs, and GitOps-driven infrastructure provisioning.
Claude Code for Prisma Advanced: Transactions, Extensions, and Type Safety
Master Prisma ORM with Claude Code — interactive transactions, client extensions for soft delete and audit, middleware for logging, Prisma Pulse for real-time change streams, type-safe queries with selectRelationCount, and testing with Prisma mock.
Claude Code for LlamaIndex: Production RAG Pipelines
Build production RAG systems with LlamaIndex and Claude Code — document ingestion pipelines, vector store integration, query engines, RAG evaluation with RAGAS, hybrid search, and multi-document agent workflows.
Claude Code for Vercel AI SDK: Streaming AI in Next.js Apps
Build AI-powered web apps with the Vercel AI SDK and Claude Code — useChat and useCompletion hooks, streamText and generateObject with Zod schemas, tool calls, multi-step agentic loops, and RSC streaming with AI SDK React.
Claude Code for Ansible: Playbooks, Roles, and Idempotent Automation
Automate infrastructure with Ansible and Claude Code — playbook structure, role design, Jinja2 templates, handlers, Vault for secrets, dynamic inventory, molecule testing, and AWX/AAP job templates.
Claude Code for DuckDB: In-Process Analytics on Files
Run analytical SQL on files with DuckDB and Claude Code — scan Parquet and CSV directly, httpfs for S3 queries, window functions, PIVOT, spatial extensions, Python integration, and building local data lakehouse architectures.
Claude Code for Polars: Fast DataFrames in Python
Analyze data efficiently with Polars and Claude Code — lazy API with scan_parquet, expression syntax, group_by aggregations, joins, window functions, streaming large datasets, and replacing pandas patterns with Polars equivalents.
Claude Code for HashiCorp Vault: Dynamic Secrets and PKI
Manage secrets at scale with HashiCorp Vault and Claude Code — dynamic database credentials, AWS IAM roles, AppRole auth, PKI certificate authority, Vault Agent sidecar, Transit encryption-as-a-service, and Kubernetes integration.
Claude Code for Pulumi: TypeScript Infrastructure as Code
Define cloud infrastructure with Pulumi and TypeScript using Claude Code — stacks, ComponentResources, StackReferences for cross-stack dependencies, dynamic providers, Pulumi ESC for secrets, and testing with mocks.
Claude Code for PostgreSQL Performance: Indexes, Query Plans, and Partitioning
Optimize PostgreSQL with Claude Code — EXPLAIN ANALYZE interpretation, index design for common query patterns, partial indexes, covering indexes, table partitioning, connection pooling with PgBouncer, and VACUUM strategy.
Claude Code for Vue 3: Composition API, Pinia, and Nuxt 4 Patterns
Build Vue 3 apps with Claude Code — Composition API with script setup, Pinia stores, composables, Vue Router 4, Vite, component testing with Vitest, and Nuxt 4 pages with server-side rendering.
Claude Code for Java Testing: JUnit 5, Mockito, TestContainers, and Spring Test
Write comprehensive Java tests with Claude Code — JUnit 5 parameterized tests, Mockito mocks and stubs, Spring Boot test slices, TestContainers for real databases, ArchUnit for architecture tests, and JaCoCo coverage.
Claude Code for Backstage and IDPs: Developer Portals, Golden Paths, and DORA Metrics
Build internal developer platforms with Claude Code — Backstage catalog-info.yaml, scaffolder templates, custom plugins, environment self-service, DORA metrics collection, and platform API design.
Claude Code for Deno and Fresh: Server-Side Rendering Without Build Steps
Build web apps with Deno and Fresh using Claude Code — Fresh 2 island architecture, Preact components, Deno Deploy, Deno KV for persistence, Fresh middleware, server-side rendering, and zero-config deployments.
Claude Code for AWS Bedrock: Building AI Applications on Managed Infrastructure
Build AI apps on AWS Bedrock with Claude Code — invoke Claude and other foundation models, streaming responses, Bedrock Agents with action groups, Knowledge Bases with RAG, Guardrails, and cost management.
Claude Code for ClickHouse Analytics: Real-Time OLAP and High-Throughput Ingestion
Build real-time analytics with ClickHouse and Claude Code — MergeTree table design, materialized views, Window functions for funnel and cohort analysis, ReplacingMergeTree for deduplication, Kafka engine integration, and Python client patterns.
Claude Code for Android: Kotlin, Jetpack Compose, and Modern Android Development
Build Android apps with Claude Code — Jetpack Compose UI, Kotlin Coroutines, ViewModel with StateFlow, Room database, Hilt dependency injection, WorkManager for background tasks, and Play Store submission.
Claude Code for iOS Development: Swift, SwiftUI, and Apple Frameworks
Build iOS apps with Claude Code — SwiftUI views and navigation, Swift Concurrency, Core Data with CloudKit sync, push notifications with APNs, WidgetKit, SwiftData, and App Store submission.
Claude Code for Redis Advanced: Streams, Lua Scripts, Pub/Sub, and Clustering
Use Redis beyond caching with Claude Code — Redis Streams for event sourcing, Lua scripts for atomic operations, Pub/Sub with patterns, RedisSearch full-text search, cluster mode, and Redis Stack.
Claude Code for Data Pipelines: ETL, dbt, and Orchestration Patterns
Build reliable data pipelines with Claude Code — SQLAlchemy ETL patterns, dbt models and tests, incremental strategies, Dagster asset definitions, data quality with Great Expectations, and pipeline observability.
Claude Code for NGINX and Caddy: Reverse Proxy, SSL, and Performance Tuning
Configure NGINX and Caddy with Claude Code — reverse proxy setup, automatic SSL with Caddy, rate limiting, caching headers, WebSocket proxying, load balancing, security hardening, and performance tuning.
Claude Code for GraphQL Federation: Schemas, Subgraphs, and Router Config
Build Apollo Federation 2 supergraphs with Claude Code — subgraph schema design with @key and @external, entity resolution, shared types, Apollo Router YAML config, demand control, and contract schemas.
Claude Code for TypeScript Generics: Advanced Types, Inference, and Utility Patterns
Master TypeScript generics with Claude Code — conditional types, mapped types, template literal types, infer keyword, recursive types, builder patterns, type-safe event emitters, and discriminated unions.
Claude Code for Python Testing: pytest, Fixtures, Mocking, and Coverage
Write comprehensive Python tests with Claude Code — pytest fixtures and parametrize, unittest.mock, async tests with anyio, property-based testing with Hypothesis, mutation testing, and CI coverage reporting.
Claude Code for React Native + Expo: Mobile Apps with TypeScript and EAS
Build cross-platform mobile apps with React Native, Expo, and Claude Code — Expo Router, native modules, Expo EAS builds, push notifications, offline storage, animations with Reanimated, and app store submission.
Claude Code for Kubernetes Operators: Custom Resources, Controllers, and Kubebuilder
Build Kubernetes operators with Claude Code — CRD design, controller reconciliation loops, Kubebuilder scaffolding, status conditions, webhook validation, RBAC manifests, and operator testing with envtest.
Claude Code for Apache Kafka: Consumer Groups, Exactly-Once, and Stream Processing
Build robust Kafka applications with Claude Code — consumer group patterns, exactly-once semantics, Kafka Streams topologies, dead letter queues, schema registry with Avro, and observability with consumer lag monitoring.
Claude Code for Rust + WebAssembly: wasm-pack, wasm-bindgen, and Browser Integration
Compile Rust to WebAssembly with Claude Code — wasm-pack workflow, wasm-bindgen for JS interop, passing complex types, web workers for non-blocking execution, SIMD optimization, and npm package publishing.
Claude Code for Next.js Server Actions: Forms, Mutations, and Optimistic UI
Use Next.js Server Actions with Claude Code — form handling without API routes, revalidation, optimistic updates with useOptimistic, progressive enhancement, error handling, and type-safe actions with next-safe-action.
Claude Code for Go Testing: Table Tests, Mocks, Integration Tests, and Benchmarks
Write comprehensive Go tests with Claude Code — table-driven tests, interface mocks with testify/mock, HTTP handler testing, database integration tests with testcontainers, fuzz testing, and benchmarks.
Claude Code for Turborepo: Monorepo Pipelines, Caching, and Remote Cache
Manage monorepos with Turborepo and Claude Code — pipeline configuration, task dependencies, remote caching with Vercel, workspace packages, code sharing patterns, and pruned Docker builds.
Claude Code for Pydantic v2: Validation, Serialization, and Settings
Use Pydantic v2 with Claude Code — model definitions, field validators, model validators, computed fields, pydantic-settings for env config, JSON Schema generation, serialization modes, and FastAPI integration.
Claude Code for SvelteKit: Advanced Patterns for Full-Stack Apps
Build production SvelteKit apps with Claude Code — load functions, form actions, server-side rendering, streaming, hooks, error boundaries, Svelte 5 runes, and deployment to Cloudflare/Vercel.
Claude Code for Tauri: Building Desktop Apps with Rust and Web Frontend
Build cross-platform desktop apps with Tauri and Claude Code — Rust commands, IPC bridge, file system access, system tray, auto-updater, SQLite with tauri-plugin-sql, and packaging for macOS/Windows/Linux.
Claude Code for PyTorch: Model Training, Custom Datasets, and Production Deployment
Train and deploy ML models with PyTorch and Claude Code — custom Dataset/DataLoader, training loops, gradient checkpointing, mixed precision, model checkpointing, TorchScript export, and ONNX conversion.
Claude Code for MCP: Building Model Context Protocol Servers
Build MCP servers with Claude Code — Model Context Protocol tools, resources, prompts, TypeScript SDK, Python SDK, stdio and HTTP transports, and integrating external APIs into Claude's context.
Claude Code for MongoDB: Aggregation Pipelines, Indexes, and Change Streams
Build MongoDB applications with Claude Code — aggregation pipelines, compound indexes, Atlas Search, transactions, change streams, schema validation, and the document modeling patterns that prevent N+1 queries.
Claude Code for Fastify: High-Performance Node.js APIs
Build fast Node.js APIs with Fastify and Claude Code — TypeBox schema validation, plugin architecture, lifecycle hooks, decorators, JWT auth, and benchmarking patterns for production TypeScript servers.
Claude Code for Cloudflare D1: SQLite at the Edge
Build database-backed edge applications with Cloudflare D1 and Claude Code — D1 bindings in Workers, schema migrations, query patterns, D1 with Drizzle ORM, and multi-region read replicas.
Claude Code for TanStack Table: Advanced Data Grids in React
Build powerful data grids with TanStack Table v8 and Claude Code — sorting, filtering, pagination, column visibility, row selection, virtualization, and server-side data for large datasets.
Claude Code for DynamoDB: Single-Table Design and Access Patterns
Master DynamoDB with Claude Code — single-table design, composite sort keys, GSI/LSI patterns, condition expressions, DynamoDB Streams, transactions, and the access-pattern-first modeling approach.
Claude Code for Webhooks: Reliable Delivery, Signatures, and Event Systems
Build production webhook systems with Claude Code — webhook delivery with retries, HMAC signature verification, idempotency, event catalog design, fanout architecture, and webhook testing patterns.
Claude Code for TimescaleDB: Time-Series Data with PostgreSQL
Build time-series applications with TimescaleDB and Claude Code — hypertables, continuous aggregates, compression policies, time_bucket queries, retention policies, and PostgreSQL compatibility.
Claude Code for Flutter: Cross-Platform Mobile and Web Development
Build cross-platform apps with Flutter and Claude Code — Widget tree patterns, state management with Riverpod, navigation with go_router, platform channels, responsive layouts, and testing.
Claude Code for NATS: High-Performance Messaging and Event Streaming
Build event-driven systems with NATS and Claude Code — pub/sub, request/reply, NATS JetStream for durable messaging, key/value store, object store, and microservice communication patterns.
Claude Code for OPA and Rego: Policy as Code
Implement policy as code with Open Policy Agent and Rego using Claude Code — authorization policies, Kubernetes admission control, API gateway policies, Rego unit tests, and integrating OPA into CI pipelines.
Claude Code for AWS Step Functions: Serverless Workflow Orchestration
Orchestrate serverless workflows with AWS Step Functions and Claude Code — state machine definitions, parallel states, error handling, wait states, Express vs Standard workflows, and CDK integration.
Claude Code for AWS CDK: Infrastructure as TypeScript
Define AWS infrastructure with CDK and Claude Code — Constructs, Stacks, context-aware resources, CDK Pipelines, custom constructs, environment-specific configuration, and best practices for production CDK apps.
Claude Code for Advanced React Hooks: Custom Hooks, Patterns, and Composition
Master advanced React hooks with Claude Code — custom hook design, useReducer for complex state, context composition, useSyncExternalStore, concurrent features, and performance hooks for production React apps.
Claude Code for ClickHouse: Real-Time Analytics at Scale
Build real-time analytics with ClickHouse and Claude Code — MergeTree table engines, materialized views, aggregation functions, partitioning, time-series queries, and Python client patterns for high-volume event processing.
Claude Code for LangChain and LangGraph: AI Agent Orchestration
Build AI agent systems with LangChain and LangGraph using Claude Code — chains, tool use, LangGraph stateful agents, multi-agent graphs, human-in-the-loop, and production observability with LangSmith.
Claude Code for Passkeys and WebAuthn: Passwordless Authentication
Implement passkeys and WebAuthn with Claude Code — registration and authentication ceremonies, credential storage, authenticator types, attestation, and progressive enhancement alongside existing passwords.
Claude Code for Snowflake: Data Warehouse SQL Patterns and Automation
Build Snowflake data warehouse solutions with Claude Code — virtual warehouses, Streams and Tasks, Time Travel, dynamic data masking, Snowpark Python, and cost optimization patterns.
Claude Code for Zod: Runtime Validation and Type-Safe Schemas
Build type-safe validation with Zod and Claude Code — schema definition, form validation, API request/response validation, custom refinements, Zod with tRPC, and validation error handling patterns.
Claude Code for Apache Spark: Large-Scale Data Processing with PySpark
Process large datasets with Apache Spark and Claude Code — PySpark DataFrames, Spark SQL, window functions, streaming with Structured Streaming, Delta Lake, and performance tuning for production pipelines.
Claude Code for Celery: Distributed Task Queues and Background Jobs
Build distributed task queues with Celery and Claude Code — task definitions, Redis/RabbitMQ brokers, retry strategies, task routing, scheduled tasks with Celery Beat, and monitoring with Flower.
Claude Code for Ray: Distributed Python, Parallel Training, and Hyperparameter Tuning
Scale Python workloads with Ray and Claude Code — Ray Core tasks and actors, Ray Data for distributed ETL, Ray Train for distributed ML, Ray Tune for hyperparameter search, and Ray Serve for model serving.
Claude Code for Vector Databases: Embeddings, Semantic Search, and RAG
Build vector search and RAG applications with Claude Code — pgvector for PostgreSQL, Pinecone, Weaviate, embedding generation, similarity search, hybrid search, and production retrieval patterns.
Claude Code for Chaos Engineering: Fault Injection and Resilience Testing
Build chaos engineering practices with Claude Code — fault injection, failure scenarios, Chaos Monkey patterns, chaos experiments, circuit breakers, and resilience testing in staging and production.
Claude Code for Bun: Runtime, Bundler, and Test Runner
Use Bun with Claude Code — Bun's built-in HTTP server, SQLite, test runner, bundler, shell API, and drop-in Node.js compatibility for fast TypeScript development.
Claude Code for Drizzle ORM: Type-Safe SQL with Zero Magic
Use Drizzle ORM with Claude Code — schema definition, migrations, relational queries, transactions, connection pooling, and type-safe SQL patterns for PostgreSQL and SQLite.
Claude Code with the Anthropic SDK: Tool Use, Streaming, and Agent Patterns
Build AI-powered applications with the Anthropic SDK and Claude Code — tool use, function calling, streaming responses, multi-turn conversations, Computer Use, and production agent patterns.
Claude Code for Embedded Systems: RTOS, Hardware Interfaces, and Firmware Patterns
Write firmware and embedded systems code with Claude Code — FreeRTOS task design, UART/SPI/I2C drivers, interrupt handlers, memory constraints, bootloader patterns, and hardware-in-the-loop testing.
Claude Code for HTMX and Alpine.js: Hypermedia and Lightweight Interactivity
Build interactive web applications with HTMX and Alpine.js using Claude Code — server-driven UI, out-of-band swaps, SSE for real-time, Alpine.js for local state, and progressive enhancement.
Claude Code for Accessibility: ARIA Patterns, Screen Readers, and WCAG Compliance
Build accessible web applications with Claude Code — ARIA roles and properties, keyboard navigation, screen reader testing, focus management, color contrast, and WCAG 2.1 AA compliance auditing.
Claude Code for LLM Evaluations: Testing AI Systems Reliably
Build LLM evaluation frameworks with Claude Code — automated evals, human eval pipelines, regression testing, LLM-as-judge patterns, benchmark datasets, and continuous eval in CI.
Claude Code for Kotlin and Spring Boot: Coroutines, WebFlux, and Idiomatic Kotlin
Build Spring Boot applications with Kotlin and Claude Code — coroutines for reactive code, WebFlux with Kotlin Flow, DSL-style bean configuration, data classes, sealed classes for error handling, and testing.
Claude Code for Pulumi: Infrastructure as Real Code with TypeScript and Python
Manage cloud infrastructure with Pulumi and Claude Code — TypeScript/Python infrastructure, component resources, stack references, automation API, and testing with mocks.
Claude Code for SOLID Principles: Applying Design Patterns in Practice
Apply SOLID principles with Claude Code — Single Responsibility refactoring, Open-Closed with strategy pattern, Liskov substitution, Interface Segregation, Dependency Inversion, and when to break the rules.
Claude Code for dbt Advanced: Exposures, Packages, and Cross-Project Refs
Advanced dbt patterns with Claude Code — exposures for downstream tracking, dbt packages for reuse, cross-project references, semantic layer, data contracts, and dbt-core CI optimization.
Claude Code for GraphQL Federation: Subgraphs, Gateway, and Distributed Schema
Build GraphQL Federation with Claude Code — Apollo Federation v2 subgraphs, router configuration, entity resolution, @defer for streaming, and schema contracts.
Claude Code for Terraform: Modules, Remote State, and Multi-Environment Patterns
Manage infrastructure with Terraform and Claude Code — reusable modules, remote state backends, workspace strategies, drift detection, cost estimation, and testing with Terratest.
Claude Code for FastAPI: Advanced Patterns, Auth, and Production FastAPI
Build production FastAPI applications with Claude Code — dependency injection, background tasks, WebSocket endpoints, custom middleware, Pydantic v2 validation, async SQLAlchemy, and deployment.
Claude Code for Go Microservices: HTTP Handlers, gRPC, and Concurrency Patterns
Build production Go microservices with Claude Code — idiomatic HTTP handlers, gRPC services, context propagation, goroutine patterns, structured logging with slog, and graceful shutdown.
Claude Code for Nix: Reproducible Environments, Flakes, and Development Shells
Use Nix with Claude Code — Nix flakes for reproducible dev environments, devShell for onboarding, NixOS modules, Home Manager, and CI with deterministic builds.
Claude Code for Apache Flink: Real-Time Analytics, CEP, and Stateful Processing
Build real-time data pipelines with Apache Flink and Claude Code — DataStream API, Table API, Complex Event Processing, checkpointing, watermarks, and late event handling.
Claude Code for Ruby: Rack Middleware, Rails Patterns, and Background Jobs
Build Ruby applications with Claude Code — Rack middleware stack, Rails service objects, Sidekiq background jobs, ActiveRecord optimizations, and Ruby-specific testing patterns.
Claude Code for ML Inference: vLLM Serving, Batching, and Model APIs
Deploy ML models for production inference with Claude Code — vLLM for LLM serving, continuous batching, tensor parallelism, OpenAI-compatible API, TorchServe for PyTorch, and GPU memory optimization.
Claude Code for Kafka Streams: Stream Processing, Stateful Joins, and Windowed Aggregations
Build stream processing applications with Kafka Streams and Claude Code — KStream/KTable, windowed aggregations, stream-table joins, interactive queries, and fault-tolerant state stores.
Claude Code for Dapr: Service Invocation, Pub/Sub, and Distributed State
Build distributed applications with Dapr and Claude Code — service-to-service calls, pub/sub messaging, state store abstraction, secrets management, and workflow orchestration.
Claude Code for Feature Flags: OpenFeature, LaunchDarkly, and Safe Rollouts
Implement feature flags with Claude Code — OpenFeature standard, provider integration, targeting rules, flag-driven database migrations, percentage rollouts, and kill switches.
Claude Code for Progressive Web Apps: Service Workers, Offline, and Background Sync
Build production-quality PWAs with Claude Code — service worker lifecycle, caching strategies, offline fallbacks, background sync, push notifications, and install prompts.
Claude Code for WebRTC: Peer-to-Peer Video, Signaling Servers, and Data Channels
Build WebRTC applications with Claude Code — signaling server implementation, ICE negotiation, TURN servers, data channels for multiplayer, screen sharing, and connection diagnostics.
Claude Code for Bazel: Hermetic Builds, Remote Caching, and Monorepo Efficiency
Use Bazel with Claude Code — BUILD files, remote caching, custom rules, query language, Go/TypeScript/Python targets, and speeding up CI in a monorepo.
Claude Code for CQRS: Command Query Responsibility Segregation Patterns
Implement CQRS with Claude Code — command handlers, query handlers, separate read/write models, eventual consistency, and when CQRS helps vs adds complexity.
Claude Code for Zero-Downtime Deployments: Blue-Green, Rolling, and Database Migrations
Deploy without downtime using Claude Code — blue-green deployments, rolling deployments, feature flags for data migrations, backward-compatible schema changes, and rollback strategies.
Claude Code for Internationalization: i18n, l10n, and Multi-Language Apps
Implement internationalization with Claude Code — translation extraction, ICU message format, pluralization rules, RTL layout support, date/number formatting, and locale-aware routing.
Claude Code for OAuth2 and Authentication: Flows, PKCE, and Session Management
Implement OAuth2 correctly with Claude Code — authorization code flow with PKCE, refresh token rotation, session management, social login, OIDC, and securing API routes.
Claude Code for SRE: SLOs, Error Budgets, and Reliability Engineering
Apply Site Reliability Engineering practices with Claude Code — defining SLIs and SLOs, calculating error budgets, writing burn rate alerts, building reliability dashboards, and blameless postmortems.
Claude Code for Reactive Programming: RxJS Patterns and Stream-Based Architecture
Master reactive programming with RxJS and Claude Code — observable patterns, operator chains, error handling, hot vs cold observables, higher-order observables, and real-world use cases.
Claude Code for Event Sourcing: Immutable Audit Logs and Temporal Queries
Implement event sourcing with Claude Code — event store design, aggregate patterns, projections, snapshots, temporal queries, and migrating from CRUD to event-sourced models.
Claude Code for Supply Chain Security: SBOM, Sigstore, and Dependency Hardening
Secure your software supply chain with Claude Code — generating SBOMs, signing artifacts with Sigstore/cosign, dependency pinning, Renovate for automated updates, and container image hardening.
Claude Code for Monolith-to-Microservices Migration: Strangler Fig and Beyond
Migrate from monolithic architecture to microservices with Claude Code — the Strangler Fig pattern, domain extraction, data decomposition, anti-corruption layers, and avoiding the distributed monolith trap.
Claude Code for Rate Limiting: Algorithms, Distributed Patterns, and Implementation
Implement production rate limiting with Claude Code — token bucket, sliding window, fixed window algorithms, Redis-based distributed rate limiting, per-user quotas, and graceful degradation.
Claude Code for Cryptography: Practical Patterns for Developers
Implement cryptography correctly with Claude Code — password hashing, symmetric and asymmetric encryption, JWT signing, key rotation, envelope encryption, and common mistakes to avoid.
Claude Code for WebAssembly Components: WASI, Component Model, and Cross-Language Modules
Build portable WebAssembly components with Claude Code — WASI APIs, the Component Model for language interoperability, Wasmtime embedding, compiling Rust/C/Go to WASM, and deploying to Cloudflare Workers.
Claude Code for Developer Documentation: API Docs, READMEs, and Technical Guides
Generate high-quality developer documentation with Claude Code — API reference from code, README structure, architecture decision records, runbooks, and keeping docs synchronized with code changes.
Claude Code for SQLite in Production: Patterns, Performance, and When to Use It
Run SQLite reliably in production with Claude Code — WAL mode, connection handling, migration strategies, libSQL and Turso for edge deployment, SQLite in Electron apps, and benchmarking vs PostgreSQL.
Claude Code for Rust Async: Tokio Patterns, Concurrency, and Async Best Practices
Master async Rust with Claude Code — Tokio task management, channels, select!, timeouts, streams, avoiding common pitfalls like holding locks across await points, and performance tuning.
Claude Code for Protocol Buffers and gRPC: Schema Design and Service Implementation
Build gRPC services with Claude Code — proto schema design, service implementation in Go and TypeScript, streaming RPCs, interceptors, testing, and migration from REST to gRPC.
Claude Code for Workflow Orchestration: Airflow and Prefect Pipelines
Build data pipelines and workflow orchestration with Claude Code — Airflow DAG design, task dependencies, dynamic task mapping, Prefect flows, retries, backfill strategies, and monitoring.
Prompt Engineering for Code: Getting Better Output from Claude Code
Advanced prompt patterns for Claude Code — CLAUDE.md design, effective task decomposition, working with large codebases, debugging prompts that fail, and customizing Claude Code behavior.
Claude Code for MLOps: Model Training, Deployment, and Monitoring Pipelines
Build production ML infrastructure with Claude Code — experiment tracking, model training pipelines, containerized deployment, A/B testing, data drift detection, and model monitoring.
Claude Code for eBPF: Linux Kernel Observability and Performance Analysis
Use Claude Code to write eBPF programs for production observability — tracing system calls, profiling CPU hotspots, network packet analysis, and security monitoring with BCC and libbpf.
Claude Code for RAG Systems: Retrieval-Augmented Generation Implementation
Build production RAG pipelines with Claude Code — document chunking, embedding strategies, vector search with pgvector and Pinecone, hybrid retrieval, reranking, and evaluation.
Claude Code for Service Mesh: Istio, Traffic Management, and Zero-Trust Security
Implement service mesh patterns with Istio and Claude Code — traffic management, circuit breaking, mTLS, observability, canary deployments, and debugging mesh issues.
Claude Code for dbt: Analytics Engineering, Testing, and Data Modeling
Build production-grade analytics pipelines with dbt and Claude Code — model organization, incremental models, testing strategies, macros, documentation, and dbt Cloud CI integration.
Claude Code for Temporal Workflows: Durable Execution and Long-Running Processes
Build reliable long-running workflows with Temporal and Claude Code — workflow definitions, activity implementations, signals, queries, child workflows, schedules, and testing strategies.
Claude Code for Functional Programming: Pure Functions, Composition, and fp-ts
Apply functional programming principles with Claude Code — pure functions and referential transparency, function composition, Either/Option monads with fp-ts, immutable data patterns, and practical FP in TypeScript.
Claude Code for Web Scraping: Playwright, Anti-Bot Handling, and Data Pipelines
Build production web scrapers with Claude Code — Playwright for browser automation, handling anti-bot measures, rate limiting and proxies, structured data extraction, and processing into data pipelines.
Claude Code for Incident Response: Runbooks, Postmortems, and Chaos Engineering
Improve system reliability with Claude Code — writing runbooks for on-call, incident response playbooks, postmortem documentation, chaos engineering experiments, and SLO alerting setup.
Claude Code for Infrastructure Cost Optimization: AWS, GCP, and Database Rightsizing
Reduce cloud infrastructure costs with Claude Code — identifying idle resources, rightsizing EC2/GCP instances, database query optimization for cost, CDN tuning, and setting up cost alerting.
Claude Code for Search Implementation: Full-Text, Vector, and Faceted Search
Build production search with Claude Code — PostgreSQL full-text search with tsvector, Elasticsearch integration, vector similarity search with pgvector, faceted filtering, and search analytics.
Claude Code for Refactoring Large Codebases: Systematic Transformations and Safety
Refactor large codebases safely with Claude Code — AST-based transformations with jscodeshift, systematic search-and-replace, incremental migration strategies, test coverage before refactoring, and verifying correctness.
Claude Code for Edge Computing: Cloudflare Workers, Durable Objects, and KV
Build edge-native applications with Claude Code — Cloudflare Workers for low-latency APIs, Durable Objects for stateful edge logic, KV for global configuration, and R2 for object storage.
Claude Code for API Versioning: Strategies, Breaking Changes, and SDK Maintenance
Design and maintain versioned APIs with Claude Code — URL versioning vs header versioning, backward-compatible evolution, deprecation workflows, breaking change detection, and maintaining multiple SDK versions.
Claude Code for Advanced TypeScript: Mapped Types, Template Literals, and Compiler API
Master advanced TypeScript with Claude Code — mapped types for transformations, template literal types for string manipulation, conditional types, infer keyword, declaration merging, and TypeScript compiler API for code generation.
Claude Code for Advanced CI/CD: Deployment Pipelines, Canary Releases, and Rollbacks
Build production deployment pipelines with Claude Code — multi-stage Docker builds, GitHub Actions deployment workflows, canary releases, blue-green deployments, automated rollbacks, and release gates.
Claude Code for Developer Experience: Local Dev Setup, Onboarding, and Tooling
Improve developer experience with Claude Code — one-command local setup with Docker Compose, automated onboarding scripts, pre-commit hooks, dev container configuration, and team tooling standardization.
Claude Code for React Server Components: Patterns, Pitfalls, and Performance
Deep dive into React Server Components with Claude Code — component composition patterns, when to use use client, data fetching in RSC, the use() hook, server actions with optimistic updates, and common pitfalls.
Claude Code for Advanced PostgreSQL: Window Functions, CTEs, and Query Optimization
Master advanced PostgreSQL with Claude Code — window functions for analytics, recursive CTEs, lateral joins, partial indexes, query plan analysis with EXPLAIN ANALYZE, and materialized views.
Claude Code for Mobile Offline-First: Sync, Conflict Resolution, and Local Storage
Build offline-first mobile apps with Claude Code — SQLite with expo-sqlite, optimistic updates, conflict resolution strategies, background sync, and React Native offline patterns.
Claude Code for Database Sharding: Horizontal Partitioning, Routing, and Migration
Implement database sharding with Claude Code — shard key selection, hash vs range partitioning, application-level routing, cross-shard queries, rebalancing strategies, and migrating from a monolithic database.
Claude Code for Building LLM Agents: Tool Use, Memory, and Multi-Step Reasoning
Build production LLM agents with Claude Code — tool calling patterns, agent memory systems, multi-step task orchestration, ReAct loops, streaming responses, and evaluation frameworks.
Claude Code for Kubernetes Operators: Custom Resources, Controllers, and Reconciliation
Build Kubernetes operators with Claude Code — custom resource definitions (CRDs), controller-runtime reconciliation loops, status conditions, finalizers, and operator testing with envtest.
Claude Code for Elixir OTP: GenServers, Supervisors, and Phoenix LiveView
Build fault-tolerant Elixir applications with Claude Code — GenServer for stateful processes, Supervisor trees, Phoenix LiveView for real-time UI, Ecto queries, and testing with ExUnit.
Claude Code for Nx Monorepos: Generators, Affected Commands, and Module Boundaries
Manage large Nx monorepos with Claude Code — workspace generators, nx affected for CI optimization, module boundary enforcement, plugins, and migrating from a polyrepo.
Claude Code for OpenAPI Code Generation: Type-Safe Clients and Server Stubs
Generate type-safe API clients and server stubs from OpenAPI specs with Claude Code — openapi-typescript, oapi-codegen for Go, contract-first API design, mock servers, and spec validation.
Claude Code for Change Data Capture: Debezium, Kafka Connect, and Event Streaming
Implement change data capture (CDC) with Claude Code — Debezium connectors, Kafka Connect configuration, consuming change events in consumers, handling schema evolution, and dead letter queues.
Claude Code for Rust Web with Axum: Extractors, Middleware, and Async Handlers
Build production Rust web APIs with Axum and Claude Code — type-safe extractors, tower middleware, state management, error handling with thiserror, PostgreSQL with sqlx, and testing.
Claude Code for FastAPI: Dependency Injection, Background Tasks, and Production Patterns
Advanced FastAPI with Claude Code — dependency injection chains, background tasks, middleware, WebSockets, Pydantic v2 models, async SQLAlchemy, and testing with pytest-asyncio.
Claude Code for Ruby on Rails: Models, Controllers, Services, and Testing
Build production Rails applications with Claude Code — ActiveRecord patterns, service objects, background jobs with Sidekiq, API mode with Devise JWT, and RSpec testing strategies.
Claude Code for NestJS: Modules, Guards, Interceptors, and Dependency Injection
Build production NestJS APIs with Claude Code — modules and providers, guards for authorization, interceptors for logging and caching, pipes for validation, decorators, and testing with Jest.
Claude Code for State Machines: XState, Finite Automata, and Complex UI Flows
Model complex application logic with state machines using Claude Code — XState v5 actors, state charts for UI flows, parallel states, guards, and replacing ad-hoc boolean flags with explicit state models.
Claude Code for Dependency Injection: IoC Containers, Testing, and Modular Architecture
Structure applications with dependency injection using Claude Code — InversifyJS for TypeScript IoC, manual DI for simpler cases, testing with mock substitution, circular dependency detection, and DI for React.
Claude Code for Type Safety: Advanced TypeScript, Branded Types, and Runtime Validation
Write truly safe TypeScript with Claude Code — branded types to prevent ID confusion, conditional types and template literals, Zod for runtime validation with TypeScript inference, discriminated unions, and type-safe event systems.
Claude Code for Background Jobs: Workers, Queues, and Long-Running Processes
Build reliable background job systems with Claude Code — BullMQ worker patterns, job prioritization, dead letter queues, idempotent job handlers, worker health monitoring, and distributed job locking.
Claude Code for Caching: Redis Patterns, CDN, and Application Cache Layers
Implement caching at every layer with Claude Code — Redis cache-aside and write-through patterns, cache invalidation strategies, CDN edge caching, API response caching, and cache stampede prevention.
Claude Code for Audit Logging: Compliance, Change Tracking, and Forensic Trails
Build audit logging systems with Claude Code — immutable event logs, SOC2/HIPAA compliance patterns, change tracking with before/after diffs, user activity logs, tamper detection, and log retention policies.
Claude Code for Real-Time Collaboration: CRDTs, Operational Transform, and Shared Editing
Build collaborative editing features with Claude Code — Yjs CRDT for conflict-free merging, awareness (cursors, presence), room-based collaboration with Y-WebSocket, and integrating with ProseMirror and CodeMirror.
Claude Code for File Uploads: S3, Presigned URLs, and Direct Browser Uploads
Build robust file upload systems with Claude Code — S3 direct upload with presigned URLs, chunked uploads with resumable support, image processing pipelines, virus scanning, and CDN delivery.
Claude Code for Notification Systems: Email, Push, and In-App Notifications
Build multi-channel notification systems with Claude Code — transactional email with React Email, web push notifications, in-app notification feeds, user preferences, rate limiting, and delivery tracking.
Claude Code for Payment Systems: Subscriptions, Billing, and Payment Orchestration
Build complete payment systems with Claude Code — Stripe subscriptions with proration, dunning management, payment failure handling, multiple payment methods, webhook reliability, and PCI compliance.
Claude Code for OAuth and SSO: Google, GitHub, and Enterprise Authentication
Implement OAuth 2.0 and SSO with Claude Code — Google and GitHub OAuth flows, PKCE for SPAs, Auth0/Clerk integration, SAML for enterprise SSO, session management, and token refresh patterns.
Claude Code for Data Visualization: Charts, Dashboards, and D3.js
Build data visualizations with Claude Code — Recharts/Chart.js for React, D3.js custom visualizations, real-time dashboard updates, accessible charts with ARIA, and large dataset rendering.
Claude Code for API Gateways: Rate Limiting, Authentication, and Routing
Build API gateway functionality with Claude Code — rate limiting strategies, JWT authentication middleware, request routing, API versioning, circuit breakers, and Kong/Traefik configuration.
Claude Code for Infrastructure as Code: Pulumi, CDK, and Cloud Resource Management
Define cloud infrastructure as code with Claude Code — Pulumi TypeScript programs, AWS CDK constructs, resource dependencies, stack outputs, drift detection, and multi-environment infrastructure.
Claude Code for Mobile Performance: React Native Optimization and Bundle Size
Optimize React Native app performance with Claude Code — FlatList optimization, reducing re-renders with memo/useMemo, bundle analysis, hermes profiling, image optimization, and startup time reduction.
Claude Code for Machine Learning: Model Integration, Fine-tuning, and ML Pipelines
Build ML-powered features with Claude Code — integrating OpenAI and Hugging Face models, scikit-learn workflows, embedding generation for semantic search, model evaluation, and serving predictions via APIs.
Claude Code for Event-Driven Architecture: Event Sourcing, CQRS, and Message Brokers
Build event-driven systems with Claude Code — event sourcing with EventStoreDB, CQRS read/write model separation, Kafka event publishing, outbox pattern for reliable delivery, and saga orchestration.
Claude Code for Database Migrations: Safe Schema Changes, Zero-Downtime, and Rollbacks
Manage database schema changes safely with Claude Code — migration strategies for zero-downtime deployments, backward-compatible changes, data migrations, Flyway/Liquibase configuration, and rollback planning.
Claude Code for Unity and Game Development: C# Scripting, ECS, and Game Architecture
Accelerate Unity game development with Claude Code — C# component scripting, Unity ECS/DOTS for performance, game architecture patterns, shader generation, and editor tooling automation.
Claude Code for WebAssembly: Go, AssemblyScript, and WASM in Production
Build WebAssembly modules beyond Rust with Claude Code — Go to WASM compilation, AssemblyScript for TypeScript developers, WASM component model, shared memory with workers, and WASM in Node.js servers.
Claude Code for Helm Charts: Kubernetes Package Templating and Chart Development
Create and manage Helm charts with Claude Code — chart structure, values.yaml design, helper templates, multi-environment overrides, chart testing with helm-unittest, and publishing to OCI registries.
Claude Code for React Native Navigation: React Navigation, Deep Links, and Auth Flows
Build React Native navigation with Claude Code — React Navigation stack/tab/drawer setup, typed navigation props, deep linking configuration, authentication flow with persistent login, and modal patterns.
Claude Code for Turborepo: Monorepo Build Pipelines, Caching, and Workspace Management
Speed up monorepo development with Turborepo and Claude Code — pipeline configuration, remote caching, workspace dependency graphs, code sharing between apps, and migration from Lerna/Yarn Workspaces.
Claude Code for Load Testing: k6 Scripts, Performance Baselines, and Bottleneck Analysis
Load test your APIs and find performance bottlenecks with Claude Code — k6 script generation, virtual user scenarios, performance baselines, spike testing, and interpreting results to fix bottlenecks.
Claude Code for GitOps: ArgoCD, Flux, and Kubernetes Deployment Automation
Implement GitOps with Claude Code — ArgoCD Application manifests, sync policies, Flux Kustomization, multi-environment promotion, secrets management with Sealed Secrets, and progressive delivery.
Claude Code for Contract Testing: Pact, Consumer-Driven Contracts, and API Compatibility
Prevent integration failures with contract testing using Claude Code — Pact for consumer-driven contracts, provider verification, bi-directional contracts, and CI/CD integration for microservices.
Claude Code for Multi-Tenancy: Row-Level Security and Tenant Isolation
Build multi-tenant SaaS applications with Claude Code — schema strategies (shared vs separate), PostgreSQL Row-Level Security, tenant context in middleware, data isolation testing, and tenant provisioning.
Claude Code for Scheduled Jobs: Cron, Background Workers, and Job Queues
Build reliable scheduled jobs with Claude Code — cron with node-cron and BullMQ, job queues with retry logic, distributed locking to prevent duplicate runs, monitoring, and failure handling.
Claude Code for Design Systems: Tokens, Component Libraries, and Documentation
Build a production design system with Claude Code — design tokens with CSS custom properties and Style Dictionary, component APIs, theming, documentation with Storybook, and the design-to-code workflow.
Claude Code for Search: Elasticsearch, Typesense, and Full-Text Search
Build search features with Claude Code — Elasticsearch index design, full-text queries with fuzzy matching, Typesense for simpler search, PostgreSQL full-text search, faceted filtering, and result highlighting.
Claude Code for React 19: Actions, Transitions, and the New Compiler
Use React 19 features with Claude Code — useActionState, useFormStatus, useOptimistic, the React Compiler for automatic memoization, Actions for async mutations, and upgrading from React 18.
Claude Code for Error Handling: Patterns That Don't Mask Bugs
Build robust error handling with Claude Code — Result types vs exceptions, error boundaries, centralized error tracking, error codes, retry logic with backoff, and the difference between operational and programmer errors.
Claude Code for Cloudflare Workers: Edge Computing and D1 Database
Build edge applications with Cloudflare Workers using Claude Code — Workers KV, D1 SQLite database, R2 object storage, Durable Objects for stateful edge, and the Hono framework for routing.
Claude Code for TanStack Query: Server State, Caching, and Mutations
Master TanStack Query (React Query) with Claude Code — query keys, stale-while-revalidate caching, optimistic mutations, infinite scroll, prefetching, and the server state vs client state distinction.
Claude Code for SQL Query Optimization: EXPLAIN, Indexes, and N+1 Queries
Optimize slow database queries with Claude Code — reading EXPLAIN ANALYZE output, choosing the right indexes, eliminating N+1 queries, query rewriting strategies, and PostgreSQL-specific optimizations.
Claude Code for Solid.js: Fine-Grained Reactivity Without Virtual DOM
Build high-performance UIs with Solid.js using Claude Code — signals and derived state, stores, SolidStart full-stack framework, resource primitives, and the reactivity model that makes Solid faster than React.
Claude Code for OpenTelemetry: Distributed Tracing and Metrics
Instrument applications with OpenTelemetry using Claude Code — distributed tracing across services, custom spans, metrics with histograms and gauges, log correlation, and exporting to Datadog and Jaeger.
Claude Code for WebSocket Scaling: Redis Pub/Sub and Sticky Sessions
Scale WebSocket servers across multiple instances with Claude Code — Redis pub/sub for message broadcasting, sticky session load balancing, Socket.io cluster adapter, health checks, and connection management.
Claude Code for gRPC: Protocol Buffers, Streaming, and Service Mesh
Build gRPC services with Claude Code — Protobuf schema design, unary and streaming RPCs, gRPC-Web for browsers, interceptors for auth and observability, and service mesh integration.
Claude Code for CLI Development: Node.js and Go Command-Line Tools
Build production CLI tools with Claude Code — argument parsing with Commander and Cobra, interactive prompts with Inquirer, progress bars, config management, and distribution with npm and Homebrew.
Claude Code for Feature Flags: Safe Deployments and Gradual Rollouts
Implement feature flags with Claude Code — LaunchDarkly and OpenFeature integration, gradual rollouts, A/B testing, kill switches, and testing code behind flags.
Claude Code for Storybook: Component Documentation and Visual Testing
Build a living component library with Storybook using Claude Code — writing stories, interaction tests, visual regression with Chromatic, accessibility checks, and documentation patterns.
Claude Code for GraphQL Code Generation: Type-Safe Queries with graphql-codegen
Generate TypeScript types from GraphQL schemas using Claude Code — graphql-codegen setup, typed hooks for Apollo and React Query, fragment-based data fetching patterns, and schema-first development.
Claude Code for Mobile CI/CD: App Store Deployment with Fastlane and GitHub Actions
Automate iOS and Android releases with Claude Code — Fastlane lanes for building and signing, GitHub Actions workflows, beta distribution with TestFlight and Firebase App Distribution, and release automation.
Claude Code for Spring Boot Security: JWT, OAuth2, and Method Security
Secure Spring Boot APIs with Claude Code — JWT authentication, Spring Security filter chains, OAuth2 resource server configuration, role-based access control, and security testing.
Claude Code for Elixir and Phoenix: Functional Web Development
Build concurrent web applications with Elixir and Phoenix using Claude Code — LiveView for real-time UI, Ecto for database queries, GenServer processes, and fault-tolerant supervision trees.
Claude Code for Progressive Web Apps: Offline, Push Notifications, and Install
Build production PWAs with Claude Code — service workers, cache strategies, push notifications, background sync, Web App Manifest, and installability testing.
Claude Code for WebAssembly: Rust, C++, and Performance-Critical Code
Use Claude Code to build WebAssembly modules in Rust and C++, integrate with JavaScript, optimize for binary size and performance, and choose when WebAssembly is the right tool.
Claude Code for Django REST Framework: Building Production APIs
Build production-ready APIs with Django REST Framework using Claude Code — serializers, ViewSets, authentication, permissions, filtering, pagination, and testing with pytest.
Claude Code for Electron: Desktop Apps with Web Technologies
Build cross-platform desktop apps with Electron using Claude Code — main/renderer process architecture, IPC communication, native OS integration, auto-updates, and security hardening.
Claude Code for Remix: Loaders, Actions, and Full-Stack React
Build full-stack React apps with Remix using Claude Code — route loaders, form actions, error boundaries, optimistic UI, nested routing, and deployment to Cloudflare Workers.
Claude Code for Nuxt 3: Full-Stack Vue with Server Routes and Nitro
Build full-stack applications with Nuxt 3 using Claude Code — server routes, Nitro engine, useFetch composables, Pinia state management, hybrid rendering, and deployment to Vercel and Cloudflare.
Claude Code with Deno and Bun: Modern JavaScript Runtimes
Using Claude Code with Deno 2 and Bun — native TypeScript, permissions model, built-in tooling, JSR packages, Bun's bundler and test runner, and migrating from Node.js.
Claude Code for REST API Design: Best Practices, OpenAPI, and Versioning
How to use Claude Code to design and document REST APIs — resource naming, HTTP methods, status codes, OpenAPI 3.1 specs, API versioning strategies, and error response formats.
Claude Code for GitHub Actions: Advanced Workflows, Matrix Builds, and Automation
How to use Claude Code to build advanced GitHub Actions workflows — matrix builds, reusable workflows, workflow dispatch, environments, secrets management, and cost optimization.
Claude Code for Astro: Static Sites, Content Collections, and Island Architecture
How to use Claude Code with Astro — content collections, island architecture, component islands, SSR vs static, Markdown/MDX, and deploying to Cloudflare Pages or Netlify.
Claude Code Testing Strategy: Unit vs Integration vs E2E — What to Write
How to use Claude Code to build the right testing strategy — when to write unit tests vs integration tests vs E2E tests, the testing trophy, test coverage that matters, and avoiding over-testing.
Claude Code for AWS Lambda: Functions, API Gateway, and Event Processing
How to use Claude Code with AWS Lambda — function patterns, API Gateway integration, SQS/SNS event processing, Lambda layers, cold start optimization, and CDK deployment.
Claude Code for tRPC: End-to-End Type Safety Without Code Generation
How to use Claude Code with tRPC — routers, procedures, input validation, middleware, React Query integration, subscriptions, and why tRPC beats REST for TypeScript monorepos.
Claude Code for SvelteKit: Runes, Server Actions, and Full-Stack Patterns
How to use Claude Code with SvelteKit — Svelte 5 Runes for reactivity, SvelteKit form actions, load functions, server-side rendering, and deployment to Cloudflare and Vercel.
Claude Code for Angular: Standalone Components, Signals, and RxJS
How to use Claude Code with Angular 17+ — standalone components, new Signals API, RxJS reactive patterns, Angular Material, NgRx state management, and testing with Jest.
Claude Code for Redis: Caching, Sessions, Rate Limiting, and Pub/Sub
How to use Claude Code with Redis — caching strategies with TTL, session storage, rate limiting patterns, pub/sub for real-time features, sorted sets for leaderboards, and Lua scripts.
Claude Code for Vue.js: Composition API, Pinia, and Vue 3 Patterns
How to use Claude Code with Vue.js 3 — Composition API with script setup, Pinia state management, composables, Vue Router 4, component testing with Vitest, and performance optimization.
Claude Code for Stripe Integration: Payments, Subscriptions, and Webhooks
How to use Claude Code to implement Stripe payments — checkout sessions, subscription management, webhook handling, SCA compliance, customer portal, and testing payment flows.
Claude Code for Prisma: Schema Design, Migrations, and Query Optimization
How to use Claude Code with Prisma ORM — schema design, type-safe queries, migrations, relations, and performance optimization for PostgreSQL, MySQL, and SQLite.
Claude Code for Python Data Science: Pandas, NumPy, and ML Workflows
How to use Claude Code for data science in Python — EDA with pandas, vectorized NumPy operations, scikit-learn pipelines, Jupyter integration, data cleaning automation, and ML model deployment.
Claude Code in Vim and Neovim: Terminal-First AI Development
How to use Claude Code with Vim and Neovim — terminal multiplexer setup, shell integration, keybindings, working with tmux, and efficient terminal-first Claude Code workflows.
Claude Code for Security Testing: Penetration Testing Patterns and Automated Scanning
How to use Claude Code for security testing — OWASP Top 10 scanning, dependency audits, secrets detection, SQL injection testing, SAST integration, and security-focused code review.
Claude Code for Next.js App Router: Server Components, Actions, and Caching
Deep dive into Next.js 14+ App Router with Claude Code — server components, server actions, route handlers, Suspense streaming, caching strategies, and migration from Pages Router.
Claude Code for Real-Time GraphQL: Subscriptions, Federation, and Performance
Build real-time features with GraphQL subscriptions using Claude Code — WebSocket transport, subscription resolvers, Apollo Federation for microservices, persisted queries, and N+1 optimization.
Claude Code for Mobile Testing: Detox, React Native, and Device Automation
How to use Claude Code to write mobile E2E tests with Detox, automate React Native testing, debug flaky tests on simulators, and integrate mobile testing into CI/CD.
Claude Code for Accessibility: WCAG Compliance, ARIA, and Automated Testing
How to use Claude Code to audit and fix web accessibility — WCAG 2.1 compliance, semantic HTML, ARIA labels, keyboard navigation, screen reader testing, and axe-core integration.
Claude Code for AI/LLM Integrations: Building with APIs, RAG, and Agents
How to use Claude Code to build AI-powered features — LLM API integration, RAG pipelines, embeddings, streaming responses, function calling, and multi-step AI agents.
Claude Code for Kafka and Message Queues: Async Patterns That Scale
How to use Claude Code to implement Kafka producers and consumers, RabbitMQ message queues, dead letter queues, exactly-once processing, and event streaming patterns.
Claude Code for E2E Testing: Playwright and Cypress Automation
How to use Claude Code to write and maintain end-to-end tests with Playwright and Cypress — page object models, CI integration, visual regression, and debugging flaky tests.
Claude Code for Teams: Shared Workflows, Standards, and Collaboration
How development teams use Claude Code together — shared CLAUDE.md standards, PR review automation, team conventions, onboarding new developers, and maintaining consistency.
Claude Code for Microservices: Service Design, Communication, and Patterns
How to use Claude Code to design and build microservices — service boundaries, REST and gRPC communication, service mesh, circuit breakers, distributed tracing, and event-driven patterns.
Claude Code for Data Engineering: ETL Pipelines, dbt, and Data Workflows
How to use Claude Code for data engineering — building ETL/ELT pipelines, writing dbt models, querying data warehouses, debugging pipeline failures, and orchestrating with Airflow.
Claude Code for Performance Optimization: Profiling, Bottlenecks, and Speed
How to use Claude Code to find and fix performance bottlenecks — profiling Node.js and Python apps, memory leak detection, database query optimization, and frontend performance.
Claude Code for Documentation: README, API Docs, and Developer Guides
How to use Claude Code to write and maintain documentation — README files, API documentation with OpenAPI/Swagger, JSDoc/TSDoc, Storybook stories, and developer guides.
Claude Code for API Testing: REST, Contract Testing, and Mock Servers
How to use Claude Code for comprehensive API testing — unit testing endpoints, contract testing, integration tests with real databases, mock servers with msw, and API client testing.
Claude Code for Observability: OpenTelemetry, Logging, and Monitoring
Use Claude Code to add observability to production systems — structured logging, OpenTelemetry tracing, Prometheus metrics, Grafana dashboards, and alerting patterns.
Claude Code for Terraform and Infrastructure as Code
How to use Claude Code to write Terraform configurations, debug plan errors, structure modules, manage state, and build infrastructure for AWS, GCP, and Azure.
Claude Code for Serverless: AWS Lambda, Cloudflare Workers, and Vercel Functions
How to use Claude Code for serverless development — AWS Lambda functions, Cloudflare Workers, Vercel Edge Functions, cold starts, event processing, and deployment.
Claude Code for Authentication: JWT, OAuth, Sessions, and Auth Patterns
How to use Claude Code to implement authentication — JWT tokens, OAuth2/OIDC flows, session management, refresh token rotation, and securing API endpoints.
Claude Code for WebSockets and Real-Time Apps: Patterns and Implementation
How to use Claude Code to build real-time features — WebSocket servers, Socket.IO, Server-Sent Events, presence systems, collaborative editing, and live dashboards.
Claude Code for Monorepos: Turborepo, Nx, and Multi-Package Workspaces
How to use Claude Code to manage monorepos — Turborepo pipelines, Nx project graphs, shared packages, workspace dependencies, and cross-package refactoring.
Claude Code for Rust: Ownership, Error Handling, and Systems Programming
How to use Claude Code for Rust development — ownership and borrowing patterns, Result/Option error handling, async with Tokio, CLI tools with Clap, and writing idiomatic Rust.
Claude Code for CLI Tools: Building Command-Line Apps in Node.js, Python, and Go
How to use Claude Code to build CLI tools — argument parsing, interactive prompts, progress indicators, config management, and publishing to npm and PyPI.
Claude Code for GraphQL: Schema Design, Resolvers, and Client Integration
How to use Claude Code for GraphQL development — schema-first design, resolver patterns, N+1 problem (DataLoader), subscriptions, and TypeScript integration with Apollo and codegen.
Claude Code for React Native: Mobile App Development Workflows
How to use Claude Code for React Native development — navigation setup, native modules, state management, platform-specific code, performance, and testing mobile apps.
Claude Code for Java and Spring Boot: REST APIs, JPA, and Enterprise Patterns
How to use Claude Code for Java development — Spring Boot REST APIs, JPA/Hibernate queries, Spring Security, testing with JUnit 5, and enterprise design patterns.
Claude Code for Kubernetes: Manifests, Helm Charts, and Cluster Operations
Use Claude Code to write Kubernetes manifests, debug failing pods, create Helm charts, configure resource limits, and manage production cluster operations.
Claude Code for Python Web Development: FastAPI, Flask, and Django
How to use Claude Code for Python web development — FastAPI REST APIs, Flask apps, Django projects, async patterns, Pydantic validation, and Python testing workflows.
Claude Code for Database Work: SQL, Migrations, and Query Optimization
How to use Claude Code to write SQL queries, design schemas, optimize slow queries, and handle database migrations safely. Works with PostgreSQL, MySQL, SQLite.
Claude Code for Go: Idiomatic Go, Error Handling, and Concurrency Patterns
How to use Claude Code for Go development — idiomatic patterns, proper error handling, goroutines and channels, testing, and building production Go services.
Using Claude Code for Code Review: Automated and Manual Review Workflows
How to use Claude Code to do thorough code reviews — security checks, performance analysis, architecture feedback, and PR review automation that actually catches real bugs.
Claude Code for Docker and DevOps: Containers, Compose, and CI/CD
Use Claude Code to write Dockerfiles, debug container issues, build Docker Compose stacks, and automate DevOps workflows. Practical examples for real projects.
Claude Code for Next.js: App Router, Server Components, and Full-Stack Workflows
How to use Claude Code for Next.js development — App Router patterns, Server vs Client Components, API routes, and full-stack workflows with TypeScript.
Claude Code vs GitHub Copilot: Which AI Coding Tool Wins in 2026?
Honest comparison of Claude Code and GitHub Copilot. We cover context window, agentic tasks, code quality, pricing, and when to use each. No hype — real differences.
Claude Code for TypeScript: Types, Generics, and Type-Safe Patterns
How to use Claude Code to write better TypeScript — proper generics, utility types, discriminated unions, and avoiding common pitfalls like overusing 'any'.
How to Refactor Code with Claude Code: A Systematic Approach
Use Claude Code to refactor large codebases safely. Covers systematic refactoring workflows, handling legacy code, and using Claude to modernize technical debt.
Claude Code for React Frontend Development: Build Faster with AI
How to use Claude Code to build React components, debug UI issues, and automate frontend workflows. Practical guide with real examples for React developers.
Claude Code in CI/CD: Automated Reviews, Pre-commit Hooks, and GitHub Actions
How to integrate Claude Code into your CI/CD pipeline with GitHub Actions, pre-commit hooks, and automated code review gates. Real configs and workflows.
Claude Code for Startups: Ship Faster With a 2-Person Team That Moves Like 10
How early-stage startups use Claude Code to build faster, reduce hiring pressure, and punch above their weight in engineering velocity. Real workflows for founders and small teams.
Claude Code for Testing and Debugging: A Practical Guide (2026)
How to use Claude Code to write unit tests, debug complex bugs, and run automated code reviews. Real workflows, skill examples, and TDD patterns.
Claude Code Agents: How to Run Autonomous Tasks Without Staying at Your Keyboard
Learn how Claude Code agents differ from skills, how to configure autonomous agents for background work, and real-world patterns for multi-agent development workflows.
Claude Code Slash Commands: The Complete Guide (2026)
Master every Claude Code slash command and discover how to extend Claude Code with custom skills. Covers built-in commands, custom skills, and advanced usage patterns.
How to Create Your Own Claude Code Skills (Complete Guide 2026)
Learn to build custom Claude Code skills from scratch — the file format, slash commands, agent patterns, and how to structure skills that actually work in production.
CLAUDE.md: The Complete Guide to Project-Specific Claude Code Instructions
Learn how to configure CLAUDE.md to give Claude persistent context, custom behaviors, and project-specific rules. Master the file that controls how Claude works in every project.
Claude Code Hooks: Automate Before & After Every Action (2026 Guide)
Claude Code hooks let you run shell scripts before and after every tool call, stop event, or notification. Learn how to configure hooks to build powerful automations.
The Claude Skills Bundle: 2,350+ Skills for Claude Code in One Package
Get the complete Claude Code skills bundle — 2,350+ skills, 45+ agents, 12 swarms across 18 categories. One-time $39, instant delivery, 90-second install.
Claude Code Tutorial for Beginners: Build Your First Project in 30 Minutes
A step-by-step Claude Code tutorial for beginners. Follow along as we build a real project from scratch — installation, first commands, file editing, testing, and deployment.
Getting Started with Claude Code: From Zero to Productive in 15 Minutes
A quickstart guide to getting started with Claude Code. Install, configure, and start building in 15 minutes. Covers essential commands, project setup, and the shortcuts experienced developers need.
How to Use Claude Code: The Complete 2026 Guide
Learn how to use Claude Code from installation to advanced workflows. This practical guide covers setup, commands, skills, MCP servers, and real-world automation patterns.
10 Claude Code Skills Every Freelancer Needs in 2026
The skills that let freelancers earn 3x more by automating proposals, contracts, clients, content, and operations. Plus the exact command to invoke each one.
How Small Businesses Use AI Agents to Compete with Enterprise
Discover how small businesses are using AI agents to level the playing field. Real ROI calculations and 5 proven use cases for agencies, consultants, and SaaS founders.
AI Agents Aren't Replacing Employees — They're Replacing the Boring Parts
What AI agents actually automate (data entry, reporting, scheduling). What they can't touch. Building AI-first ops. The honest take.
Skills vs Prompts: Why Claude Code Skills Are 100x More Powerful
Understand the fundamental differences between one-off prompts and reusable AI skills, and why skills change the game.
n8n + Claude Code: The Ultimate Workflow Automation Stack
Connect n8n workflows to Claude Code skills for enterprise-grade automation. Real examples, setup guide, and patterns.
Automate Your Business with Claude Code & AI Agents
Automate business operations with Claude Code — customer support, content, reporting & lead gen. Practical playbook for entrepreneurs and founders.
How Agencies Are Automating Client Onboarding With AI Agents
Manual client onboarding is a money pit. Discover how AI agents handle contracts, access, documentation, and account setup automatically—saving agencies 15+ hours per client.
How to Build a SaaS Product with Claude Code in 30 Days
A week-by-week breakdown for launching a SaaS product using Claude Code skills and agents. From idea to first paying customers in one month.
Using Claude Code for Stock Analysis and Portfolio Management
Build an AI-powered financial analyst agent for stock research, technical indicators, risk metrics, and portfolio optimization using Claude Code and financial data MCPs.
How Marketing Agencies Use Claude Code to 10x Output
Real-world strategies for agencies to automate client work, reporting, and content with AI-powered skills.
The Freelancer's Guide to Claude Code: Bill More, Work Less
How freelancers can use Claude Code to automate proposals, contracts, reports. Save 10+ hours weekly. ROI calculator included.
Building a Personal Knowledge Base with Claude Code Skills
Create a persistent knowledge management system using Claude Code. Build your AI-powered second brain with memory systems, GraphRAG, and skill-based knowledge retrieval.
Claude Code Best Practices & Productivity Hacks (2026)
15 Claude Code best practices and productivity hacks that save hours weekly. Master workflows, skills, agents & shortcuts to ship code 10x faster.
Running a Complete Security Audit with Claude Code
Run a full OWASP security audit on your codebase in under an hour with Claude Code. Find SQL injection, leaked secrets, and broken auth — with copy-paste fix commands.
Claude Code Automation Guide: n8n + AI Workflows
Complete Claude Code automation guide using n8n. Automate lead qualification, invoicing, content publishing & reporting. Replace manual ops work.
Knowledge Graphs for Business: How to Build Your Company's Second Brain
GraphRAG + Claude Code for competitive advantage. Build searchable knowledge bases from documents, emails, customer data in 2 hours.
GraphRAG: The Knowledge System That Makes AI Actually Useful for Business
RAG is broken. GraphRAG fixes it. Learn how knowledge graphs transform AI accuracy for customer support, docs, and internal knowledge.
Claude Code MCP Servers: Setup Guide & Custom Config
Set up Claude Code MCP servers step by step. Install, configure & build custom MCP servers to integrate 50+ tools into your AI workflow.
How to Set Up Automated Cron Jobs with Claude Code
Learn how to set up recurring tasks and scheduled workflows using Claude Code. Automate daily reports, data syncs, and business operations with cron jobs and workflow automation.
The 25 Most Useful Claude Code Skills in 2026
Complete guide to the 25 most powerful Claude Code skills for developers, DevOps, and engineering teams.
Build AI Agents with Claude Code: Tutorial & Guide
Claude Code agent tutorial — design autonomous AI agents that plan, execute multi-step tasks & recover from errors. Practical guide with examples.
Claude Code vs Cursor vs GitHub Copilot (2026 Comparison)
Claude Code vs GitHub Copilot vs Cursor — honest feature, pricing & workflow comparison. See which AI coding tool wins for your use case.
How Entrepreneurs Are Using AI Swarms to Run Their Businesses
From solo founders to agency teams — real-world examples of multi-agent AI systems handling entire business functions overnight.
MCP Servers for Claude Code: What They Are & How to Use Them
Claude Code MCP servers explained — what Model Context Protocol is, how it works, and how to install or build custom servers for your business stack.
Ready to transform your workflow?
Explore Claude Skills 360 — 2,350+ professional skills, 45+ autonomous agents, and 12 business swarms. One-time purchase. Lifetime updates.
New articles every week
No spam, no sales pitches. Just insights from practitioners.
Coming soon. Newsletter launching in March 2026.