nbsync 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

nbsync/cell.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import textwrap
+import uuid
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from nbsync.markdown import is_truelike
+
+from .logger import logger
+
+if TYPE_CHECKING:
+    from nbstore.markdown import Image
+
+
+@dataclass
+class Cell:
+    image: Image
+    """The image instance from the Markdown file."""
+
+    language: str
+    """The language of the source to be used to generate the image."""
+
+    mime: str
+    """The MIME type of the image."""
+
+    content: bytes | str
+    """The content of the image."""
+
+    def convert(self) -> str:
+        kind = self.image.attributes.pop("source", "")
+        tabs = self.image.attributes.pop("tabs", "")
+
+        if "/" not in self.mime or not self.content or kind == "source-only":
+            if self.image.source:
+                source = get_source(self, include_attrs=True)
+                kind = "only"
+            else:
+                source = ""
+            result, self.image.url = "", ""
+
+        elif self.mime.startswith("text/") and isinstance(self.content, str):
+            source = get_source(self, include_attrs=True)
+            result, self.image.url = self.content, ""
+            result = result.rstrip()
+
+        else:
+            source = get_source(self, include_attrs=False)
+            result = get_result(self)
+
+        if markdown := get_markdown(kind, source, result, tabs):
+            return textwrap.indent(markdown, self.image.indent)
+
+        return ""  # no cov
+
+
+def get_source(cell: Cell, *, include_attrs: bool = False) -> str:
+    attrs = [cell.language]
+    if include_attrs:
+        attrs.extend(cell.image.iter_parts())
+    attr = " ".join(attrs)
+    return f"```{attr}\n{cell.image.source}\n```"
+
+
+def get_result(cell: Cell) -> str:
+    msg = f"{cell.image.url}#{cell.image.identifier} [{cell.mime}]"
+    logger.debug(f"Converting image: {msg}")
+
+    ext = cell.mime.split("/")[1].split("+")[0]
+    cell.image.url = f"{uuid.uuid4()}.{ext}"
+
+    attr = " ".join(cell.image.iter_parts(include_identifier=True))
+    return f"![{cell.image.alt}]({cell.image.url}){{{attr}}}"
+
+
+def get_markdown(kind: str, source: str, result: str, tabs: str) -> str:
+    if all(not x for x in (kind, source, result)):
+        return ""
+
+    if not kind or not source:
+        return result
+
+    if kind == "only":
+        return source
+
+    if is_truelike(kind) or kind == "above":
+        return f"{source}\n\n{result}"
+
+    if kind == "below":
+        return f"{result}\n\n{source}"
+
+    if kind == "material-block":
+        result = f'<div class="result" markdown="1">{result}</div>'
+        return f"{source}\n\n{result}"
+
+    if kind == "tabbed-left":
+        tabs = tabs if "|" in tabs else "Source|Result"
+        return get_tabbed(source, result, tabs)
+
+    if kind == "tabbed-right":
+        tabs = tabs if "|" in tabs else "Result|Source"
+        return get_tabbed(result, source, tabs)
+
+    return result
+
+
+def get_tabbed(left: str, right: str, tabs: str) -> str:
+    left_title, right_title = tabs.split("|", 1)
+    left = textwrap.indent(left, "    ")
+    left = f'===! "{left_title}"\n\n{left}'
+    right = textwrap.indent(right, "    ")
+    right = f'=== "{right_title}"\n\n{right}'
+    return f"{left}\n\n{right}\n"

nbsync/logger.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from mkdocs.plugins import get_plugin_logger
+
+logger = get_plugin_logger("nbsync")

nbsync/markdown.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import textwrap
+from typing import TYPE_CHECKING, TypeAlias
+
+import nbstore.markdown
+from nbstore.markdown import CodeBlock, Image
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Iterator
+
+Element: TypeAlias = str | CodeBlock | Image
+
+
+def convert_image(image: Image, index: int | None = None) -> Iterator[Element]:
+    if image.source:
+        if not image.identifier and index is None:
+            msg = "index is required when source is present and identifier is not set"
+            raise ValueError(msg)
+
+        image.identifier = image.identifier or f"image-nbsync-{index}"
+        yield CodeBlock("", image.identifier, [], {}, image.source, image.url)
+        yield image
+
+    elif image.identifier:
+        yield image
+
+    else:
+        yield image.text
+
+
+def convert_code_block(code_block: CodeBlock) -> Iterator[Element]:
+    source = code_block.attributes.get("source", None)
+    if source == "tabbed-nbsync":
+        yield from _convert_code_block_tabbed(code_block)
+    else:
+        yield code_block
+
+
+def _convert_code_block_tabbed(code_block: CodeBlock) -> Iterator[Element]:
+    markdown = code_block.text.replace('source="tabbed-nbsync"', "")
+    markdown = textwrap.indent(markdown, "    ")
+    yield f'===! "Markdown"\n\n{markdown}\n\n'
+
+    text = textwrap.indent(code_block.source, "    ")
+    text = f'=== "Rendered"\n\n{text}'
+    yield from nbstore.markdown.parse(text)
+
+
+SUPPORTED_EXTENSIONS = (".ipynb", ".md", ".py")
+
+
+def set_url(elem: Image | CodeBlock, url: str) -> tuple[Element, str]:
+    """Set the URL of the image or code block.
+
+    If the URL is empty or ".", set the URL to the current URL.
+    """
+    if elem.url in ["", "."] and url:
+        elem.url = url
+        return elem, url
+
+    if elem.url.endswith(SUPPORTED_EXTENSIONS):
+        return elem, elem.url
+
+    return elem.text, url
+
+
+def resolve_urls(elems: Iterable[Element]) -> Iterator[Element]:
+    """Parse the URL of the image or code block.
+
+    If a code block has no URL, yield the text of the code block,
+    which means that the code block is not processed further.
+    """
+    url = ""
+
+    for elem in elems:
+        if isinstance(elem, CodeBlock) and not elem.url:
+            yield elem.text
+
+        elif isinstance(elem, Image | CodeBlock):
+            elem_, url = set_url(elem, url)
+            yield elem_
+
+        else:
+            yield elem
+
+
+def convert_code_blocks(elems: Iterable[Element]) -> Iterator[Element]:
+    for elem in elems:
+        if isinstance(elem, CodeBlock):
+            yield from convert_code_block(elem)
+        else:
+            yield elem
+
+
+def convert_images(elems: Iterable[Element]) -> Iterator[Element]:
+    for index, elem in enumerate(elems):
+        if isinstance(elem, Image):
+            yield from convert_image(elem, index)
+        else:
+            yield elem
+
+
+def parse(text: str) -> Iterator[Element]:
+    elems = nbstore.markdown.parse(text)
+    elems = convert_code_blocks(elems)
+    elems = resolve_urls(elems)
+    yield from convert_images(elems)
+
+
+def is_truelike(value: str | None) -> bool:
+    return value is not None and value.lower() in ("yes", "true", "1", "on")

nbsync/notebook.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import copy
+from typing import TYPE_CHECKING
+
+import nbstore.notebook
+
+if TYPE_CHECKING:
+    from nbformat import NotebookNode
+
+
+class Notebook:
+    nb: NotebookNode
+    is_modified: bool
+    execution_needed: bool
+
+    def __init__(self, nb: NotebookNode) -> None:
+        self.nb = nb
+        self.is_modified = False
+        self.execution_needed = False
+
+    def set_execution_needed(self) -> None:
+        self.execution_needed = True
+
+    def add_cell(self, identifier: str, source: str) -> None:
+        if not self.is_modified:
+            self.nb = copy.deepcopy(self.nb)
+            self.is_modified = True
+
+        cell = nbstore.notebook.new_code_cell(identifier, source)
+        self.nb.cells.append(cell)
+        self.set_execution_needed()
+
+    def equals(self, other: Notebook) -> bool:
+        return nbstore.notebook.equals(self.nb, other.nb)
+
+    def execute(self) -> None:
+        nbstore.notebook.execute(self.nb)
+        self.execution_needed = False

nbsync/plugin.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+from mkdocs.config import Config as BaseConfig
+from mkdocs.config import config_options
+from mkdocs.plugins import BasePlugin
+from mkdocs.structure.files import File
+from nbstore.store import Store
+
+from .logger import logger
+from .sync import Synchronizer
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from mkdocs.config.defaults import MkDocsConfig
+    from mkdocs.structure.files import Files
+    from mkdocs.structure.pages import Page
+
+    from .cell import Cell
+
+
+class Config(BaseConfig):
+    """Configuration for Nbstore plugin."""
+
+    src_dir = config_options.Type((str, list), default=".")
+
+
+class Plugin(BasePlugin[Config]):
+    store: ClassVar[Store | None] = None
+    syncs: ClassVar[dict[str, Synchronizer]] = {}
+    files: Files
+
+    def on_config(self, config: MkDocsConfig, **kwargs: Any) -> MkDocsConfig:
+        if isinstance(self.config.src_dir, str):
+            src_dirs = [self.config.src_dir]
+        else:
+            src_dirs = self.config.src_dir
+
+        src_dirs = [(Path(config.docs_dir) / s).resolve() for s in src_dirs]
+
+        store = self.__class__.store
+
+        if store is None or store.src_dirs != src_dirs:
+            self.__class__.store = Store(src_dirs)
+            config.watch.extend(x.as_posix() for x in src_dirs)
+
+        for name in ["attr_list", "md_in_html"]:
+            if name not in config.markdown_extensions:
+                config.markdown_extensions.append(name)
+
+        return config
+
+    def on_files(self, files: Files, config: MkDocsConfig, **kwargs: Any) -> Files:
+        self.files = files
+        return files
+
+    def on_page_markdown(
+        self,
+        markdown: str,
+        page: Page,
+        config: MkDocsConfig,
+        **kwargs: Any,
+    ) -> str:
+        if self.__class__.store is None:
+            msg = "Store must be initialized before processing markdown"
+            logger.error(msg)
+            return markdown
+
+        src_uri = page.file.src_uri
+        syncs = self.__class__.syncs
+
+        if src_uri not in syncs:
+            syncs[src_uri] = Synchronizer(self.__class__.store)
+
+        markdowns = []
+
+        for elem in syncs[src_uri].convert(markdown):
+            if isinstance(elem, str):
+                markdowns.append(elem)
+
+            elif markdown := elem.convert():
+                markdowns.append(markdown)
+
+                if elem.image.url and elem.content:
+                    file = generate_file(elem, src_uri, config)
+                    self.files.append(file)
+
+        return "".join(markdowns)
+
+
+def generate_file(cell: Cell, page_uri: str, config: MkDocsConfig) -> File:
+    src_uri = (Path(page_uri).parent / cell.image.url).as_posix()
+    return File.generated(config, src_uri, content=cell.content)

nbsync/sync.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import re
+import textwrap
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+import nbformat
+from nbstore.markdown import CodeBlock, Image
+from nbstore.notebook import get_language, get_mime_content, get_source
+
+import nbsync.markdown
+from nbsync.cell import Cell
+from nbsync.markdown import is_truelike
+from nbsync.notebook import Notebook
+
+from .logger import logger
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from nbformat import NotebookNode
+    from nbstore import Store
+
+
+@dataclass
+class Synchronizer:
+    store: Store
+    notebooks: dict[str, Notebook] = field(default_factory=dict, init=False)
+
+    def parse(self, text: str) -> Iterator[str | Image | CodeBlock]:
+        notebooks: dict[str, Notebook] = {}
+
+        for elem in nbsync.markdown.parse(text):
+            yield elem
+
+            if isinstance(elem, Image | CodeBlock):
+                update_notebooks(notebooks, elem, self.store)
+
+        for url, notebook in notebooks.items():
+            if url not in self.notebooks or not self.notebooks[url].equals(notebook):
+                self.notebooks[url] = notebook
+
+    def execute(self) -> None:
+        for url, notebook in self.notebooks.items():
+            if not notebook.execution_needed:
+                continue
+
+            path = ".md" if url == ".md" else self.store.find_path(url)
+            logger.info(f"Executing notebook: {path}")
+            notebook.execute()
+
+    def convert(self, text: str) -> Iterator[str | Cell]:
+        elems = list(self.parse(text))
+        self.execute()
+
+        for elem in elems:
+            if isinstance(elem, str):
+                yield elem
+
+            elif elem.identifier not in [".", "_"]:
+                if isinstance(elem, Image):
+                    nb = self.notebooks[elem.url].nb
+                    yield convert_image(elem, nb)
+                else:
+                    yield convert_code_block(elem)
+
+
+def update_notebooks(
+    notebooks: dict[str, Notebook],
+    elem: Image | CodeBlock,
+    store: Store,
+) -> None:
+    url = elem.url
+
+    if url not in notebooks:
+        if url == ".md":
+            notebooks[url] = Notebook(nbformat.v4.new_notebook())
+        else:
+            try:
+                notebooks[url] = Notebook(store.read(url))
+            except Exception:  # noqa: BLE001
+                logger.warning(f"Error reading notebook: {url}")
+                return
+
+    notebook = notebooks[url]
+
+    if is_truelike(elem.attributes.pop("exec", None)):
+        notebook.set_execution_needed()
+
+    if isinstance(elem, CodeBlock):
+        source = textwrap.dedent(elem.source)
+        notebook.add_cell(elem.identifier, source)
+
+
+def convert_image(image: Image, nb: NotebookNode) -> Cell:
+    try:
+        image.source = get_source(nb, image.identifier)
+        mime_content = get_mime_content(nb, image.identifier)
+    except ValueError:
+        cell = f"{image.url}#{image.identifier}"
+        logger.warning(f"Error reading cell: {cell!r}")
+        image.source = ""
+        mime_content = ("", "")
+
+    return Cell(image, get_language(nb), *mime_content)
+
+
+def convert_code_block(code_block: CodeBlock) -> str:
+    source = code_block.attributes.pop("source", None)
+    if not is_truelike(source):
+        return ""
+
+    lines = code_block.text.splitlines()
+    if lines:
+        pattern = f"\\S+#{code_block.identifier}"
+        lines[0] = re.sub(pattern, "", lines[0])
+        pattern = r"source=[^\s}]+"
+        lines[0] = re.sub(pattern, "", lines[0])
+
+    return "\n".join(lines)

nbsync-0.1.0.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: nbsync
+Version: 0.1.0
+Summary: MkDocs plugin treating Jupyter notebooks, Python scripts and Markdown files as first-class citizens for documentation with dynamic execution and real-time synchronization
+Project-URL: Documentation, https://daizutabi.github.io/nbsync/
+Project-URL: Source, https://github.com/daizutabi/nbsync
+Project-URL: Issues, https://github.com/daizutabi/nbsync/issues
+Author-email: daizutabi <daizutabi@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Daizu
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: documentation,dynamic-execution,jupyter,markdown,mkdocs,notebook,python,real-time-sync,visualization
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Documentation
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.10
+Requires-Dist: mkdocs>=1.6
+Requires-Dist: nbstore>=0.4.7
+Description-Content-Type: text/markdown
+
+# nbsync
+
+[![PyPI Version][pypi-v-image]][pypi-v-link]
+[![Python Version][python-v-image]][python-v-link]
+[![Build Status][GHAction-image]][GHAction-link]
+[![Coverage Status][codecov-image]][codecov-link]
+
+<strong>Connect Jupyter notebooks to your MkDocs documentation</strong>
+
+nbsync is a MkDocs plugin that seamlessly embeds Jupyter notebook
+visualizations in your documentation, solving the disconnect between
+code development and documentation.
+
+## Why Use nbsync?
+
+### The Documentation Challenge
+
+Data scientists, researchers, and technical writers face a common dilemma:
+
+- **Development happens in notebooks** - ideal for experimentation and visualization
+- **Documentation lives in markdown** - perfect for narrative and explanation
+- **Connecting the two is painful** - screenshots break, exports get outdated
+
+### Our Solution
+
+This plugin creates a live bridge between your notebooks and documentation by:
+
+- **Keeping environments separate** - work in the tool best suited for each task
+- **Maintaining connections** - reference specific figures from notebooks
+- **Automating updates** - changes to notebooks reflect in documentation
+
+## Key Benefits
+
+- **True Separation of Concerns**:
+  Develop visualizations in Jupyter notebooks and write documentation
+  in markdown files, with each tool optimized for its purpose.
+
+- **Intuitive Markdown Syntax**:
+  Use standard image syntax with a simple extension to reference
+  notebook figures: `![alt text](notebook.ipynb){#figure-id}`
+
+- **Automatic Updates**:
+  When you modify your notebooks, your documentation updates
+  automatically in MkDocs serve mode.
+
+- **Clean Source Documents**:
+  Your markdown remains readable and focused on content, without
+  code distractions or complex embedding techniques.
+
+- **Enhanced Development Experience**:
+  Take advantage of IDE features like code completion and syntax
+  highlighting in the appropriate environment.
+
+## Quick Start
+
+### 1. Installation
+
+```bash
+pip install nbsync
+```
+
+### 2. Configuration
+
+Add to your `mkdocs.yml`:
+
+```yaml
+plugins:
+  - nbsync:
+      src_dir: ../notebooks
+```
+
+### 3. Mark Figures in Your Notebook
+
+In your Jupyter notebook, identify figures with a comment:
+
+```python
+# #my-figure
+import matplotlib.pyplot as plt
+
+fig, ax = plt.subplots(figsize=(8, 4))
+ax.plot([1, 2, 3, 4], [10, 20, 25, 30])
+```
+
+### 4. Reference in Markdown
+
+Use standard Markdown image syntax with the figure identifier:
+
+```markdown
+![Chart description](my-notebook.ipynb){#my-figure}
+```
+
+## Advanced Usage
+
+For more detailed information on how to use nbsync, see:
+
+- [Notebook Configuration](usage/notebook.md) - Setting up notebook directories
+- [Class Options](usage/class.md) - Control how notebook content is displayed
+<!-- - [Workflow Tips](usage/workflow.md) - Best practices for documentation -->
+
+## The Power of Separation
+
+Creating documentation and developing visualizations involve different
+workflows and timeframes. When building visualizations in Jupyter notebooks,
+you need rapid cycles of execution, verification, and modification.
+
+This plugin is designed specifically to address these separation of
+concerns, allowing you to:
+
+- **Focus on code** in notebooks without documentation distractions
+- **Focus on narrative** in markdown without code interruptions
+- **Maintain powerful connections** between both environments
+
+Each environment is optimized for its purpose, while the plugin
+handles the integration automatically.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License.
+
+<!-- Badges -->
+[pypi-v-image]: https://img.shields.io/pypi/v/nbsync.svg
+[pypi-v-link]: https://pypi.org/project/nbsync/
+[python-v-image]: https://img.shields.io/pypi/pyversions/nbsync.svg
+[python-v-link]: https://pypi.org/project/nbsync
+[GHAction-image]: https://github.com/daizutabi/nbsync/actions/workflows/ci.yaml/badge.svg?branch=main&event=push
+[GHAction-link]: https://github.com/daizutabi/nbsync/actions?query=event%3Apush+branch%3Amain
+[codecov-image]: https://codecov.io/github/daizutabi/nbsync/coverage.svg?branch=main
+[codecov-link]: https://codecov.io/github/daizutabi/nbsync?branch=main

nbsync-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+nbsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nbsync/cell.py,sha256=HjGV7WHYwoW-X8AK9EePcjHz2wHl0rVaEAS_hdI8QNw,3248
+nbsync/logger.py,sha256=tQK8Z8HdWQNhVohQYLwZtJhdaj2w0UTyhHQak3mPqNc,119
+nbsync/markdown.py,sha256=sGNPuyLTfQFv-I1m6jK6uDKFRHAPYY6hpy4P1bJjmkE,3185
+nbsync/notebook.py,sha256=Voh-e8RQsoYmWKnaHzAn4bm6Ud5v-aHwmng2Uc0rUts,1009
+nbsync/plugin.py,sha256=YywBAD7fcrPg3-_9T_kSuvD8RBzsc_ovlIviGlKR9po,2835
+nbsync/sync.py,sha256=RTF6h0izF1emc1CpG6atEgAQHC7mZCit9NkXK26sOA8,3575
+nbsync-0.1.0.dist-info/METADATA,sha256=t97_Xq3uoqCGveX9XblM-zTwyHA7npBBK32PdhN_e9Y,6604
+nbsync-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nbsync-0.1.0.dist-info/entry_points.txt,sha256=bSqmJTDmrUoSm4yDjk8YDWxI71SShx16judadGdiKbA,47
+nbsync-0.1.0.dist-info/licenses/LICENSE,sha256=wy1pqn52upuo_qYwY-epWmspwE-3UWJso0xodciGXYc,1062
+nbsync-0.1.0.dist-info/RECORD,,

nbsync-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[mkdocs.plugins]
+nbsync = nbsync.plugin:Plugin

nbsync-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Daizu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nbsync-0.0.1.dist-info/METADATA

@@ -1,29 +0,0 @@
-Metadata-Version: 2.4
-Name: nbsync
-Version: 0.0.1
-Summary: Tools for notebook synchronization and management
-Author-email: daizutabi <daizutabi@gmail.com>
-License: MIT License
-        
-        Copyright (c) 2020-present daizutabi <daizutabi@gmail.com>
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-License-File: LICENSE
-Keywords: content-management,documentation,extraction,jupyter,markdown,notebook,visualization
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Documentation
-Classifier: Topic :: Software Development :: Documentation
-Classifier: Topic :: Text Processing :: Markup :: Markdown
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-
-# nbsync-monorepo

nbsync-0.0.1.dist-info/RECORD

@@ -1,5 +0,0 @@
-nbsync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nbsync-0.0.1.dist-info/METADATA,sha256=uSwdGxT3JAkRIc7dbbithBN1254yd6fu8wyQuRQszig,1965
-nbsync-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nbsync-0.0.1.dist-info/licenses/LICENSE,sha256=dbO9NY-nQXzIS5St3j3rPUd7gm5r6pczFYaNy5GVNdI,1105
-nbsync-0.0.1.dist-info/RECORD,,

nbsync-0.0.1.dist-info/licenses/LICENSE

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2020-present daizutabi <daizutabi@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.