mikro-next 0.19.0__tar.gz

mikro_next-0.19.0/.gitignore

@@ -0,0 +1,147 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+**/__pycache__
+*.py[cod]
+*$py.class
+*.pyc
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# static files generated from Django application using `collectstatic`
+media
+export
+static_collected
+data
+token.temp

mikro_next-0.19.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.4
+Name: mikro-next
+Version: 0.19.0
+Summary: next images for arkitekt
+Author-email: jhnnsrs <jhnnsrs@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.11
+Requires-Dist: dask>=2024.12.1
+Requires-Dist: fakts-next>=2
+Requires-Dist: numcodecs>=0.16.1
+Requires-Dist: numpy>=1.26; python_version ~= '3.12'
+Requires-Dist: pandas>=2.2
+Requires-Dist: pytest>=8.3.5
+Requires-Dist: rath>=3.7
+Requires-Dist: s3fs>=2024.10.0
+Requires-Dist: websockets>=15.0.1
+Requires-Dist: xarray>=2024.11.0
+Requires-Dist: zarr>=3.1
+Provides-Extra: complete
+Requires-Dist: pyarrow>=12.0.1; extra == 'complete'
+Provides-Extra: table
+Requires-Dist: pyarrow>=12.0.1; extra == 'table'
+Provides-Extra: turms
+Description-Content-Type: text/markdown
+
+# mikro
+
+[![codecov](https://codecov.io/gh/arkitektio/mikro-next/graph/badge.svg?token=PRoouTwAGx)](https://codecov.io/gh/arkitektio/mikro-next)
+[![PyPI version](https://badge.fury.io/py/mikro-next.svg)](https://pypi.org/project/mikro-next/)
+[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://pypi.org/project/mikro-next/)
+![Maintainer](https://img.shields.io/badge/maintainer-jhnnsrs-blue)
+[![PyPI pyversions](https://img.shields.io/pypi/pyversions/mikro-next.svg)](https://pypi.python.org/pypi/mikro-next/)
+[![PyPI status](https://img.shields.io/pypi/status/mikro-next.svg)](https://pypi.python.org/pypi/mikro-next/)
+[![PyPI download month](https://img.shields.io/pypi/dm/mikro-next.svg)](https://pypi.python.org/pypi/mikro-next/)
+
+mikro-next is the python client for the next version of the mikro-server environment.
+
+
+# Quick Start
+
+Let's discover **mikro in less than 5 minutes**.
+
+
+### Inspiration
+
+Mikro is the client app for the mikro-server, a graphql compliant server for hosting your microscopy data. Mikro tries to
+facilitate a transition to use modern technologies for the storage and retrieval of microscopy data. It emphasizes the importance
+of relations within your data and tries to make them accessible through a GraphQL Interface.
+
+### Installation
+
+```bash
+pip install mikro-next
+```
+
+### Design
+
+Mikro is just a client and therefore only concerns itself with the querying (retrieval) and mutation (altering) of data on
+the central server. Therefore its only composes two major components:
+
+- Rath: A graphql client to query complex relationships in your data through simple queries.
+- Datalayer: A way of accessing and retrieving binary data (image arrays, big tables,...) through known python apis like xarray and numpy
+
+Under the hood Mikro is build on the growing ecosystem of graphql and pydantic as well as the amazing toolstack
+of zarr, dask and xarray for scientific computation.
+
+### Features
+
+- Easy to extend with custom graphql logic (together with turms can generate APIs for very complex relationship)
+- Interoperable and standardization (has bindings for Dataframes and Numpy arrays)
+- Fully Typed and Validated(uses pydantic for validation)
+
+### Prerequisits
+
+You need a fully configured mikro-server running in your lab, that mikro can connect to. The easiest way to do this is to
+use the [arkitekt.live](https://arkitekt.live) platform, which provides a fully managed mikro-server for your lab. Just
+follow the instructions on the website to get started. If you just want a local test service, check out the 
+tests/integration/docker-compose.yml file, which contains a docker-compose file to start a mikro-server
+locally with a postgres database and a minio object storage.
+
+## Example Use case
+
+The API of Mikro is best explained on this example:
+
+```python
+from arkitekt_next import easy
+from mikro_next.api.schema import get_random_image
+
+
+with easy("my-app") as app:
+    g = get_random_image()
+
+    maximum_intensity_l = g.data.max()
+    maximum_intensity = maximum_intensity.compute()
+```
+
+1. **First we construct an App**:
+   App is the entrypoint of every client accessing the mikro service,
+   in a more complex example here you would define the configuration of
+   the connection. In this example we use the `easy` function to
+   construct an arkitekt-app with a default configuration. 
+
+2. **Entering the Context**:
+   This is the most important concept to learn, every interaction you have with
+   mikro needs to happen within a context. This is needed because mikro uses
+   asyncrhonous programming to retrieve, and save data efficiently. The context
+   ensures that every connection gets cleaned up effienctly and safely.
+
+3. **Retrieving Model**:
+   On calling `get_random_image` we are calling the graphql server and retrieve
+   the metadata of a reandom image. This function just
+   executes a default graphqlquery and constructs a typed python model out of it.
+
+4. **Retrieving Data**:
+   Here we are actually doing operations on the image data. Every Image
+   has a `data` attribute. This data attribute resolves to a lazily loaded
+   xarray that connects to a zarr store on the s3 datalayer. What that means for you
+   is that you can use this as a normal xarray with dask array.
+
+5. **Computing Data**
+   Only on Computing Data is the data actually downloaded from the datalayer. If you
+   only act on partial data, only partial data is downloaded. This is the magic of
+   zarr and xarray.
+
+## Other usage options
+
+If you dont want to use a context manager you can also choose to
+use the connect/disconnect methods:
+
+```python
+from arkitekt_next import easy 
+from mikro_next.api.schema import get_image
+
+
+app = easy()
+app.enter()
+
+g = get_image(107)
+
+maximum_intensity = g.data.max().compute()
+
+#later
+app.exit()
+
+
+```
+:::warning
+If you choose this approach, make sure that you call disconnect in your code at some
+stage. Especially when using asynchronous links/transports (supporting subscriptions) in a sync
+environment,as only on disconnect we will close the threaded loop that these transports required
+to operate. Otherwise this connection will stay open.
+:::
+
+# Async Usage:
+
+If you love asyncio, the way we do, you can also take full control over what happens in your app
+within an asynchrouns loop. Actually this is the API we would recommend.
+
+```python
+from mikro import MikroApp, aget_representation
+from fakts import Fakts
+
+
+app = MikroApp()
+
+async with app:
+    g = await aget_representation(107)
+
+    maximum_intensity = g.data.max() # DO NOT DO THIS IN YOUR ASYNC LOOP
+
+```
+
+:::warning
+
+In this scenario we are using the asyncio event loop and do not spawn a seperate thread, so calling
+g.data.max() actually calculates the array (e.g downloads everything blockingly in this loop)
+
+:::
+
+If you want to know more about why we use apps, composition and how we handle threads, check out koil
+(mikros async-sync-helper library)

mikro_next-0.19.0/README.md

@@ -0,0 +1,156 @@
+# mikro
+
+[![codecov](https://codecov.io/gh/arkitektio/mikro-next/graph/badge.svg?token=PRoouTwAGx)](https://codecov.io/gh/arkitektio/mikro-next)
+[![PyPI version](https://badge.fury.io/py/mikro-next.svg)](https://pypi.org/project/mikro-next/)
+[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://pypi.org/project/mikro-next/)
+![Maintainer](https://img.shields.io/badge/maintainer-jhnnsrs-blue)
+[![PyPI pyversions](https://img.shields.io/pypi/pyversions/mikro-next.svg)](https://pypi.python.org/pypi/mikro-next/)
+[![PyPI status](https://img.shields.io/pypi/status/mikro-next.svg)](https://pypi.python.org/pypi/mikro-next/)
+[![PyPI download month](https://img.shields.io/pypi/dm/mikro-next.svg)](https://pypi.python.org/pypi/mikro-next/)
+
+mikro-next is the python client for the next version of the mikro-server environment.
+
+
+# Quick Start
+
+Let's discover **mikro in less than 5 minutes**.
+
+
+### Inspiration
+
+Mikro is the client app for the mikro-server, a graphql compliant server for hosting your microscopy data. Mikro tries to
+facilitate a transition to use modern technologies for the storage and retrieval of microscopy data. It emphasizes the importance
+of relations within your data and tries to make them accessible through a GraphQL Interface.
+
+### Installation
+
+```bash
+pip install mikro-next
+```
+
+### Design
+
+Mikro is just a client and therefore only concerns itself with the querying (retrieval) and mutation (altering) of data on
+the central server. Therefore its only composes two major components:
+
+- Rath: A graphql client to query complex relationships in your data through simple queries.
+- Datalayer: A way of accessing and retrieving binary data (image arrays, big tables,...) through known python apis like xarray and numpy
+
+Under the hood Mikro is build on the growing ecosystem of graphql and pydantic as well as the amazing toolstack
+of zarr, dask and xarray for scientific computation.
+
+### Features
+
+- Easy to extend with custom graphql logic (together with turms can generate APIs for very complex relationship)
+- Interoperable and standardization (has bindings for Dataframes and Numpy arrays)
+- Fully Typed and Validated(uses pydantic for validation)
+
+### Prerequisits
+
+You need a fully configured mikro-server running in your lab, that mikro can connect to. The easiest way to do this is to
+use the [arkitekt.live](https://arkitekt.live) platform, which provides a fully managed mikro-server for your lab. Just
+follow the instructions on the website to get started. If you just want a local test service, check out the 
+tests/integration/docker-compose.yml file, which contains a docker-compose file to start a mikro-server
+locally with a postgres database and a minio object storage.
+
+## Example Use case
+
+The API of Mikro is best explained on this example:
+
+```python
+from arkitekt_next import easy
+from mikro_next.api.schema import get_random_image
+
+
+with easy("my-app") as app:
+    g = get_random_image()
+
+    maximum_intensity_l = g.data.max()
+    maximum_intensity = maximum_intensity.compute()
+```
+
+1. **First we construct an App**:
+   App is the entrypoint of every client accessing the mikro service,
+   in a more complex example here you would define the configuration of
+   the connection. In this example we use the `easy` function to
+   construct an arkitekt-app with a default configuration. 
+
+2. **Entering the Context**:
+   This is the most important concept to learn, every interaction you have with
+   mikro needs to happen within a context. This is needed because mikro uses
+   asyncrhonous programming to retrieve, and save data efficiently. The context
+   ensures that every connection gets cleaned up effienctly and safely.
+
+3. **Retrieving Model**:
+   On calling `get_random_image` we are calling the graphql server and retrieve
+   the metadata of a reandom image. This function just
+   executes a default graphqlquery and constructs a typed python model out of it.
+
+4. **Retrieving Data**:
+   Here we are actually doing operations on the image data. Every Image
+   has a `data` attribute. This data attribute resolves to a lazily loaded
+   xarray that connects to a zarr store on the s3 datalayer. What that means for you
+   is that you can use this as a normal xarray with dask array.
+
+5. **Computing Data**
+   Only on Computing Data is the data actually downloaded from the datalayer. If you
+   only act on partial data, only partial data is downloaded. This is the magic of
+   zarr and xarray.
+
+## Other usage options
+
+If you dont want to use a context manager you can also choose to
+use the connect/disconnect methods:
+
+```python
+from arkitekt_next import easy 
+from mikro_next.api.schema import get_image
+
+
+app = easy()
+app.enter()
+
+g = get_image(107)
+
+maximum_intensity = g.data.max().compute()
+
+#later
+app.exit()
+
+
+```
+:::warning
+If you choose this approach, make sure that you call disconnect in your code at some
+stage. Especially when using asynchronous links/transports (supporting subscriptions) in a sync
+environment,as only on disconnect we will close the threaded loop that these transports required
+to operate. Otherwise this connection will stay open.
+:::
+
+# Async Usage:
+
+If you love asyncio, the way we do, you can also take full control over what happens in your app
+within an asynchrouns loop. Actually this is the API we would recommend.
+
+```python
+from mikro import MikroApp, aget_representation
+from fakts import Fakts
+
+
+app = MikroApp()
+
+async with app:
+    g = await aget_representation(107)
+
+    maximum_intensity = g.data.max() # DO NOT DO THIS IN YOUR ASYNC LOOP
+
+```
+
+:::warning
+
+In this scenario we are using the asyncio event loop and do not spawn a seperate thread, so calling
+g.data.max() actually calculates the array (e.g downloads everything blockingly in this loop)
+
+:::
+
+If you want to know more about why we use apps, composition and how we handle threads, check out koil
+(mikros async-sync-helper library)

mikro_next-0.19.0/mikro_next/__init__.py

@@ -0,0 +1,32 @@
+from .mikro_next import MikroNext
+from .utils import rechunk
+
+try:
+    #
+    from .arkitekt import MikroService
+except ImportError as e:
+    try:
+        import arkitekt
+
+        raise ImportError(
+            "Arkitekt is installed, but the MikroService could not be imported. This may indicate a version mismatch or missing dependencies."
+        ) from e
+    except ImportError:
+        pass
+
+
+try:
+    from .rekuest import structure_reg
+
+    print("Imported structure_reg")
+except ImportError as e:
+    print("Could not import structure_reg", e)
+    pass
+
+
+__all__ = [
+    "MikroNext",
+    "rechunk",
+    "structure_reg",
+    "MikroService",
+]

mikro_next-0.19.0/mikro_next/api/__init__.py

@@ -0,0 +1 @@
+