solara-enterprise 1.45.0__py3-none-any.whl

solara_enterprise/cache/multi_level.py

@@ -0,0 +1,25 @@
+from typing import ChainMap
+
+
+class MultiLevel(ChainMap):
+    """Use multiple caches, where we assume the first is the fastest"""
+
+    def __getitem__(self, key):
+        for level, mapping in enumerate(self.maps):
+            try:
+                value = mapping[key]
+                # write back to lower levels
+                for i in range(level):
+                    self.maps[i][key] = value
+                return value
+            except KeyError:
+                pass
+        return self.__missing__(key)
+
+    def __setitem__(self, key, value):
+        for cache in self.maps:
+            cache[key] = value
+
+    def __delitem__(self, key):
+        for cache in self.maps:
+            del cache[key]

solara_enterprise/cache/redis.py

@@ -0,0 +1,25 @@
+from typing import Any, Callable, Optional
+
+import redis
+import solara.settings
+
+from solara_enterprise.cache.base import Base, make_key
+
+
+class Redis(Base):
+    """Wraps a client such that the values are pickled/unpickled"""
+
+    def __init__(
+        self, client: Optional[redis.Redis] = None, clear=solara.settings.cache.clear, prefix=b"solara:cache:", make_key: Callable[[Any], bytes] = make_key
+    ):
+        self.client = client or redis.Redis()
+        super().__init__(self.client, prefix=prefix, clear=clear, make_key=make_key)
+
+    def clear(self):
+        with self.client.lock(b"lock:" + self.prefix):
+            keys = self.keys()
+            for key in keys:
+                del self[key]
+
+    def keys(self):
+        return self.client.keys(self.prefix + b"*")

solara_enterprise/license.py

@@ -0,0 +1,17 @@
+import sys
+from typing import Dict
+
+from rich import print
+
+warned: Dict[str, bool] = {}
+
+
+def check(name):
+    if name in warned:
+        return
+    warned[name] = True
+    print(  # noqa: T201
+        f"[bold yellow]Using the enterprise {name} feature requires a license, unless used for non-commerical use. "
+        "Please contact us at contact@solara.dev to get a license.",
+        file=sys.stderr,
+    )

solara_enterprise/search/index.py

@@ -0,0 +1,89 @@
+import json
+from pathlib import Path
+from typing import Any, List
+
+import solara
+from rich import print as rprint
+from solara.server import settings
+from typing_extensions import TypedDict
+
+from .. import license
+
+
+class DocumentData(TypedDict):
+    id: str
+    text: str
+    location: str
+    title: str
+
+
+def build_index(base_url: str):
+    license.check("search")
+    import solara.server.app
+    import solara.server.kernel
+
+    build_path = settings.ssg.build_path
+    assert build_path is not None
+    app_script = solara.server.app.apps["__default__"]
+    rprint(f"Building search index for {app_script.name} by using {build_path}")
+    routes = app_script.routes
+
+    documents: List[DocumentData] = []
+
+    for route in routes:
+        add_document(f"{base_url}/", route, build_path, documents)
+    index_file = app_script.directory.parent / "assets" / "search.json"
+    rprint("Writing search index to", index_file)
+    with open(index_file, "w") as f:
+        json.dump(documents, f, indent=4)
+
+
+def add_document(base_url: str, route: solara.Route, build_path: Path, documents: List[DocumentData]):
+    url = base_url + (route.path if route.path != "/" else "")
+    if not route.children:
+        path = build_path / ("index.html" if route.path == "/" else route.path + ".html")
+        rprint("Processing", path)
+        from bs4 import BeautifulSoup  # , Tag
+
+        if not path.exists():
+            rprint(f"Warning: {path} does not exist")
+        else:
+            soup = BeautifulSoup(path.read_text("utf8"), "html.parser")
+            node = soup.find(class_="solara-page-content-search")
+
+            if node is None:
+                rprint(f"Warning: {path} has no solara-page-content-search")
+            else:
+                # split by h1 and h2
+                parts: List[List[Any]] = [[]]
+                ids = []
+                titles = [soup.title.string if soup.title else ""]
+                current = parts[-1]
+                # remove invisible title elements
+                for el in node.find_all("span", attrs={"style": "display: none;"}):
+                    el.string = ""
+                for el in node.descendants:
+                    if el.name == "h1" or el.name == "h2":
+                        ids.append(el.get("id"))
+                        parts.append([])
+                        titles.append(el.string)
+                        current = parts[-1]
+                    else:
+                        current.append(el)
+                # join the next node
+                text = ""
+                for i, part in enumerate(parts):
+                    for el in part:
+                        if el.string:
+                            text += el.string.strip() + " "
+                    # texts.append("")
+                    id = ids[i]
+                    location = f"{url}#{id}" if id else url
+                    text = text.strip()
+                    title = titles[i].strip()
+                    if title != text:
+                        documents.append({"id": id, "text": text, "location": location, "title": title})
+                    text = ""
+                # documents.append({"id": url, "html": str(node), "location": url})
+    for child in route.children:
+        add_document(url + "/", child, build_path / Path(route.path), documents)

solara_enterprise/search/search.py

@@ -0,0 +1,25 @@
+import ipyvue
+import solara
+import traitlets
+
+
+class SearchWidget(ipyvue.VueTemplate):
+    template_file = (__file__, "search.vue")
+    forceUpdateList = traitlets.Int(0).tag(sync=True)
+    item = traitlets.Any().tag(sync=True)
+    query = traitlets.Unicode("", allow_none=True).tag(sync=True)
+    search_open = traitlets.Bool(False).tag(sync=True)
+    failed = traitlets.Bool(False).tag(sync=True)
+    cdn = traitlets.Unicode(None, allow_none=True).tag(sync=True)
+
+    @traitlets.default("cdn")
+    def _cdn(self):
+        import solara.settings
+
+        if not solara.settings.assets.proxy:
+            return solara.settings.assets.cdn
+
+
+@solara.component
+def Search():
+    return SearchWidget.element()

solara_enterprise/search/search.vue

@@ -0,0 +1,170 @@
+<template>
+    <div>
+        <v-menu v-model="search_open" offset-y>
+            <template v-slot:activator="on">
+                <v-text-field prepend-icon="mdi-magnify" v-model="query" return-object append-icon="" no-filter
+                    clearable @click="onClick" hide-details class="d-none d-md-flex">
+                </v-text-field>
+
+            </template>
+            <v-card class="solara-search-menu">
+                <div v-if="failed">
+                    <v-alert type="error">
+                        Failed to load search index, maybe the server is still indexing.
+                        <v-btn text @click="fetchData">Retry</v-btn>
+                    </v-alert>
+                </div>
+                <v-list class="pa-3" :key="forceUpdateList" v-if="!failed">
+                    <v-list-item v-for="item in items.slice(0, 20)" v-if="items" @click="onClickItem(item)">
+                        <v-list-item-content class="solara-search-list-item">
+                            <v-list-item-title>{{ item.title }}</v-list-item-title>
+                            <v-list-item-subtitle>{{ item.location }}</v-list-item-subtitle>
+                            <v-list-item-subtitle>{{ item.text }}</v-list-item-subtitle>
+                        </v-list-item-content>
+                    </v-list-item>
+                    <v-list-item v-if="items.length > 20">
+                        <v-list-item-content>
+                            And {{ items.length - 20 }} more pages.
+                        </v-list-item-content>
+
+                    </v-list-item>
+                    <v-list-item v-if="items.length == 0">
+                        No search results found.
+                    </v-list-item>
+                </v-list>
+            </v-card>
+        </v-menu>
+    </div>
+</template>
+<script>
+module.exports = {
+    created() {
+        this.items = [];
+    },
+    async mounted() {
+        window.search = this;
+        await this.loadRequire();
+        this.lunr = (await this.import([`${this.getCdn()}/lunr/lunr.js`]))[0];
+        this.fetchData();
+        window.search = this;
+
+    },
+    watch: {
+        query(value) {
+            this.search_open = true;
+            this.search();
+        },
+        item(value) {
+            solara.router.push(value.location);
+            this.$nextTick(() => {
+                // we cannot do this directly it seems
+                // this.query = "";
+            })
+        },
+    },
+    methods: {
+        async fetchData() {
+            const url = `${window.solara.rootPath}/static/assets/search.json`
+            let documents = [];
+            try {
+                documents = await (await fetch(url)).json();
+                this.failed = false;
+            } catch (e) {
+                this.failed = true;
+                return;
+            }
+
+            this.documents = {}
+            documents.forEach((document) => {
+                this.documents[document.location] = document;
+            })
+            this.idx = this.lunr(function () {
+                this.ref('location')
+                this.field('title')
+
+                this.field('text')
+                documents.forEach(function (doc) {
+                    this.add(doc)
+                }, this)
+            })
+
+        },
+        onClickItem(item) {
+            // console.log(item)
+            this.item = item;
+        },
+        onClick() {
+            this.search_open = true;
+        },
+        search() {
+            if (this.idx) {
+                const searchResult = this.idx.search(this.query || "");
+                items = []
+                searchResult.forEach((item) => {
+                    items.push(this.documents[item.ref])
+                })
+                this.items = items;
+                // items is not reactive, so use this proxy
+                this.forceUpdateList += 1
+            }
+        },
+        import(deps) {
+            return this.loadRequire().then(
+                () => {
+                    if (window.jupyterVue) {
+                        // in jupyterlab, we take Vue from ipyvue/jupyterVue
+                        define("vue", [], () => window.jupyterVue.Vue);
+                    } else {
+                        define("vue", ['jupyter-vue'], jupyterVue => jupyterVue.Vue);
+                    }
+                    return new Promise((resolve, reject) => {
+                        requirejs(deps, (...modules) => resolve(modules));
+                    })
+                }
+            );
+        },
+        loadRequire() {
+            /* Needed in lab */
+            if (window.requirejs) {
+                console.log('require found');
+                return Promise.resolve()
+            }
+            return new Promise((resolve, reject) => {
+                const script = document.createElement('script');
+                script.src = `${this.getCdn()}/requirejs@2.3.6/require.js`;
+                script.onload = resolve;
+                script.onerror = reject;
+                document.head.appendChild(script);
+            });
+        },
+        getJupyterBaseUrl() {
+            // if base url is set, we use ./ for relative paths compared to the base url
+            if (document.getElementsByTagName("base").length) {
+                return document.baseURI;
+            }
+            const labConfigData = document.getElementById('jupyter-config-data');
+            if (labConfigData) {
+                /* lab and Voila */
+                return JSON.parse(labConfigData.textContent).baseUrl;
+            }
+            let base = document.body.dataset.baseUrl || document.baseURI;
+            if (!base.endsWith('/')) {
+                base += '/';
+            }
+            return base
+        },
+        getCdn() {
+            return this.cdn || (window.solara ? window.solara.cdn : `${this.getJupyterBaseUrl()}_solara/cdn`);
+        },
+    }
+}
+</script>
+<style id="solara-search">
+.solara-search-list-item {
+    max-width: 400px;
+}
+
+.solara-search-menu {
+    max-height: 80vh;
+}
+</style>

solara_enterprise/ssg.py

@@ -0,0 +1,249 @@
+import concurrent.futures.thread
+import logging
+import threading
+import time
+import typing
+import urllib
+import weakref
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import solara
+from rich import print as rprint
+from solara.server import settings
+from typing_extensions import TypedDict
+
+from . import license
+
+logger = logging.getLogger("solara.server.ssg")
+
+if typing.TYPE_CHECKING:
+    import playwright.sync_api
+    import playwright.sync_api._context_manager
+
+
+class Playwright(threading.local):
+    browser: Optional["playwright.sync_api.Browser"] = None
+    sync_playwright: Optional["playwright.sync_api.Playwright"] = None
+    context_manager: Optional["playwright.sync_api._context_manager.PlaywrightContextManager"] = None
+    page: Optional["playwright.sync_api.Page"] = None
+
+
+pw = Playwright()
+_used: List[Tuple["playwright.sync_api.Browser", "playwright.sync_api._context_manager.PlaywrightContextManager"]] = []
+
+
+class SSGData(TypedDict):
+    title: str
+    html: str
+    styles: List[str]
+    metas: List[str]
+
+
+def _get_playwright():
+    if hasattr(pw, "browser") and pw.browser is not None:
+        return pw
+    from playwright.sync_api import sync_playwright
+
+    pw.number = 42
+    pw.context_manager = sync_playwright()
+    pw.sync_playwright = pw.context_manager.start()
+
+    pw.browser = pw.sync_playwright.chromium.launch(headless=not settings.ssg.headed)
+    pw.page = pw.browser.new_page()
+    _used.append((pw.browser, pw.context_manager))
+    return pw
+
+
+def _worker_with_cleanup(*args, **kwargs):
+    try:
+        concurrent.futures.thread._worker(*args, **kwargs)
+    finally:
+        pw = _get_playwright()
+        pw.browser.close()
+        pw.context_manager.__exit__(None, None, None)
+
+
+class CleanupThreadPoolExecutor(concurrent.futures.ThreadPoolExecutor):
+    def _adjust_thread_count(self):
+        # copy of the original code with _worker replaced
+        # if idle threads are available, don't spin new threads
+        if self._idle_semaphore.acquire(timeout=0):
+            return
+
+        # When the executor gets lost, the weakref callback will wake up
+        # the worker threads.
+        def weakref_cb(_, q=self._work_queue):
+            q.put(None)
+
+        num_threads = len(self._threads)
+        if num_threads < self._max_workers:
+            thread_name = "%s_%d" % (self._thread_name_prefix or self, num_threads)
+            t = threading.Thread(
+                name=thread_name, target=_worker_with_cleanup, args=(weakref.ref(self, weakref_cb), self._work_queue, self._initializer, self._initargs)
+            )
+            t.start()
+            self._threads.add(t)  # type: ignore
+            concurrent.futures.thread._threads_queues[t] = self._work_queue  # type: ignore
+
+
+def ssg_crawl(base_url: str):
+    license.check("SSG")
+    import solara.server.app
+    import solara.server.kernel
+
+    build_path = settings.ssg.build_path
+    assert build_path is not None
+    build_path.mkdir(exist_ok=True)
+
+    app_script = solara.server.app.apps["__default__"]
+    rprint(f"Building {app_script.name} at {build_path}")
+    routes = app_script.routes
+
+    # although in theory we should be able to run this with multiple threads
+    # there are issues with uvloop:
+    #  e.g.: "Racing with another loop to spawn a process."
+    thread_pool = CleanupThreadPoolExecutor(max_workers=1)
+
+    results = []
+    for route in routes:
+        results.append(thread_pool.submit(ssg_crawl_route, f"{base_url}/", route, build_path, thread_pool))
+
+    def wait(async_result):
+        results = async_result.result()
+        for result in results:
+            wait(result)
+
+    for result in results:
+        wait(result)
+
+    thread_pool.shutdown()
+
+    rprint("Done building SSG")
+
+
+def ssg_crawl_route(base_url: str, route: solara.Route, build_path: Path, thread_pool: CleanupThreadPoolExecutor):
+    # if route
+    url = base_url + (route.path if route.path != "/" else "")
+    if not route.children:
+        rprint("Check SSG for URL", url)
+        build_path.mkdir(exist_ok=True, parents=True)
+        path = build_path / ("index.html" if route.path == "/" else route.path + ".html")
+        stale = False
+        pw = _get_playwright()
+        page = pw.page
+        if path.exists():
+            if route.file is None:
+                rprint(f"File corresponding to {url} is not found (route: {route})")
+            else:
+                assert route.file is not None
+                stale = path.stat().st_mtime < route.file.stat().st_mtime
+                if stale:
+                    rprint(f"Path {path} is stale: mtime {path} is older than {route.file} mtime {route.file.stat().st_mtime}")
+        if not path.exists() or stale:
+            rprint(f"Will generate {path}")
+            response = page.goto(url, wait_until="networkidle")
+            if response.status != 200:
+                raise Exception(f"Failed to load {url} with status {response.status}")
+            # TODO: if we don't want to detached, we get stack trace showing errors in solara
+            # make sure the html is loaded
+            try:
+                page.locator("#app").wait_for()
+                # make sure vue took over
+                page.locator("#pre-rendered-html-present").wait_for(state="detached")
+                # and wait for the
+                page.locator("text=Loading app").wait_for(state="detached")
+                page.locator("#kernel-busy-indicator").wait_for(state="hidden")
+                # page.wait_
+                time.sleep(0.5)
+                raw_html = page.content()
+            except Exception:
+                logger.exception("Failure retrieving content for url: %s", url)
+                raise
+            request_path = urllib.parse.urlparse(url).path
+
+            import solara.server.server
+
+            # the html from playwright is not what we want, pass it through the jinja template again
+            html = solara.server.server.read_root(request_path, ssg_data=_ssg_data(raw_html))
+            if html is None:
+                raise Exception(f"Failed to render {url}")
+            path.write_text(html, encoding="utf-8")
+            rprint(f"Wrote to {path}")
+            page.goto("about:blank")
+        else:
+            rprint(f"Skipping existing render: {path}")
+    results = []
+    for child in route.children:
+        result = thread_pool.submit(ssg_crawl_route, url + "/", child, build_path / Path(route.path), thread_pool)
+        results.append(result)
+    return results
+
+
+def ssg_content(path: str) -> Optional[str]:
+    license.check("SSG")
+    # still not sure why we sometimes end with a double slash
+    if path.endswith("//"):
+        path = path[:-2]
+    if path.endswith("/"):
+        path = path[:-1]
+    if path.startswith("/"):
+        # remove / so we don't get absolute paths on disk
+        path = path[1:]
+    # TODO: how do we know the app?
+    build_path = settings.ssg.build_path
+    if build_path and settings.ssg.enabled:
+        html_path = build_path / path
+        if (html_path / "index.html").exists():
+            html_path = html_path / "index.html"
+        else:
+            html_path = html_path.with_suffix(".html")
+        if html_path.exists() and html_path.is_file():
+            logger.info("Using pre-rendered html at %r", html_path)
+            return html_path.read_text("utf8")
+        else:
+            logger.error("Count not find html at %r", html_path)
+    return None
+
+
+def _ssg_data(html: str) -> Optional[SSGData]:
+    license.check("SSG")
+    from bs4 import BeautifulSoup, Tag
+
+    # pre_rendered_css = ""
+    styles = []
+    title = "Solara ☀️"
+
+    soup = BeautifulSoup(html, "html.parser")
+    node = soup.find(id="app")
+    # TODO: add classes...
+    if node and isinstance(node, Tag):
+        # only render children
+        html = "".join(str(x) for x in node.contents)
+    title_tag = soup.find("title")
+    if title_tag:
+        title = title_tag.text
+
+    # include all meta tags
+    rendered_metas = soup.find_all("meta")
+    metas = []
+    for meta in rendered_metas:
+        # but only the ones added by solara
+        if meta.attrs.get("data-solara-head-key"):
+            metas.append(str(meta))
+
+    # include all styles
+    rendered_styles = soup.find_all("style")
+    for style in rendered_styles:
+        style_html = str(style)
+        # skip css that was already in the template so we don't include it multiple times
+        # or such that we do not include the CSS from the theme as ssg build time
+        if 'class="solara-template-css"' in style_html:
+            continue
+        # in case we want to skip the mathjax css
+        # if "MJXZERO" in style_html:
+        #     continue
+        # pre_rendered_css += style_html
+        styles.append(style_html)
+        logger.debug("Include style (size is %r mb):\n\t%r", len(style_html) / 1024**2, style_html[:200])
+    return SSGData(title=title, html=html, styles=styles, metas=metas)

solara_enterprise-1.45.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.3
+Name: solara-enterprise
+Version: 1.45.0
+Dynamic: Summary
+Project-URL: Home, https://www.github.com/widgetti/solara
+Author-email: "Maarten A. Breddels" <maartenbreddels@gmail.com>, Mario Buikhuizen <mariobuikhuizen@gmail.com>
+License: Not open source, contact contact@solara.dev for licencing.
+Classifier: License :: Free for non-commercial use
+Requires-Python: >=3.7
+Requires-Dist: solara-server==1.45.0
+Requires-Dist: solara-ui==1.45.0
+Provides-Extra: all
+Requires-Dist: authlib; extra == 'all'
+Requires-Dist: beautifulsoup4; extra == 'all'
+Requires-Dist: diskcache; extra == 'all'
+Requires-Dist: httpx; extra == 'all'
+Requires-Dist: itsdangerous; extra == 'all'
+Requires-Dist: playwright; extra == 'all'
+Provides-Extra: auth
+Requires-Dist: authlib; extra == 'auth'
+Requires-Dist: httpx; extra == 'auth'
+Requires-Dist: itsdangerous; extra == 'auth'
+Provides-Extra: cache
+Requires-Dist: diskcache; extra == 'cache'
+Provides-Extra: ssg
+Requires-Dist: beautifulsoup4; extra == 'ssg'
+Requires-Dist: playwright; extra == 'ssg'

solara_enterprise-1.45.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+solara_enterprise/__init__.py,sha256=92t-t5BTHmHGobETurAJRgZyY2DaxpO8axxCnR0EhjI,57
+solara_enterprise/license.py,sha256=GCGEs3x9rtKf0dYUcHkx-yteIQuRlgnS8hPbl9BDAXs,412
+solara_enterprise/ssg.py,sha256=uw3397RX0Qmg-OqOsgwaePDymhUvZTTFcBKkSWy1uCk,8935
+solara_enterprise/auth/__init__.py,sha256=83RGLIkVJrb6R1iZxg5YS0R3kaCmqMHu4qs8S74LJXo,513
+solara_enterprise/auth/components.py,sha256=mTazvLWJrduS6CrcsY60BJgkvQztH5X67CkOCRFXYV4,4038
+solara_enterprise/auth/flask.py,sha256=Y__abnQPnP1cdQAkU8BBg9FuWMZ1rNnUmTLE_x19MlE,3539
+solara_enterprise/auth/middleware.py,sha256=f9yshp6e0M2RSBaJaoeZisYlnM52NEYHTmsnjrW-h3c,5027
+solara_enterprise/auth/starlette.py,sha256=-vow0-dhOLn_H5QJ79F4jynZnn6O63iHVYWqgtxMz4Q,3937
+solara_enterprise/auth/utils.py,sha256=E54A4NNaRWhPLxB7K-B3YlHZsaCySyf3aT0Db0khOLo,1506
+solara_enterprise/cache/__init__.py,sha256=pvQocwiJeUF6V8KFtQl0xPNGo7kNnWhjWCOcChwMP_Q,47
+solara_enterprise/cache/base.py,sha256=Gx-p7khDFSxbdgG83aka7zABx5dLRtt9d9j4Zv69lwU,2098
+solara_enterprise/cache/disk.py,sha256=isHvt0v7KlZ-MHYlSfBclWkreL30OjmZ7ZBMWmCqGl4,1190
+solara_enterprise/cache/memory_size.py,sha256=5PAUaxVvHMIFINA3Z4z48zDvAATTFkEd0ehTXT5ahIA,816
+solara_enterprise/cache/multi_level.py,sha256=hMjruI1cwNwDajaRXAJ7TxQqfw5XWRvtYuAU7M4f_W8,710
+solara_enterprise/cache/redis.py,sha256=_GlACNJ5hfpRJ2Hw_2k3ma6gwEVLoVNTplS0Q5cGcRk,779
+solara_enterprise/search/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+solara_enterprise/search/index.py,sha256=W98DC_6SmQDCfX5YcmS6OfZbO0LheleBmo0FUI7NOqU,3303
+solara_enterprise/search/search.py,sha256=MzChv6DAsG2_ehPltI87orQqBqtY1xkBzXW8eDtMusU,707
+solara_enterprise/search/search.vue,sha256=PSE8KlKHQQY-ZbaNj4eOGSIB9AXH8qmdTDqnDb0l5Kc,6005
+solara_enterprise-1.45.0.dist-info/METADATA,sha256=T8zMnIAR9ZtJ1bEaEuZPAHiudb2gPUtMsR3KTNI6ZSI,1045
+solara_enterprise-1.45.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+solara_enterprise-1.45.0.dist-info/licenses/LICENSE,sha256=04_xbTWtvdcQomu6IXsIkniKk8EcD9P1GyJM2dYPoSU,59
+solara_enterprise-1.45.0.dist-info/RECORD,,

solara_enterprise-1.45.0.dist-info/WHEEL

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

solara_enterprise-1.45.0.dist-info/licenses/LICENSE

@@ -0,0 +1 @@
+Not open source, contact contact@solara.dev for licencing.