afterpython 0.0.1.dev2__py3-none-any.whl → 0.1.0.dev5__py3-none-any.whl

afterpython/tools/myst.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from afterpython._typing import tContentType, NodeEnv
+
+import subprocess
+
+import afterpython as ap
+from afterpython.utils import deep_merge
+from afterpython._io.yaml import write_yaml, read_yaml
+
+
+def update_authors_yml(data_update: dict):
+    """Update authors.yml while preserving order and formatting"""
+    file_path = ap.paths.afterpython_path / "authors.yml"
+
+    if not file_path.exists():
+        write_yaml(file_path, data_update)
+        return
+
+    existing_data = read_yaml(file_path) or {}
+
+    # merge authors, keep the author with more fields (e.g. github, x, etc.) to avoid duplication
+    merged_authors = {}
+    for author in (
+        existing_data["project"]["contributors"]
+        + data_update["project"]["contributors"]
+    ):
+        author_id = author["id"]
+        if author_id not in merged_authors:
+            merged_authors[author_id] = author
+        else:
+            # keep the author with more fields (e.g. github, x, etc.)
+            if len(author.keys()) > len(merged_authors[author_id].keys()):
+                merged_authors[author_id] = author
+    existing_data["project"]["contributors"] = list(merged_authors.values())
+
+    # set comments for project section for convenience
+    if "project" in existing_data and not existing_data["project"].ca.items.get(
+        "contributors"
+    ):
+        existing_data["project"].yaml_set_comment_before_after_key(
+            "contributors",
+            before="See more at: https://mystmd.org/guide/frontmatter#frontmatter-authors",
+        )
+    write_yaml(file_path, existing_data)
+
+
+def update_myst_yml(data_update: dict, path: Path):
+    """Update myst.yml while preserving order and formatting
+
+    Args:
+        data_update: dict of data to update
+        path: path to the myst.yml file, e.g. doc/, blog/, tutorial/, example/, guide/
+    """
+
+    file_path = path / "myst.yml"
+
+    if not file_path.exists():
+        raise FileNotFoundError(
+            f"myst.yml not found at {file_path}, did you forget to run `ap init` or `myst init`?"
+        )
+
+    existing_data = read_yaml(file_path) or {}
+    existing_data = deep_merge(existing_data, data_update)
+
+    # set comments for project section for convenience
+    if "project" in existing_data:
+        if not existing_data["project"].ca.items.get("id"):
+            existing_data["project"].yaml_set_comment_before_after_key(
+                "id",
+                before="See how to create Table of Contents at: https://mystmd.org/guide/table-of-contents",
+            )
+        if not existing_data["project"].ca.items.get("authors"):
+            existing_data["project"].yaml_set_comment_before_after_key(
+                "authors",
+                before="See more authors' fields at: https://mystmd.org/guide/frontmatter#frontmatter-authors",
+            )
+        if not existing_data["project"].ca.items.get("venue"):
+            existing_data["project"].yaml_set_comment_before_after_key(
+                "venue",
+                before="See more venue's fields at: https://mystmd.org/guide/frontmatter#venue",
+            )
+    if "site" in existing_data:
+        if not existing_data["site"].ca.items.get("options"):
+            existing_data["site"].yaml_set_comment_before_after_key(
+                "options",
+                before="See options at: https://mystmd.org/guide/website-templates#site-options",
+            )
+        if not existing_data["site"].ca.items.get("actions"):
+            existing_data["site"].yaml_set_comment_before_after_key(
+                "actions",
+                before="See web layout at: https://mystmd.org/guide/website-navigation",
+            )
+
+    write_yaml(file_path, existing_data)
+
+
+def _write_welcome_file(content_type: tContentType):
+    welcome_file = ap.paths.afterpython_path / content_type / "index.md"
+    if welcome_file.exists():
+        return
+    welcome_content = f"""# Welcome to AfterPython
+
+Welcome to your project's {content_type}! This is a starter page to help you get started.
+
+## Getting Started
+
+Replace this placeholder content with your own. Here's what you can do:
+
+- Creating new `.md` or `.ipynb` files in the `afterpython/{content_type}/` directory
+- Writing in MyST Markdown format
+- Adding images to the `afterpython/static/` directory and referencing them
+
+## Resources
+
+- [AfterPython's Project Website](https://ap.afterpython.org)
+- [MyST Markdown Guide](https://mystmd.org)
+
+Start building your amazing project! 🚀
+"""
+    welcome_file.write_text(welcome_content)
+    return welcome_file
+
+
+def init_myst():
+    """
+    Initialize MyST Markdown (mystmd) and myst.yml files in
+    doc/, blog/, tutorial/, example/, guide/ directories with sensible defaults
+    """
+    from afterpython.const import CONTENT_TYPES
+    from afterpython.utils import find_node_env
+
+    # find any existing node.js version and use it, if no, install the Node.js version specified in NODEENV_VERSION
+    node_env: NodeEnv = find_node_env()
+    subprocess.run(["npm", "install", "-g", "pnpm"], env=node_env, check=True)
+    for content_type in CONTENT_TYPES:
+        path = ap.paths.afterpython_path / content_type
+        print(f"Initializing MyST Markdown (mystmd) in {path.name}/ directory ...")
+        path.mkdir(parents=True, exist_ok=True)
+        subprocess.run(["myst", "init"], cwd=path, input="n\n", text=True, env=node_env)
+        myst_yml_defaults = {
+            "extends": "../authors.yml",
+            "project": {
+                "license": "CC-BY-4.0",
+                "subject": content_type.capitalize()
+                if content_type != "doc"
+                else "Documentation",
+            },
+            "site": {
+                "options": {
+                    "favicon": "../static/favicon.ico",
+                    "logo": "../static/logo.svg",
+                    "logo_dark": "../static/logo.svg",
+                    "analytics_google": "{{ GOOGLE_ANALYTICS_ID }}",
+                    # "twitter": "",
+                },
+            },
+        }
+        update_myst_yml(myst_yml_defaults, path)
+        _write_welcome_file(content_type)
+    subprocess.run(["ap", "sync"])

afterpython/tools/pre_commit.py

@@ -0,0 +1,62 @@
+import subprocess
+
+import afterpython as ap
+
+from afterpython._io.yaml import write_yaml, read_yaml
+
+
+pre_commit_default = {
+    # default is only ["pre-commit"], without changing the default,
+    # we need to explicitly pass in --hook-type whenever we run "pre-commit install --hook-type ..."
+    "default_install_hook_types": ["pre-commit", "commit-msg", "pre-push"],
+    "exclude": "^afterpython/_website/",  # do not check the project website template
+    "repos": [
+        {
+            "repo": "https://github.com/pre-commit/pre-commit-hooks",
+            "rev": "v6.0.0",
+            "hooks": [
+                {"id": "trailing-whitespace", "stages": ["pre-commit"]},
+                {"id": "end-of-file-fixer", "stages": ["pre-commit"]},
+                {"id": "check-yaml", "stages": ["pre-commit"]},
+                {"id": "check-toml", "stages": ["pre-commit"]},
+                {"id": "check-added-large-files", "stages": ["pre-commit"]},
+            ],
+        },
+        # {
+        #     "repo": "https://github.com/astral-sh/uv-pre-commit",
+        #     "rev": "0.9.8",
+        #     "hooks": [
+        #         {"id": "uv-lock"},  # Update the uv lockfile
+        #     ]
+        # },
+    ],
+}
+
+
+def install_pre_commit():
+    # installed in .git/hooks
+    subprocess.run(["ap", "pre-commit", "install", "--install-hooks"], check=True)
+
+
+def update_pre_commit(data_update: dict):
+    from afterpython.utils import deep_merge
+
+    pre_commit_path = ap.paths.afterpython_path / ".pre-commit-config.yaml"
+    if not pre_commit_path.exists():
+        raise FileNotFoundError(
+            f".pre-commit-config.yaml not found at {pre_commit_path}"
+        )
+    existing_data = read_yaml(pre_commit_path)
+    existing_data = deep_merge(existing_data, data_update)
+    write_yaml(pre_commit_path, existing_data)
+    install_pre_commit()
+
+
+def init_pre_commit():
+    pre_commit_path = ap.paths.afterpython_path / ".pre-commit-config.yaml"
+    if pre_commit_path.exists():
+        print(f".pre-commit-config.yaml already exists at {pre_commit_path}")
+        return
+    write_yaml(pre_commit_path, pre_commit_default)
+    print(f"Created {pre_commit_path}")
+    install_pre_commit()

afterpython/tools/pyproject.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from tomlkit.toml_document import TOMLDocument
+
+import asyncio
+
+from pyproject_metadata import StandardMetadata
+
+import afterpython as ap
+from afterpython._io.toml import read_toml, write_toml, _to_tomlkit
+
+
+def read_pyproject() -> TOMLDocument:
+    """Read pyproject.toml"""
+    return read_toml(ap.paths.pyproject_path)
+
+
+def write_pyproject(data: TOMLDocument):
+    write_toml(ap.paths.pyproject_path, data)
+
+
+def read_metadata() -> StandardMetadata:
+    """Read metadata from pyproject.toml"""
+    return StandardMetadata.from_pyproject(read_pyproject())
+
+
+def init_pyproject():
+    """Initialize pyproject.toml with sensible defaults
+    - add [build-system] section with uv build backend (same as `uv init --package`)
+    - add [project.urls] section with homepage, repository, and documentation URLs
+    """
+    import httpx
+    from afterpython.utils import fetch_pypi_json
+    from afterpython.tools._git import get_git_user_config, get_github_url
+
+    build_backend = "uv_build"
+
+    async def fetch_build_backend_version() -> str | None:
+        """Fetch the latest version of build backend package from PyPI."""
+        async with httpx.AsyncClient() as client:
+            data = await fetch_pypi_json(client, build_backend)
+            return data["info"]["version"] if data else None
+
+    data: TOMLDocument = read_pyproject()
+    is_updated = False
+
+    if "build-system" not in data:
+        uv_build_version = asyncio.run(fetch_build_backend_version())
+        if uv_build_version:
+            data["build-system"] = {
+                "requires": [f"{build_backend}>={uv_build_version}"],
+                "build-backend": build_backend,
+            }
+            is_updated = True
+
+    if "project" in data:
+        if "urls" not in data["project"]:
+            data["project"]["urls"] = {
+                "homepage": "",
+                "repository": get_github_url() or "",
+                "documentation": "",
+            }
+            is_updated = True
+        if "authors" not in data["project"]:
+            # convert git user config to tomlkit object
+            data["project"]["authors"] = _to_tomlkit([get_git_user_config()])
+            is_updated = True
+
+    if is_updated:
+        write_pyproject(data)

afterpython/utils.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pathlib import Path
+    from httpx import AsyncClient
+    from afterpython._typing import NodeEnv
+
+import os
+import re
+import shutil
+import subprocess
+
+import click
+
+
+def find_node_env() -> NodeEnv:
+    """
+    Find if there is an installed Node.js version, if yes, use it
+    If no, install the Node.js version specified in NODEENV_VERSION
+    """
+    from mystmd_py.nodeenv import find_any_node
+    from afterpython.const import NODEENV_VERSION
+
+    # from mystmd_py.main import ensure_valid_version
+    # Use mystmd's own node-finding logic
+    binary_path = os.environ.get("PATH", os.defpath)
+    _node_path, os_path = find_any_node(binary_path, nodeenv_version=NODEENV_VERSION)
+    node_env: NodeEnv = {**os.environ, "PATH": os_path}
+    return node_env
+
+
+def has_uv() -> bool:
+    """Check if uv is installed"""
+    return shutil.which("uv") is not None
+
+
+def has_gh() -> bool:
+    """Check if gh is installed"""
+    return shutil.which("gh") is not None
+
+
+async def fetch_pypi_json(client: AsyncClient, package_name: str) -> dict | None:
+    url = f"https://pypi.org/pypi/{package_name}/json"
+    try:
+        response = await client.get(url)
+        response.raise_for_status()
+        data = response.json()
+        return data
+    except Exception as e:
+        # Return None if package doesn't exist or network fails
+        print(f"Warning: Could not fetch PyPI JSON for {package_name}: {e}")
+        return None
+
+
+# VIBE-CODED
+def detect_license_from_file(file_path: str) -> str:
+    """Extract license name from LICENSE file using regex."""
+    with open(file_path, encoding="utf-8") as f:
+        content = f.read()
+
+    # Common license patterns
+    patterns = {
+        "Apache-2.0": r"Apache License\s+Version 2\.0",
+        "MIT": r"MIT License|Permission is hereby granted, free of charge",
+        "GPL-3.0": r"GNU GENERAL PUBLIC LICENSE\s+Version 3",
+        "GPL-2.0": r"GNU GENERAL PUBLIC LICENSE\s+Version 2",
+        "BSD-3-Clause": r"BSD 3-Clause License|Redistribution and use in source and binary forms",
+        "BSD-2-Clause": r"BSD 2-Clause License",
+        "ISC": r"ISC License",
+        "LGPL-3.0": r"GNU LESSER GENERAL PUBLIC LICENSE\s+Version 3",
+        "MPL-2.0": r"Mozilla Public License Version 2\.0",
+    }
+
+    # Check first 500 chars for license header
+    header = content[:500]
+
+    for license_id, pattern in patterns.items():
+        if re.search(pattern, header, re.IGNORECASE):
+            return license_id
+
+    return ""
+
+
+def deep_merge(base: dict, updates: dict) -> dict:
+    """Deep merge updates into base, preserving structure and metadata.
+
+    Works with:
+    - Regular Python dicts
+    - tomlkit TOMLDocument/Table objects
+    - ruamel.yaml CommentedMap objects
+
+    Behavior:
+    - Dicts are merged recursively
+    - Lists are extended (concatenated)
+    - Other types are overwritten
+
+    Args:
+        base: The base dictionary to merge into (modified in-place)
+        updates: The updates to apply
+
+    Returns:
+        The merged base dictionary (same object, modified in-place)
+    """
+    for key, value in updates.items():
+        if key in base:
+            if isinstance(base[key], dict) and isinstance(value, dict):
+                # Recursively merge dicts
+                deep_merge(base[key], value)
+            elif isinstance(base[key], list) and isinstance(value, list):
+                # Extend lists, but only add items that don't already exist
+                for item in value:
+                    if item not in base[key]:
+                        base[key].append(item)
+            else:
+                # Overwrite for other types
+                base[key] = value
+        else:
+            base[key] = value
+
+    return base
+
+
+def convert_author_name_to_id(name: str) -> str:
+    """Convert author name to ID
+
+    Args:
+        name: The author name
+
+    Returns:
+        The author ID
+
+    Examples:
+        - "Stephen Yau" -> "stephen_yau"
+        - "John Doe" -> "john_doe"
+        - "Jane Smith" -> "jane_smith"
+    """
+    return name.replace(" ", "_").lower()
+
+
+def find_available_port(
+    start_port: int = 3000, max_port: int = 3100, host: str = "localhost"
+) -> int:
+    """
+    Find a TCP port with no listener on `host`, starting from start_port.
+    """
+    import socket
+
+    def is_port_in_use(
+        port: int, host: str = "localhost", timeout: float = 0.2
+    ) -> bool:
+        """
+        Return True if *any* TCP listener is active on the given host:port.
+        This works across IPv4/IPv6 by using getaddrinfo().
+        """
+        try:
+            for family, socktype, proto, _canonname, sockaddr in socket.getaddrinfo(
+                host, port, type=socket.SOCK_STREAM
+            ):
+                with socket.socket(family, socktype, proto) as s:
+                    s.settimeout(timeout)
+                    if s.connect_ex(sockaddr) == 0:
+                        return True
+        except socket.gaierror:
+            # host couldn't be resolved; treat as no listener
+            return False
+        return False
+
+    for port in range(start_port, max_port + 1):
+        if not is_port_in_use(port, host=host):
+            return port
+    raise RuntimeError(
+        f"No free ports available in range {start_port}-{max_port} for host={host!r}"
+    )
+
+
+def has_content_for_myst(content_path: Path) -> bool:
+    """Check if a content directory has any content files"""
+    return any(
+        content_path.glob("*.md")
+        or content_path.glob("*.ipynb")
+        or content_path.glob("*.tex")
+    )
+
+
+def handle_passthrough_help(
+    ctx: click.Context,
+    underlying_command: list[str],
+    show_underlying: bool = True,
+    help_flags: tuple[str, ...] = ("--help", "-h"),
+) -> None:
+    """Handle --help for commands that pass through to underlying tools.
+
+    Shows both Click's help (custom options) and the underlying tool's help.
+
+    Args:
+        ctx: Click context
+        underlying_command: Command to show help for (e.g., ["cz", "bump"])
+        show_underlying: Whether to show underlying tool's help (default: True)
+        help_flags: Flags that trigger help display (default: ("--help", "-h"))
+                   Use ("--help",) if -h is reserved by the underlying tool
+    """
+    # Check if any help flag is present
+    if any(flag in ctx.args for flag in help_flags):
+        # Show Click's help first (our custom options)
+        click.echo(ctx.get_help())
+
+        # Then show underlying tool's help if requested
+        if show_underlying:
+            click.echo("\n" + "=" * 60)
+            click.echo(f"Additional options from '{' '.join(underlying_command)}':")
+            click.echo("=" * 60 + "\n")
+            subprocess.run([*underlying_command, "--help"])
+
+        ctx.exit(0)

afterpython/version.py

@@ -0,0 +1,39 @@
+from packaging.version import Version as BaseVersion
+
+
+class Version(BaseVersion):
+    def next_breaking(self, level: str = "auto") -> "Version":
+        """Get the next version that would break compatibility.
+
+        Args:
+            level: "major", "minor", or "auto" (detect from current version)
+                   - If major == 0: breaks on minor (0.x API is unstable)
+                   - If major >= 1: breaks on major (semver stable)
+
+        Examples:
+            Version("0.9.7").next_breaking() -> Version("0.10.0")
+            Version("1.2.3").next_breaking() -> Version("2.0.0")
+            Version("1.2.3").next_breaking("minor") -> Version("1.3.0")
+        """
+        if level == "auto":
+            # Follow semver convention: 0.x.x breaks on minor, 1.x.x+ breaks on major
+            level = "minor" if self.major == 0 else "major"
+
+        if level == "major":
+            return Version(f"{self.major + 1}.0.0")
+        elif level == "minor":
+            return Version(f"{self.major}.{self.minor + 1}.0")
+        else:
+            raise ValueError(f"Invalid level: {level}. Use 'major', 'minor', or 'auto'")
+
+    def bump_major(self) -> "Version":
+        """Bump major version. Example: 1.2.3 -> 2.0.0"""
+        return Version(f"{self.major + 1}.0.0")
+
+    def bump_minor(self) -> "Version":
+        """Bump minor version. Example: 0.9.7 -> 0.10.0"""
+        return Version(f"{self.major}.{self.minor + 1}.0")
+
+    def bump_patch(self) -> "Version":
+        """Bump patch version. Example: 0.9.7 -> 0.9.8"""
+        return Version(f"{self.major}.{self.minor}.{self.micro + 1}")

afterpython-0.1.0.dev5.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: afterpython
+Version: 0.1.0.dev5
+Summary: CLI tool for AfterPython
+Keywords: package-maintenance,project-website,static-site-generator,developer-tools,documentation,cli-tool,ci/cd,mystmd,semantic-release,python-packaging
+Author: Stephen Yau
+Author-email: Stephen Yau <softwareentrepreneer+afterpython@gmail.com>
+License-Expression: Apache-2.0
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: click>=8.3.1
+Requires-Dist: trogon>=0.6.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: tomlkit>=0.13.3
+Requires-Dist: ruamel-yaml>=0.18.16
+Requires-Dist: gitpython>=3.1.45
+Requires-Dist: pygithub>=2.8.1
+Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: pyproject-metadata>=0.9.1
+Requires-Dist: mystmd>=1.6.6
+Requires-Dist: pdoc>=16.0.0
+Requires-Dist: ruff>=0.14.5
+Requires-Dist: pre-commit>=4.4.0
+Requires-Dist: commitizen>=4.10.0
+Requires-Python: >=3.11
+Project-URL: documentation, https://ap.afterpython.org/doc
+Project-URL: homepage, https://afterpython.org
+Project-URL: repository, https://github.com/AfterPythonOrg/afterpython
+Description-Content-Type: text/markdown
+
+# AfterPython: Python Package Maintenance Toolkit and Project Website Generator
+
+[![afterpython](https://afterpython.org/shield.svg)](https://afterpython.org)
+[![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh)
+![PyPI downloads](https://img.shields.io/pypi/dm/afterpython)
+[![PyPI](https://img.shields.io/pypi/v/afterpython.svg)](https://pypi.org/project/afterpython)
+![PyPI - Support Python Versions](https://img.shields.io/pypi/pyversions/afterpython)
+[![Discussions](https://img.shields.io/badge/Discussions-Let's%20Chat-green)](https://github.com/AfterPythonOrg/afterpython/discussions)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/AfterPythonOrg/afterpython)
+
+
+[MyST]: https://mystmd.org
+[MyST Markdown]: https://mystmd.org/spec/
+[Jupyter Notebook]: https://jupyter.org
+[pre-commit]: https://pre-commit.com
+[pagefind]: https://pagefind.app
+[SemVer]: https://semver.org
+[pdoc]: https://pdoc.dev/
+[GitHub Actions]: https://github.com/features/actions
+[PyTorch]: https://pytorch.org
+[Scikit-Learn]: https://scikit-learn.org
+[WebLLM]: https://webllm.mlc.ai/
+[project-website-template]: https://github.com/AfterPythonOrg/project-website-template
+[uv]: https://docs.astral.sh/uv/
+[ruff]: https://docs.astral.sh/ruff/
+
+
+## Problem
+Going from **writing Python code to publishing and maintaining a package** is **time-consuming**.
+First-time maintainers must learn multiple tools and concepts, e.g. [MyST], [SemVer], CI/CD ([pre-commit] hooks, GitHub workflows), and they often spending hours just to deploy a documentation site whereas well-resourced projects like [PyTorch] and [Scikit-Learn] have **dedicated websites** that serve as their project hubs.
+
+
+## Solution
+`afterpython` **automates** the tedious parts of Python package maintenance and generates a **project website** for **building community** and **hosting content** such as documentation, **blog posts**, tutorials, examples and more — empowering more developers to write packages with ease.
+
+---
+`afterpython` is a CLI tool that **abstracts away the complexity** of **content writing, website deployment, and package release/maintenance** by providing an opinionated set of modern tools — so you don’t have to spend time selecting or learning anything beyond the basics.
+
+
+## Core Features
+- [x] Write content directly in [MyST Markdown] or [Jupyter Notebook]
+- [x] Go from writing to website deployment in minutes — no need to learn any of the underlying tools
+- [x] Centralize all your content in a modern, unified project website — from documentation to blog posts
+- [ ] Export content as PDF — for example, combine all blog posts into a single PDF file
+- [ ] **⚡ Full-text search** across **ALL** your content in your website — docs, blogs, tutorials, everything
+- [ ] **🤖 Embedded AI Chatbot** that answers questions directly using an in-browser LLM — at no cost
+
+
+## Installation
+```bash
+# install afterpython as a dev dependency
+uv add --dev afterpython
+# initialize afterpython
+ap init
+```
+
+
+## Tech Stack
+- [MyST]
+- [project-website-template]
+- [pre-commit]
+- [GitHub Actions]
+- [pdoc]
+- [uv]
+- [ruff]
+- [pagefind]
+- [WebLLM]
+<!-- - ty -->
+<!-- - [pixi] -->