Schematic

class Anchor(BaseModel):
    """Base class for placement anchors.

    Subclasses (e.g. `FixedAnchor`, `PortAnchor`) define reference points used
    to align an instance during placement. Anchors allow to place instances relative to
    to their bounding box or port positions.
    """

class Array[T: (int, float)](BaseModel, extra="forbid"):
    """General 2D array parameterization using two pitch vectors.

    Attributes:
        na: Repetition count along vector A. This vector
            needs to have a positive x component.
        nb: Repetition count along vector B. This vector
            needs to have a positive y component
        pitch_a: (dx, dy) pitch for vector A. dx must be >= 0.
        pitch_b: (dx, dy) pitch for vector B. dy must be >= 0.
    """

    na: int = Field(gt=1, default=1)
    nb: int = Field(gt=0, default=1)
    pitch_a: tuple[Annotated[T, AfterValidator(_gez)], T]
    pitch_b: tuple[T, Annotated[T, AfterValidator(_gez)]]

class Connection[T: (int, float)](SchematicNet[T]):
    """Hard connection between two ports.

    Enforced as {PortRef | PortArrayRef | Port} x {PortRef | PortArrayRef}.
    Two `Port` objects (cell ports) cannot be connected directly.

    Raises:
        TypeError: If connection attempts to join two `Port` objects.
    """

    net: tuple[PortArrayRef | PortRef | Port[T], PortArrayRef | PortRef] = Field(
        frozen=True
    )

    @field_validator("net", mode="before")
    @classmethod
    def _sort_and_validate_net(
        cls,
        v: tuple[PortArrayRef | PortRef | Port[T], ...],
    ) -> tuple[PortArrayRef | PortRef | Port[T], ...]:
        # Allow list/iterable input; normalize to a 2-tuple
        if not isinstance(v, tuple):
            v = tuple(v)
        if len(v) != 2:
            raise TypeError("net must contain exactly two endpoints")

        a, b = v

        # Sort without mutating the model instance (important for frozen fields/models)
        net_sorted = tuple(sorted((a, b)))

        # After sorting, ensure the RHS isn't a cell Port (your original invariant)
        if isinstance(net_sorted[1], Port):
            raise TypeError(
                "Two cell ports cannot be connected together. This would cause an "
                "invalid netlist."
            )

        return net_sorted

    @classmethod
    def from_list(
        cls, data: list[Any] | tuple[Any, ...] | dict[str, Any]
    ) -> Connection[T]:
        """Parse a Connection from a compact list/tuple/dict representation.

        Used for parsing legacy gdsfactory like connections.

        Supports array addressing like `( (inst, (ia, ib)), port )`.
        """
        if isinstance(data, list | tuple):
            if isinstance(data[0][0], list | tuple):
                p1 = {
                    "instance": data[0][0][0],
                    "port": data[0][1],
                    "ia": data[0][0][1][0],
                    "ib": data[0][0][1][1],
                }
            else:
                p1 = {"instance": data[0][0], "port": data[0][1]}
            if isinstance(data[1][0], list | tuple):
                p2 = {
                    "instance": data[1][0][0],
                    "port": data[1][1],
                    "ia": data[1][0][1][0],
                    "ib": data[1][0][1][1],
                }
            else:
                p2 = {"instance": data[1][0], "port": data[1][1]}

            return Connection[T].model_validate({"net": (p1, p2)})
        return Connection[T](**data)

class Constraint(BaseModel, ABC, arbitrary_types_allowed=True):
    """Base class for schematic constraints.

    Constraints operate in two phases:

    1. **enforce** — called by the routing function during the post-process phase,
       before instances are placed. Receives the `ManhattanRouter` objects and routing
       context kwargs (e.g. ``separation``, ``bend90_radius``).

    2. **check** — called by `TSchematic.create_cell` after routing is complete.
       Receives the materialized cell, the schematic, the resolved `Instance` objects
       for `instance_names`, and the `ManhattanRoute` results for `route_names`.

    Attributes:
        route_names: Names of the routes this constraint applies to.
        instance_names: Names of the instances this constraint applies to.
        on_failure: Behaviour when `check` returns False. ``"error"`` raises a
            `ValueError`. ``"show_error"`` additionally opens the cell in KLayout
            with an lyrdb marker database. ``None`` silently ignores failures.
    """

    route_names: list[str]
    instance_names: list[str] = Field(default=[])
    on_failure: Literal["error", "show_error"] | None = "error"
    _routes: dict[str | None, list[ManhattanRoute]] = PrivateAttr(default={})
    _routers: dict[str | None, list[ManhattanRouter]] = PrivateAttr(default={})

    @abstractmethod
    def enforce(
        self,
        c: KCell,
        routers: Sequence[ManhattanRouter],
        route_name: str | None,
    ) -> None:
        """Enforce the constraint on the routers before placement.

        Called by the routing function. ``**kwargs`` contains routing context
        such as ``separation`` and ``bend90_radius``.
        """
        ...

    @abstractmethod
    def check(
        self,
        c: KCell,
        schematic: TSchematic[Any],
        instances: dict[str, Instance],
        routes: dict[str, list[ManhattanRoute]],
    ) -> bool:
        """Return True if the constraint is satisfied after routing."""
        ...

    def lyrdb_markers(
        self,
        c: KCell,
        schematic: TSchematic[Any],
        instances: dict[str, Instance],
        routes: dict[str, list[ManhattanRoute]],
    ) -> rdb.ReportDatabase:
        """Build an lyrdb marker database for failing routes.

        The default implementation highlights route backbones. Override for
        constraint-specific visualisation.
        """
        from klayout import rdb as _rdb

        db = _rdb.ReportDatabase(f"{self.__class__.__name__} Constraint Failure")
        cat = db.create_category("Failing Routes")
        cell = db.create_cell(c.name)
        for name in self.route_names:
            for route in routes.get(name, []):
                if len(route.backbone) >= 2:
                    item = db.create_item(cell, cat)
                    item.add_value(
                        kdb.DPath(
                            [kdb.DPoint(p) * c.kcl.dbu for p in route.backbone],
                            route.start_port.dwidth,
                        ).polygon()
                    )
        return db

class DSchema(DSchematic):
    """Deprecated alias for `DSchematic` (will be removed in kfactory 2.0)."""

    def __init__(self, **data: Any) -> None:
        logger.warning(
            "DSchema is deprecated, please use DSchematic. "
            "It will be removed in kfactory 2.0"
        )
        if "unit" in data:
            raise ValueError(
                "Cannot set the unit direct. It needs to be set by the class init."
            )
        super().__init__(**data)

class DSchematic(TSchematic[um]):
    """Schematic with a base unit of um for placements."""

    unit: Literal["um"] = "um"

    def __init__(self, **data: Any) -> None:
        if "unit" in data:
            raise ValueError(
                "Cannot set the unit direct. It needs to be set by the class init."
            )
        super().__init__(unit="um", **data)

class FixedAnchor(Anchor):
    """Anchor an instance to a fixed point of its own bounding box.

    Attributes:
        x: Horizontal anchor relative to the instance bbox ("left", "center", "right").
        y: Vertical anchor relative to the instance bbox ("bottom", "center", "top").
    """

    x: Literal["left", "center", "right"] | None = None
    y: Literal["bottom", "center", "top"] | None = None

class MirrorPlacement(BaseModel, extra="forbid"):
    """Mirror-only placement toggle for an instance.

    Mirror only placements are used for connections. This ensures that the schematic can
    keep track of the relative mirror in case its placement is defined through
    connections only (i.e. purely relative to neighboring instances).

    Attributes:
        mirror: Whether the instance should be mirrored horizontally.
    """

    mirror: bool = False

class PathLengthMatch(Constraint):
    """Constraint that equalises optical path lengths across a set of routes.

    Uses the loop-based path-length matching already built into the optical
    router.  The `enforce` method injects meander loops into the shorter
    routers so that all routes reach the same length before instances are
    placed.  The `check` method verifies the final `ManhattanRoute` lengths
    are within `tolerance` of each other.

    Attributes:
        loops: Number of meander loops to use per route.
        loop_side: Which side of the route to place the loop on.
        loop_position: Where along the route to place the loop.
        element: Index of the straight segment to insert the loop into.
        tolerance: Maximum allowed length difference after enforcement.
    """

    loops: int = 1
    loop_side: int = -1  # LoopSide.left
    loop_position: int = -1  # LoopPosition.start
    element: int = -1
    tolerance: int = 0
    length: int | None = None
    all: bool = False

    def enforce(
        self,
        c: KCell,
        routers: Sequence[ManhattanRouter],
        route_name: str | None,
    ) -> None:
        from .routing.optical import LoopPosition, LoopSide, path_length_match

        if self.all or (len(self.route_names) - len(self._routers)) == 1:
            path_length_match(
                routers=routers,
                element=self.element,
                loops=self.loops,
                loop_side=LoopSide(self.loop_side),
                loop_position=LoopPosition(self.loop_position),
                path_length=self.length,
            )

        self._routers[route_name] = list(routers)

    def check(
        self,
        c: KCell,
        schematic: TSchematic[Any],
        instances: dict[str, Instance],
        routes: dict[str, list[ManhattanRoute]],
    ) -> bool:
        all_routes = [r for name in self.route_names for r in routes.get(name, [])]
        if not all_routes:
            return True
        lengths = [r.length for r in all_routes]
        return (max(lengths) - min(lengths)) <= self.tolerance

    def lyrdb_markers(
        self,
        c: KCell,
        schematic: TSchematic[Any],
        instances: dict[str, Instance],
        routes: dict[str, list[ManhattanRoute]],
    ) -> rdb.ReportDatabase:
        from klayout import rdb as _rdb

        all_routes = [r for name in self.route_names for r in routes.get(name, [])]
        lengths = [r.length for r in all_routes] if all_routes else []
        target = max(lengths) if lengths else 0

        db = _rdb.ReportDatabase("PathLengthMatch Constraint Failure")
        cat = db.create_category("Length Mismatch")
        cell = db.create_cell(c.name)
        for name in self.route_names:
            for route in routes.get(name, []):
                delta = target - route.length
                if delta > self.tolerance and len(route.backbone) >= 2:
                    item = db.create_item(cell, cat)
                    item.add_value(
                        kdb.DPath(
                            [kdb.DPoint(p) * c.kcl.dbu for p in route.backbone],
                            route.start_port.dwidth,
                        ).polygon()
                    )
                    item.add_value(f"length={route.length}, delta={delta}")
        return db

class Pin(BaseModel, extra="forbid"):
    """A schematic-level pin grouping one or more schematic-level ports.

    The pin will be materialized on the resulting cell at ``create_cell``
    time as a :class:`kfactory.Pin`. The ``ports`` list references entries
    in :attr:`TSchematic.ports` by name.

    Attributes:
        name: Pin name (key in :attr:`TSchematic.pins`).
        ports: Names of schematic-level ports that belong to this pin.
        pin_type: Pin type (default ``"DC"``).
        info: Free-form info attached to the pin.
    """

    name: str = Field(exclude=True)
    ports: list[str]
    pin_type: str = "DC"
    info: dict[str, JSONSerializable] = Field(default_factory=dict)

class PinRef(BaseModel, extra="forbid"):
    """Reference to a pin on a schematic instance.

    Produced by ``inst.pins["name"]`` and used as the ``pin`` argument of
    :meth:`TSchematic.add_pin` to expose an instance pin as a top-level
    schematic pin.
    """

    instance: str
    pin: str

    @property
    def name(self) -> str:
        return self.pin

    def __lt__(self, other: PinRef) -> bool:
        return (self.instance, self.pin) < (other.instance, other.pin)

    def __hash__(self) -> int:
        return hash((self.instance, self.pin))

    def __eq__(self, other: object) -> bool:
        return (
            isinstance(other, PinRef)
            and self.instance == other.instance
            and self.pin == other.pin
        )

    def as_python_str(self, inst_name: str | None = None) -> str:
        return f"{inst_name or self.instance}.pins[{self.pin!r}]"

class Pins[T: (int, float)]:
    """Indexer for an instance's pins to produce `PinRef`.

    Example:
        `inst.pins["dc"]` -> `PinRef`
    """

    __slots__ = ("instance",)

    def __init__(self, instance: SchematicInstance[T]) -> None:
        self.instance = instance

    def __getitem__(self, key: str) -> PinRef:
        """Return a pin reference."""
        return PinRef(instance=self.instance.name, pin=key)

class Placement[T: (int, float)](MirrorPlacement, extra="forbid"):
    """Absolute placement and orientation for an instance.

    Coordinates may be absolute (`x`, `y`) with
    relative offsets (`dx`, `dy`), and can reference other instance ports via
    `PortRef`/`PortArrayRef`. These are still considered absolute placements, but
    allow relative

    Attributes:
        x: x position or a port reference providing the x coordinate.
        dx: Relative X offset added to `x`.
        y: y position or a port reference providing the y coordinate.
        dy: Relative Y offset added to `y`.
        orientation: Rotation in degrees (0, 90, 180, 270). Can be a reference
            to another instance's port.
        anchor: Optional `FixedAnchor`/`PortAnchor` to align the instance relative
            to its bounding box or one of its ports.
        mirror: Whether the instance is to be mirrored or not.
    """

    x: int | T | PortRef | PortArrayRef | AnchorRefX = 0
    dx: int | T = 0
    y: int | T | PortRef | PortArrayRef | AnchorRefY = 0
    dy: int | T = 0
    orientation: float | PortRef = 0
    anchor: FixedAnchor | PortAnchor | None = None

    @model_validator(mode="before")
    @classmethod
    def _replace_rotation_orientation(cls, data: dict[str, Any]) -> dict[str, Any]:
        if "rotation" in data:
            data["orientation"] = data.pop("rotation")
        return data

    def is_placeable(self, placed_instances: set[str], placed_ports: set[str]) -> bool:
        """Return True if all referenced instances/ports are already placed.

        If true, this means this instance can be placed now.
        """
        placeable = True
        if isinstance(self.x, PortRef):
            placeable = self.x.instance in placed_instances
        elif isinstance(self.x, Port):
            placeable = placeable and self.x.name in placed_ports
        elif isinstance(self.x, AnchorRefX):
            placeable = placeable and self.x.instance in placed_instances
        if isinstance(self.y, PortRef):
            placeable = placeable and self.y.instance in placed_instances
        elif isinstance(self.y, Port):
            placeable = placeable and self.y.name in placed_ports
        elif isinstance(self.y, AnchorRefY):
            placeable = placeable and self.y.instance in placed_instances
        if isinstance(self.orientation, PortRef):
            placeable = placeable and self.orientation.instance in placed_instances
        return placeable

class Port[T: (int, float)](BaseModel, extra="forbid"):
    """A schematic-level, placeable port.

    This port is on the Schematic's cell's level, i.e. equivalent of `(D)KCell.ports`
    (or `Component.ports`).

    The port position/orientation can be absolute or derived from other placed
    instance ports via `PortRef`/`PortArrayRef`.

    Attributes:
        name: Port name (key in schematic).
        x: x position or `PortRef`.
        y: y position or `PortRef`.
        dx: Relative x offset.
        dy: Relative y offset.
        cross_section: Name of the cross-section to apply.
        orientation: Orientation in degrees or `PortRef`.

    Methods:
        is_placeable: True if all references resolve to already placed instances.
    """

    name: str = Field(exclude=True)
    x: T | PortRef | AnchorRefX
    y: T | PortRef | AnchorRefY
    dx: T = 0
    dy: T = 0
    cross_section: str
    orientation: Literal[0, 90, 180, 270] | PortRef

    def __lt__(self, other: Port[T] | PortRef) -> bool:
        if not isinstance(other, Port):
            return True
        if self.name != other.name:
            return self.name < other.name
        x = self.x
        ox = other.x
        if _is_real(x):
            if _is_real(ox):
                return x < ox
            if x != ox:
                return False
        elif _is_port_ref(x):
            if _is_real(ox):
                return False
            if _is_port_ref(ox):
                return x < ox
            return True
        else:
            if _is_real(ox) or _is_port_ref(ox):
                return False
            return x < ox  # ty:ignore[unsupported-operator]
        y = self.y
        oy = other.y
        if _is_real(y):
            if _is_real(oy):
                return y < oy
            if y != oy:
                return False
        elif _is_port_ref(y):
            if _is_real(oy):
                return False
            if _is_port_ref(oy):
                return y < oy
            return True
        else:
            if _is_real(oy) or _is_port_ref(oy):
                return False
            return y < oy  # ty:ignore[unsupported-operator]

        if self.dx != other.dx:
            return self.dx < other.dx
        if self.dy != other.dy:
            return self.dy < other.dy
        if self.cross_section != other.cross_section:
            return self.cross_section < other.cross_section
        if isinstance(self.orientation, int | float):
            if isinstance(other, int | float):
                return self.orientation < other.orientation
            return False
        if isinstance(other.orientation, PortRef):
            return self.orientation < other.orientation

        return True

    def is_placeable(self, placed_instances: set[str]) -> bool:
        placeable = True
        if isinstance(self.x, PortRef | AnchorRefX):
            placeable = self.x.instance in placed_instances
        if isinstance(self.y, PortRef | AnchorRefY):
            placeable = placeable and self.y.instance in placed_instances
        if isinstance(self.orientation, PortRef):
            placeable = placeable and self.orientation.instance in placed_instances
        return placeable

    def __str__(self) -> str:
        return self.as_python_str()

    def as_call(self) -> str:
        port_str = f"x={self.x}, y={self.y}"
        if self.dx:
            port_str += f", {self.dx}"
        if self.dy:
            port_str += f", {self.dy}"

        return port_str

    def as_python_str(self, schematic_name: str = "schematic") -> str:
        return f"{schematic_name}.ports[{self.name!r}]"

class PortAnchor(Anchor):
    """Anchor an instance using one of its ports.

    Attributes:
        port: Name of the port on the instance to use as the anchor point.
    """

    port: str

class Ports[T: (int, float)]:
    """Indexer for an instance's ports to produce `PortRef`/`PortArrayRef`.

    Example:
        `inst.ports["out"]` -> `PortRef`
        `inst.ports["out", 1, 0]` -> `PortArrayRef` (requires instance array)
    """

    __slots__ = ("instance",)

    def __init__(self, instance: SchematicInstance[T]) -> None:
        self.instance = instance

    def __getitem__(self, key: str | tuple[str, int, int]) -> PortRef | PortArrayRef:
        """Return a port reference for a (standard or array) port."""
        if isinstance(key, tuple):
            if self.instance.array is None:
                raise ValueError(
                    "Cannot use an array port reference if the schema"
                    " instance is not an Array."
                )
            return PortArrayRef(
                instance=self.instance.name, port=key[0], ia=key[1], ib=key[2]
            )
        return PortRef(instance=self.instance.name, port=key)

class RegularArray[T: (int, float)](BaseModel, extra="forbid"):
    """Rectangular array with uniform row/column pitch.

    Attributes:
        columns: Number of columns (> 0).
        column_pitch: Distance between columns.
        rows: Number of rows (> 0).
        row_pitch: Distance between rows.
    """

    columns: int = Field(gt=0, default=1)
    column_pitch: T
    rows: int = Field(gt=0, default=1)
    row_pitch: T

    def __repr__(self) -> str:
        return f"RegularArray(columns={self.columns}, columns_pitch=)"

class Route[T: (int, float)](BaseModel, extra="forbid"):
    """Bundle of `Link`s routed using a named strategy.

    Attributes:
        name: Route identifier (key in `(D)Schematic.routes`).
        routing_strategy: Name of routing function registered on the
            `Schematic.create_cell` or registered in `KCLayout` if none are given.
        settings: Keyword arguments forwarded to the routing strategy.
    """

    name: str = Field(exclude=True)
    routing_strategy: str = "route_bundle"
    settings: dict[str, JSONSerializable]

    @model_validator(mode="before")
    @classmethod
    def _parse_nets(cls, data: dict[str, Any]) -> dict[str, Any]:
        if "settings" not in data:
            data["settings"] = {}
        return data

class RouteNet[T: (int, float)](SchematicNet[T]):
    """Undirected association between two ports (refs or schematic ports).

    The pair is stored in sorted order to ensure stable equality and hashing.
    """

    route: str
    net: tuple[PortRef, ...]

class Schema(Schematic):
    """Deprecated alias for `Schematic` (will be removed in kfactory 2.0)."""

    def __init__(self, **data: Any) -> None:
        logger.warning(
            "Schema is deprecated, please use Schematic. "
            "It will be removed in kfactory 2.0"
        )
        if "unit" in data:
            raise ValueError(
                "Cannot set the unit direct. It needs to be set by the class init."
            )
        super().__init__(**data)

class Schematic(TSchematic[dbu]):
    """Schematic with a base unit of dbu for placements."""

    unit: Literal["dbu"] = "dbu"

    def __init__(self, **data: Any) -> None:
        if "unit" in data:
            raise ValueError(
                "Cannot set the unit direct. It needs to be set by the class init."
            )
        super().__init__(unit="dbu", **data)

class SchematicInstance[T: (int, float)](
    BaseModel, extra="forbid", arbitrary_types_allowed=True
):
    """Instance record within a schematic.

    Attributes:
        name: Instance name (unique within the schematic).
        component: Factory (cell function) name used to create the underlying cell.
        settings: Parameters passed to the factory.
        array: Optional array specification (`RegularArray` or `Array`).
        kcl: Layout context (`KCLayout`) to build the instance from. Defaults to
            default object.
        virtual: If True, create a virtual instance (VInstance/ComponentAllAngle).
        placement: Reference to a placement if the instance has a corresponding one.

    Properties:
        parent_schematic: `(D)Schematic` owning this instance.
        ports: Accessing `PortRef`/`PortArrayRef` resulting from this instance.

    Methods:
        place: Declare a placement, saved in the schematic owning this instance.
        connect: Create and register a `Connection` from one of my ports.
    """

    name: str = Field(exclude=True, frozen=True)
    component: str
    settings: dict[str, JSONSerializable] = Field(default_factory=dict)
    array: RegularArray[T] | Array[T] | None = None
    kcl: KCLayout = Field(default_factory=get_default_kcl)
    virtual: bool = False
    _schematic: TSchematic[T] = PrivateAttr()

    @field_validator("kcl", mode="before")
    @classmethod
    def _find_kcl(cls, value: str | KCLayout) -> KCLayout:
        if isinstance(value, str):
            return kcls[value]
        return value

    @field_serializer("kcl")
    def _serialize_kcl(self, kcl: KCLayout) -> str:
        return kcl.name

    @property
    def parent_schematic(self) -> TSchematic[T]:
        if self._schematic is None:
            raise RuntimeError("Schematic instance has no parent set.")
        return self._schematic

    @property
    def placement(self) -> Placement[T] | MirrorPlacement | None:
        return self.parent_schematic.placements.get(self.name)

    def get_placement(self) -> Placement[T] | MirrorPlacement:
        placement = self.placement
        if placement is None:
            raise ValueError(
                f"SchematicInstance {self.name!r} does not have a placement"
            )
        return placement

    def place(
        self,
        x: T | PortRef | AnchorRefX = 0,
        y: T | PortRef | AnchorRefY = 0,
        dx: T = 0,
        dy: T = 0,
        orientation: float | PortRef = 0,
        mirror: bool = False,
        anchor: FixedAnchorDict | PortAnchorDict | None = None,
    ) -> Placement[T]:
        """Declare placement/orientation/mirroring for this instance.

        Returns:
            The created `Placement` (also stored under `self.placement` which references
            `self.parent_schematic.placements`).
        """
        placement = Placement[T](
            x=x,
            y=y,
            dx=dx,
            dy=dy,
            orientation=orientation,
            mirror=mirror,
        )
        if anchor is not None:
            if _is_portdict(anchor):
                placement.anchor = PortAnchor(port=anchor["port"])
            else:
                fixed = cast("FixedAnchorDict", anchor)
                placement.anchor = FixedAnchor(x=fixed["x"], y=fixed["y"])
        self.parent_schematic.placements[self.name] = placement
        return placement

    @overload
    def __getitem__(self, value: str) -> PortRef: ...
    @overload
    def __getitem__(self, value: tuple[str, int, int]) -> PortArrayRef: ...

    def __getitem__(self, value: str | tuple[str, int, int]) -> PortRef:
        if isinstance(value, str):
            return PortRef(instance=self.name, port=value)
        return PortArrayRef(instance=self.name, port=value[0], ia=value[1], ib=value[2])

    def connect(
        self,
        port: str | tuple[str, int, int],
        other: Port[T] | PortRef,
    ) -> Connection[T]:
        """Connect one of my ports to `other` and register it on the schematic."""
        if isinstance(port, str):
            pref = PortRef(instance=self.name, port=port)
        else:
            pref = PortArrayRef(
                instance=self.name, port=port[0], ia=port[1], ib=port[2]
            )
        conn = Connection[T](net=(other, pref))
        self.parent_schematic.nets.append(conn)
        return conn

    @property
    def mirror(self) -> bool:
        if self.placement is None:
            return False
        return self.placement.mirror

    @mirror.setter
    def mirror(self, value: bool) -> None:
        if self.placement is None:
            if value:
                self.parent_schematic.placements[self.name] = MirrorPlacement(
                    mirror=True
                )
        else:
            self.placement.mirror = value

    @cached_property
    def ports(self) -> Ports[T]:
        return Ports(instance=self)

    @cached_property
    def pins(self) -> Pins[T]:
        return Pins(instance=self)

    @property
    def xmin(self) -> AnchorRefX:
        return AnchorRefX(instance=self.name, x="left")

    @property
    def xmax(self) -> AnchorRefX:
        return AnchorRefX(instance=self.name, x="left")

    @property
    def ymin(self) -> AnchorRefY:
        return AnchorRefY(instance=self.name, y="bottom")

    @property
    def ymax(self) -> AnchorRefY:
        return AnchorRefY(instance=self.name, y="top")

    @property
    def center(self) -> tuple[AnchorRefX, AnchorRefY]:
        return (
            AnchorRefX(instance=self.name, x="center"),
            AnchorRefY(instance=self.name, y="center"),
        )