analog-daddy 3.0.1.dev1__tar.gz → 3.0.1.dev2__tar.gz

{analog_daddy-3.0.1.dev1 → analog_daddy-3.0.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: analog-daddy
-Version: 3.0.1.dev1
+Version: 3.0.1.dev2
 Summary: This library is an attempt to make transistor sizing for Analog Design less painful. Additionally, provides helper utilities to minimize churn and errors in repetative tasks.
 Author: Siddhant Laddha
 Author-email: Siddhant Laddha <25705822+siddhantladdha@users.noreply.github.com>

{analog_daddy-3.0.1.dev1 → analog_daddy-3.0.1.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "analog-daddy"
-version = "3.0.1.dev1"
+version = "3.0.1.dev2"
 description = "This library is an attempt to make transistor sizing for Analog Design less painful. Additionally, provides helper utilities to minimize churn and errors in repetative tasks."
 readme = "README.md"
 requires-python = ">= 3.12"
@@ -46,6 +46,7 @@ analog_daddy = "analog_daddy.cli:app"
 [dependency-groups]
 dev = [
     "format-docstring",
+    "hypothesis",
     "pytest",
     "ruff",
     "ty",

{analog_daddy-3.0.1.dev1 → analog_daddy-3.0.1.dev2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "analog-daddy"
-version = "3.0.1.dev1"
+version = "3.0.1.dev2"
 description = "This library is an attempt to make transistor sizing for Analog Design less painful. Additionally, provides helper utilities to minimize churn and errors in repetative tasks."
 readme = "README.md"
 requires-python = ">= 3.12"
@@ -44,6 +44,7 @@ analog_daddy = "analog_daddy.cli:app"
 [dependency-groups]
 dev = [
   "format-docstring",
+  "hypothesis",
   "pytest",
   "ruff",
   "ty",

analog_daddy-3.0.1.dev2/src/analog_daddy/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for Analog Daddy."""
+
+from importlib.metadata import version
+
+__version__ = version("analog-daddy")

{analog_daddy-3.0.1.dev1 → analog_daddy-3.0.1.dev2}/src/analog_daddy/mootils.py

@@ -14,6 +14,7 @@ import marimo as mo
 import polars as pl
 import polars.selectors as cs
 from rich.console import Console, RenderableType
+from wigglystuff import CopyToClipboard
 
 from analog_daddy.utils import render
 
@@ -121,3 +122,35 @@ def rich_md(
     console = Console(file=capture, **console_kwargs)
     console.print(*renderables, **print_kwargs)
     return mo.Html(console.export_html(**export_html_kwargs))
+
+
+def df_repr_docstr_clip(
+    df: pl.DataFrame, max_rows: int = 3
+) -> CopyToClipboard:
+    """
+    Copy the repr of a polars DataFrame to the clipboard.
+
+    Parameters
+    ----------
+    df : pl.DataFrame
+        The DataFrame to copy the repr of.
+    max_rows : int, default=3
+        The maximum number of rows to include in the repr.
+
+    Returns
+    -------
+    CopyToClipboard
+        A CopyToClipboard object containing the repr of the DataFrame.
+
+    Examples
+    --------
+    >>> a = pl.DataFrame(
+    ...     {"x": [9.0, 11.0], "foo": [10.0, 10.0], "bar": [5.0, 5.0]},
+    ... )
+    >>> df_repr_docstr_clip(a).text_to_copy.startswith("shape: (2, 3)")
+    True
+    """
+
+    return CopyToClipboard(
+        text_to_copy=df.slice(offset=0, length=max_rows).__repr__(),
+    )

{analog_daddy-3.0.1.dev1 → analog_daddy-3.0.1.dev2}/src/analog_daddy/plexpr.py

@@ -440,7 +440,51 @@ def spec(
     raise ValueError(f"bad spec: {spec}")
 
 
-def list_cast():
+def list_cast() -> tuple[pl.Expr, pl.Expr]:
+    """
+    Cast list columns to list[str]
+
+    Uses ``render`` to convert numeric values and casts categorical
+    values to string.
+
+    Returns
+    -------
+    tuple[pl.Expr, pl.Expr]
+
+    Examples
+    --------
+    >>> (
+    ...     df := pl.DataFrame(
+    ...         {"a": [[1000, 2.5e-6]], "b": [["x", "y"]]},
+    ...         schema={
+    ...             "a": pl.List(pl.Float64),
+    ...             "b": pl.List(pl.Categorical),
+    ...         },
+    ...     )
+    ... )
+    shape: (1, 2)
+    ┌─────────────────────┬────────────┐
+    │ a                   ┆ b          │
+    │ ---                 ┆ ---        │
+    │ list[f64]           ┆ list[cat]  │
+    ╞═════════════════════╪════════════╡
+    │ [1000.0, 0.0000025] ┆ ["x", "y"] │
+    └─────────────────────┴────────────┘
+    >>> out = df.with_columns(*list_cast())
+    >>> out
+    shape: (1, 2)
+    ┌────────────────┬────────────┐
+    │ a              ┆ b          │
+    │ ---            ┆ ---        │
+    │ list[str]      ┆ list[str]  │
+    ╞════════════════╪════════════╡
+    │ ["1k", "2.5u"] ┆ ["x", "y"] │
+    └────────────────┴────────────┘
+    >>> out.schema.contains_dtype(pl.String, recursive=True)
+    True
+    >>> out.schema.contains_dtype(pl.Categorical, recursive=True)
+    False
+    """
     return (
         cs.list(cs.numeric()).list.eval(
             pl.element().map_elements(
@@ -452,7 +496,42 @@ def list_cast():
     )
 
 
-def list_render_unique(max_len: int = 3):
+def list_render_unique(max_len: int = 3) -> pl.Expr:
+    """
+    Render unique values of list[str] columns as a comma-joined string.
+
+    Lists with more than ``max_len`` unique values are truncated and
+    suffixed with the count of omitted values. The ordering is not
+    deterministic since ``pl.Expr.unique`` doesn't maintain order.
+
+    Parameters
+    ----------
+    max_len : int, default=3
+        Maximum number of unique values to show before truncating.
+
+    Returns
+    -------
+    pl.Expr
+        Expression (over all list[str] columns) yielding a string.
+
+    Examples
+    --------
+    >>> (df := pl.DataFrame({"a": [["x", "x"], ["a", "b", "c", "d", "e"]]}))
+    shape: (2, 1)
+    ┌───────────────────┐
+    │ a                 │
+    │ ---               │
+    │ list[str]         │
+    ╞═══════════════════╡
+    │ ["x", "x"]        │
+    │ ["a", "b", … "e"] │
+    └───────────────────┘
+    >>> out = df.select(list_render_unique(max_len=3))["a"].to_list()
+    >>> out[0]
+    'x'
+    >>> out[1].endswith(" + 2 more")
+    True
+    """
     ulist = cs.list(cs.string()).list.unique().list
     n = ulist.len()
     head_n = ulist.head(max_len).list

{analog_daddy-3.0.1.dev1 → analog_daddy-3.0.1.dev2}/src/analog_daddy/plutils.py

@@ -22,15 +22,36 @@ def drop_all_null(df: pl.DataFrame) -> pl.DataFrame:
 
     Examples
     --------
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "a": [None, None, None],
-    ...         "b": [1, 2, None],
-    ...         "c": ["x", "y", ""],
-    ...     }
+    >>> (
+    ...     df := pl.DataFrame(
+    ...         {
+    ...             "a": [None, None, None],
+    ...             "b": [1, 2, None],
+    ...             "c": ["x", "y", ""],
+    ...         }
+    ...     )
     ... )
-    >>> drop_all_null(df).columns
-    ['b', 'c']
+    shape: (3, 3)
+    ┌──────┬──────┬─────┐
+    │ a    ┆ b    ┆ c   │
+    │ ---  ┆ ---  ┆ --- │
+    │ null ┆ i64  ┆ str │
+    ╞══════╪══════╪═════╡
+    │ null ┆ 1    ┆ x   │
+    │ null ┆ 2    ┆ y   │
+    │ null ┆ null ┆     │
+    └──────┴──────┴─────┘
+    >>> drop_all_null(df)
+    shape: (3, 2)
+    ┌──────┬─────┐
+    │ b    ┆ c   │
+    │ ---  ┆ --- │
+    │ i64  ┆ str │
+    ╞══════╪═════╡
+    │ 1    ┆ x   │
+    │ 2    ┆ y   │
+    │ null ┆     │
+    └──────┴─────┘
     """
     return df[[ser.name for ser in df if ser.null_count() != df.height]]
 
@@ -51,12 +72,24 @@ def filter_all_null(df: pl.DataFrame) -> pl.DataFrame:
 
     Examples
     --------
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "a": [1, None, 3],
-    ...         "b": ["x", None, None],
-    ...     }
+    >>> (
+    ...     df := pl.DataFrame(
+    ...         {
+    ...             "a": [1, None, 3],
+    ...             "b": ["x", None, None],
+    ...         }
+    ...     )
     ... )
+    shape: (3, 2)
+    ┌──────┬──────┐
+    │ a    ┆ b    │
+    │ ---  ┆ ---  │
+    │ i64  ┆ str  │
+    ╞══════╪══════╡
+    │ 1    ┆ x    │
+    │ null ┆ null │
+    │ 3    ┆ null │
+    └──────┴──────┘
     >>> filter_all_null(df)
     shape: (2, 2)
     ┌─────┬──────┐
@@ -110,17 +143,30 @@ def scan_nested_params(
 
     Examples
     --------
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "Point": [
-    ...             "Parameters: var1=-12k, var_b=1n",
-    ...             "1",
-    ...             "Parameters: var3=-12k",
-    ...             "2",
-    ...         ],
-    ...         "Value": [None, 10, 1, None],
-    ...     }
+    >>> (
+    ...     df := pl.DataFrame(
+    ...         {
+    ...             "Point": [
+    ...                 "Parameters: var1=-12k, var_b=1n",
+    ...                 "1",
+    ...                 "Parameters: var3=-12k",
+    ...                 "2",
+    ...             ],
+    ...             "Value": [None, 10, 1, None],
+    ...         }
+    ...     )
     ... )
+    shape: (4, 2)
+    ┌─────────────────────────────────┬───────┐
+    │ Point                           ┆ Value │
+    │ ---                             ┆ ---   │
+    │ str                             ┆ i64   │
+    ╞═════════════════════════════════╪═══════╡
+    │ Parameters: var1=-12k, var_b=1… ┆ null  │
+    │ 1                               ┆ 10    │
+    │ Parameters: var3=-12k           ┆ 1     │
+    │ 2                               ┆ null  │
+    └─────────────────────────────────┴───────┘
     >>> scan_nested_params(df, scan_col="Point")
     ['var1', 'var_b']
     """
@@ -169,12 +215,24 @@ def explode_nested_params(
 
     Examples
     --------
-    >>> df = pl.DataFrame(
-    ...     {
-    ...         "Point": ["Parameters: ds=0, gs=1", "1", "2"],
-    ...         "Value": [None, 10, 20],
-    ...     }
+    >>> (
+    ...     df := pl.DataFrame(
+    ...         {
+    ...             "Point": ["Parameters: ds=0, gs=1", "1", "2"],
+    ...             "Value": [None, 10, 20],
+    ...         }
+    ...     )
     ... )
+    shape: (3, 2)
+    ┌────────────────────────┬───────┐
+    │ Point                  ┆ Value │
+    │ ---                    ┆ ---   │
+    │ str                    ┆ i64   │
+    ╞════════════════════════╪═══════╡
+    │ Parameters: ds=0, gs=1 ┆ null  │
+    │ 1                      ┆ 10    │
+    │ 2                      ┆ 20    │
+    └────────────────────────┴───────┘
     >>> explode_nested_params(df, keys=["ds", "gs"])
     shape: (2, 4)
     ┌───────┬───────┬─────┬─────┐

analog_daddy-3.0.1.dev2/src/analog_daddy/units.py

@@ -0,0 +1,337 @@
+"""
+Pydantic ready ``quantiphy.Quantity`` units
+
+Examples
+--------
+
+>>> from pydantic import BaseModel
+>>> class RC(BaseModel):
+...     resistance: Resistance
+...     time: Time
+>>> rc = RC(resistance="4.7 kOhm", time="1n")
+>>> rc.resistance
+Resistance('4.7 kOhm')
+>>> rc.time
+Time('1 ns')
+>>> rc.model_dump_json()
+'{"resistance":4700.0,"time":1e-9}'
+>>> rc.model_dump_json(context={"quantity_format": "str"})
+'{"resistance":"4.7 kOhm","time":"1 ns"}'
+>>> rc.model_dump_json(context={"quantity_format": "as_tuple"})
+'{"resistance":[4700.0,"Ohm"],"time":[1e-9,"s"]}'
+
+Notes
+-----
+
+The following approaches were considered based on Pydantic docs and
+discussions with a LLM model for parts which confused me.
+
+Chosen approach: Put the pydantic hook on the type itself. Works
+everywhere automatically, best autocomplete, but ties Time to pydantic
+and uses a lower-level API pydantic calls experimental.
+
+- Annotate as str, secretly swap it to Time in a validator.
+Rejected since: the type hint lie, so
+autocomplete/type-checker/serialization all get confused.
+- model_validator(mode="after"). Only makes sense when one field needs to be derived from
+another (cross-field logic), not for a single field's own conversion.
+- Approach from pydantic_pint seemed unncessary, but might have to consider if
+there are any issues.
+"""
+
+from typing import TYPE_CHECKING, Any, Self
+
+from pydantic import (
+    GetCoreSchemaHandler,
+    GetJsonSchemaHandler,
+    SerializationInfo,
+)
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import core_schema
+from quantiphy import (
+    QuantiPhyError,
+    UnitConversion,
+    as_real,
+    as_tuple,
+)
+from quantiphy import Quantity as _Quantity
+
+UnitConversion(["ohm", "Ohms", "ohms", "Ω"], "Ohm")
+
+
+class Quantity(_Quantity):
+    """
+    Wrapper around ``quantiphy.Quantity`` to add Pydantic support.
+    """
+
+    units: str = ""
+
+    if TYPE_CHECKING:
+
+        def __new__(
+            cls,
+            value: float | str | Self,
+            *args: Any,
+            **kwargs: Any,
+        ) -> Self: ...
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, _source_type, _handler: GetCoreSchemaHandler
+    ) -> core_schema.CoreSchema:
+        """
+        Generate a Pydantic core schema for the Quantity type.
+
+        The schema is union based with the serialization support for
+        as_real, str, and as_tuple serialization options using the
+        context dictionary.
+        """
+        return core_schema.union_schema(
+            [
+                core_schema.is_instance_schema(cls),
+                core_schema.no_info_plain_validator_function(cls._parse),
+            ],
+            mode="left_to_right",
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                cls._serialize,
+                info_arg=True,
+                return_schema=core_schema.union_schema(
+                    [
+                        core_schema.str_schema(),
+                        core_schema.float_schema(),
+                        core_schema.tuple_schema(
+                            items_schema=[
+                                core_schema.float_schema(),
+                                core_schema.str_schema(),
+                            ],
+                            strict=True,
+                        ),
+                    ]
+                ),
+            ),
+        )
+
+    @classmethod
+    def _parse(cls, value: float | str) -> Self:
+        """
+        Parse value using Quantiphy's native mechanism.
+        """
+        try:
+            return cls(value)
+        except QuantiPhyError as error:
+            # TODO: Consider custom error message for user.
+            raise ValueError(str(error)) from error
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls,
+        _core_schema: core_schema.CoreSchema,
+        handler: GetJsonSchemaHandler,
+    ) -> JsonSchemaValue:
+        """Generate a JSON schema for the Quantity type."""
+        json_schema = handler(core_schema.str_schema())
+        json_schema["description"] = (
+            f"Physical quantity with units: {cls.units}"
+            if cls.units
+            else "Quantiphy quantity without units"
+        )
+        json_schema["examples"] = (
+            [f"1 {cls.units}", f"1 n{cls.units}", f"1 M{cls.units}"]
+            if cls.units
+            else ["1", "1n", "1M"]
+        )
+        return json_schema
+
+    def _serialize(
+        self, info: SerializationInfo
+    ) -> str | float | tuple[float, str]:
+        """Customizable options to serialize the quantity."""
+        if isinstance(info.context, dict):
+            quantity_format = info.context.get("quantity_format", "as_real")
+            match quantity_format:
+                case "as_real":
+                    return as_real(self)
+                case "str":
+                    return str(self)
+                case "as_tuple":
+                    return as_tuple(self)
+                case _:
+                    raise ValueError(
+                        f"Unknown quantity_format value: {quantity_format}"
+                    )
+        else:
+            return as_real(self)
+
+
+class Time(Quantity):
+    """
+    Time quantity with units of seconds.
+
+    Attributes
+    ----------
+    units : str, default="s"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Time("1 ns")
+    Time('1 ns')
+    >>> Time(1e-9)
+    Time('1 ns')
+    """
+
+    units: str = "s"
+
+
+class Voltage(Quantity):
+    """
+    Voltage quantity with units of Volts.
+
+    Attributes
+    ----------
+    units : str, default="V"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Voltage("1 uV")
+    Voltage('1 uV')
+    >>> Voltage(1e-9)
+    Voltage('1 nV')
+    """
+
+    units: str = "V"
+
+
+class Current(Quantity):
+    """
+    Current quantity with units of Amperes.
+
+    Attributes
+    ----------
+    units : str, default="A"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Current("1 uA")
+    Current('1 uA')
+    >>> Current(1e-9)
+    Current('1 nA')
+    """
+
+    units: str = "A"
+
+
+class Power(Quantity):
+    """
+    Power quantity with units of Watts.
+
+    Attributes
+    ----------
+    units : str, default="W"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Power("12 mW")
+    Power('12 mW')
+    >>> Power(1e3)
+    Power('1 kW')
+    """
+
+    units: str = "W"
+
+
+class Resistance(Quantity):
+    """
+    Resistance quantity with units of Ohms/ohm/etc.
+
+    Attributes
+    ----------
+    units : str, default="Ohm"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Resistance("5 ohms")
+    Resistance('5 Ohm')
+    >>> Resistance("5 mΩ")
+    Resistance('5 mOhm')
+    >>> Resistance(50)
+    Resistance('50 Ohm')
+    """
+
+    units: str = "Ohm"
+
+
+class Capacitance(Quantity):
+    """
+    Capacitance quantity with units of Farads.
+
+    Attributes
+    ----------
+    units : str, default="F"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Capacitance("5e-15 F")
+    Capacitance('5 fF')
+    """
+
+    units: str = "F"
+
+
+class Inductance(Quantity):
+    """
+    Inductance quantity with units of Henry.
+
+    Attributes
+    ----------
+    units : str, default="H"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Inductance(5e-9)
+    Inductance('5 nH')
+    """
+
+    units: str = "H"
+
+
+class Temperature(Quantity):
+    """
+    Temperature quantity with units of Celsius.
+
+    Attributes
+    ----------
+    units : str, default="C"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Temperature(25)
+    Temperature('25 C')
+    """
+
+    units: str = "C"
+
+
+class Frequency(Quantity):
+    """
+    Frequency quantity with units of Hertz.
+
+    Attributes
+    ----------
+    units : str, default="Hz"
+        Unit symbol.
+
+    Examples
+    --------
+    >>> Frequency(5e9)
+    Frequency('5 GHz')
+    """
+
+    units: str = "Hz"

analog_daddy-3.0.1.dev1/src/analog_daddy/__init__.py

@@ -1 +0,0 @@
-"""Top-level package for Analog Daddy."""