UNPICK added AGENTS.md, copilot-instructions.md

Author: kosiew

.github/copilot-instructions.md

@@ -0,0 +1,102 @@
+# Copilot Instructions
+
+## Python Code Style
+
+When generating Python code for the DataFusion Python project, adhere to the following style guidelines:
+
+1. Follow the [PEP 8](https://www.python.org/dev/peps/pep-0008/) style guide
+2. Comply with Ruff lint rules, specifically:
+
+   - Use double quotes for string literals
+   - Use explicit relative imports (e.g., `from .module import Class`)
+   - Limit line length to 88 characters (Black formatter standard) (prevent E501, W505)
+   - Use type hints for function parameters and return values
+   - Avoid unused imports
+   - Use f-strings instead of `.format()` or `%` formatting
+   - Avoid unnecessary `else` statements after `return`
+   - Use `isinstance()` instead of comparing types directly
+   - Keep docstrings concise and follow Google-style docstring format
+   - Assign exception message strings to variables before raising (prevent EM101)
+
+     ```python
+     # Correct:
+     msg = "Invalid input value"
+     raise ValueError(msg)
+
+     # Incorrect:
+     raise ValueError("Invalid input value")
+     ```
+
+3. Include comprehensive docstrings for:
+
+   - Modules
+   - Classes
+   - Functions/methods
+
+4. For tests:
+   - Use meaningful test function names that describe what is being tested
+   - Group related tests in classes
+   - Use pytest style assertions instead of unittest style
+
+## Rust Code Style
+
+When generating Rust code for DataFusion, follow these guidelines:
+
+1. Do not add unnecessary parentheses around `if` conditions:
+
+   - Correct: `if some_condition`
+   - Incorrect: `if (some_condition)`
+
+2. Follow the standard Rust style conventions from rustfmt
+
+### Code Organization
+
+- Keep functions concise and focused on a single task
+- Aim for functions under 40-50 lines of code
+- Break long or complex operations into smaller, well-named helper functions
+- Before creating new utility functions, check if existing helper functions in the codebase can be reused or extended
+- Consider adding parameters to existing functions rather than creating similar parallel implementations
+- Don't overengineer; avoid creating abstractions that are not needed
+- Look for similar patterns in the codebase and follow established conventions
+
+## Comments
+
+- Add meaningful comments for complex logic
+- Avoid obvious comments
+- Start inline comments with a capital letter
+
+## Example Style
+
+```python
+from typing import Optional, List
+
+def process_data(data: List[str], max_length: Optional[int] = None) -> List[str]:
+    """Process a list of string data.
+
+    Args:
+        data: List of strings to process
+        max_length: Optional maximum length for each string
+
+    Returns:
+        List of processed strings
+
+    Raises:
+        ValueError: If invalid data is provided
+    """
+    if not data:
+        raise ValueError("Empty data list provided")
+
+    result = []
+    for item in data:
+        # Skip empty items
+        if not item.strip():
+            continue
+
+        processed = item.strip().lower()
+        if max_length is not None and len(processed) > max_length:
+            processed = processed[:max_length]
+
+        result.append(processed)
+
+    return result
+```

AGENTS.md

@@ -0,0 +1,91 @@
+# Repository instructions for datafusion-python
+
+## Style and Linting
+- Python formatting and linting is handled by **ruff**.
+- Follow [PEP 8](https://www.python.org/dev/peps/pep-0008/) and these key
+  ruff rules:
+  - Use double quotes for string literals
+  - Use explicit relative imports such as `from .module import Class`
+  - Limit lines to 88 characters
+  - Provide type hints for parameters and return values
+  - Avoid unused imports
+  - Prefer f-strings over other string formatting
+  - Avoid `else` blocks after `return`
+  - Use `isinstance()` instead of direct type comparison
+  - Keep docstrings concise in Google format
+  - Assign exception messages to variables before raising
+- All modules, classes, and functions should include docstrings.
+- Tests must use descriptive function names, pytest style assertions, and be
+  grouped in classes when appropriate.
+- Rust code must pass `cargo fmt`, `cargo clippy`, and `cargo tomlfmt`.
+- Install the pre-commit hooks with `pre-commit install` and run them with
+  `pre-commit run --files <file1> <file2>` or `pre-commit run --all-files`.
+
+Install the required Rust components before running pre-commit:
+
+```bash
+rustup component add rustfmt clippy
+```
+
+If installation is blocked by a proxy, see the [offline installation guide](https://rust-lang.github.io/rustup/installation/other.html).
+
+- The same checks can be run manually using the scripts in `ci/scripts`:
+  - `./ci/scripts/python_lint.sh`
+  - `./ci/scripts/rust_fmt.sh`
+  - `./ci/scripts/rust_clippy.sh`
+  - `./ci/scripts/rust_toml_fmt.sh`
+
+## Rust Code Style
+
+When generating Rust code for DataFusion, follow these guidelines:
+
+1. Do not add unnecessary parentheses around `if` conditions:
+   - Correct: `if some_condition`
+   - Incorrect: `if (some_condition)`
+
+2. Do not use `expect()` or `panic!()` except in tests - use proper error handling with `Result` types
+
+3. Follow the standard Rust style conventions from rustfmt
+
+## Code Organization
+- Keep functions focused and under about 50 lines.
+- Break complex tasks into well-named helper functions and reuse existing
+  helpers when possible.
+- Prefer adding parameters to existing functions rather than creating new
+  versions with similar behavior.
+- Avoid unnecessary abstractions and follow established patterns in the
+  codebase.
+
+## Comments
+- Add meaningful comments for complex logic and avoid obvious comments.
+- Start inline comments with a capital letter.
+
+## Running Tests
+1. Ensure submodules are initialized:
+   ```bash
+   git submodule update --init
+   ```
+2. Create a development environment and install dependencies:
+   ```bash
+   uv sync --dev --no-install-package datafusion
+   ```
+3. Build the Python extension:
+   ```bash
+   uv run --no-project maturin develop --uv
+   ```
+4. Execute the test suite:
+   ```bash
+   uv run --no-project pytest -v .
+   ```
+
+## Building Documentation
+- Documentation dependencies can be installed with the `docs` group:
+  ```bash
+  uv sync --dev --group docs --no-install-package datafusion
+  ```
+- Build the docs with:
+  ```bash
+  uv run --no-project maturin develop --uv
+  uv run --no-project docs/build.sh
+  ```
+- The generated HTML appears under `docs/build/html`.