# How `material_gate.py` Checks for Required Disclosure Materials in Patent Applications

> Learn how material_gate.py verifies required patent disclosure materials. It checks for documents, detects patent type, and validates assets before advancing the application.

- Repository: [handsomestWei/patent-disclosure-skill](https://github.com/handsomestWei/patent-disclosure-skill)
- Tags: how-to-guide
- Published: 2026-09-08

---

**The [`material_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/material_gate.py) script verifies required disclosure materials by scanning the case directory for a disclosure document, detecting the patent type from its content, and validating type-specific assets including schemas, figure plans, and visual assets before allowing the application pipeline to proceed.**

The [`material_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/material_gate.py) script in `handsomestWei/patent-disclosure-skill` serves as the entry checkpoint for patent application workflows. Located at [`skills/patent-application/tools/material_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/skills/patent-application/tools/material_gate.py), it performs a deterministic validation sequence to check for required disclosure materials, ensuring that invention, utility model, and design patent cases contain every necessary file before downstream processing begins.

## Locate the Disclosure Document

The script initiates the check by locating the disclosure document within the case directory. If the user provides the `--disclosure` argument, the script uses that path directly. Otherwise, it automatically scans for files matching `.md` or `.docx` extensions, preferring those that match a timestamp pattern or contain the "技术交底书" heading.

This search logic is implemented in the `find_disclosure` function (lines 83‑101). The function iterates through the case directory, filtering candidates by extension and content markers to identify the authoritative disclosure file.

```python

# From skills/patent-application/tools/material_gate.py

def find_disclosure(case_dir: Path, hint: Optional[Path] = None) -> Optional[Path]:
    # Lines 83-101: Searches for .md/.docx files with timestamp patterns

    # or "技术交底书" headers when no explicit --disclosure path is given

    pass

```

## Detect the Patent Type from Content

Once the disclosure document is located, the script extracts the patent type declaration. For markdown disclosures, the `detect_type_from_disclosure` function (lines 104‑115) uses the `PATENT_TYPE_LINE` regular expression to find lines declaring the type (e.g., "**专利类型**: 发明").

The extracted Chinese label is normalized through the `TYPE_ALIASES` mapping to one of three canonical types:

- `invention` (发明)
- `utility_model` (实用新型)
- `design` (外观设计)

This normalization ensures that variations in user input resolve to standardized categories for subsequent validation logic.

## Gather Supporting Assets and Schemas

After determining the patent type, the script collects supporting files using the `_first_file` helper against predefined name sets stored in `SCHEMA_NAMES` (lines 41‑45). The script specifically looks for:

- **Structure schema**: [`structure_schema.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/structure_schema.yaml) or `.json` (for utility models)
- **Appearance schema**: [`appearance_schema.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/appearance_schema.yaml) or `.json` (for design patents)
- **Figure plan**: [`figure_plan.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/figure_plan.yaml) or `.json`

If a figure plan exists, the script parses it via `yaml.safe_load` or `json.loads` and extracts figures marked with `use_in_disclosure=True` using the `in_disclosure_figures` function (lines 28‑34).

```python

# Schema name definitions from lines 41-45

SCHEMA_NAMES = {
    "structure_schema": ["structure_schema.yaml", "structure_schema.json"],
    "appearance_schema": ["appearance_schema.yaml", "appearance_schema.json"],
    "figure_plan": ["figure_plan.yaml", "figure_plan.json"]
}

```

## Validate Type-Specific Requirements

The core validation logic resides in the `check_case` function (lines 136‑225), which applies different rules based on the detected patent type to check for required disclosure materials:

**Utility Model Patents**
- Requires `structure_schema` and `figure_plan`
- Must reference at least one lineart asset in the figure plan
- Missing items reported as: `structure_schema`, `figure_plan`, `lineart`

**Design Patents**
- Requires `appearance_schema`, `figure_plan`, and at least one lineart
- Must include photo assets (`photo_clean` or `photo_scene`)
- Missing items reported as: `appearance_schema`, `figure_plan`, `lineart`, `photo`

**Invention Patents**
- No additional schema requirements beyond the disclosure document itself
- Presence of a valid disclosure file is sufficient

The function constructs a result dictionary containing `ok` (boolean pass/fail), `type` (canonical patent type), `missing` (list of gaps), `files` (resolved paths), and counts for `lineart` and `photo` assets.

## Command-Line Interface and Exit Codes

The script provides a command-line interface for gate-checking case directories before pipeline execution.

```bash
python tools/material_gate.py --case-dir outputs/案件_XYZ

# Optional overrides:

#   --disclosure outputs/案件_XYZ/交底书_20240101120000.md

#   --type utility_model

```

On execution, the script prints a one-line status string formatted by the `_kv` helper (lines 36‑48):

```

APPLICATION_GATE: ok=1 type=utility_model missing=- lineart=2 photo=0 ...

```

Exit codes follow Unix conventions:
- `0` — All required materials are present and valid
- `2` — Validation failed (missing files, unreadable schemas, ambiguous patent type, or unsupported configurations)

## Programmatic Integration

You can import the validation logic directly into Python workflows to check for required disclosure materials programmatically.

```python
from pathlib import Path
from skills.patent_application.tools.material_gate import check_case

case_path = Path("outputs/案件_XYZ")
result = check_case(case_path)  # Auto-detects disclosure and patent type

if result["ok"]:
    print(f"Patent type: {result['type']}")
    print(f"Lineart assets: {result['lineart']}")
else:
    print("Missing materials:", result["missing"])

```

The returned dictionary mirrors the command-line output structure, enabling fine-grained diagnostics for automation scripts and CI/CD pipelines.

## Summary

- **[`material_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/material_gate.py)** acts as the gatekeeper for patent application cases in the `handsomestWei/patent-disclosure-skill` repository.
- The script **locates disclosure documents** automatically or via explicit `--disclosure` flags.
- **Patent type detection** uses regex patterns and alias normalization to categorize cases as invention, utility_model, or design.
- **Type-specific validation** enforces schema requirements: utility models need structure schemas and lineart, while design patents require appearance schemas plus photo assets.
- **Exit code 2** signals missing materials, preventing incomplete cases from proceeding to downstream processing.

## Frequently Asked Questions

### How does the script handle multiple disclosure files in one case directory?

The `find_disclosure` function employs a scoring mechanism that prefers files matching timestamp patterns (e.g., `交底书_20240101120000.md`) or containing the "技术交底书" header. If multiple candidates exist, it selects the most recently modified file that matches these criteria, ensuring deterministic selection without manual intervention.

### Can I override the patent type detection if the disclosure document is ambiguous?

Yes. The script accepts a `--type` command-line argument that bypasses automatic detection. When provided, the value is validated against `TYPE_ALIASES` and used directly in the `check_case` function, skipping the `detect_type_from_disclosure` logic entirely. This is useful for testing or when processing legacy documents with non-standard headers.

### What happens if the figure plan references assets that don't exist on disk?

The validation logic in `check_case` (lines 136‑225) verifies that referenced lineart and photo entries in the figure plan correspond to actual files in the case directory. If assets are referenced but missing, they are added to the `missing` list in the result dictionary, causing the script to exit with code `2` and report the specific gaps in the `APPLICATION_GATE` output line.

### Why does the invention patent type require fewer validation checks than utility models or designs?

According to the source code implementation, invention patents (发明) are considered sufficiently documented by the disclosure text alone, which must contain detailed claims and technical descriptions. In contrast, utility models and design patents require additional structural or appearance schemas plus corresponding visual assets (lineart/photos) to satisfy patent office filing requirements, necessitating stricter material validation.