marimo-dev 0.1.0__tar.gz → 0.1.2__tar.gz

marimo_dev-0.1.2/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.3
+Name: marimo-dev
+Version: 0.1.2
+Summary: Build and publish python packages from marimo notebooks
+Author: Deufel
+Author-email: Deufel <MDeufel13@gmail.com>
+License: MIT
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# marimo_dev
+
+A literate programming build system that converts Marimo notebooks into distributable Python packages. Inspired by nbdev.
+
+
+## What it does
+
+Looks in `/notebooks` dir for [self contained functions and classes](https://docs.marimo.io/guides/reusing_functions/) and extracts them into a PyPI ready directory. Each notebook will be striped of the leading `##_`, and `XX_` and `test` notebooks will be ignored. Run `md build` to generate a proper Python package with `__init__.py`, module files, and `llms.txt` API documentation.
+
+## What it does not
+
+An intentional effort to minimise magic project set up. You are responsible for setting up your pyproject.toml, and even `mkdir notebooks`. 
+  **Note:** *I highly reccommend that you use uv my main motivation for making this was the dependency harmony betwwen marimo and uv*
+
+
+
+## Project structure
+
+```
+my-project/
+├── README.md
+├── pyproject.toml
+├── notebooks/
+│   ├── 01_core.py
+│   ├── 02_read.py
+│   ├── ...
+├── src/                 # auto created
+│   └── my_package/
+│       ├── __init__.py 
+│       ├── core.py    
+│       ├── read.py
+│       └── ...
+├── docs/                # auto created
+│   ├── index.html       # Fut ver. 0.2
+│   └── llms.txt
+└── dist/                # auto created
+    └──...
+```
+
+## How it works
+
+The build system parses notebooks via AST, extracts decorated exports (`@app.function`, `@app.class_definition`), and writes clean module files. It reads metadata from `pyproject.toml` and generates `__init__.py` with proper imports and `__all__` exports.
+
+The `llms.txt` file contains function signatures with inline documentation extracted from comments, formatted for LLM consumption. This provides a compact API reference.
+  **Note:** *this will work much better with [fastcore.docments](https://fastcore.fast.ai/docments.html) style function definitions*
+
+## CLI usage
+
+```bash
+md build              # build package from notebooks/
+md publish            # publish to PyPI
+md publish --test     # publish to Test PyPI
+```
+
+## Requirements
+
+- Python 3.12+, Marimo, uv, pyproject.toml
+  - for relative imports to work in multi module libraries add the following to your pyproject.tml
+  - ``` [tool.marimo.runtime]
+   pythonpath = ["src"]  ```
+
+**Tip** *let marimo manages your `pyproject.toml` through its package tab, making dependencies visible and easy to update. When you add packages and remove them from the marimo package tab marimo will automaticly update your pyproject.toml*
+
+## Install
+
+```bash
+uv add marimo-dev
+```
+
+## Helpful
+```bash
+uv sync --upgrade` # to update uv.lock and pyroject.toml in one go...
+uv cache clean     # General Trouble Shooting Tip
+```
+- you need to manually update the version in pyproject.toml
+
+## Module structure
+
+- `core.py`  - Data model: `Kind`, `Param`, `Node`
+- `read.py`  - Parse notebooks, extract exports, scan project
+- `pkg.py`   - Write module files and `__init__.py`
+- `docs.py`  - Generate signatures and `llms.txt`
+- `build.py` - Orchestrate the build
+- `cli.py`   - Command-line interface

marimo_dev-0.1.2/README.md

@@ -0,0 +1,84 @@
+# marimo_dev
+
+A literate programming build system that converts Marimo notebooks into distributable Python packages. Inspired by nbdev.
+
+
+## What it does
+
+Looks in `/notebooks` dir for [self contained functions and classes](https://docs.marimo.io/guides/reusing_functions/) and extracts them into a PyPI ready directory. Each notebook will be striped of the leading `##_`, and `XX_` and `test` notebooks will be ignored. Run `md build` to generate a proper Python package with `__init__.py`, module files, and `llms.txt` API documentation.
+
+## What it does not
+
+An intentional effort to minimise magic project set up. You are responsible for setting up your pyproject.toml, and even `mkdir notebooks`. 
+  **Note:** *I highly reccommend that you use uv my main motivation for making this was the dependency harmony betwwen marimo and uv*
+
+
+
+## Project structure
+
+```
+my-project/
+├── README.md
+├── pyproject.toml
+├── notebooks/
+│   ├── 01_core.py
+│   ├── 02_read.py
+│   ├── ...
+├── src/                 # auto created
+│   └── my_package/
+│       ├── __init__.py 
+│       ├── core.py    
+│       ├── read.py
+│       └── ...
+├── docs/                # auto created
+│   ├── index.html       # Fut ver. 0.2
+│   └── llms.txt
+└── dist/                # auto created
+    └──...
+```
+
+## How it works
+
+The build system parses notebooks via AST, extracts decorated exports (`@app.function`, `@app.class_definition`), and writes clean module files. It reads metadata from `pyproject.toml` and generates `__init__.py` with proper imports and `__all__` exports.
+
+The `llms.txt` file contains function signatures with inline documentation extracted from comments, formatted for LLM consumption. This provides a compact API reference.
+  **Note:** *this will work much better with [fastcore.docments](https://fastcore.fast.ai/docments.html) style function definitions*
+
+## CLI usage
+
+```bash
+md build              # build package from notebooks/
+md publish            # publish to PyPI
+md publish --test     # publish to Test PyPI
+```
+
+## Requirements
+
+- Python 3.12+, Marimo, uv, pyproject.toml
+  - for relative imports to work in multi module libraries add the following to your pyproject.tml
+  - ``` [tool.marimo.runtime]
+   pythonpath = ["src"]  ```
+
+**Tip** *let marimo manages your `pyproject.toml` through its package tab, making dependencies visible and easy to update. When you add packages and remove them from the marimo package tab marimo will automaticly update your pyproject.toml*
+
+## Install
+
+```bash
+uv add marimo-dev
+```
+
+## Helpful
+```bash
+uv sync --upgrade` # to update uv.lock and pyroject.toml in one go...
+uv cache clean     # General Trouble Shooting Tip
+```
+- you need to manually update the version in pyproject.toml
+
+## Module structure
+
+- `core.py`  - Data model: `Kind`, `Param`, `Node`
+- `read.py`  - Parse notebooks, extract exports, scan project
+- `pkg.py`   - Write module files and `__init__.py`
+- `docs.py`  - Generate signatures and `llms.txt`
+- `build.py` - Orchestrate the build
+- `cli.py`   - Command-line interface

{marimo_dev-0.1.0 → marimo_dev-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "marimo-dev"
-version = "0.1.0"
+version = "0.1.2"
 description = "Build and publish python packages from marimo notebooks"
 readme = "README.md"
 requires-python = ">=3.12"

{marimo_dev-0.1.0 → marimo_dev-0.1.2}/src/marimo_dev/__init__.py

@@ -1,24 +1,26 @@
 """Build and publish python packages from marimo notebooks"""
-__version__ = '0.1.0'
+__version__ = '0.1.2'
 __author__ = 'Deufel'
 from .core import Kind, Param, Node
 from .read import inline_doc, parse_params, parse_class_params, parse_ret, src_with_decs, is_export, parse_import, parse_const, parse_export, parse_node, parse_file, read_meta, nb_name, scan
 from .pkg import clean, write, write_mod, write_init
 from .docs import cls_sig, fn_sig, sig, write_llms
-from .build import publish
-from .cli import init, main
+from .build import build, tidy, nuke
+from .cli import main
+from .publish import publish
 __all__ = [
     "Kind",
     "Node",
     "Param",
+    "build",
     "clean",
     "cls_sig",
     "fn_sig",
-    "init",
     "inline_doc",
     "is_export",
     "main",
     "nb_name",
+    "nuke",
     "parse_class_params",
     "parse_const",
     "parse_export",
@@ -32,6 +34,7 @@ __all__ = [
     "scan",
     "sig",
     "src_with_decs",
+    "tidy",
     "write",
     "write_init",
     "write_llms",

marimo_dev-0.1.2/src/marimo_dev/build.py

@@ -0,0 +1,40 @@
+from marimo_dev.core import Kind, Param, Node
+from marimo_dev.read import scan
+from marimo_dev.pkg import write_mod, write_init
+from marimo_dev.docs import write_llms
+from pathlib import Path
+import ast, shutil
+
+def build(
+    nbs='notebooks', # directory containing notebook files
+    out='src',       # output directory for built package
+    root='.',        # root directory containing pyproject.toml
+    rebuild=True,    # remove existing package directory before building
+)->str:              # path to built package
+    "Build a Python package from notebooks."
+    meta, mods = scan(nbs, root)
+    pkg = Path(out) / meta['name'].replace('-', '_')
+    if rebuild and pkg.exists(): shutil.rmtree(pkg)
+    pkg.mkdir(parents=True, exist_ok=True)
+    for name, nodes in mods:
+        if name != 'index' and any(n.kind == Kind.EXP for n in nodes): write_mod(pkg/f'{name}.py', nodes)
+    write_init(pkg/'__init__.py', meta, mods)
+    all_exp = [n for _, nodes in mods for n in nodes if n.kind == Kind.EXP]
+    if all_exp: write_llms(meta, all_exp)
+    return str(pkg)
+
+def tidy():
+    "Remove cache and temporary files (__pycache__, __marimo__, .pytest_cache, etc)."
+    import shutil
+    for p in Path('.').rglob('__pycache__'): shutil.rmtree(p, ignore_errors=True)
+    for p in Path('.').rglob('__marimo__'): shutil.rmtree(p, ignore_errors=True)
+    for p in Path('.').rglob('.pytest_cache'): shutil.rmtree(p, ignore_errors=True)
+    for p in Path('.').rglob('*.pyc'): p.unlink(missing_ok=True)
+    print("Cleaned cache files")
+
+def nuke():
+    "Remove all build artifacts (dist, docs, src) and cache files."
+    import shutil
+    tidy()
+    for d in ['dist', 'docs', 'src']: shutil.rmtree(d, ignore_errors=True)
+    print("Nuked build artifacts")

marimo_dev-0.1.2/src/marimo_dev/cli.py

@@ -0,0 +1,18 @@
+from marimo_dev.build import build, clean, nuke
+from marimo_dev.publish import publish
+import sys, subprocess
+from pathlib import Path
+
+def main():
+    if len(sys.argv) < 2: print("Usage: md [build|publish|clean|nuke]"); sys.exit(1)
+    cmd = sys.argv[1]
+    if cmd == 'build':
+        from m_dev.build import build
+        print(f"Built package at: {build()}")
+    elif cmd == 'publish':
+        test = '--test' in sys.argv or '-t' in sys.argv
+        from m_dev.publish import publish
+        publish(test=test)
+    elif cmd == 'clean': clean()
+    elif cmd == 'nuke': nuke()
+    else: print(f"Unknown command: {cmd}"); sys.exit(1)

{marimo_dev-0.1.0 → marimo_dev-0.1.2}/src/marimo_dev/docs.py

@@ -1,4 +1,4 @@
-from m_dev.core import Kind, Param, Node
+from marimo_dev.core import Kind, Param, Node
 from pathlib import Path
 import ast
 

{marimo_dev-0.1.0 → marimo_dev-0.1.2}/src/marimo_dev/pkg.py

@@ -1,4 +1,4 @@
-from m_dev.core import Kind, Param, Node
+from marimo_dev.core import Kind, Param, Node
 from pathlib import Path
 import ast
 

marimo_dev-0.1.0/src/marimo_dev/build.py → marimo_dev-0.1.2/src/marimo_dev/publish.py

@@ -1,19 +1,17 @@
-from m_dev.core import Kind, Param, Node
-from m_dev.read import scan
-from m_dev.pkg import write_mod, write_init
-from m_dev.docs import write_llms
+import subprocess, configparser, shutil
 from pathlib import Path
-import ast
+from marimo_dev.build import build
 
 def publish(
     test:bool=True, # Use Test PyPI if True, real PyPI if False
 ):
     "Build and publish package to PyPI. Looks for ~/.pypirc for credentials, otherwise prompts."
-    import subprocess, configparser, shutil
-    from pathlib import Path
+
+    print("Rebuilding package from notebooks...")
+    build(rebuild=True)
 
     shutil.rmtree('dist', ignore_errors=True)
-    print("Building package...")
+    print("Building distribution...")
     subprocess.run(['uv', 'build'], check=True)
 
     pypirc, cmd = Path.home() / '.pypirc', ['uv', 'publish']

{marimo_dev-0.1.0 → marimo_dev-0.1.2}/src/marimo_dev/read.py

@@ -1,4 +1,4 @@
-from m_dev.core import Kind, Param, Node
+from marimo_dev.core import Kind, Param, Node
 from pathlib import Path
 import ast, re, tomllib
 

marimo_dev-0.1.0/PKG-INFO

@@ -1,74 +0,0 @@
-Metadata-Version: 2.3
-Name: marimo-dev
-Version: 0.1.0
-Summary: Build and publish python packages from marimo notebooks
-Author: Deufel
-Author-email: Deufel <MDeufel13@gmail.com>
-License: MIT
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-
-# m_dev
-
-A literate programming build system that converts Marimo notebooks into distributable Python packages.
-
-## What it does
-
-Write code in numbered notebook files in a `notebooks/` directory. Mark functions and classes for export by making them purely functional with references from the setup cell—Marimo detects these automatically. Run `md build` to generate a proper Python package with `__init__.py`, module files, and `llms.txt` API documentation.
-
-## Project structure
-
-```
-my-project/
-├── pyproject.toml
-├── notebooks/
-│   ├── 00_core.py
-│   ├── 01_read.py
-│   ├── 02_pkg.py
-│   ├── 03_docs.py
-│   └── 04_build.py
-└── src/
-    └── my_package/
-        ├── __init__.py
-        ├── core.py
-        ├── read.py
-        └── ...
-```
-
-## How it works
-
-The build system parses notebooks via AST, extracts decorated exports (`@app.function`, `@app.class_definition`), and writes clean module files. It reads metadata from `pyproject.toml` and generates `__init__.py` with proper imports and `__all__` exports.
-
-The `llms.txt` file contains function signatures with inline documentation extracted from comments, formatted for LLM consumption. This provides a compact API reference.
-
-## CLI usage
-
-```bash
-md build              # build package from notebooks/
-md publish            # publish to PyPI
-md publish --test     # publish to Test PyPI
-```
-
-## Requirements
-
-- Python 3.10+
-- Marimo for notebook management
-- uv for dependency management
-- pyproject.toml with project metadata
-
-Marimo manages your `pyproject.toml` through its package tab, making dependencies visible and easy to update.
-
-## Install
-
-```bash
-uv add m-dev --index testpypi=https://test.pypi.org/simple --index pypi=https://pypi.org/simple --index-strategy unsafe-best-match
-```
-
-## Module structure
-
-- `core.py` - Data model: `Kind`, `Param`, `Node`
-- `read.py` - Parse notebooks, extract exports, scan project
-- `pkg.py` - Write module files and `__init__.py`
-- `docs.py` - Generate signatures and `llms.txt`
-- `build.py` - Orchestrate the build
-- `cli.py` - Command-line interface

marimo_dev-0.1.0/README.md

@@ -1,64 +0,0 @@
-# m_dev
-
-A literate programming build system that converts Marimo notebooks into distributable Python packages.
-
-## What it does
-
-Write code in numbered notebook files in a `notebooks/` directory. Mark functions and classes for export by making them purely functional with references from the setup cell—Marimo detects these automatically. Run `md build` to generate a proper Python package with `__init__.py`, module files, and `llms.txt` API documentation.
-
-## Project structure
-
-```
-my-project/
-├── pyproject.toml
-├── notebooks/
-│   ├── 00_core.py
-│   ├── 01_read.py
-│   ├── 02_pkg.py
-│   ├── 03_docs.py
-│   └── 04_build.py
-└── src/
-    └── my_package/
-        ├── __init__.py
-        ├── core.py
-        ├── read.py
-        └── ...
-```
-
-## How it works
-
-The build system parses notebooks via AST, extracts decorated exports (`@app.function`, `@app.class_definition`), and writes clean module files. It reads metadata from `pyproject.toml` and generates `__init__.py` with proper imports and `__all__` exports.
-
-The `llms.txt` file contains function signatures with inline documentation extracted from comments, formatted for LLM consumption. This provides a compact API reference.
-
-## CLI usage
-
-```bash
-md build              # build package from notebooks/
-md publish            # publish to PyPI
-md publish --test     # publish to Test PyPI
-```
-
-## Requirements
-
-- Python 3.10+
-- Marimo for notebook management
-- uv for dependency management
-- pyproject.toml with project metadata
-
-Marimo manages your `pyproject.toml` through its package tab, making dependencies visible and easy to update.
-
-## Install
-
-```bash
-uv add m-dev --index testpypi=https://test.pypi.org/simple --index pypi=https://pypi.org/simple --index-strategy unsafe-best-match
-```
-
-## Module structure
-
-- `core.py` - Data model: `Kind`, `Param`, `Node`
-- `read.py` - Parse notebooks, extract exports, scan project
-- `pkg.py` - Write module files and `__init__.py`
-- `docs.py` - Generate signatures and `llms.txt`
-- `build.py` - Orchestrate the build
-- `cli.py` - Command-line interface

marimo_dev-0.1.0/src/marimo_dev/cli.py

@@ -1,36 +0,0 @@
-from m_dev.build import build
-import sys, subprocess
-from pathlib import Path
-
-def init(
-    name:str=None, # project name (defaults to current directory name)
-):
-    "Initialize a new m-dev project with notebooks dir and pyproject.toml."
-    cmd = ['uv', 'init', '--bare', '--no-readme', '--no-pin-python', '--vcs', 'none']
-    if name: cmd.append(name)
-    subprocess.run(cmd, check=True)
-    Path('notebooks').mkdir(exist_ok=True)
-    p = Path('pyproject.toml')
-    content = p.read_text()
-    additions = '''
-[tool.marimo.runtime]
-pythonpath = ["src"]
-
-[build-system]
-requires = ["uv_build>=0.9.15,<0.10.0"]
-build-backend = "uv_build"
-'''
-    if '[build-system]' not in content: p.write_text(content.rstrip() + '\n' + additions)
-
-def main():
-    if len(sys.argv) < 2: print("Usage: md [init|build|publish]"); sys.exit(1)
-    cmd = sys.argv[1]
-    if cmd == 'init': init(sys.argv[2] if len(sys.argv) > 2 else None)
-    elif cmd == 'build':
-        from m_dev.build import build
-        print(f"Built package at: {build()}")
-    elif cmd == 'publish':
-        test = '--test' in sys.argv or '-t' in sys.argv
-        from m_dev.publish import publish
-        publish(test=test)
-    else: print(f"Unknown command: {cmd}"); sys.exit(1)