{"id":2075,"library":"interegular","title":"interegular","description":"Interegular is a Python library designed to check a subset of Python regular expressions for intersections. Currently at version 0.3.3, it focuses on speed and compatibility with Python's `re` module syntax, differentiating itself from libraries like `greenery` by prioritizing performance over regex reconstruction from Finite State Machines (FSMs). The project appears to have an active development status, with updates released on an irregular cadence. [1, 2, 3]","status":"active","version":"0.3.3","language":"en","source_language":"en","source_url":"https://github.com/MegaIng/regex_intersections","tags":["regex","regular expressions","intersection","fsm","finite state machine","lark-parser"],"install":[{"cmd":"pip install interegular","lang":"bash","label":"Install `interegular`"}],"dependencies":[{"reason":"The library is adapted for and relies on `lark-parser` for its backend, particularly for parsing regex patterns.","package":"lark","optional":false}],"imports":[{"symbol":"compare_regexes","correct":"from interegular import compare_regexes"},{"symbol":"parse_pattern","correct":"from interegular import parse_pattern"},{"symbol":"Pattern","correct":"from interegular import Pattern"},{"symbol":"REFlags","correct":"from interegular import REFlags"},{"symbol":"FSM","correct":"from interegular import FSM"},{"symbol":"Comparator","correct":"from interegular import Comparator"}],"quickstart":{"code":"from interegular import compare_regexes\n\n# Example 1: Simple intersection\nregexes1 = [r\"a+\", r\"a*b\"]\nintersections1 = list(compare_regexes(*regexes1))\nprint(f\"Intersections for {regexes1}: {intersections1}\")\n\n# Example 2: No intersection\nregexes2 = [r\"[0-9]+\", r\"[a-zA-Z]+\"]\nintersections2 = list(compare_regexes(*regexes2))\nprint(f\"Intersections for {regexes2}: {intersections2}\")\n\n# Example 3: More complex patterns\nregexes3 = [r\"foo(bar|baz)+\", r\"foobar+\"]\nintersections3 = list(compare_regexes(*regexes3))\nprint(f\"Intersections for {regexes3}: {intersections3}\")\n\n# You can also work with Pattern objects directly\nfrom interegular import parse_pattern, compare_patterns\n\npattern_a = parse_pattern(r\"A.*Z\")\npattern_b = parse_pattern(r\"A[0-9]+Z\")\n\npattern_intersections = list(compare_patterns(pattern_a, pattern_b))\nprint(f\"Pattern intersections: {pattern_intersections}\")","lang":"python","description":"This quickstart demonstrates how to use `interegular.compare_regexes` to find intersections between multiple regular expression strings and `compare_patterns` for pre-parsed `Pattern` objects. It shows cases with and without common matches. [1, 2, 3]"},"warnings":[{"fix":"Avoid using unsupported regex features. Test complex patterns thoroughly to ensure correct behavior. Consider simplifying regexes if unexpected results occur.","message":"The library does not support all Python `re` features due to its FSM backend. Specifically, it lacks support for backwards references (e.g., `\\1`, `(?P=name)`) and conditional matching (e.g., `(?(1)a|b)`). Some complex lookaheads/lookbacks may also not work correctly, potentially parsing but yielding incorrect results. [1, 2, 3]","severity":"gotcha","affected_versions":"All versions"},{"fix":"Check the `REFlags` enum for supported flags. If a crucial flag is missing, you might need to preprocess your regex or adjust your logic to not depend on that flag.","message":"Not all `re` flags are currently implemented. The documentation specifically mentions 'ims' (from `aiLmsux`) as being in progress. If your regexes rely on specific flags, verify their support. [1, 2, 3]","severity":"gotcha","affected_versions":"All versions"},{"fix":"Ensure your `lark` parser configuration, if used directly, specifies a `basic` or `contextual` lexer for compatibility with `interegular`.","message":"`interegular` is designed to work with the `lark` parser, but its functionality is currently limited to when the lexer in `lark` is set to `basic` or `contextual`. Using other lexer types might lead to unexpected behavior or errors. [8]","severity":"gotcha","affected_versions":"All versions"},{"fix":"Be aware that lazy quantifiers will behave greedily. Adjust your regexes to achieve the desired effect without relying on non-greedy semantics, or accept the greedy interpretation when using `interegular`.","message":"Lazy quantifiers (e.g., `*?`, `+?`, `??`) are currently treated the same way as their greedy counterparts (`*`, `+`, `?`). This can lead to surprising behavior and incorrect intersection results if your regex logic relies on non-greedy matching. [18]","severity":"gotcha","affected_versions":"All versions"}],"env_vars":null,"last_verified":"2026-04-09T00:00:00.000Z","next_check":"2026-07-08T00:00:00.000Z"}