linhai 0.1.0__tar.gz

linhai-0.1.0/.gitea/scripts/check_any_object_type_annotations.py

@@ -0,0 +1,194 @@
+import sys
+import os
+import subprocess
+import ast
+from typing import List, Set, Tuple, Optional, Dict
+
+
+def get_any_aliases(tree: ast.AST) -> Set[str]:
+    """Extract all aliases for typing.Any from import statements."""
+    aliases: Set[str] = {"Any"}
+    typing_module_names: Set[str] = set()
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom):
+            if node.module == "typing":
+                for alias in node.names:
+                    if alias.name == "Any":
+                        if alias.asname:
+                            aliases.add(alias.asname)
+            elif node.module and node.module.startswith("typing."):
+                for alias in node.names:
+                    if alias.name == "Any":
+                        if alias.asname:
+                            aliases.add(alias.asname)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "typing" or alias.name.startswith("typing."):
+                    typing_module_names.add(alias.asname or alias.name)
+    print(aliases)
+    return aliases
+
+
+def get_changed_python_files(base_ref: str = "origin/main") -> List[str]:
+    try:
+        check_cmd = ["git", "rev-parse", "--verify", base_ref]
+        if subprocess.run(check_cmd, capture_output=True).returncode != 0:
+            base_ref = "HEAD^"
+
+        cmd = [
+            "git",
+            "diff",
+            "--name-only",
+            "--diff-filter=ACMR",
+            base_ref,
+            "HEAD",
+            "--",
+            "linhai/",
+        ]
+        output = subprocess.check_output(
+            cmd, universal_newlines=True, stderr=subprocess.DEVNULL
+        ).strip()
+
+        if not output:
+            return []
+
+        files = output.split("\n")
+        return [f for f in files if f.endswith(".py") and os.path.exists(f)]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def is_any_or_object_annotation(
+    node: ast.AST, any_aliases: Set[str]
+) -> Tuple[bool, str]:
+    if isinstance(node, ast.Name):
+        if node.id in any_aliases:
+            if node.id == "Any":
+                return True, "Any"
+            else:
+                return True, f"Any (imported as '{node.id}')"
+        if node.id == "object":
+            return True, "object"
+    elif isinstance(node, ast.Attribute):
+        if (
+            node.attr == "Any"
+            and isinstance(node.value, ast.Name)
+            and node.value.id == "typing"
+        ):
+            return True, "typing.Any"
+        if (
+            node.attr == "Object"
+            and isinstance(node.value, ast.Name)
+            and node.value.id == "typing"
+        ):
+            return True, "typing.Object"
+    return False, ""
+
+
+def check_function_args(
+    node: ast.FunctionDef, violations: List[Tuple[int, str, str]], any_aliases: Set[str]
+) -> None:
+    for arg in node.args.args:
+        if arg.annotation:
+            is_invalid, type_name = is_any_or_object_annotation(
+                arg.annotation, any_aliases
+            )
+            if is_invalid:
+                violations.append((arg.lineno, arg.arg, type_name))
+
+    for arg in node.args.kwonlyargs:
+        if arg.annotation:
+            is_invalid, type_name = is_any_or_object_annotation(
+                arg.annotation, any_aliases
+            )
+            if is_invalid:
+                violations.append((arg.lineno, arg.arg, type_name))
+
+    if node.args.vararg and node.args.vararg.annotation:
+        is_invalid, type_name = is_any_or_object_annotation(
+            node.args.vararg.annotation, any_aliases
+        )
+        if is_invalid:
+            violations.append(
+                (node.args.vararg.lineno, node.args.vararg.arg, type_name)
+            )
+
+    if node.args.kwarg and node.args.kwarg.annotation:
+        is_invalid, type_name = is_any_or_object_annotation(
+            node.args.kwarg.annotation, any_aliases
+        )
+        if is_invalid:
+            violations.append((node.args.kwarg.lineno, node.args.kwarg.arg, type_name))
+
+
+def check_any_object_in_file(file_path: str) -> List[Tuple[int, str, str]]:
+    violations = []
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        tree = ast.parse(content, filename=file_path)
+    except (SyntaxError, UnicodeDecodeError) as e:
+        print(f"WARNING: Failed to parse {file_path}: {e}")
+        return violations
+
+    any_aliases = get_any_aliases(tree)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            check_function_args(node, violations, any_aliases)
+        elif isinstance(node, ast.AsyncFunctionDef):
+            check_function_args(node, violations, any_aliases)
+
+    return violations
+
+
+def main() -> None:
+    base_ref = os.environ.get("BASE_REF")
+    if base_ref:
+        base_ref = f"origin/{base_ref}"
+    else:
+        base_ref = "origin/main"
+
+    python_files = get_changed_python_files(base_ref)
+
+    if not python_files:
+        print("No Python files changed in linhai/ directory.")
+        sys.exit(0)
+
+    print(
+        f"Checking {len(python_files)} changed Python file(s) for Any/object type annotations..."
+    )
+
+    errors_found = False
+    for file_path in python_files:
+        violations = check_any_object_in_file(file_path)
+        if violations:
+            errors_found = True
+            print(f"\nERROR: Any/object type annotations found in {file_path}:")
+            for line, arg_name, type_name in violations:
+                print(
+                    f"  Line {line}: Parameter '{arg_name}' has type annotation '{type_name}'"
+                )
+
+    if errors_found:
+        print(
+            "\nERROR: Any or object type annotations detected in function parameters."
+        )
+        print("Using type aliases (e.g., 'from typing import Any as XXX') to bypass")
+        print("detection is FORBIDDEN and violates the code standards.")
+        print("\nPlease use specific types instead of Any or object.")
+        print("Examples:")
+        print("  def foo(x: int) -> str:      # Good")
+        print("  def bar(x: Optional[int]) -> None:  # Good")
+        print("  def baz(x: Any) -> None:    # BAD")
+        print("  def qux(x: XXX) -> None:    # BAD (where XXX is an alias for Any)")
+        sys.exit(1)
+    else:
+        print("SUCCESS: No Any/object type annotations found in changed Python files.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

linhai-0.1.0/.gitea/scripts/check_black_overformat.py

@@ -0,0 +1,89 @@
+import sys
+import subprocess
+import tempfile
+import os
+
+
+def get_changed_py_files(base_ref="origin/main"):
+    try:
+        check_cmd = ["git", "rev-parse", "--verify", base_ref]
+        if subprocess.run(check_cmd, capture_output=True).returncode != 0:
+            base_ref = "HEAD^"
+        cmd = ["git", "diff", "--name-only", base_ref, "HEAD", "--", "linhai/"]
+        output = subprocess.check_output(
+            cmd, universal_newlines=True, stderr=subprocess.DEVNULL
+        )
+        files = [f for f in output.strip().split("\n") if f and f.endswith(".py")]
+        return files
+    except subprocess.CalledProcessError:
+        return []
+
+
+def check_black_overformat(file_path):
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            original = f.read()
+
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as tmp:
+            tmp.write(original)
+            tmp_path = tmp.name
+
+        cmd = ["uv", "run", "black", "--quiet", tmp_path]
+        subprocess.run(cmd, capture_output=True, check=True)
+
+        with open(tmp_path, "r", encoding="utf-8") as f:
+            formatted = f.read()
+
+        os.unlink(tmp_path)
+
+        if original != formatted:
+            original_lines = original.split("\n")
+            formatted_lines = formatted.split("\n")
+
+            diff_count = 0
+            for i, (orig, fmt) in enumerate(zip(original_lines, formatted_lines)):
+                if orig != fmt:
+                    stripped_orig = orig.rstrip()
+                    stripped_fmt = fmt.rstrip()
+                    if stripped_orig == stripped_fmt:
+                        diff_count += 1
+
+            if diff_count > len(original_lines) * 0.3:
+                return True
+        return False
+    except Exception:
+        return False
+
+
+def main():
+    base_ref = "origin/main"
+    try:
+        check_cmd = ["git", "rev-parse", "--verify", base_ref]
+        if subprocess.run(check_cmd, capture_output=True).returncode != 0:
+            base_ref = "HEAD^"
+    except Exception:
+        base_ref = "HEAD^"
+
+    files = get_changed_py_files(base_ref)
+    if not files:
+        print("No Python files changed in linhai/ directory.")
+        sys.exit(0)
+
+    errors = []
+    for file_path in files:
+        if check_black_overformat(file_path):
+            errors.append(file_path)
+
+    if errors:
+        print("ERROR: Black appears to be overformatting these files:")
+        for err in errors:
+            print(f"  {err}")
+        print("\nPlease check if black is making excessive formatting changes.")
+        sys.exit(1)
+    else:
+        print("SUCCESS: No black overformatting detected.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

linhai-0.1.0/.gitea/scripts/check_branch_behind.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+set -euo pipefail
+
+if [ -z "${CI:-}" ]; then
+    echo "Not running in CI, skipping branch behind check."
+    exit 0
+fi
+
+if git merge-base --is-ancestor origin/main HEAD 2>/dev/null; then
+    echo "Branch is up to date with main."
+else
+    echo "ERROR: Branch is behind or diverged from main."
+    echo "Please rebase your branch onto main: git fetch upstream && git rebase upstream/main"
+    exit 1
+fi

linhai-0.1.0/.gitea/scripts/check_cast_usage.py

@@ -0,0 +1,167 @@
+import sys
+import os
+import subprocess
+import ast
+from typing import List, Set, Tuple, Optional
+
+
+def get_changed_python_files(base_ref: str = "origin/main") -> List[str]:
+    """
+    Get list of changed Python files in the diff.
+    """
+    try:
+        # Check if base_ref exists, fallback to HEAD^
+        check_cmd = ["git", "rev-parse", "--verify", base_ref]
+        if subprocess.run(check_cmd, capture_output=True).returncode != 0:
+            base_ref = "HEAD^"
+
+        cmd = [
+            "git",
+            "diff",
+            "--name-only",
+            "--diff-filter=d",
+            base_ref,
+            "HEAD",
+            "--",
+            "linhai/",
+        ]
+        output = subprocess.check_output(
+            cmd, universal_newlines=True, stderr=subprocess.DEVNULL
+        ).strip()
+
+        if not output:
+            return []
+
+        files = output.split("\n")
+        return [f for f in files if f.endswith(".py") and os.path.exists(f)]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def get_import_aliases(tree: ast.AST) -> Set[str]:
+    """
+    Extract all import aliases for 'cast' from the AST.
+    Returns set of names that refer to cast function.
+    """
+    cast_names = {"cast"}  # Always include 'cast' as a base name
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom):
+            if node.module == "typing" or (
+                node.module and node.module.endswith(".typing")
+            ):
+                for alias in node.names:
+                    if alias.name == "cast":
+                        if alias.asname:
+                            cast_names.add(alias.asname)
+                        else:
+                            cast_names.add("cast")
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "typing":
+                    # import typing - we'll need to check typing.cast
+                    pass
+                elif alias.name == "cast":
+                    if alias.asname:
+                        cast_names.add(alias.asname)
+                    else:
+                        cast_names.add("cast")
+
+    return cast_names
+
+
+def check_cast_usage_in_file(file_path: str) -> List[Tuple[int, int, str]]:
+    """
+    Check a Python file for cast usage.
+    Returns list of violations as (line, col, message).
+    """
+    violations = []
+
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        tree = ast.parse(content, filename=file_path)
+    except (SyntaxError, UnicodeDecodeError) as e:
+        print(f"WARNING: Failed to parse {file_path}: {e}")
+        return violations
+
+    # Get all names that refer to cast function
+    cast_names = get_import_aliases(tree)
+
+    # Walk AST to find cast calls
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            # Check for direct cast call: cast(Type, value)
+            if isinstance(node.func, ast.Name):
+                if node.func.id in cast_names:
+                    violations.append(
+                        (
+                            node.lineno,
+                            node.col_offset,
+                            f"Direct cast call: {node.func.id}",
+                        )
+                    )
+
+            # Check for typing.cast call
+            elif isinstance(node.func, ast.Attribute):
+                if node.func.attr == "cast":
+                    # Check if it's typing.cast or something.typing.cast
+                    if isinstance(node.func.value, ast.Name):
+                        if node.func.value.id == "typing":
+                            violations.append(
+                                (node.lineno, node.col_offset, "typing.cast call")
+                            )
+                    elif isinstance(node.func.value, ast.Attribute):
+                        # Handle cases like module.typing.cast
+                        if isinstance(node.func.value.value, ast.Name):
+                            if (
+                                node.func.value.value.id + "." + node.func.value.attr
+                                == "typing"
+                            ):
+                                violations.append(
+                                    (node.lineno, node.col_offset, "typing.cast call")
+                                )
+
+    return violations
+
+
+def main() -> None:
+    """
+    Main function to check all changed Python files for cast usage.
+    """
+    base_ref = os.environ.get("BASE_REF")
+    if base_ref:
+        base_ref = f"origin/{base_ref}"
+    else:
+        base_ref = "origin/main"
+
+    python_files = get_changed_python_files(base_ref)
+
+    if not python_files:
+        print("No Python files changed in linhai/ directory.")
+        sys.exit(0)
+
+    print(f"Checking {len(python_files)} changed Python file(s) for cast usage...")
+
+    errors_found = False
+    for file_path in python_files:
+        violations = check_cast_usage_in_file(file_path)
+        if violations:
+            errors_found = True
+            print(f"\nERROR: Cast usage found in {file_path}:")
+            for line, col, msg in violations:
+                print(f"  Line {line}, Col {col}: {msg}")
+
+    if errors_found:
+        print("\nERROR: cast() or typing.cast() usage detected.")
+        print(
+            "Please avoid using cast for type assertions. Use proper type hints instead."
+        )
+        sys.exit(1)
+    else:
+        print("SUCCESS: No cast usage found in changed Python files.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

linhai-0.1.0/.gitea/scripts/check_code_emoji.py

@@ -0,0 +1,85 @@
+import sys
+import os
+import re
+import subprocess
+
+
+def contains_emoji(text):
+    emoji_pattern = re.compile(
+        "["
+        "\U0001f600-\U0001f64f"
+        "\U0001f300  \U0001f5ff"
+        "\U0001f680-\U0001f6ff"
+        "\U0001f1e0-\U0001f1ff"
+        "]",
+        flags=re.UNICODE,
+    )
+    return bool(emoji_pattern.search(text))
+
+
+def get_changed_files():
+    current_branch = os.environ.get("GITHUB_REF_NAME", "")
+    target_branch = os.environ.get("GITHUB_BASE_REF", "main")
+    if not current_branch:
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                capture_output=True,
+                text=True,
+            )
+            current_branch = result.stdout.strip()
+        except:
+            current_branch = "HEAD"
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--name-only", f"{target_branch}...{current_branch}", "--"],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            print(f"Warning: git diff failed: {result.stderr}")
+            return []
+        files = result.stdout.strip().split("\n")
+        python_files = [f for f in files if f and f.endswith(".py")]
+        return python_files
+    except Exception as e:
+        print(f"Warning: Could not get changed files: {e}")
+        return []
+
+
+def check_changed_files():
+    changed_files = get_changed_files()
+    if not changed_files:
+        print("No Python files changed in this PR.")
+        return []
+    errors = []
+    for filepath in changed_files:
+        if not os.path.exists(filepath):
+            print(f"Warning: File {filepath} does not exist.")
+            continue
+        try:
+            with open(filepath, "r", encoding="utf-8") as f:
+                content = f.read()
+                if contains_emoji(content):
+                    errors.append(filepath)
+        except Exception as e:
+            print(f"Warning: Could not read {filepath}: {e}")
+    return errors
+
+
+def main():
+    print("Checking for emoji in changed Python files...")
+    errors = check_changed_files()
+    if errors:
+        print("ERROR: Emoji detected in changed code files:")
+        for err in errors:
+            print(f"  {err}")
+        print("\nPlease remove emoji from changed code files.")
+        sys.exit(1)
+    else:
+        print("SUCCESS: No emoji found in changed code files.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

linhai-0.1.0/.gitea/scripts/check_commit_count.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# This script checks if the number of commits in a PR is reasonable.
+# It fails if:
+#   - number of commits > number of files changed
+
+set -e
+
+echo "Checking if commit count is reasonable..."
+
+# Check if we're in a PR context
+if ! git rev-parse --verify origin/main >/dev/null 2>&1; then
+    echo "WARNING: Cannot find origin/main reference, skipping commit count check"
+    exit 0
+fi
+
+# Get the number of commits in the PR (from origin/main to HEAD)
+commit_count=$(git log --oneline origin/main..HEAD | wc -l)
+
+# Get the number of files changed (excluding deleted files)
+file_count=$(git diff --name-only --diff-filter=ACMR origin/main..HEAD | wc -l)
+
+echo "Number of commits: $commit_count"
+echo "Number of files changed: $file_count"
+
+# If commit count exceeds file count, fail
+if [ "$commit_count" -gt "$file_count" ]; then
+    echo "ERROR: PR has $commit_count commits but only $file_count files changed."
+    echo "       Please squash commits to have at most one commit per file changed."
+    exit 1
+else
+    echo "SUCCESS: Commit count check passed."
+    exit 0
+fi