code-explore-by-sql 0.1.0__py3-none-any.whl

code_source_sql/edge_extractor.py

@@ -0,0 +1,183 @@
+"""Strict edge extractor — only deterministic, unambiguous relationships.
+
+Extracts exactly 4 edge types per plan.md:
+- inheritance: class A : public B
+- type_dependency: function signature types (excluding basic types)
+- static_call: explicit scope calls (Super::BeginPlay, UGameplayStatics::...)
+- rpc_routing: framework-determined implicit routing (Server -> _Implementation)
+
+Anti-Cartesian-Product rules:
+- NEVER extract generalized pointer calls (Comp->Init())
+- Basic types (TArray, FString, int, FName) generate NO edges
+
+Refactored to accept LanguageConfig + FrameworkConfig instead of hardcoded constants.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .configs import FrameworkConfig, LanguageConfig
+from .symbol_analyzer import ExtraSymbol, SymbolDef
+
+
+@dataclass
+class StrictEdge:
+    source_qn: str
+    target_qn: str
+    edge_type: str  # inheritance, type_dependency, static_call, rpc_routing
+    language: str = ""
+
+
+def extract_edges(
+    symbols: list[SymbolDef],
+    extra_symbols: list[ExtraSymbol],
+    lines: list[str],
+    fw: FrameworkConfig,
+    lang: LanguageConfig,
+) -> list[StrictEdge]:
+    """Extract all deterministic edges for a file.
+
+    Uses both symbol metadata and source text to find strict edges.
+    All regex patterns come from LanguageConfig and FrameworkConfig.
+    """
+    language = lang.name
+    base_kw = lang.base_keyword
+    type_re = lang.type_re
+    static_call_re = lang.static_call_re
+    super_call_re = lang.super_call_re
+    param_type_re = lang.param_type_re
+    control_flow_names = lang.control_flow_names
+    access_spec_names = lang.access_spec_names
+
+    edges: list[StrictEdge] = []
+    seen: set[tuple[str, str, str]] = set()
+
+    all_skip = lang.basic_skip_types | fw.skip_types | fw.noise_type_names
+
+    def _add(src: str, tgt: str, etype: str) -> None:
+        if src == tgt:
+            return
+        key = (src, tgt, etype)
+        if key not in seen:
+            seen.add(key)
+            edges.append(StrictEdge(source_qn=src, target_qn=tgt, edge_type=etype, language=language))
+
+    # Build a lookup of QN -> SymbolDef for resolving static calls
+    qn_set: set[str] = set()
+    for s in symbols:
+        qn_set.add(s.qualified_name)
+
+    # --- Pass 1: Symbol metadata edges ---
+
+    for sym in symbols:
+        qn = sym.qualified_name
+
+        # 1. Inheritance
+        if sym.block_type == "class" and sym.inheritance_base:
+            base = sym.inheritance_base
+            if base not in all_skip and len(base) >= 3:
+                _add(qn, base, "inheritance")
+
+        # 2. Framework-specific edges from decoration metadata
+        if sym.decoration_meta and fw.extract_framework_edges:
+            for target_qn, edge_type in fw.extract_framework_edges(qn, sym.decoration_meta):
+                _add(qn, target_qn, edge_type)
+
+    # --- Pass 2: Source text scanning for static_call and type_dependency ---
+
+    # QN internal convention uses "::" as separator regardless of language.
+    # scope_operator is only used for source text regex matching above.
+    _QN_SEP = "::"
+
+    method_symbols = [
+        s for s in symbols
+        if s.block_type in ("method", "function")
+        and s.qualified_name.split(_QN_SEP)[-1].lower() not in control_flow_names
+    ]
+
+    for sym in method_symbols:
+        qn = sym.qualified_name
+        start = sym.start_line - 1
+        end = sym.end_line
+
+        for line_idx in range(start, min(end, len(lines))):
+            line = lines[line_idx].strip()
+
+            # Skip comments and preprocessor
+            if ((lang.line_comment and line.startswith(lang.line_comment)) or
+                (lang.block_comment_pair and line.startswith(lang.block_comment_pair[0])) or
+                (lang.preprocessor_prefix and line.startswith(lang.preprocessor_prefix))):
+                continue
+            # Skip framework decoration macro lines
+            if fw.decoration_macro_names and any(
+                line.startswith(m) for m in fw.decoration_macro_names
+            ):
+                continue
+            # Skip string literals (rough check)
+            if line.startswith('"') or (lang.raw_string_char and line.startswith(lang.raw_string_char + '"')):
+                continue
+
+            # 3. Static calls: ClassName.Method( or ClassName::Method(
+            if static_call_re:
+                for m in static_call_re.finditer(line):
+                    cls_name = m.group(1)
+                    method_name = m.group(2)
+                    if cls_name == base_kw and sym.parent_class:
+                        target = f"{sym.parent_class}::{method_name}"
+                        _add(qn, target, "static_call")
+                    elif cls_name not in all_skip and cls_name not in control_flow_names:
+                        target = f"{cls_name}::{method_name}"
+                        _add(qn, target, "static_call")
+
+            # Super/base calls
+            if super_call_re:
+                for m in super_call_re.finditer(line):
+                    method_name = m.group(1)
+                    if sym.parent_class:
+                        target = f"{sym.parent_class}::{method_name}"
+                        _add(qn, target, "static_call")
+
+            # 4. Type dependencies from function signature (only on declaration lines)
+            if line_idx == start and param_type_re:
+                for m in param_type_re.finditer(line):
+                    tname = m.group(1)
+                    if tname and tname not in all_skip and len(tname) >= 3:
+                        _add(qn, tname, "type_dependency")
+
+    # --- Pass 3: Type dependencies from class member variables ---
+    class_symbols = [s for s in symbols if s.block_type == "class"]
+    for sym in class_symbols:
+        qn = sym.qualified_name
+        start = sym.start_line - 1
+        end = sym.end_line
+
+        for line_idx in range(start, min(end, len(lines))):
+            line = lines[line_idx].strip()
+            if not line:
+                continue
+            if ((lang.line_comment and line.startswith(lang.line_comment)) or
+                (lang.block_comment_pair and line.startswith(lang.block_comment_pair[0])) or
+                (lang.preprocessor_prefix and line.startswith(lang.preprocessor_prefix))):
+                continue
+            if line in access_spec_names:
+                continue
+            if fw.decoration_macro_names and any(
+                line.startswith(m) for m in fw.decoration_macro_names
+            ):
+                continue
+
+            # Member variable: Type* Name; or Type& Name; or Type Name;
+            if type_re:
+                for m in type_re.finditer(line):
+                    tname = m.group(1)
+                    if not tname or tname in all_skip:
+                        continue
+                    if len(tname) < 3:
+                        continue
+                    pos = m.end()
+                    rest = line[pos:].lstrip() if pos < len(line) else ""
+                    if rest and (rest[0] in lang.type_indicator_chars or (rest[0].isalpha() or rest[0] == "_")):
+                        _add(qn, tname, "type_dependency")
+
+    return edges

code_source_sql/languages/__init__.py

@@ -0,0 +1,31 @@
+"""Language factory registry — imports all language factories and registers them."""
+
+from __future__ import annotations
+
+from ..configs import register_language
+from .c import make_c_language
+from .cpp import make_cpp_language
+from .csharp import make_csharp_language
+from .glsl import make_glsl_language
+from .go import make_go_language
+from .hlsl import make_hlsl_language
+from .java import make_java_language
+from .javascript import make_javascript_language, make_typescript_language
+from .kotlin import make_kotlin_language
+from .python import make_python_language
+from .rust import make_rust_language
+from .swift import make_swift_language
+
+register_language("cpp", make_cpp_language)
+register_language("csharp", make_csharp_language)
+register_language("c", make_c_language)
+register_language("java", make_java_language)
+register_language("glsl", make_glsl_language)
+register_language("go", make_go_language)
+register_language("hlsl", make_hlsl_language)
+register_language("rust", make_rust_language)
+register_language("javascript", make_javascript_language)
+register_language("typescript", make_typescript_language)
+register_language("kotlin", make_kotlin_language)
+register_language("swift", make_swift_language)
+register_language("python", make_python_language)

code_source_sql/languages/c.py

@@ -0,0 +1,118 @@
+"""C language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+_NEVER_MATCH = re.compile(r"(?!x)x")
+
+
+def make_c_language() -> LanguageConfig:
+    """C language configuration — similar to C++ but no templates, namespaces,
+    classes, lambdas, or export macros."""
+    return LanguageConfig(
+        name="c",
+        # C has struct/union (no class); enum same as C++
+        class_re=re.compile(
+            r"(?:^|\s)(struct|union)\s+"
+            r"(?:(?:[A-Z][A-Z0-9_]*_API|[A-Z][A-Z0-9_]*(?:\s*\([^)]*\))?)\s+)*"
+            r"(\w+)"
+            r"\s*",
+        ),
+        enum_re=re.compile(r"\benum\s+(\w+)"),
+        # No namespaces in C
+        namespace_re=_NEVER_MATCH,
+        func_name_re=re.compile(r"(\w+)\s*\([^)]*\)\s*$"),
+        # No export macros in plain C
+        export_macro_re=_NEVER_MATCH,
+        calling_conv_re=re.compile(
+            r"\b(?:__cdecl|__stdcall|__fastcall|__thiscall|__vectorcall|WINAPI|CALLBACK|"
+            r"STDMETHODCALLTYPE|FORCEINLINE|FORCENOINLINE|FORCEINLINE_DEBUGGABLE|inline)\b"
+        ),
+        attribute_re=re.compile(
+            r"\b(?:__declspec|__attribute__|alignas)\s*\([^)]*(?:\)[^)]*)?\)|\[\[[^\]]*\]\]"
+        ),
+        # No templates in C
+        template_re=_NEVER_MATCH,
+        # No destructors in C
+        dtor_re=_NEVER_MATCH,
+        control_flow_re=re.compile(r"\b(if|else\s+if|else|while|for|do|switch|catch|try)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "switch", "catch", "try",
+            "return", "delete", "goto", "break", "continue", "throw",
+        }),
+        trailing_mods_re=re.compile(
+            r"\s*(?:const|constexpr|inline|static)\s*[;{]*\s*$"
+        ),
+        access_spec_re=re.compile(r"^(?!x)x"),  # C has no access specifiers
+        macro_like_re=re.compile(r"^[A-Z][A-Z0-9_]*\s*(?:\([^{};]*\))?\s*$"),
+        define_re=re.compile(r"#\s*define\s+"),
+        extern_c_re=re.compile(r'\bextern\s+"C"'),
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=False,
+        uses_colon_inheritance=False,
+        # Edge extraction
+        scope_operator="::",
+        base_keyword="Super",
+        static_call_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)::([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        super_call_re=None,
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(
+            r"(?:const\s+)?([A-Z][A-Za-z0-9_]+)\s*(?:\*+|&)?\s+\w+"
+        ),
+        basic_skip_types=frozenset({
+            "int8", "int16", "int32", "int64",
+            "uint8", "uint16", "uint32", "uint64",
+            "float", "double", "bool", "void", "int", "char", "long", "short",
+            "unsigned", "size_t",
+        }),
+        # Block classification helpers
+        block_keyword_re=re.compile(r"\b(?:struct|enum|union)\b"),
+        # No lambdas in C
+        lambda_re=None,
+        # No namespaces in C
+        namespace_sig_re=_NEVER_MATCH,
+        init_list_re=None,
+        # View / summary helpers
+        access_spec_names=frozenset(),
+        view_structural_kws=("struct ", "enum ", "union "),
+        view_modifier_kws=("static ", "FORCEINLINE"),
+        local_var_modifiers="const|static|volatile",
+        # Bracket scanner hints
+        verbatim_string_prefix=None,
+        raw_string_char="R",
+        # Function body summary hints — C has no range-based for
+        range_for_re=None,
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"', "'"}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="#",
+        has_preprocessor_macros=True,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="};",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s*\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="*&",
+        define_line_re=re.compile(r"#\s*define\s+(\w+)(\([^)]*\))?\s*(.*)"),
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )

code_source_sql/languages/cpp.py

@@ -0,0 +1,106 @@
+"""C/C++ language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+
+def make_cpp_language() -> LanguageConfig:
+    """C/C++ language configuration."""
+    return LanguageConfig(
+        name="cpp",
+        class_re=re.compile(
+            r"(?:^|\s)(class|struct)\s+"
+            r"(?:(?:[A-Z][A-Z0-9_]*_API|[A-Z][A-Z0-9_]*(?:\s*\([^)]*\))?)\s+)*"
+            r"(\w+)"
+            r"\s*(?::\s*(?:public|protected|private)\s+(\w+))?",
+        ),
+        enum_re=re.compile(r"\benum\s+(?:(?:class|struct)\s+)?(\w+)"),
+        namespace_re=re.compile(r"\bnamespace\s+(\w+)"),
+        func_name_re=re.compile(r"(\w+(?:\s*::\s*\w+)*)\s*\([^)]*\)\s*$"),
+        export_macro_re=re.compile(r"\b[A-Z][A-Z0-9_]*_API\b"),
+        calling_conv_re=re.compile(
+            r"\b(?:__cdecl|__stdcall|__fastcall|__thiscall|__vectorcall|WINAPI|CALLBACK|"
+            r"STDMETHODCALLTYPE|FORCEINLINE|FORCENOINLINE|FORCEINLINE_DEBUGGABLE|inline)\b"
+        ),
+        attribute_re=re.compile(
+            r"\b(?:__declspec|__attribute__|alignas)\s*\([^)]*(?:\)[^)]*)?\)|\[\[[^\]]*\]\]"
+        ),
+        template_re=re.compile(r"\btemplate\s*<[^<>]*>"),
+        dtor_re=re.compile(r"~(\w+)\s*\("),
+        control_flow_re=re.compile(r"\b(if|else\s+if|else|while|for|do|switch|catch|try)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "do", "switch", "catch", "try",
+            "return", "delete", "goto", "break", "continue", "throw",
+            "co_await", "co_yield", "co_return",
+        }),
+        trailing_mods_re=re.compile(
+            r"\s*(?:const|override|final|noexcept|mutable|constexpr|inline|static)\s*[;{]*\s*$"
+        ),
+        access_spec_re=re.compile(r"^(?:public|private|protected)\s*:\s*(?://.*)?$"),
+        macro_like_re=re.compile(r"^[A-Z][A-Z0-9_]*\s*(?:\([^{};]*\))?\s*$"),
+        define_re=re.compile(r"#\s*define\s+"),
+        extern_c_re=re.compile(r'\bextern\s+"C"'),
+        operator_re=re.compile(r"\boperator\b"),
+        uses_braces=True,
+        uses_namespaces=True,
+        uses_colon_inheritance=True,
+        scope_operator="::",
+        base_keyword="Super",
+        static_call_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)::([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        super_call_re=re.compile(r"\bSuper::([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(
+            r"(?:const\s+)?([A-Z][A-Za-z0-9_]+)\s*(?:\*+|&)?\s+\w+"
+        ),
+        basic_skip_types=frozenset({
+            "int8", "int16", "int32", "int64",
+            "uint8", "uint16", "uint32", "uint64",
+            "float", "double", "bool", "void", "int", "char", "long", "short",
+            "unsigned", "size_t", "auto", "nullptr_t",
+        }),
+        block_keyword_re=re.compile(r"\b(?:namespace|class|struct|enum)\b"),
+        lambda_re=re.compile(r"\[.*\]\s*[\(]"),
+        namespace_sig_re=re.compile(r"(?:inline\s+)?namespace\s+(\w+)?\s*$"),
+        init_list_re=re.compile(r"\)\s*:"),
+        access_spec_names=frozenset({"public:", "protected:", "private:"}),
+        view_structural_kws=("class ", "struct ", "enum ", "namespace "),
+        view_modifier_kws=("virtual ", "static ", "override", "FORCEINLINE"),
+        local_var_modifiers="const|static|mutable|constexpr|volatile",
+        verbatim_string_prefix=None,
+        raw_string_char="R",
+        range_for_re=re.compile(
+            r"for\s*\(\s*(?:const\s+)?(\w+(?:\s*<[^>]*>)?)\s*[*&]?\s+(\w+)\s*:\s*(\w+)"
+        ),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"', "'"}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="#",
+        has_preprocessor_macros=True,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="};",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s*\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="*&",
+        define_line_re=re.compile(r"#\s*define\s+(\w+)(\([^)]*\))?\s*(.*)"),
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )

code_source_sql/languages/csharp.py

@@ -0,0 +1,103 @@
+"""C# language configuration."""
+
+from __future__ import annotations
+
+import re
+
+from ..configs import LanguageConfig
+
+
+def make_csharp_language() -> LanguageConfig:
+    """C# language configuration."""
+    return LanguageConfig(
+        name="csharp",
+        class_re=re.compile(
+            r"(?:^|\s)(class|struct|interface|record)"
+            r"(?:\s+(?:class|struct))?"
+            r"\s+"
+            r"(\w+)"
+            r"\s*(?::\s*(\w+))?",
+        ),
+        enum_re=re.compile(r"\benum\s+(\w+)"),
+        namespace_re=re.compile(r"\bnamespace\s+([\w.]+)"),
+        func_name_re=re.compile(r"(\w+)\s*\([^)]*\)\s*$"),
+        export_macro_re=re.compile(r"(?!x)x"),
+        calling_conv_re=re.compile(r"(?!x)x"),
+        attribute_re=re.compile(r"\[[^\]]*\]"),
+        template_re=re.compile(r"<[^<>]*>"),
+        dtor_re=re.compile(r"(?!x)x"),
+        control_flow_re=re.compile(r"\b(if|else\s+if|else|while|for|foreach|do|switch|catch|try|using|lock)\b"),
+        control_flow_names=frozenset({
+            "if", "else", "while", "for", "foreach", "do", "switch", "catch", "try",
+            "return", "break", "continue", "throw", "using", "lock", "yield",
+            "async", "await", "new", "this", "base", "typeof", "sizeof", "nameof",
+            "default", "checked", "unchecked", "delegate",
+        }),
+        trailing_mods_re=re.compile(r"\s*(?:override|virtual|abstract|sealed|static|async)\s*[;{]*\s*$"),
+        access_spec_re=re.compile(r"^(?!x)x"),
+        macro_like_re=re.compile(r"(?!x)x"),
+        define_re=re.compile(r"(?!x)x"),
+        extern_c_re=re.compile(r"(?!x)x"),
+        operator_re=None,
+        uses_braces=True,
+        uses_namespaces=True,
+        uses_colon_inheritance=True,
+        scope_operator=".",
+        base_keyword="base",
+        static_call_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\.([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        super_call_re=re.compile(r"\bbase\.([A-Za-z_][A-Za-z0-9_]*)\s*\("),
+        type_re=re.compile(r"\b([A-Z][A-Za-z0-9_]+)\b"),
+        param_type_re=re.compile(r"([A-Z][A-Za-z0-9_]+)\s+\w+"),
+        basic_skip_types=frozenset({
+            "int", "uint", "long", "ulong", "short", "ushort",
+            "byte", "sbyte", "float", "double", "decimal",
+            "bool", "string", "object", "void", "char",
+            "var", "dynamic", "nint", "nuint",
+        }),
+        block_keyword_re=re.compile(r"\b(?:namespace|class|struct|interface|record|enum)\b"),
+        lambda_re=re.compile(r"(?:\w+\s*=>|delegate\s*\()"),
+        namespace_sig_re=re.compile(r"namespace\s+([\w.]+)\s*$"),
+        init_list_re=None,
+        access_spec_names=frozenset({
+            "public", "private", "protected", "internal",
+            "protected internal", "private protected",
+        }),
+        view_structural_kws=("class ", "struct ", "interface ", "record ", "enum ", "namespace "),
+        view_modifier_kws=("virtual ", "static ", "override", "abstract ", "sealed ", "async "),
+        local_var_modifiers="const|static|volatile|readonly|ref|out",
+        verbatim_string_prefix="@",
+        raw_string_char=None,
+        range_for_re=re.compile(
+            r"foreach\s*\(\s*(\w+(?:\s*<[^>]*>)?)\s+(\w+)\s+in\s+(\w+)"
+        ),
+        # Comment syntax
+        line_comment="//",
+        block_comment_pair=("/*", "*/"),
+        # String syntax
+        string_delimiters=frozenset({'"'}),
+        string_escape_char="\\",
+        triple_quote_strings=(),
+        # Block style
+        uses_indent_blocks=False,
+        # Preprocessor
+        preprocessor_prefix="",
+        has_preprocessor_macros=False,
+        # Statement / block close
+        statement_terminator=";",
+        block_close_suffix="}",
+        summary_comment_prefix="//",
+        # Config-driven control flow
+        control_flow_patterns=(
+            ("for", re.compile(r"^\s*for\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("foreach", re.compile(r"^\s*foreach\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("while", re.compile(r"^\s*while\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("if", re.compile(r"^\s*(?:else\s+)?if\s*\((.{1,80})\)\s*\{?\s*$")),
+            ("switch", re.compile(r"^\s*switch\s*\((.{1,40})\)\s*\{?\s*$")),
+        ),
+        return_re=re.compile(r"^\s*return\s+(.{1,60});"),
+        # Extra syntax hints
+        type_indicator_chars="",
+        define_line_re=None,
+        has_template_strings=False,
+        raw_string_style="cpp",
+    )