nyancad 0.1.0__tar.gz

nyancad-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: nyancad
+Version: 0.1.0
+Summary: NyanCAD Python library for schematic editor with anywidget integration
+Author-email: Pepijn de Vos <me@pepijndevos.nl>
+License: MPL-2.0
+Project-URL: Homepage, https://github.com/NyanCAD/Mosaic
+Project-URL: Repository, https://github.com/NyanCAD/Mosaic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: anywidget>=0.9.0
+Requires-Dist: traitlets
+
+# NyanCAD Python Library
+
+A Python library for the [NyanCAD schematic editor](https://github.com/NyanCAD/Mosaic) with anywidget integration. Provides live access to schematic data from marimo notebooks.
+
+## Installation
+
+```bash
+pip install nyancad
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+import marimo as mo
+from nyancad import SchematicBridge
+
+# Create a schematic bridge widget
+bridge = SchematicBridge()
+
+# Display the widget (shows connection status)
+bridge
+
+# Access live schematic data
+print(bridge.schematic_data)
+
+# Send simulation data back to the editor
+bridge.simulation_data = {
+    "results": [1.2, 3.4, 5.6],
+    "timestamp": "2024-01-01T00:00:00Z"
+}
+```
+
+### Integration with Marimo
+
+The SchematicBridge widget automatically connects to the NyanCAD editor running in the same marimo session. Any changes made in the schematic editor will be immediately reflected in the Python widget.
+
+```python
+# In a marimo cell
+bridge = SchematicBridge()
+bridge  # This will show the connection status
+
+# In another marimo cell - access the live data
+mo.md(f"""
+## Schematic Analysis
+Raw schematic data: {len(bridge.schematic_data)} items
+""")
+
+# View the actual schematic data structure
+bridge.schematic_data
+```
+
+## Features
+
+- **Live Sync**: Real-time synchronization with NyanCAD schematic editor via PouchDB
+- **Bidirectional Communication**: Send simulation data back to the editor from Python
+- **Zero Configuration**: Automatically detects and connects to the active schematic
+- **Raw Data Access**: Direct access to the complete schematic data structure
+- **Marimo Integration**: Seamless integration with marimo notebooks
+
+## API Reference
+
+### SchematicBridge
+
+The main widget class that provides bidirectional communication with the Mosaic editor.
+
+#### Properties
+
+- `schematic_data` (dict): Raw schematic data from the Mosaic editor, automatically synced
+- `simulation_data` (dict): Simulation data to send to the Mosaic editor. Setting this will store the data with a timestamp in the editor's database
+
+## Development
+
+This package is part of the [NyanCAD](https://github.com/NyanCAD/Mosaic) project. The anywidget integration uses a ClojureScript bridge that compiles to an ESM module, allowing seamless data sharing between the schematic editor and Python environment.
+
+## License
+
+This project is licensed under the Mozilla Public License 2.0 - see the [LICENSE](../../LICENSE) file for details.

nyancad-0.1.0/README.md

@@ -0,0 +1,79 @@
+# NyanCAD Python Library
+
+A Python library for the [NyanCAD schematic editor](https://github.com/NyanCAD/Mosaic) with anywidget integration. Provides live access to schematic data from marimo notebooks.
+
+## Installation
+
+```bash
+pip install nyancad
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+import marimo as mo
+from nyancad import SchematicBridge
+
+# Create a schematic bridge widget
+bridge = SchematicBridge()
+
+# Display the widget (shows connection status)
+bridge
+
+# Access live schematic data
+print(bridge.schematic_data)
+
+# Send simulation data back to the editor
+bridge.simulation_data = {
+    "results": [1.2, 3.4, 5.6],
+    "timestamp": "2024-01-01T00:00:00Z"
+}
+```
+
+### Integration with Marimo
+
+The SchematicBridge widget automatically connects to the NyanCAD editor running in the same marimo session. Any changes made in the schematic editor will be immediately reflected in the Python widget.
+
+```python
+# In a marimo cell
+bridge = SchematicBridge()
+bridge  # This will show the connection status
+
+# In another marimo cell - access the live data
+mo.md(f"""
+## Schematic Analysis
+Raw schematic data: {len(bridge.schematic_data)} items
+""")
+
+# View the actual schematic data structure
+bridge.schematic_data
+```
+
+## Features
+
+- **Live Sync**: Real-time synchronization with NyanCAD schematic editor via PouchDB
+- **Bidirectional Communication**: Send simulation data back to the editor from Python
+- **Zero Configuration**: Automatically detects and connects to the active schematic
+- **Raw Data Access**: Direct access to the complete schematic data structure
+- **Marimo Integration**: Seamless integration with marimo notebooks
+
+## API Reference
+
+### SchematicBridge
+
+The main widget class that provides bidirectional communication with the Mosaic editor.
+
+#### Properties
+
+- `schematic_data` (dict): Raw schematic data from the Mosaic editor, automatically synced
+- `simulation_data` (dict): Simulation data to send to the Mosaic editor. Setting this will store the data with a timestamp in the editor's database
+
+## Development
+
+This package is part of the [NyanCAD](https://github.com/NyanCAD/Mosaic) project. The anywidget integration uses a ClojureScript bridge that compiles to an ESM module, allowing seamless data sharing between the schematic editor and Python environment.
+
+## License
+
+This project is licensed under the Mozilla Public License 2.0 - see the [LICENSE](../../LICENSE) file for details.

nyancad-0.1.0/nyancad/__init__.py

@@ -0,0 +1,9 @@
+"""
+NyanCAD Python Library
+
+A Python library for the NyanCAD schematic editor with anywidget integration.
+Provides live access to schematic data from marimo notebooks.
+"""
+
+__version__ = "0.1.0"
+__all__ = []

nyancad-0.1.0/nyancad/anywidget.py

@@ -0,0 +1,50 @@
+"""
+Anywidget integration for Mosaic schematic editor.
+
+Provides a live bridge to schematic data from the Mosaic editor via PouchDB.
+"""
+
+import anywidget
+import traitlets
+import marimo as mo
+
+
+class SchematicBridge(anywidget.AnyWidget):
+    """
+    An anywidget that provides live bidirectional communication with the Mosaic editor.
+    
+    The widget displays a simple status indicator and automatically syncs schematic
+    data from the Mosaic editor's PouchDB storage into the Python model, while also
+    enabling Python to send simulation data back to the editor.
+    
+    Attributes:
+        schematic_data (dict): Live schematic data from the Mosaic editor
+        simulation_data (dict): Simulation data to send to the Mosaic editor.
+                               Setting this will store the data with a timestamp in the editor's database.
+    """
+    
+    # ESM shim that dynamically imports the Shadow CLJS compiled anywidget module
+    # Uses window.location.origin to resolve the full URL since ESM runs from data: URL
+    _esm = """
+const { render } = await import(`${window.location.origin}/js/anywidget.js`);
+export default { render };
+"""
+    
+    # Schematic data that gets synced from the ClojureScript side
+    schematic_data = traitlets.Dict().tag(sync=True)
+    
+    # Simulation data that gets synced to the ClojureScript side
+    simulation_data = traitlets.Dict().tag(sync=True)
+
+    @property
+    def name(self):
+        return mo.query_params()["schem"]
+
+def schematic_bridge():
+    """
+    Create a SchematicBridge widget for use in Marimo notebooks.
+    
+    Returns:
+        SchematicBridge: An instance of the SchematicBridge widget.
+    """
+    return mo.ui.anywidget(SchematicBridge())

nyancad-0.1.0/nyancad/netlist.py

@@ -0,0 +1,332 @@
+# SPDX-FileCopyrightText: 2022 Pepijn de Vos
+#
+# SPDX-License-Identifier: MPL-2.0
+"""
+This module communicates with CouchDB to fetch schematics, and generate SPICE netlists out of them.
+
+"""
+
+from collections import deque, namedtuple
+
+class SchemId(namedtuple("SchemId", ["cell", "model", "device"])):
+    @classmethod
+    def from_string(cls, id):
+        schem, dev, *_= id.split(':') + [None]
+        cell, model = schem.split('$')
+        return cls(cell, model, dev)
+
+    @property
+    def schem(self):
+        return f"{self.cell}${self.model}"
+
+def shape_ports(shape):
+    for y, s in enumerate(shape):
+        for x, c in enumerate(s):
+            if c != ' ':
+                yield x, y, c
+
+
+mosfet_shape = list(shape_ports([
+    " D ",
+    "GB ",
+    " S ",
+]))
+
+bjt_shape = list(shape_ports([
+    " C ",
+    "B  ",
+    " E ",
+]))
+
+
+twoport_shape = list(shape_ports([
+    " P ",
+    "   ",
+    " N ",
+]))
+
+
+def rotate(shape, transform, devx, devy):
+    a, b, c, d, e, f = transform
+    width = max(max(x, y) for x, y, _ in shape)+1
+    mid = width/2-0.5
+    res = {}
+    for px, py, p in shape:
+        x = px-mid
+        y = py-mid
+        nx = a*x+c*y+e
+        ny = b*x+d*y+f
+        res[round(devx+nx+mid), round(devy+ny+mid)] = p
+    return res
+
+
+def getports(doc, models):
+    cell = doc['cell']
+    x = doc['x']
+    y = doc['y']
+    tr = doc.get('transform', [1, 0, 0, 1, 0, 0])
+    if cell == 'wire':
+        rx = doc['rx']
+        ry = doc['ry']
+        return {(x, y): None,
+                (x+rx, y+ry): None}
+    elif cell == 'text':
+        return {}
+    elif cell == 'port':
+        return {(x, y): doc['name']}
+    elif cell in {'nmos', 'pmos'}:
+        return rotate(mosfet_shape, tr, x, y)
+    elif cell in {'npn', 'pnp'}:
+        return rotate(bjt_shape, tr, x, y)
+    elif cell in {'resistor', 'capacitor', 'inductor', 'vsource', 'isource', 'diode'}:
+        return rotate(twoport_shape, tr, x, y)
+    else:
+        return rotate(models[f"models:{cell}"]['conn'], tr, x, y)
+
+
+def port_index(docs, models):
+    wire_index = {}
+    device_index = {}
+    for doc in docs.values():
+        cell = doc['cell']
+        for (x, y), p in getports(doc, models).items():
+            if cell in {'wire', 'port'}:
+                wire_index.setdefault((x, y), []).append(doc)
+            else:
+                device_index.setdefault((x, y), []).append((p, doc))
+                # add a dummy net so two devices can connect directly
+                wire_index.setdefault((x, y), []).append({"cell": "wire", "x": x, "y": y, "rx": 0, "ry": 0})
+    return device_index, wire_index
+
+
+def wire_net(wireid, docs, models):
+    device_index, wire_index = port_index(docs, models)
+    netname = None
+    net = deque([docs[wireid]]) # all the wires on this net
+    while net:
+        doc = net.popleft() # take a wire from the net
+        cell = doc['cell']
+        if cell == 'wire':
+            wirename = doc.get('name')
+            if netname == None and wirename != None:
+                netname = wirename
+            for ploc in getports(doc, models).keys(): # get the wire ends
+                # if the wire connects to another wire,
+                # that we have not seen, add it to the net
+                if ploc in wire_index:
+                    net.extend(wire_index.pop(ploc))
+        elif cell == 'port':
+            netname = doc.get('name')
+        else:
+            raise ValueError(cell)
+    return netname
+
+def netlist(docs, models):
+    """
+    Turn a collection of documents as returned by `get_docs` into a netlist structure.
+    Returns a dictionary of device ID: {port: net}
+    Usage:
+    ```
+    async with SchematicService("http://localhost:5984/offline") as service:
+        name = "top$top"
+        seq, docs = await service.get_all_schem_docs(name)
+        print(netlist(docs[name], models))
+    ```
+    """
+    device_index, wire_index = port_index(docs, models)
+    nl = {}
+    netnum = 0
+    while wire_index:  # while there are wires left
+        loc, locwires = wire_index.popitem()  # take one
+        netname = None
+        net = deque(locwires) # all the wires on this net
+        netdevs = {} # all the devices on this net
+        while net:
+            doc = net.popleft() # take a wire from the net
+            cell = doc['cell']
+            if cell == 'wire':
+                wirename = doc.get('name')
+                if netname == None and wirename != None:
+                    netname = wirename
+                for ploc in getports(doc, models).keys(): # get the wire ends
+                    # if the wire connects to another wire,
+                    # that we have not seen, add it to the net
+                    if ploc in wire_index:
+                        net.extend(wire_index.pop(ploc))
+                    # if the wire connect to a device, add its port to netdevs
+                    if ploc in device_index:
+                        for p, dev in device_index[ploc]:
+                            netdevs.setdefault(dev['_id'], []).append(p)
+            elif cell == 'port':
+                netname = doc.get('name')
+            else:
+                raise ValueError(cell)
+        if netname == None:
+            netname = f"net{netnum}"
+            netnum += 1
+        for k, v in netdevs.items():
+            nl.setdefault(netname, {}).setdefault(k, []).extend(v)
+    inl = {}
+    for net, devs in nl.items():
+        for dev, pts in devs.items():
+            for port in pts:
+                inl.setdefault(dev, {})[port] = net
+    return inl
+
+
+def print_props(props):
+    prs = []
+    for k, v in props.items():
+        if k == "model":
+            prs.insert(0, v)
+        elif k == "spice":
+            prs.append(v)
+        else:
+            prs.append(f"{k}={v}")
+    return " ".join(prs)
+
+
+def circuit_spice(docs, models, declarations, corner, sim):
+    nl = netlist(docs, models)
+    cir = []
+    for id, ports in nl.items():
+        dev = docs[id]
+        cell = dev['cell']
+        mname = dev.get('props', {}).get('model', '')
+        name = dev.get('name') or id
+        # print(ports)
+        def p(p): return ports[p]
+        propstr = print_props(dev.get('props', {}))
+        if cell == "resistor":
+            ports = ' '.join(p(c) for c in ['P', 'N'])
+            templ = "R{name} {ports} {properties}"
+        elif cell == "capacitor":
+            ports = ' '.join(p(c) for c in ['P', 'N'])
+            templ = "C{name} {ports} {properties}"
+        elif cell == "inductor":
+            ports = ' '.join(p(c) for c in ['P', 'N'])
+            templ = "L{name} {ports} {properties}"
+        elif cell == "diode":
+            ports = ' '.join(p(c) for c in ['P', 'N'])
+            templ = "D{name} {ports} {properties}"
+        elif cell == "vsource":
+            ports = ' '.join(p(c) for c in ['P', 'N'])
+            templ = "V{name} {ports} {properties}"
+        elif cell == "isource":
+            ports = ' '.join(p(c) for c in ['P', 'N'])
+            templ = "I{name} {ports} {properties}"
+        elif cell in {"pmos", "nmos"}:
+            ports = ' '.join(p(c) for c in ['D', 'G', 'S', 'B'])
+            templ = "M{name} {ports} {properties}"
+        elif cell in {"npn", "pnp"}:
+            ports = ' '.join(p(c) for c in ['C', 'B', 'E'])
+            templ = "Q{name} {ports} {properties}"
+        else:  # subcircuit
+            m = models[f"models:{cell}"]
+            ports = ' '.join(p(c[2]) for c in m['conn'])
+            templ = "X{name} {ports} {properties}"
+
+        # a spice type model can overwrite its reference
+        # for example if the mosfet is really a subcircuit
+        try:
+            m = models[f"models:{cell}"]["models"][mname][sim]
+            templ = m['reftempl']
+            declarations.add(m['decltempl'].format(corner=corner))
+        except KeyError:
+            pass
+
+        cir.append(templ.format(name=name, ports=ports, properties=propstr))
+    return '\n'.join(cir)
+
+
+def spice_netlist(name, schem, extra="", corner='tt', temp=None, sim="NgSpice", **params):
+    """
+    Generate a spice netlist, taking a dictionary of schematic documents, and the name of the top level schematic.
+    It is possible to pass extra SPICE code and specify the simulation corner.
+    """
+    models = schem["models"]
+    declarations = set()
+    for subname, docs in schem.items():
+        if subname in {name, "models"}: continue
+        _id = SchemId.from_string(subname)
+        mod = models[f"models:{_id.cell}"]
+        ports = ' '.join(c[2] for c in mod['conn'])
+        body = circuit_spice(docs, models, declarations, corner, sim)
+        declarations.add(f".subckt {_id.model} {ports}\n{body}\n.ends {_id.model}") # parameters??
+
+    body = circuit_spice(schem[name], models, declarations, corner, sim)
+    ckt = []
+    ckt.append(f"* {name}")
+    ckt.extend(declarations)
+    ckt.append(body)
+    ckt.append(extra)
+    ckt.append(".end\n")
+
+    return "\n".join(ckt)
+
+default_device_vectors = {
+    'resistor': ['i'],
+    'capacitor': ['i'],
+    'inductor': ['i'],
+    'vsource': ['i'],
+    'isource': [],
+    'diode': [],
+    'nmos': ['gm', 'id', 'vdsat'],
+    'pmos': ['gm', 'id', 'vdsat'],
+    'npn': ['gm', 'ic', 'ib'],
+    'pnp': ['gm', 'ic', 'ib'],
+
+}
+device_prefix = {
+    'resistor': 'r',
+    'capacitor': 'c',
+    'inductor': 'l',
+    'vsource': 'v',
+    'isource': 'i',
+    'diode': 'd',
+    'nmos': 'm',
+    'pmos': 'm',
+    'npn': 'q',
+    'pnp': 'q',
+
+}
+# @m.xx1.xmc1.msky130_fd_pr__nfet_01v8[gm]
+def ngspice_vectors(name, schem, path=()):
+    """
+    Extract all the relevant vectors from the schematic,
+    and format them in NgSpice syntax.
+    Saves label/port net names, and vectors indicated on spice models.
+    """
+    models = schem["models"]
+    vectors = []
+    for id, elem in schem[name].items():
+        if elem['cell'] == 'port' and elem['name'].lower() != 'gnd':
+            vectors.append(('.'.join(path + (elem['name'],))).lower())
+            continue
+        m = models.get("models:"+elem['cell'], {})
+        n = m.get('models', {}).get(elem.get('props', {}).get('model'), {})
+        if n.get('type') == 'spice':
+            vex = n.get('NgSpice', {}).get('vectors', [])
+            comp = n.get('NgSpice', {}).get('component')
+            reftempl = n.get('NgSpice', {}).get('reftempl')
+            typ = (comp or reftempl or 'X')[0]
+            dtyp = (reftempl or 'X')[0]
+            if comp:
+                full = typ + '.' + '.'.join(path + (dtyp+elem['name'], comp))
+            elif path:
+                full = typ + '.' + '.'.join(path + (dtyp+elem['name'],))
+            else:
+                full = typ+elem['name']
+            vectors.extend(f"@{full}[{v}]".lower() for v in vex)
+        elif n.get('type') == 'schematic':
+            name = elem['cell']+"$"+elem['props']['model']
+            vectors.extend(ngspice_vectors(name, schem, path+("X"+elem['name'],)))
+        elif elem['cell'] in default_device_vectors: # no model specified
+            vex = default_device_vectors[elem['cell']]
+            typ = device_prefix.get(elem['cell'], 'x')
+            if path:
+                full = typ + '.' + '.'.join(path + (typ+elem['name'],))
+            else:
+                full = typ+elem['name']
+            vectors.extend(f"@{full}[{v}]".lower() for v in vex)
+    return vectors

nyancad-0.1.0/nyancad.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: nyancad
+Version: 0.1.0
+Summary: NyanCAD Python library for schematic editor with anywidget integration
+Author-email: Pepijn de Vos <me@pepijndevos.nl>
+License: MPL-2.0
+Project-URL: Homepage, https://github.com/NyanCAD/Mosaic
+Project-URL: Repository, https://github.com/NyanCAD/Mosaic
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: anywidget>=0.9.0
+Requires-Dist: traitlets
+
+# NyanCAD Python Library
+
+A Python library for the [NyanCAD schematic editor](https://github.com/NyanCAD/Mosaic) with anywidget integration. Provides live access to schematic data from marimo notebooks.
+
+## Installation
+
+```bash
+pip install nyancad
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+import marimo as mo
+from nyancad import SchematicBridge
+
+# Create a schematic bridge widget
+bridge = SchematicBridge()
+
+# Display the widget (shows connection status)
+bridge
+
+# Access live schematic data
+print(bridge.schematic_data)
+
+# Send simulation data back to the editor
+bridge.simulation_data = {
+    "results": [1.2, 3.4, 5.6],
+    "timestamp": "2024-01-01T00:00:00Z"
+}
+```
+
+### Integration with Marimo
+
+The SchematicBridge widget automatically connects to the NyanCAD editor running in the same marimo session. Any changes made in the schematic editor will be immediately reflected in the Python widget.
+
+```python
+# In a marimo cell
+bridge = SchematicBridge()
+bridge  # This will show the connection status
+
+# In another marimo cell - access the live data
+mo.md(f"""
+## Schematic Analysis
+Raw schematic data: {len(bridge.schematic_data)} items
+""")
+
+# View the actual schematic data structure
+bridge.schematic_data
+```
+
+## Features
+
+- **Live Sync**: Real-time synchronization with NyanCAD schematic editor via PouchDB
+- **Bidirectional Communication**: Send simulation data back to the editor from Python
+- **Zero Configuration**: Automatically detects and connects to the active schematic
+- **Raw Data Access**: Direct access to the complete schematic data structure
+- **Marimo Integration**: Seamless integration with marimo notebooks
+
+## API Reference
+
+### SchematicBridge
+
+The main widget class that provides bidirectional communication with the Mosaic editor.
+
+#### Properties
+
+- `schematic_data` (dict): Raw schematic data from the Mosaic editor, automatically synced
+- `simulation_data` (dict): Simulation data to send to the Mosaic editor. Setting this will store the data with a timestamp in the editor's database
+
+## Development
+
+This package is part of the [NyanCAD](https://github.com/NyanCAD/Mosaic) project. The anywidget integration uses a ClojureScript bridge that compiles to an ESM module, allowing seamless data sharing between the schematic editor and Python environment.
+
+## License
+
+This project is licensed under the Mozilla Public License 2.0 - see the [LICENSE](../../LICENSE) file for details.

nyancad-0.1.0/nyancad.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+nyancad/__init__.py
+nyancad/anywidget.py
+nyancad/netlist.py
+nyancad.egg-info/PKG-INFO
+nyancad.egg-info/SOURCES.txt
+nyancad.egg-info/dependency_links.txt
+nyancad.egg-info/requires.txt
+nyancad.egg-info/top_level.txt

nyancad-0.1.0/nyancad.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nyancad-0.1.0/nyancad.egg-info/requires.txt

@@ -0,0 +1,2 @@
+anywidget>=0.9.0
+traitlets

nyancad-0.1.0/nyancad.egg-info/top_level.txt

@@ -0,0 +1 @@
+nyancad

nyancad-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nyancad"
+version = "0.1.0"
+description = "NyanCAD Python library for schematic editor with anywidget integration"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MPL-2.0"}
+authors = [
+    {name = "Pepijn de Vos", email = "me@pepijndevos.nl"},
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "anywidget>=0.9.0",
+    "traitlets",
+]
+
+[project.urls]
+Homepage = "https://github.com/NyanCAD/Mosaic"
+Repository = "https://github.com/NyanCAD/Mosaic"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["nyancad*"]

nyancad-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+