gdsfactoryx 9.51.0__py3-none-any.whl

gdsfactory/__init__.py

@@ -0,0 +1,192 @@
+"""Main module for gdsfactory."""
+
+# NOTE: import order matters. Only change the order if you know what you are doing
+# isort: skip_file
+
+from __future__ import annotations
+from gdsfactory import _dist_conflict  # noqa: F401  (must run first: errors if upstream gdsfactory is also installed)
+import sys
+import warnings
+from functools import partial
+from toolz import compose
+from aenum import constant
+
+import kfactory as kf
+from kfactory.layout import Constants
+from kfactory import LayerEnum
+from kfactory.layout import kcl
+from kfactory import logger
+import klayout.db as kdb
+from kfactory import DSchematic as Schematic
+
+from gdsfactory import _jax  # enables float64 and provides tracer helpers
+from gdsfactory._ports import Pin as DPin
+from gdsfactory._ports import Pin as ProtoPin
+from gdsfactory.transform import Transform
+
+from gdsfactory._cell import cell, vcell, cell_with_module_name, schematic_cell
+from gdsfactory._kcl import clear_cache
+from gdsfactory.path import Path
+from gdsfactory.component import (
+    Component,
+    ComponentBase,
+    ComponentAllAngle,
+    ComponentReference,
+    ComponentReference as Instance,
+    container,
+)
+from gdsfactory.config import CONF, PATH, __version__
+from gdsfactory.port import Port
+from gdsfactory.typings import Pin
+from gdsfactory.read.import_gds import import_gds
+from gdsfactory.cross_section import (
+    ComponentAlongPath,
+    CrossSection,
+    Section,
+    xsection,
+    get_cross_sections,
+)
+from gdsfactory.difftest import DiffResult, LayerDiff, difftest, diff
+from gdsfactory.boolean import boolean
+
+from gdsfactory import config
+from gdsfactory import cross_section
+from gdsfactory import port
+from gdsfactory import components
+from gdsfactory import containers
+from gdsfactory import labels
+from gdsfactory import typings
+from gdsfactory import path
+from gdsfactory import snap
+from gdsfactory import read
+from gdsfactory import add_ports
+from gdsfactory import write_cells
+from gdsfactory import add_pins
+from gdsfactory import technology
+from gdsfactory import routing
+from gdsfactory import export
+from gdsfactory import functions
+from gdsfactory import gpdk
+
+from gdsfactory.add_padding import (
+    add_padding,
+    add_padding_container,
+    get_padding_points,
+    add_padding_to_size,
+)
+from gdsfactory.pack import pack
+from gdsfactory.pdk import (
+    Pdk,
+    get_component,
+    get_cross_section,
+    get_layer,
+    get_layer_tuple,
+    get_layer_name,
+    get_layer_info,
+    get_active_pdk,
+    get_cell,
+    get_constant,
+)
+from gdsfactory.get_factories import get_cells
+from gdsfactory.grid import grid, grid_with_text
+
+from gdsfactory import rasterize
+from gdsfactory.klayout_bridge import show
+
+c = components
+Region = kdb.Region
+
+# Check Python version and issue a warning if using Python 3.10
+if sys.version_info[:2] == (3, 10):
+    warnings.warn(
+        "Support for Python 3.10 has been dropped. Please upgrade to Python 3.11 or later "
+        "to continue using the latest features and improvements. "
+        "To get the latest gdsfactory, upgrading your Python version is required.",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+
+__all__ = (
+    "CONF",
+    "PATH",
+    "Component",
+    "ComponentAllAngle",
+    "ComponentAlongPath",
+    "ComponentBase",
+    "ComponentReference",
+    "Constants",
+    "CrossSection",
+    "DPin",
+    "DiffResult",
+    "Instance",
+    "LayerDiff",
+    "LayerEnum",
+    "Path",
+    "Pdk",
+    "Pin",
+    "Port",
+    "ProtoPin",
+    "Region",
+    "Schematic",
+    "Section",
+    "Transform",
+    "__version__",
+    "add_padding",
+    "add_padding_container",
+    "add_padding_to_size",
+    "add_pins",
+    "add_ports",
+    "boolean",
+    "c",
+    "cell",
+    "cell_with_module_name",
+    "clear_cache",
+    "components",
+    "compose",
+    "config",
+    "constant",
+    "container",
+    "containers",
+    "cross_section",
+    "diff",
+    "difftest",
+    "export",
+    "functions",
+    "get_active_pdk",
+    "get_cell",
+    "get_cells",
+    "get_component",
+    "get_constant",
+    "get_cross_section",
+    "get_cross_sections",
+    "get_layer",
+    "get_layer_info",
+    "get_layer_name",
+    "get_layer_tuple",
+    "get_padding_points",
+    "gpdk",
+    "grid",
+    "grid_with_text",
+    "import_gds",
+    "kcl",
+    "kdb",
+    "kf",
+    "labels",
+    "logger",
+    "pack",
+    "partial",
+    "path",
+    "port",
+    "read",
+    "routing",
+    "schematic_cell",
+    "rasterize",
+    "show",
+    "snap",
+    "technology",
+    "typings",
+    "vcell",
+    "write_cells",
+    "xsection",
+)

gdsfactory/_cell.py

@@ -0,0 +1,337 @@
+"""Cell decorator for the differentiable backend.
+
+``@gf.cell`` turns a function returning a Component into a cached factory:
+
+- the bound arguments are stored in ``component.settings``
+- the component gets a deterministic name from function name + parameters
+- calls with identical (concrete) arguments return the same locked Component
+
+When any argument carries a JAX tracer (e.g. inside ``jax.grad``), the cache is
+bypassed so derivative information flows through the geometry.
+"""
+
+from __future__ import annotations
+
+import functools
+import inspect
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING, Any, ParamSpec, Protocol, cast
+
+from gdsfactory._jax import has_tracers
+
+if TYPE_CHECKING:
+    from gdsfactory.component import Component
+
+ComponentParams = ParamSpec("ComponentParams")
+
+MAX_NAME_LENGTH = 99
+_CACHES: list[dict[Any, Any]] = []
+_BY_NAME: dict[str, Any] = {}
+factories: dict[str, Callable[..., Any]] = {}
+"""Registry of cell functions (name -> decorated function)."""
+
+
+class ComponentFunc(Protocol[ComponentParams]):
+    __name__: str
+
+    def __call__(
+        self, *args: ComponentParams.args, **kwargs: ComponentParams.kwargs
+    ) -> Component: ...
+
+
+def clean_name(name: str) -> str:
+    """Ensures that gds cells are composed of [a-zA-Z0-9_\\-]."""
+    from kfactory.serialization import clean_name as _kf_clean_name
+
+    return _kf_clean_name(name)
+
+
+def _module_basename(func: Callable[..., Any]) -> str:
+    name, module = func.__name__, func.__module__
+    return clean_name(name if module == "__main__" else f"{name}_{module}")
+
+
+def _concrete(value: Any) -> Any:
+    """Replaces tracers / jax arrays by concrete python values (for naming)."""
+    import numpy as np
+
+    from gdsfactory._jax import is_tracer, primal
+
+    if is_tracer(value):
+        value = primal(value)
+    if type(value).__module__.startswith("jax"):
+        arr = np.asarray(value)
+        return arr.item() if arr.ndim == 0 else arr.tolist()
+    if isinstance(value, dict):
+        # kfactory sorts nested dict keys when naming
+        return {k: _concrete(value[k]) for k in sorted(value)}
+    if isinstance(value, list):
+        return [_concrete(v) for v in value]
+    if isinstance(value, tuple):
+        return tuple(_concrete(v) for v in value)
+    return value
+
+
+def get_cell_name(cell_type: str, max_cellname_length: int | None = None, **kwargs: Any) -> str:
+    """Returns a cell name from the function name and its parameters.
+
+    Same algorithm as kfactory (so names match upstream gdsfactory).
+    """
+    from kfactory.serialization import get_cell_name as _kf_get_cell_name
+
+    params = {k: _concrete(v) for k, v in kwargs.items()}
+    return _kf_get_cell_name(cell_type, max_cellname_length=max_cellname_length, **params)
+
+
+def _layout_cache_enabled() -> bool:
+    from gdsfactory.config import CONF
+
+    return bool(getattr(CONF, "cell_layout_cache", False))
+
+
+def _metadata(value: Any) -> Any:
+    """Settings value as kfactory stores it (functions -> names); keeps jax values."""
+    from kfactory.serialization import convert_metadata_type
+
+    if has_tracers(value) or type(value).__module__.startswith("jax"):
+        return value
+    if isinstance(value, dict):
+        return {k: _metadata(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_metadata(v) for v in value]
+    if isinstance(value, tuple):
+        return tuple(_metadata(v) for v in value)
+    try:
+        return convert_metadata_type(value)
+    except Exception:
+        return value
+
+
+def _freeze(value: Any) -> Any:
+    """Hashable key for caching (only called without tracers)."""
+    import pydantic
+
+    from gdsfactory.serialization import clean_value_json
+
+    if isinstance(value, pydantic.BaseModel):
+        # exact field values (clean_value_json rounds floats)
+        try:
+            return ("__model__", type(value).__name__, _freeze(dict(value)))
+        except Exception:
+            return ("__id__", id(value))
+
+    try:
+        hash(value)
+        if not isinstance(value, float | int | str | bool | type(None) | tuple | frozenset):
+            # functions / partials / components: hash by identity or serialization
+            if callable(value) or hasattr(value, "name"):
+                try:
+                    return ("__json__", repr(clean_value_json(value)))
+                except Exception:
+                    return ("__id__", id(value))
+        if isinstance(value, tuple):
+            return tuple(_freeze(v) for v in value)
+        return value
+    except TypeError:
+        pass
+    if isinstance(value, dict):
+        return tuple(sorted((k, _freeze(v)) for k, v in value.items()))
+    if isinstance(value, list | tuple):
+        return tuple(_freeze(v) for v in value)
+    if isinstance(value, set):
+        return frozenset(_freeze(v) for v in value)
+    try:
+        return ("__json__", repr(clean_value_json(value)))
+    except Exception:
+        return ("__id__", id(value))
+
+
+def clear_cache() -> None:
+    for c in _CACHES:
+        c.clear()
+    _BY_NAME.clear()
+
+
+def cached_cells() -> list[Any]:
+    """Components currently stored in the cell caches."""
+    return [c for cache in _CACHES for c in cache.values()]
+
+
+def cell(
+    _func: Callable[..., Any] | None = None,
+    /,
+    *,
+    set_settings: bool = True,
+    set_name: bool = True,
+    check_ports: bool = True,
+    check_instances: Any = None,
+    snap_ports: bool = True,
+    add_port_layers: bool = True,
+    cache: dict[Any, Any] | None = None,
+    basename: str | None = None,
+    drop_params: list[str] | None = None,
+    register_factory: bool = True,
+    overwrite_existing: bool | None = None,
+    layout_cache: bool | None = None,
+    info: dict[str, Any] | None = None,
+    post_process: Iterable[Callable[[Component], None]] | None = None,
+    debug_names: bool | None = None,
+    tags: list[str] | None = None,
+    with_module_name: bool = False,
+    lvs_equivalent_ports: list[list[str]] | None = None,
+    ports: Any = None,
+    schematic_function: Callable[..., Any] | None = None,
+    output_type: Any = None,
+) -> Any:
+    """Decorator to convert a function into a (cached, differentiable) Component factory."""
+    drop = set(drop_params if drop_params is not None else ["self", "cls"])
+    post = list(post_process or [])
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        sig = inspect.signature(func)
+        _cache: dict[Any, Any] = cache if cache is not None else {}
+        _CACHES.append(_cache)
+        _basename = basename or (_module_basename(func) if with_module_name else None)
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Component:
+            from gdsfactory.component import Component
+
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            params = {k: v for k, v in bound.arguments.items() if k not in drop}
+            # flatten **kwargs parameters
+            for name, p in sig.parameters.items():
+                if p.kind is inspect.Parameter.VAR_KEYWORD and name in params:
+                    params.update(params.pop(name))
+            # unsnapped cells (gf.snap.SNAP_ENABLED = False) never enter the cache
+            from gdsfactory import snap as _snap
+
+            traced = has_tracers(params) or not _snap.SNAP_ENABLED
+            key = None
+            if not traced:
+                try:
+                    key = _freeze(params)
+                    hash(key)
+                except Exception:
+                    key = None
+                if key is not None and key in _cache:
+                    return cast("Component", _cache[key])
+                if set_name and _layout_cache_enabled():
+                    # like upstream (CONF.cell_layout_cache): reuse an existing cell
+                    # with the same name (e.g. a function passed by its name)
+                    name = get_cell_name(_basename or func.__name__, **params)
+                    existing = _BY_NAME.get(name)
+                    if existing is not None:
+                        if key is not None:
+                            _cache[key] = existing
+                        return cast("Component", existing)
+
+            c = func(*bound.args, **bound.kwargs)
+            if not isinstance(c, Component):
+                raise TypeError(
+                    f"{func.__name__} must return a Component, got {type(c)}"
+                )
+            if c.locked:
+                # returned a cached cell from another factory: wrap a copy
+                c = c.copy()
+
+            function_name = func.__name__
+            if set_name:
+                c._name = get_cell_name(_basename or function_name, **params)
+            if set_settings:
+                c.settings = type(c.settings)(
+                    {k: _metadata(v) for k, v in params.items()}
+                )
+                c.function_name = function_name
+                c.basename = _basename
+                c.module = func.__module__
+            if info:
+                c.info.update(info)
+            if lvs_equivalent_ports:
+                c.lvs_equivalent_ports = lvs_equivalent_ports
+            for pp in post:
+                pp(c)
+            if schematic_function is not None:
+                c._schematic_function = schematic_function  # type: ignore[attr-defined]
+            c.locked = True
+            if key is not None:
+                _cache[key] = c
+                if set_name:
+                    _BY_NAME.setdefault(c.name, c)
+            return c
+
+        wrapper.is_gf_cell = True  # type: ignore[attr-defined]
+        wrapper.cache = _cache  # type: ignore[attr-defined]
+        wrapper.tags = tags or []  # type: ignore[attr-defined]
+        if schematic_function is not None:
+            wrapper.schematic_function = schematic_function  # type: ignore[attr-defined]
+
+        def get_schematic(*args: Any, **kwargs: Any) -> Any:
+            if schematic_function is None:
+                raise ValueError(f"{func.__name__} has no schematic_function")
+            return schematic_function(*args, **kwargs)
+
+        wrapper.get_schematic = get_schematic  # type: ignore[attr-defined]
+        if register_factory:
+            factories[_basename or func.__name__] = wrapper
+        return wrapper
+
+    if _func is not None:
+        return decorator(_func)
+    return decorator
+
+
+def vcell(_func: Callable[..., Any] | None = None, /, **kwargs: Any) -> Any:
+    """Like ``cell`` (all components support any angle in gdsfactoryx)."""
+    kwargs = {k: v for k, v in kwargs.items() if k in _CELL_KWARGS_EARLY}
+
+    def mark(f: Callable[..., Any]) -> Callable[..., Any]:
+        f.is_gf_vcell = True  # type: ignore[attr-defined]
+        return f
+
+    if _func is not None:
+        return mark(cell(_func, **kwargs))
+    return lambda f: mark(cell(**kwargs)(f))
+
+
+_CELL_KWARGS_EARLY = set(inspect.signature(cell).parameters) - {"_func"}
+
+
+def cell_with_module_name(_func: Callable[..., Any] | None = None, /, **kwargs: Any) -> Any:
+    """Decorator like ``cell`` but with ``with_module_name=True`` by default."""
+    return cell(_func, with_module_name=True, **kwargs)
+
+
+def schematic_cell(_func: Callable[..., Any] | None = None, /, **kwargs: Any) -> Any:
+    """Builds a Component from a function returning a schematic/netlist dict."""
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        def build(*args: Any, **kw: Any) -> Component:
+            from gdsfactory.read.from_yaml import from_yaml
+
+            schematic = func(*args, **kw)
+            netlist = schematic.model_dump() if hasattr(schematic, "model_dump") else schematic
+            return from_yaml(netlist)
+
+        return cell(build, **{k: v for k, v in kwargs.items() if k in _CELL_KWARGS})
+
+    if _func is not None:
+        return decorator(_func)
+    return decorator
+
+
+_CELL_KWARGS = set(inspect.signature(cell).parameters) - {"_func"}
+
+__all__ = [
+    "cell",
+    "cell_with_module_name",
+    "clean_name",
+    "cached_cells",
+    "factories",
+    "clear_cache",
+    "get_cell_name",
+    "schematic_cell",
+    "vcell",
+]

gdsfactory/_deprecation.py

@@ -0,0 +1,13 @@
+import warnings
+
+from gdsfactory.config import __next_major_version__
+
+
+def deprecate(old_name: str, new_name: str | None = None, stacklevel: int = 3) -> None:
+    warnings.warn(
+        f"{old_name} is deprecated."
+        + (f" Use {new_name} instead." if new_name else "")
+        + f" It will be removed in {__next_major_version__}.",
+        DeprecationWarning,
+        stacklevel=stacklevel,
+    )

gdsfactory/_dist_conflict.py

@@ -0,0 +1,36 @@
+"""Fail fast when upstream ``gdsfactory`` and ``gdsfactoryx`` are installed together.
+
+Both distributions ship the same top-level ``gdsfactory`` package, and pip does not
+stop one from overwriting the other's files. An environment with both installed
+holds an unpredictable mix of the two, so importing it raises instead of
+misbehaving later.
+
+The check only fires when *both* distributions are installed. Running gdsfactoryx
+from a source checkout (``PYTHONPATH``) is unaffected, because the ``gdsfactoryx``
+distribution is then not installed.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, distribution
+
+
+def _is_installed(name: str) -> bool:
+    try:
+        distribution(name)
+    except PackageNotFoundError:
+        return False
+    return True
+
+
+def check_no_conflicting_distribution() -> None:
+    """Raise ``ImportError`` if upstream gdsfactory is installed next to gdsfactoryx."""
+    if _is_installed("gdsfactory") and _is_installed("gdsfactoryx"):
+        raise ImportError(
+            "Both the upstream 'gdsfactory' distribution and 'gdsfactoryx' are installed. "
+            "They provide the same 'gdsfactory' package and overwrite each other's files. "
+            "Fix: pip uninstall -y gdsfactory gdsfactoryx && pip install gdsfactoryx"
+        )
+
+
+check_no_conflicting_distribution()