chore: import upstream snapshot with attribution

scripts/create_provider_plugin.py

@@ -0,0 +1,825 @@
+#!/usr/bin/env python3
+# Copyright 2025 Google LLC.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Create a new LangExtract provider plugin with all boilerplate code.
+
+This script automates steps 1-6 of the provider creation checklist:
+1. Setup Package Structure
+2. Configure Entry Point
+3. Implement Provider
+4. Add Schema Support (optional)
+5. Create and run tests
+6. Generate documentation
+
+For detailed documentation, see:
+https://github.com/google/langextract/blob/main/langextract/providers/README.md
+
+Usage:
+    python create_provider_plugin.py MyProvider
+    python create_provider_plugin.py MyProvider --with-schema
+    python create_provider_plugin.py MyProvider --patterns "^mymodel" "^custom"
+"""
+
+import argparse
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+import textwrap
+
+
+def create_directory_structure(package_name: str, force: bool = False) -> Path:
+  """Step 1: Setup Package Structure."""
+  print("\n" + "=" * 60)
+  print("STEP 1: Setup Package Structure")
+  print("=" * 60)
+
+  base_dir = Path(f"langextract-{package_name}")
+  package_dir = base_dir / f"langextract_{package_name}"
+
+  if base_dir.exists() and any(base_dir.iterdir()) and not force:
+    print(f"ERROR: {base_dir} already exists and is not empty.")
+    print("Use --force to overwrite or choose a different package name.")
+    sys.exit(1)
+
+  base_dir.mkdir(parents=True, exist_ok=True)
+  package_dir.mkdir(parents=True, exist_ok=True)
+
+  print(f"✓ Created directory: {base_dir}/")
+  print(f"✓ Created package: {package_dir}/")
+  print("✅ Step 1 complete: Package structure created")
+
+  return base_dir
+
+
+def create_pyproject_toml(
+    base_dir: Path, provider_name: str, package_name: str
+) -> None:
+  """Step 2: Configure Entry Point."""
+  print("\n" + "=" * 60)
+  print("STEP 2: Configure Entry Point")
+  print("=" * 60)
+
+  content = textwrap.dedent(f"""\
+        [build-system]
+        requires = ["setuptools>=61.0", "wheel"]
+        build-backend = "setuptools.build_meta"
+
+        [project]
+        name = "langextract-{package_name}"
+        version = "0.1.0"
+        description = "LangExtract provider plugin for {provider_name}"
+        readme = "README.md"
+        requires-python = ">=3.10"
+        license = {{text = "Apache-2.0"}}
+        dependencies = [
+            "langextract>=1.0.0",
+            # Add your provider's SDK dependencies here
+        ]
+
+        [project.entry-points."langextract.providers"]
+        {package_name} = "langextract_{package_name}.provider:{provider_name}LanguageModel"
+
+        [tool.setuptools.packages.find]
+        where = ["."]
+        include = ["langextract_{package_name}*"]
+    """)
+
+  (base_dir / "pyproject.toml").write_text(content, encoding="utf-8")
+  print("✓ Created pyproject.toml with entry point configuration")
+  print("✅ Step 2 complete: Entry point configured")
+
+
+def create_provider(
+    base_dir: Path,
+    provider_name: str,
+    package_name: str,
+    patterns: list[str],
+    with_schema: bool,
+) -> None:
+  """Step 3: Implement Provider."""
+  print("\n" + "=" * 60)
+  print("STEP 3: Implement Provider")
+  print("=" * 60)
+
+  package_dir = base_dir / f"langextract_{package_name}"
+
+  patterns_str = ", ".join(f"r'{p}'" for p in patterns)
+  env_var_safe = re.sub(r"[^A-Z0-9]+", "_", package_name.upper()) + "_API_KEY"
+
+  schema_imports = (
+      f"""
+from langextract_{package_name}.schema import {provider_name}Schema"""
+      if with_schema
+      else ""
+  )
+
+  schema_init = (
+      """
+                self.response_schema = kwargs.get('response_schema')
+                self.structured_output = kwargs.get('structured_output', False)"""
+      if with_schema
+      else ""
+  )
+
+  schema_methods = f"""
+
+            @classmethod
+            def get_schema_class(cls):
+                \"\"\"Tell LangExtract about our schema support.\"\"\"
+                from langextract_{package_name}.schema import {provider_name}Schema
+                return {provider_name}Schema
+
+            def apply_schema(self, schema_instance):
+                \"\"\"Apply or clear schema configuration.\"\"\"
+                super().apply_schema(schema_instance)
+                if schema_instance:
+                    config = schema_instance.to_provider_config()
+                    self.response_schema = config.get('response_schema')
+                    self.structured_output = config.get('structured_output', False)
+                else:
+                    self.response_schema = None
+                    self.structured_output = False""" if with_schema else ""
+
+  schema_infer = (
+      """
+                    api_params = {}
+                    if self.response_schema:
+                        api_params['response_schema'] = self.response_schema
+                    # result = self.client.generate(prompt, **api_params)"""
+      if with_schema
+      else """
+                    # result = self.client.generate(prompt, **kwargs)"""
+  )
+
+  provider_content = textwrap.dedent(f'''\
+        """Provider implementation for {provider_name}."""
+
+        import os
+        import langextract as lx{schema_imports}
+
+
+        @lx.providers.registry.register({patterns_str}, priority=10)
+        class {provider_name}LanguageModel(lx.inference.BaseLanguageModel):
+            """LangExtract provider for {provider_name}.
+
+            This provider handles model IDs matching: {patterns}
+            """
+
+            def __init__(self, model_id: str, api_key: str = None, **kwargs):
+                """Initialize the {provider_name} provider.
+
+                Args:
+                    model_id: The model identifier.
+                    api_key: API key for authentication.
+                    **kwargs: Additional provider-specific parameters.
+                """
+                super().__init__()
+                self.model_id = model_id
+                self.api_key = api_key or os.environ.get('{env_var_safe}'){schema_init}
+
+                # self.client = YourClient(api_key=self.api_key)
+                self._extra_kwargs = kwargs{schema_methods}
+
+            def infer(self, batch_prompts, **kwargs):
+                """Run inference on a batch of prompts.
+
+                Args:
+                    batch_prompts: List of prompts to process.
+                    **kwargs: Additional inference parameters.
+
+                Yields:
+                    Lists of ScoredOutput objects, one per prompt.
+                """
+                for prompt in batch_prompts:{schema_infer}
+                    result = f"Mock response for: {{prompt[:50]}}..."
+                    yield [lx.inference.ScoredOutput(score=1.0, output=result)]
+    ''')
+
+  (package_dir / "provider.py").write_text(provider_content, encoding="utf-8")
+  print("✓ Created provider.py with mock implementation")
+
+  # Create __init__.py
+  init_content = textwrap.dedent(f'''\
+        """LangExtract provider plugin for {provider_name}."""
+
+        from langextract_{package_name}.provider import {provider_name}LanguageModel
+
+        __all__ = ['{provider_name}LanguageModel']
+        __version__ = "0.1.0"
+    ''')
+
+  (package_dir / "__init__.py").write_text(init_content, encoding="utf-8")
+  print("✓ Created __init__.py with exports")
+  print("✅ Step 3 complete: Provider implementation created")
+
+
+def create_schema(
+    base_dir: Path, provider_name: str, package_name: str
+) -> None:
+  """Step 4: Add Schema Support."""
+  print("\n" + "=" * 60)
+  print("STEP 4: Add Schema Support (Optional)")
+  print("=" * 60)
+
+  package_dir = base_dir / f"langextract_{package_name}"
+
+  schema_content = textwrap.dedent(f'''\
+        """Schema implementation for {provider_name} provider."""
+
+        import langextract as lx
+        from langextract import schema
+
+
+        class {provider_name}Schema(lx.schema.BaseSchema):
+            """Schema implementation for {provider_name} structured output."""
+
+            def __init__(self, schema_dict: dict):
+                """Initialize the schema with a dictionary."""
+                self._schema_dict = schema_dict
+
+            @property
+            def schema_dict(self) -> dict:
+                """Return the schema dictionary."""
+                return self._schema_dict
+
+            @classmethod
+            def from_examples(cls, examples_data, attribute_suffix="_attributes"):
+                """Build schema from example extractions.
+
+                Args:
+                    examples_data: Sequence of ExampleData objects.
+                    attribute_suffix: Suffix for attribute fields.
+
+                Returns:
+                    A configured {provider_name}Schema instance.
+                """
+                extraction_types = {{}}
+                for example in examples_data:
+                    for extraction in example.extractions:
+                        class_name = extraction.extraction_class
+                        if class_name not in extraction_types:
+                            extraction_types[class_name] = set()
+                        if extraction.attributes:
+                            extraction_types[class_name].update(extraction.attributes.keys())
+
+                schema_dict = {{
+                    "type": "object",
+                    "properties": {{
+                        "extractions": {{
+                            "type": "array",
+                            "items": {{"type": "object"}}
+                        }}
+                    }},
+                    "required": ["extractions"]
+                }}
+
+                return cls(schema_dict)
+
+            def to_provider_config(self) -> dict:
+                """Convert to provider-specific configuration.
+
+                Returns:
+                    Dictionary of provider-specific configuration.
+                """
+                return {{
+                    "response_schema": self._schema_dict,
+                    "structured_output": True
+                }}
+
+            @property
+            def supports_strict_mode(self) -> bool:
+                """Whether this schema guarantees valid structured output.
+
+                Returns:
+                    True if the provider enforces valid JSON output.
+                """
+                return False  # Set to True only if your provider guarantees valid JSON
+    ''')
+
+  (package_dir / "schema.py").write_text(schema_content, encoding="utf-8")
+  print("✓ Created schema.py with BaseSchema implementation")
+  print("✅ Step 4 complete: Schema support added")
+
+
+def create_test_script(
+    base_dir: Path,
+    provider_name: str,
+    package_name: str,
+    patterns: list[str],
+    with_schema: bool,
+) -> None:
+  """Step 5: Create and run tests."""
+  print("\n" + "=" * 60)
+  print("STEP 5: Create Tests")
+  print("=" * 60)
+
+  patterns_literal = "[" + ", ".join(repr(p) for p in patterns) + "]"
+  provider_cls_name = f"{provider_name}LanguageModel"
+
+  test_content = textwrap.dedent(f'''\
+        #!/usr/bin/env python3
+        """Test script for {provider_name} provider (Step 5 checklist)."""
+
+        import re
+        import sys
+        import langextract as lx
+        from langextract.providers import registry
+
+        try:
+            from langextract_{package_name} import {provider_cls_name}
+        except ImportError:
+            print("ERROR: Plugin not installed. Run: pip install -e .")
+            sys.exit(1)
+
+        lx.providers.load_plugins_once()
+
+        PROVIDER_CLS_NAME = "{provider_cls_name}"
+        PATTERNS = {patterns_literal}
+
+        def _example_id(pattern: str) -> str:
+            \"\"\"Generate test model ID from pattern.\"\"\"
+            base = re.sub(r'^\\^', '', pattern)
+            m = re.match(r"[A-Za-z0-9._-]+", base)
+            base = m.group(0) if m else (base or "model")
+            return f"{{base}}-test"
+
+        sample_ids = [_example_id(p) for p in PATTERNS]
+        sample_ids.append("unknown-model")
+
+        print("Testing {provider_name} Provider - Step 5 Checklist:")
+        print("-" * 50)
+
+        # 1 & 2. Provider registration + pattern matching via resolve()
+        print("1–2. Provider registration & pattern matching")
+        for model_id in sample_ids:
+            try:
+                provider_class = registry.resolve(model_id)
+                ok = provider_class.__name__ == PROVIDER_CLS_NAME
+                status = "✓" if (ok or model_id == "unknown-model") else "✗"
+                note = "expected" if ok else ("expected (no provider)" if model_id == "unknown-model" else "unexpected provider")
+                print(f"   {{status}} {{model_id}} -> {{provider_class.__name__ if ok else 'resolved'}} {{note}}")
+            except Exception as e:
+                if model_id == "unknown-model":
+                    print(f"   ✓ {{model_id}}: No provider found (expected)")
+                else:
+                    print(f"   ✗ {{model_id}}: resolve() failed: {{e}}")
+
+        # 3. Inference sanity check
+        print("\\n3. Test inference with sample prompts")
+        try:
+            model_id = sample_ids[0] if sample_ids[0] != "unknown-model" else (_example_id(PATTERNS[0]) if PATTERNS else "test-model")
+            provider = {provider_cls_name}(model_id=model_id)
+            prompts = ["Test prompt 1", "Test prompt 2"]
+            results = list(provider.infer(prompts))
+            print(f"   ✓ Inference returned {{len(results)}} results")
+            for i, result in enumerate(results):
+                try:
+                    out = result[0].output if result and result[0] else None
+                    print(f"   ✓ Result {{i+1}}: {{(out or '')[:60]}}...")
+                except Exception:
+                    print(f"   ✗ Result {{i+1}}: Unexpected result shape: {{result}}")
+        except Exception as e:
+            print(f"   ✗ ERROR: {{e}}")
+    ''')
+
+  if with_schema:
+    test_content += textwrap.dedent(f"""
+        # 4. Test schema creation and application
+        print("\\n4. Test schema creation and application")
+        try:
+            from langextract_{package_name}.schema import {provider_name}Schema
+            from langextract import data
+
+            examples = [
+                data.ExampleData(
+                    text="Test text",
+                    extractions=[
+                        data.Extraction(
+                            extraction_class="entity",
+                            extraction_text="test",
+                            attributes={{"type": "example"}}
+                        )
+                    ]
+                )
+            ]
+
+            schema = {provider_name}Schema.from_examples(examples)
+            print(f"   ✓ Schema created (keys={{list(schema.schema_dict.keys())}})")
+
+            schema_class = {provider_cls_name}.get_schema_class()
+            print(f"   ✓ Provider schema class: {{schema_class.__name__}}")
+
+            provider = {provider_cls_name}(model_id=_example_id(PATTERNS[0]) if PATTERNS else "test-model")
+            provider.apply_schema(schema)
+            print(f"   ✓ Schema applied: response_schema={{provider.response_schema is not None}} structured={{getattr(provider, 'structured_output', False)}}")
+        except Exception as e:
+            print(f"   ✗ ERROR: {{e}}")
+        """)
+
+  test_content += textwrap.dedent(f"""
+        # 5. Test factory integration
+        print("\\n5. Test factory integration")
+        try:
+            from langextract import factory
+            config = factory.ModelConfig(
+                model_id=_example_id(PATTERNS[0]) if PATTERNS else "test-model",
+                provider="{provider_cls_name}"
+            )
+            model = factory.create_model(config)
+            print(f"   ✓ Factory created: {{type(model).__name__}}")
+        except Exception as e:
+            print(f"   ✗ ERROR: {{e}}")
+
+        print("\\n" + "-" * 50)
+        print("✅ Testing complete!")
+        """)
+
+  (base_dir / "test_plugin.py").write_text(test_content, encoding="utf-8")
+  print("✓ Created test_plugin.py with comprehensive tests")
+  print("✅ Step 5 complete: Test suite created")
+
+
+def create_readme(
+    base_dir: Path, provider_name: str, package_name: str, patterns: list[str]
+) -> None:
+  """Create README documentation."""
+  print("\n" + "=" * 60)
+  print("STEP 6: Documentation")
+  print("=" * 60)
+
+  def _display(p: str) -> str:
+    """Strip leading ^ from pattern for display."""
+    return p[1:] if p.startswith("^") else p
+
+  env_var_safe = re.sub(r"[^A-Z0-9]+", "_", package_name.upper()) + "_API_KEY"
+
+  supported = "\n".join(
+      f"- `{_display(p)}*`: Models matching pattern {p}" for p in patterns
+  )
+
+  readme_content = textwrap.dedent(f"""\
+        # LangExtract {provider_name} Provider
+
+A provider plugin for LangExtract that supports {provider_name} models.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Supported Model IDs
+
+{supported}
+
+## Environment Variables
+
+- `{env_var_safe}`: API key for authentication
+
+## Usage
+
+```python
+import langextract as lx
+
+result = lx.extract(
+    text="Your document here",
+    model_id="{_display(patterns[0]) if patterns else package_name}-model",
+    prompt_description="Extract entities",
+    examples=[...]
+)
+```
+
+## Development
+
+1. Install in development mode: `pip install -e .`
+2. Run tests: `python test_plugin.py`
+3. Build package: `python -m build`
+4. Publish to PyPI: `twine upload dist/*`
+
+## License
+
+Apache License 2.0
+    """)
+
+  (base_dir / "README.md").write_text(readme_content, encoding="utf-8")
+  print("✓ Created README.md with usage examples")
+
+
+def create_gitignore(base_dir: Path) -> None:
+  """Create .gitignore file with Python-specific entries."""
+  gitignore_content = textwrap.dedent("""\
+        # Python
+        __pycache__/
+        *.py[cod]
+        *$py.class
+        *.so
+
+        # Distribution / packaging
+        build/
+        dist/
+        *.egg-info/
+        .eggs/
+        *.egg
+
+        # Virtual environments
+        .env
+        .venv
+        env/
+        venv/
+        ENV/
+
+        # Testing & coverage
+        .pytest_cache/
+        .tox/
+        htmlcov/
+        .coverage
+        .coverage.*
+
+        # Type checking
+        .mypy_cache/
+        .dmypy.json
+        dmypy.json
+        .pytype/
+
+        # IDEs
+        .idea/
+        .vscode/
+        *.swp
+        *.swo
+
+        # OS-specific
+        .DS_Store
+        Thumbs.db
+
+        # Logs
+        *.log
+
+        # Temp files
+        *.tmp
+        *.bak
+        *.backup
+    """)
+
+  (base_dir / ".gitignore").write_text(gitignore_content, encoding="utf-8")
+  print("✓ Created .gitignore file with Python-specific entries")
+
+
+def create_license(base_dir: Path) -> None:
+  """Create LICENSE file."""
+  license_content = textwrap.dedent("""\
+        # LICENSE
+
+        TODO: Add your license here.
+
+        This is a placeholder license file for your provider plugin.
+        Please replace this with your actual license before distribution.
+
+        Common options include:
+        - Apache License 2.0
+        - MIT License
+        - BSD License
+        - GPL License
+        - Proprietary/Commercial License
+    """)
+
+  (base_dir / "LICENSE").write_text(license_content, encoding="utf-8")
+  print("✓ Created LICENSE file")
+  print("✅ Step 6 complete: Documentation created")
+
+
+def install_and_test(base_dir: Path) -> bool:
+  """Install the plugin and run tests."""
+  print("\n" + "=" * 60)
+  print("Installing and testing the plugin...")
+  print("=" * 60)
+
+  os.chdir(base_dir)
+  print("\nInstalling plugin...")
+  result = subprocess.run(
+      [sys.executable, "-m", "pip", "install", "-e", "."],
+      capture_output=True,
+      text=True,
+      check=False,
+  )
+  if result.returncode:
+    print(f"Installation failed: {result.stderr}")
+    return False
+  print("✓ Plugin installed successfully")
+
+  print("\nRunning tests...")
+  result = subprocess.run(
+      [sys.executable, "test_plugin.py"],
+      capture_output=True,
+      text=True,
+      check=False,
+  )
+  print(result.stdout)
+  if result.returncode:
+    print(f"Tests failed: {result.stderr}")
+    return False
+
+  return True
+
+
+def parse_arguments():
+  """Parse command line arguments.
+
+  Returns:
+    Parsed arguments from argparse.
+  """
+  parser = argparse.ArgumentParser(
+      description="Create a new LangExtract provider plugin",
+      formatter_class=argparse.RawDescriptionHelpFormatter,
+      epilog=textwrap.dedent("""
+        Examples:
+            python create_provider_plugin.py MyProvider
+            python create_provider_plugin.py MyProvider --with-schema
+            python create_provider_plugin.py MyProvider --patterns "^mymodel" "^custom"
+            python create_provider_plugin.py MyProvider --package-name my_custom_name
+        """),
+  )
+
+  parser.add_argument(
+      "provider_name",
+      help="Name of your provider (e.g., MyProvider, CustomLLM)",
+  )
+
+  parser.add_argument(
+      "--patterns",
+      nargs="+",
+      default=None,
+      help="Regex patterns for model IDs (default: based on provider name)",
+  )
+
+  parser.add_argument(
+      "--package-name",
+      default=None,
+      help="Package name (default: lowercase provider name)",
+  )
+
+  parser.add_argument(
+      "--with-schema",
+      action="store_true",
+      help="Include schema support (Step 4)",
+  )
+
+  parser.add_argument(
+      "--no-install", action="store_true", help="Skip installation and testing"
+  )
+
+  parser.add_argument(
+      "--force",
+      action="store_true",
+      help="Overwrite existing plugin directory if it exists",
+  )
+
+  return parser.parse_args()
+
+
+def validate_patterns(patterns: list[str]) -> None:
+  """Validate regex patterns.
+
+  Args:
+    patterns: List of regex patterns to validate.
+
+  Raises:
+    SystemExit: If any pattern is invalid.
+  """
+  for p in patterns:
+    try:
+      re.compile(p)
+    except re.error as e:
+      print(f"ERROR: Invalid regex pattern '{p}': {e}")
+      sys.exit(1)
+
+
+def print_summary(
+    provider_name: str,
+    package_name: str,
+    patterns: list[str],
+    with_schema: bool,
+) -> None:
+  """Print configuration summary.
+
+  Args:
+    provider_name: Name of the provider.
+    package_name: Package name.
+    patterns: List of model ID patterns.
+    with_schema: Whether to include schema support.
+  """
+  print("\n" + "=" * 60)
+  print("LANGEXTRACT PROVIDER PLUGIN GENERATOR")
+  print("=" * 60)
+  print(f"Provider Name: {provider_name}")
+  print(f"Package Name: langextract-{package_name}")
+  print(f"Model Patterns: {patterns}")
+  print(f"Include Schema: {with_schema}")
+  print("\nFor documentation, see:")
+  print(
+      "https://github.com/google/langextract/blob/main/langextract/providers/README.md"
+  )
+
+
+def create_plugin(
+    args: argparse.Namespace, package_name: str, patterns: list[str]
+) -> Path:
+  """Create the plugin with all necessary files.
+
+  Args:
+    args: Parsed command line arguments.
+    package_name: Package name.
+    patterns: List of model ID patterns.
+
+  Returns:
+    Path to the created plugin directory.
+  """
+  base_dir = create_directory_structure(package_name, force=args.force)
+  create_pyproject_toml(base_dir, args.provider_name, package_name)
+  create_provider(
+      base_dir, args.provider_name, package_name, patterns, args.with_schema
+  )
+
+  if args.with_schema:
+    create_schema(base_dir, args.provider_name, package_name)
+
+  create_test_script(
+      base_dir, args.provider_name, package_name, patterns, args.with_schema
+  )
+  create_readme(base_dir, args.provider_name, package_name, patterns)
+  create_gitignore(base_dir)
+  create_license(base_dir)
+
+  return base_dir
+
+
+def print_completion_summary(with_schema: bool) -> None:
+  """Print completion summary.
+
+  Args:
+    with_schema: Whether schema support was included.
+  """
+  print("\n" + "=" * 60)
+  print("SUMMARY: Steps 1-6 Completed")
+  print("=" * 60)
+  print("✅ Package structure created")
+  print("✅ Entry point configured")
+  print("✅ Provider implemented")
+  if with_schema:
+    print("✅ Schema support added")
+  print("✅ Tests created")
+  print("✅ Documentation generated")
+
+
+def main():
+  """Main entry point for the provider plugin generator."""
+  args = parse_arguments()
+
+  package_name = args.package_name or args.provider_name.lower()
+  patterns = args.patterns if args.patterns else [f"^{package_name}"]
+
+  validate_patterns(patterns)
+  print_summary(args.provider_name, package_name, patterns, args.with_schema)
+
+  base_dir = create_plugin(args, package_name, patterns)
+  print_completion_summary(args.with_schema)
+
+  if not args.no_install:
+    success = install_and_test(base_dir)
+    if success:
+      print("\n✅ Plugin created, installed, and tested successfully!")
+      print(f"\nYour plugin is ready at: {base_dir.absolute()}")
+      print("\nNext steps:")
+      print("  1. Replace mock inference with actual API calls")
+      print("  2. Update documentation with real examples")
+      print("  3. Build package: python -m build")
+      print("  4. Publish to PyPI: twine upload dist/*")
+    else:
+      print(
+          "\n⚠️ Plugin created but tests failed. Please check the"
+          " implementation."
+      )
+      sys.exit(1)
+  else:
+    print(f"\nPlugin created at: {base_dir.absolute()}")
+    print("\nTo install and test:")
+    print(f"  cd {base_dir}")
+    print("  pip install -e .")
+    print("  python test_plugin.py")
+
+
+if __name__ == "__main__":
+  main()