ee-toolkit 0.0.2__py3-none-any.whl

ee_toolkit/smps.py

@@ -0,0 +1,330 @@
+"""
+Switching converter power-stage sizing (boost / buck).
+
+All formulas are the standard CCM (continuous-conduction-mode) first-order
+approximations: the input/output voltages are assumed constant within a
+switching cycle, the converter is assumed to stay in CCM, and ESR/ESL are
+ignored (negligible for ceramics, add ΔV_ESR = ΔI·ESR for electrolytics).
+Good to ~10–20 % — the right accuracy for picking parts.
+
+Inductor (V = L·dI/dt over the charging interval)
+-------------------------------------------------
+  Boost duty:        D = 1 - Vin/Vrail          (volt-second balance)
+  Buck  duty:        D = Vout/Vrail
+  Boost ripple:      ΔI = Vin·D / (L·fsw)        = Vin(1-Vin/Vrail)/(L·fsw)
+  Buck  ripple:      ΔI = Vout(1-D) / (L·fsw)    = Vout(1-Vout/Vrail)/(L·fsw)
+
+  The ripple term V(1-V/Vrail) is a downward parabola, maximised at V = Vrail/2,
+  so that is the worst-case ripple operating point used for sizing L.
+
+Capacitor (I = C·dV/dt)
+-----------------------
+  Buck output:   C = ΔI / (8·fsw·ΔV)     (cap absorbs only the triangular ripple)
+  Boost output:  C = Iout·D / (fsw·ΔV)   (cap supplies the FULL load during D·T)
+  Buck input RMS: I_rms = Iout·√(D(1-D)) (pulsed input current heating)
+"""
+import math
+
+import click
+
+from .units   import parse_si, fmt_si
+from .eseries import nearest_in_series
+
+
+# ---------------------------------------------------------------------------
+# Duty cycle (steady-state volt-second balance)
+# ---------------------------------------------------------------------------
+
+def boost_duty(vin: float, vrail: float) -> float:
+    """Boost duty cycle D = 1 - Vin/Vrail."""
+    return 1.0 - vin / vrail
+
+
+def buck_duty(vrail: float, vout: float) -> float:
+    """Buck duty cycle D = Vout/Vrail."""
+    return vout / vrail
+
+
+# ---------------------------------------------------------------------------
+# Inductor ripple / sizing
+# ---------------------------------------------------------------------------
+
+def boost_inductor_ripple(vin: float, vrail: float, l: float, fsw: float) -> float:
+    """Peak-to-peak inductor ripple current of a boost stage (A)."""
+    return vin * boost_duty(vin, vrail) / (l * fsw)
+
+
+def boost_inductance(vin: float, vrail: float, ripple_i: float, fsw: float) -> float:
+    """Inductance (H) giving *ripple_i* peak-to-peak ripple at this operating point."""
+    return vin * boost_duty(vin, vrail) / (ripple_i * fsw)
+
+
+def buck_inductor_ripple(vrail: float, vout: float, l: float, fsw: float) -> float:
+    """Peak-to-peak inductor ripple current of a buck stage (A)."""
+    return vout * (1.0 - buck_duty(vrail, vout)) / (l * fsw)
+
+
+def buck_inductance(vrail: float, vout: float, ripple_i: float, fsw: float) -> float:
+    """Inductance (H) giving *ripple_i* peak-to-peak ripple at this operating point."""
+    return vout * (1.0 - buck_duty(vrail, vout)) / (ripple_i * fsw)
+
+
+# ---------------------------------------------------------------------------
+# Capacitor sizing
+# ---------------------------------------------------------------------------
+
+def buck_output_cap(ripple_i: float, fsw: float, ripple_v: float) -> float:
+    """Output capacitance (F) bounding buck output ripple to *ripple_v* (capacitive term)."""
+    return ripple_i / (8.0 * fsw * ripple_v)
+
+
+def boost_output_cap(iout: float, duty: float, fsw: float, ripple_v: float) -> float:
+    """Output capacitance (F) bounding boost output ripple to *ripple_v*.
+
+    *iout* is the boost stage output current (= P_rail / Vrail); the cap alone
+    supplies the load during the D·T on-time.
+    """
+    return iout * duty / (fsw * ripple_v)
+
+
+def buck_input_rms(iout: float, duty: float) -> float:
+    """RMS ripple current drawn by a buck stage from its input rail (A)."""
+    return iout * math.sqrt(duty * (1.0 - duty))
+
+
+# ---------------------------------------------------------------------------
+# Worst-case helper
+# ---------------------------------------------------------------------------
+
+def worst_ripple_voltage(v_low: float, v_high: float, vrail: float) -> float:
+    """Voltage in [v_low, v_high] that maximises ripple V·(1-V/Vrail).
+
+    Unconstrained maximum is at Vrail/2; clamp to the supplied range.
+    """
+    v_star = vrail / 2.0
+    if v_star < v_low:
+        return v_low
+    if v_star > v_high:
+        return v_high
+    return v_star
+
+
+def inductor_rms(i_avg: float, ripple_i: float) -> float:
+    """RMS current of a triangular-ripple inductor waveform (A)."""
+    return math.sqrt(i_avg ** 2 + (ripple_i ** 2) / 12.0)
+
+
+def snap_e12(value: float):
+    """Snap *value* to the nearest E12 standard value in any decade.
+
+    Thin wrapper over :func:`eseries.nearest_in_series` for L/C component picks.
+    Returns (snapped_value, error_percent).
+    """
+    return nearest_in_series(value, 'E12')
+
+
+# ---------------------------------------------------------------------------
+# Click commands
+# ---------------------------------------------------------------------------
+
+def _snap(value: float, unit: str):
+    """Snap *value* to the nearest E12 standard value; return (snapped, text)."""
+    snapped, err = snap_e12(value)
+    return snapped, f"{fmt_si(snapped, unit)}  ({err:+.1f}% vs {fmt_si(value, unit)} ideal)"
+
+
+def _hdr(text: str):
+    click.secho(text, fg='cyan', bold=True)
+
+
+def _row(cells, widths, color=None, marker=''):
+    line = '  ' + '  '.join(f"{c:<{w}}" for c, w in zip(cells, widths))
+    click.secho(line + marker, fg=color)
+
+
+@click.group()
+def smps_group():
+    """Switching converter power-stage sizing (boost / buck)."""
+
+
+@smps_group.command('boost')
+@click.option('--vin-min', 'vin_min_str', required=True, metavar='VALUE',
+              help='Minimum input voltage (pack empty), e.g. 9')
+@click.option('--vin-max', 'vin_max_str', required=True, metavar='VALUE',
+              help='Maximum input voltage (pack full), e.g. 25.2')
+@click.option('--vrail', 'vrail_str', required=True, metavar='VALUE',
+              help='Boost output / intermediate-rail voltage, e.g. 30')
+@click.option('--pout', 'pout_str', required=True, metavar='VALUE',
+              help='Power delivered to the rail (boost output power), e.g. 105')
+@click.option('--fsw', 'fsw_str', required=True, metavar='VALUE',
+              help='Switching frequency, e.g. 250k')
+@click.option('--ripple', default=0.4, show_default=True,
+              help='Target peak-to-peak inductor ripple as a fraction of I_avg.')
+@click.option('--eff', default=0.95, show_default=True,
+              help='Boost stage efficiency (for input-current estimate).')
+@click.option('--dvrail', 'dvrail_str', default='300m', show_default=True, metavar='VALUE',
+              help='Allowed rail voltage ripple, e.g. 300m')
+@click.option('--inductance', 'l_str', default=None, metavar='VALUE',
+              help='Analyse a fixed inductor instead of sizing one, e.g. 10u')
+@click.option('--margin', default=1.3, show_default=True,
+              help='Safety margin applied to peak current for I_sat selection.')
+def cmd_boost(vin_min_str, vin_max_str, vrail_str, pout_str, fsw_str,
+              ripple, eff, dvrail_str, l_str, margin):
+    """Size a boost stage (Vin range → fixed rail).
+
+    \b
+    D = 1 - Vin/Vrail
+    ΔI = Vin·D / (L·fsw)            (worst case at Vin = Vrail/2)
+    C_rail = Iout·D / (fsw·ΔV)      (cap supplies full load during D·T)
+
+    Example (3S-6S pack → 30 V rail, 105 W):
+      ee-calc smps boost --vin-min 9 --vin-max 25.2 --vrail 30 --pout 105 --fsw 250k
+    """
+    vin_min = parse_si(vin_min_str)
+    vin_max = parse_si(vin_max_str)
+    vrail   = parse_si(vrail_str)
+    pout    = parse_si(pout_str)
+    fsw     = parse_si(fsw_str)
+    dvrail  = parse_si(dvrail_str)
+
+    if vrail <= vin_max:
+        raise click.UsageError(
+            f"Rail ({fmt_si(vrail, 'V')}) must exceed max input "
+            f"({fmt_si(vin_max, 'V')}) — a boost can only step up.")
+
+    p_in = pout / eff
+    v_star = worst_ripple_voltage(vin_min, vin_max, vrail)
+
+    if l_str:
+        l = parse_si(l_str)
+        l_note = f"{fmt_si(l, 'H')}  (as supplied)"
+    else:
+        i_avg_star = p_in / v_star
+        l_ideal = boost_inductance(v_star, vrail, ripple * i_avg_star, fsw)
+        l, l_note = _snap(l_ideal, 'H')
+
+    _hdr("Boost stage")
+    click.echo(f"  Vin    = {fmt_si(vin_min, 'V')} … {fmt_si(vin_max, 'V')}")
+    click.echo(f"  Vrail  = {fmt_si(vrail, 'V')}    Pout(rail) = {fmt_si(pout, 'W')}    η = {eff:.0%}")
+    click.echo(f"  fsw    = {fmt_si(fsw, 'Hz')}    Pin ≈ {fmt_si(p_in, 'W')}")
+    click.secho(f"  L      = {l_note}", fg='green', bold=True)
+
+    _hdr("\nOperating sweep")
+    widths = (10, 7, 10, 10, 9, 10)
+    _row(('Vin', 'Duty', 'I_avg', 'ΔI(pp)', 'ripple', 'I_peak'), widths)
+    click.echo("  " + "─" * 62)
+    peak_max = 0.0
+    irms_max = 0.0
+    for vin in (vin_min, v_star, vin_max):
+        d = boost_duty(vin, vrail)
+        i_avg = p_in / vin
+        di = boost_inductor_ripple(vin, vrail, l, fsw)
+        i_peak = i_avg + di / 2.0
+        peak_max = max(peak_max, i_peak)
+        irms_max = max(irms_max, inductor_rms(i_avg, di))
+        marker = '  ◀ worst ripple' if abs(vin - v_star) < 1e-9 else ''
+        _row((f"{vin:.2f} V", f"{d:.3f}", f"{i_avg:.2f} A",
+              f"{di:.2f} A", f"{di / i_avg:.0%}", f"{i_peak:.2f} A"),
+             widths, marker=marker)
+
+    i_out = pout / vrail
+    c_rail_ideal = boost_output_cap(i_out, boost_duty(vin_min, vrail), fsw, dvrail)
+    _, c_note = _snap(c_rail_ideal, 'F')
+
+    _hdr("\nComponent selection")
+    click.secho(f"  Inductor : ≥ {fmt_si(peak_max * margin, 'A')} I_sat "
+                f"(peak {fmt_si(peak_max, 'A')} × {margin:g}), "
+                f"≥ {fmt_si(irms_max, 'A')} I_rms", fg='green')
+    click.secho(f"  Rail cap : {c_note}", fg='green')
+    click.secho("             (size for RMS current too — the buck input adds to this rail)",
+                fg='yellow')
+
+
+@smps_group.command('buck')
+@click.option('--vrail', 'vrail_str', required=True, metavar='VALUE',
+              help='Input / intermediate-rail voltage, e.g. 30')
+@click.option('--vout-min', 'vout_min_str', required=True, metavar='VALUE',
+              help='Minimum output voltage, e.g. 3.3')
+@click.option('--vout-max', 'vout_max_str', required=True, metavar='VALUE',
+              help='Maximum output voltage, e.g. 21')
+@click.option('--iout', 'iout_str', required=True, metavar='VALUE',
+              help='Maximum output current, e.g. 5')
+@click.option('--fsw', 'fsw_str', required=True, metavar='VALUE',
+              help='Switching frequency, e.g. 250k')
+@click.option('--ripple', default=0.4, show_default=True,
+              help='Target peak-to-peak inductor ripple as a fraction of I_out.')
+@click.option('--dvout', 'dvout_str', default='50m', show_default=True, metavar='VALUE',
+              help='Allowed output voltage ripple, e.g. 50m')
+@click.option('--inductance', 'l_str', default=None, metavar='VALUE',
+              help='Analyse a fixed inductor instead of sizing one, e.g. 15u')
+@click.option('--margin', default=1.3, show_default=True,
+              help='Safety margin applied to peak current for I_sat selection.')
+def cmd_buck(vrail_str, vout_min_str, vout_max_str, iout_str, fsw_str,
+             ripple, dvout_str, l_str, margin):
+    """Size a buck stage (fixed rail → Vout range).
+
+    \b
+    D = Vout/Vrail
+    ΔI = Vout(1-D) / (L·fsw)        (worst case at Vout = Vrail/2)
+    C_out = ΔI / (8·fsw·ΔV)
+    I_rail,rms = Iout·√(D(1-D))     (rail cap RMS, max at D=0.5)
+
+    Example (30 V rail → PD/PPS 3.3-21 V, 5 A):
+      ee-calc smps buck --vrail 30 --vout-min 3.3 --vout-max 21 --iout 5 --fsw 250k
+    """
+    vrail    = parse_si(vrail_str)
+    vout_min = parse_si(vout_min_str)
+    vout_max = parse_si(vout_max_str)
+    iout     = parse_si(iout_str)
+    fsw      = parse_si(fsw_str)
+    dvout    = parse_si(dvout_str)
+
+    if vout_max >= vrail:
+        raise click.UsageError(
+            f"Max output ({fmt_si(vout_max, 'V')}) must be below the rail "
+            f"({fmt_si(vrail, 'V')}) — a buck can only step down.")
+
+    v_star = worst_ripple_voltage(vout_min, vout_max, vrail)
+
+    if l_str:
+        l = parse_si(l_str)
+        l_note = f"{fmt_si(l, 'H')}  (as supplied)"
+    else:
+        l_ideal = buck_inductance(vrail, v_star, ripple * iout, fsw)
+        l, l_note = _snap(l_ideal, 'H')
+
+    _hdr("Buck stage")
+    click.echo(f"  Vrail  = {fmt_si(vrail, 'V')}")
+    click.echo(f"  Vout   = {fmt_si(vout_min, 'V')} … {fmt_si(vout_max, 'V')}    Iout = {fmt_si(iout, 'A')}")
+    click.echo(f"  fsw    = {fmt_si(fsw, 'Hz')}")
+    click.secho(f"  L      = {l_note}", fg='green', bold=True)
+
+    _hdr("\nOperating sweep")
+    widths = (10, 7, 10, 9, 10, 11)
+    _row(('Vout', 'Duty', 'ΔI(pp)', 'ripple', 'I_peak', 'I_rail,rms'), widths)
+    click.echo("  " + "─" * 64)
+    di_max = 0.0
+    irms_max = 0.0
+    for vout in (vout_min, v_star, vout_max):
+        d = buck_duty(vrail, vout)
+        di = buck_inductor_ripple(vrail, vout, l, fsw)
+        i_peak = iout + di / 2.0
+        i_rms = buck_input_rms(iout, d)
+        di_max = max(di_max, di)
+        irms_max = max(irms_max, i_rms)
+        marker = '  ◀ worst ripple' if abs(vout - v_star) < 1e-9 else ''
+        _row((f"{vout:.2f} V", f"{d:.3f}", f"{di:.2f} A",
+              f"{di / iout:.0%}", f"{i_peak:.2f} A", f"{i_rms:.2f} A"),
+             widths, marker=marker)
+
+    c_out_ideal = buck_output_cap(di_max, fsw, dvout)
+    _, c_note = _snap(c_out_ideal, 'F')
+
+    _hdr("\nComponent selection")
+    click.secho(f"  Inductor : ≥ {fmt_si((iout + di_max / 2) * margin, 'A')} I_sat, "
+                f"≥ {fmt_si(iout, 'A')} I_rms", fg='green')
+    click.secho(f"  Out cap  : {c_note}", fg='green')
+    click.secho(f"  Rail cap : carries ≥ {fmt_si(irms_max, 'A')} RMS from the buck side",
+                fg='green')
+    click.secho("             (don't oversize C_out — it slows PPS voltage slewing)",
+                fg='yellow')

ee_toolkit/units.py

@@ -0,0 +1,77 @@
+"""
+Shared utilities: SI prefix parsing and pretty-printing.
+"""
+import re
+
+_PREFIX_MAP = {
+    'G': 1e9,
+    'M': 1e6,
+    'k': 1e3,
+    'K': 1e3,
+    '':  1.0,
+    'm': 1e-3,
+    'u': 1e-6,
+    'µ': 1e-6,
+    'n': 1e-9,
+    'p': 1e-12,
+    'f': 1e-15,
+}
+
+_SI_SCALE = [
+    (1e9,  'G'),
+    (1e6,  'M'),
+    (1e3,  'k'),
+    (1.0,  ''),
+    (1e-3, 'm'),
+    (1e-6, 'µ'),
+    (1e-9, 'n'),
+    (1e-12,'p'),
+]
+
+_UNIT_RE = re.compile(
+    r'^\s*([+-]?[0-9]*\.?[0-9]+(?:[eE][+-]?[0-9]+)?)'
+    r'\s*([GMkKmuµnpf]?)\s*$'
+)
+
+
+def parse_si(text: str) -> float:
+    """
+    Parse a string with an optional SI prefix into a float.
+
+    Examples
+    --------
+    >>> parse_si('10k')   # 10 000
+    10000.0
+    >>> parse_si('100n')  # 100e-9
+    1e-07
+    >>> parse_si('3.3M')  # 3 300 000
+    3300000.0
+    """
+    m = _UNIT_RE.match(text)
+    if not m:
+        raise ValueError(
+            f"Cannot parse '{text}' – expected a number with an optional SI prefix "
+            "(G M k m u µ n p f)."
+        )
+    number = float(m.group(1))
+    prefix = m.group(2)
+    return number * _PREFIX_MAP[prefix]
+
+
+def fmt_si(value: float, unit: str = '', decimals: int = 4) -> str:
+    """
+    Format *value* with an SI prefix and optional unit string.
+
+    Examples
+    --------
+    >>> fmt_si(15920.0, 'Hz')
+    '15.92 kHz'
+    >>> fmt_si(1e-9, 'F')
+    '1.0 nF'
+    """
+    for scale, prefix in _SI_SCALE:
+        if abs(value) >= scale:
+            return f"{value / scale:.{decimals}g} {prefix}{unit}"
+    # Fallback for very small values
+    scale, prefix = _SI_SCALE[-1]
+    return f"{value / scale:.{decimals}g} {prefix}{unit}"

ee_toolkit-0.0.2.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: ee-toolkit
+Version: 0.0.2
+Project-URL: Documentation, https://git.sr.ht/~laplace/ee-toolkit#readme
+Project-URL: Issues, https://git.sr.ht/~laplace/ee-toolkit/todo
+Project-URL: Source, https://git.sr.ht/~laplace/ee-toolkit
+Author-email: Alexander Becker <nabla.becker@mailbox.org>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0
+Description-Content-Type: text/markdown
+
+# ee-toolkit
+
+[![PyPI - Version](https://img.shields.io/pypi/v/ee-toolkit.svg)](https://pypi.org/project/ee-toolkit)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/ee-toolkit.svg)](https://pypi.org/project/ee-toolkit)
+
+A command-line EE calculator
+
+This is essentially the cli version of many of the online 'electronics' focussed calculators
+for all the usual things like filter cutoff frequencies or resonances or resistor approximations
+
+## License
+
+`ee-toolkit` is licensed under the terms of the GPL-v3 license.
+
+## Install
+
+```bash
+pip install ee-toolkit
+```
+
+## Commands
+
+### `filter`
+```bash
+ee-calc filter rc --r 10k --c 100n          # RC cutoff
+ee-calc filter lc --l 10u --c 100p          # LC resonance
+```
+
+### `eseries`
+```bash
+ee-calc eseries find --value 10.5k                        # nearest E24 values
+ee-calc eseries find --value 47n --series E96 --unit F    # E96 capacitor
+ee-calc eseries find --value 10u --series E12 --unit H    # E12 inductor
+ee-calc eseries decompose --value 10.5k --combo series    # two-resistor series
+ee-calc eseries decompose --value 10.5k --combo parallel  # two-resistor parallel
+```
+Value snapping is decade-independent — it works across the full pF…GΩ/µH range,
+not just resistor decades.
+
+### `smps`
+Switching-converter power-stage sizing (inductor, capacitor, frequency trade).
+```bash
+# Boost stage: 3S-6S pack (9-25.2 V) → 30 V intermediate rail, 105 W
+ee-calc smps boost --vin-min 9 --vin-max 25.2 --vrail 30 --pout 105 --fsw 250k
+
+# Buck stage: 30 V rail → USB-PD/PPS output (3.3-21 V), 5 A
+ee-calc smps buck --vrail 30 --vout-min 3.3 --vout-max 21 --iout 5 --fsw 250k
+
+# Analyse a fixed inductor instead of sizing one
+ee-calc smps buck --vrail 30 --vout-min 3.3 --vout-max 21 --iout 5 --fsw 250k --inductance 15u
+```
+Each command reports the recommended inductance (snapped to E12), an operating
+sweep across the voltage range (duty, ripple, peak current) marking the
+worst-case ripple point, and the inductor/capacitor selection including
+saturation-current and RMS-current targets. Override ripple/voltage-ripple
+targets with `--ripple`, `--dvrail`/`--dvout`.
+
+### `oscillator`
+```bash
+ee-calc oscillator lc --l 10u --c 100p                    # LC tank
+ee-calc oscillator colpitts --l 10u --c1 100p --c2 100p   # Colpitts
+ee-calc oscillator hartley  --l1 5u  --l2 5u  --c 100p    # Hartley
+```
+
+### `opamp`
+```bash
+ee-calc opamp noninv --rf 100k --r1 10k              # non-inverting gain
+ee-calc opamp inv    --rf 100k --r1 10k              # inverting gain
+ee-calc opamp integrator    --r 10k --c 100n         # integrator corner freq
+ee-calc opamp integrator    --r 10k --c 100n --freq 500   # gain at 500 Hz
+ee-calc opamp differentiator --r 10k --c 100n             # differentiator corner freq
+ee-calc opamp differentiator --r 10k --c 100n --freq 2k   # gain at 2 kHz
+```
+
+## SI prefixes
+
+All value inputs accept SI prefixes: `G M k m u µ n p f`
+
+```
+10k  → 10 000
+100n → 100 × 10⁻⁹
+4.7M → 4 700 000
+```
+
+## Run tests
+
+```bash
+python -m pytest tests/ -v
+```

ee_toolkit-0.0.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+ee_toolkit/__about__.py,sha256=KW48ZmlfhCUsX-7BLzk9VWpZljnynWruMdpV1Jmk7pI,138
+ee_toolkit/__init__.py,sha256=Bl_M7kRF_a5EMK50H2KzTycOZvwxTYwX0QjDALGcV9U,107
+ee_toolkit/cli.py,sha256=X3OJcqFnglJMpltlGEX59vlSWb0IMWRiS3BQCCm1tK8,1631
+ee_toolkit/eseries.py,sha256=hnggGB_NsPYeO6qHVL9lFiy8wHlsomkvuTB7KU-eg7M,8510
+ee_toolkit/filters.py,sha256=1VvJ94Q-0OoKOzuF-4kGbb80LVXT1A8_dUivAOXDLHY,4731
+ee_toolkit/mosfet.py,sha256=8xSy4x7fNvF6kyF3OlSV7l1RWLavF3ZuLrLrLYUD0fM,3232
+ee_toolkit/opamp.py,sha256=D-jhX1oBdTiQJdU_j7Lty7_SVo2Of6HI_xLt_F7gJl0,6819
+ee_toolkit/oscillator.py,sha256=oaBM5-ATJt28qm091Ag3ZAeXCzYspJzqyt5IWEWb8Nc,3576
+ee_toolkit/resistor.py,sha256=qzuCt6Zg5KRBDBZ9fU4QXyGJyUZQJrxfG_yTDg_y-EM,8680
+ee_toolkit/smps.py,sha256=PP0ph2l4xEOqDaMrkDnYhNalxTMQDexSck970Kf0smA,13952
+ee_toolkit/units.py,sha256=5j--iuTUnG3kllXeX8Z6VxgJQq1SiWg4h6Rq_EazM8k,1625
+ee_toolkit-0.0.2.dist-info/METADATA,sha256=6OFWCorL6AlF7bRq-YgSYnt_yQD2rpiuhJ_B0GzSsHA,4005
+ee_toolkit-0.0.2.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+ee_toolkit-0.0.2.dist-info/entry_points.txt,sha256=B1HnQx9H8BtZXlIGnluo5Skav4demPDscKPWhibrnWw,47
+ee_toolkit-0.0.2.dist-info/licenses/LICENSE.txt,sha256=769qERkGHy-UfR4fBzJY83KqNle54WBx1PQxdrIDEww,34961
+ee_toolkit-0.0.2.dist-info/RECORD,,

ee_toolkit-0.0.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

ee_toolkit-0.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ee-calc = ee_toolkit.cli:cli