semvec/pypi-packages huggingface dataset:
Mistic 0.0.1
Mistic: A package for rendering multiple multiplexed images simultaneously
Requires Python: >=3.6

Mistic: image tSNE visualizer
=============================

This is a Python tool using the Bokeh library to view multiple multiplex
images simultaneously. The code has been tested on 7-panel Vectra TIFF,
32- & 64-panel CODEX TIFF, 16-panel CODEX QPTIFF and 44-panel t-CyCIF
TIFF images.

Mistic’s GUI with user inputs is shown below:

![](https://github.com/MathOnco/Mistic/raw/main/fig_readme/Figure_2.jpg)


**Figure description:** A sample Mistic GUI with user inputs is shown.
**A.** User-input panel where imaging technique choice, stack montage
option or markers can be selected, images borders can be added, new or
pre-defined image display coordinates can be chosen, and a theme for the
canvases can be selected. **B.** Static canvas showing the image t-SNE
colored and arranged as per user inputs. **C.** Live canvas showing the
corresponding t-SNE scatter plot where each image is represented as a
dot. The live canvas has tabs for displaying additional information per
image. Metadata for each image can be obtained by hovering over each
dot.

Features of Mistic
------------------

-  Two canvases:

   -  still canvas with the image tSNE rendering
   -  live canvases with tSNE scatter plots for image metadata rendering

-  Dropdown option to select the imaging technique: Vectra, t-CyCIF, or
   CODEX
-  Option to choose between Stack montage view or multiple multiplexed
   images by selecting the markers to be visualised at once
-  Option to place a border around each image based on image metadata
-  Option to use a pre-defined tSNE or generate a new set of tSNE
   co-ordinates
-  Option to shuffle images with the tSNE co-ordinates
-  Option to render multiple tSNE scatter plots based on image metadata
-  Hover functionality available on the tSNE scatter plot to get more
   information of each image
-  Save, zoom, etc each of the Bokeh canvases

Requirements
------------

-  Python >= 3.6 

   -  Install Python from here: https://www.python.org/downloads/



Additional information
----------------------

-  For instructions on how to run Mistic on the t-CyCIF data, please
   check:
   https://mistic-rtd.readthedocs.io/en/latest/vignette_example_tcycif.html

-  For instructions on how to run Mistic on the toy data from our NSCLC
   Vectra FoVs, please
   check:https://mistic-rtd.readthedocs.io/en/latest/vignette_example_vectra.html

-  Paper on bioRxiv:
   https://www.biorxiv.org/content/10.1101/2021.10.08.463728v1

-  Documentation: https://mistic-rtd.readthedocs.io

-  Code has been published at Zenodo:
   https://doi.org/10.5281/zenodo.5912169 

-  Toy data is published here: https://doi.org/10.5281/zenodo.6131933

-  Mistic is highlighted on Bokeh’s user showcase: http://bokeh.org/
pynada 0.0.35
Python client for NADA API

# PyNADA
A Python client for NADA API

## Setup
You can installl PyNADA using pip:
 ```sh
pip install -U pynada
 ```

## Examples
Jupyter Notebooks under examples folder show some use cases utilizing PyNADA. The examples are grouped into three categories:
* Search & Browse: codes for finding specific datasets and resources


* Create & Import: codes for adding datasets to the catalog


* Manage & Update: codes for managing existing datasets and resources
mdb-bp 1.0.3
blockpoint Systems - MultiVersion Database (MDB) ODBC
Keywords: blockpoint,mdb_bp,odbc,blockchain,database

# mdb-bp

Table of Contents
- [Requirements](#requirements)
- [Installation](#installation)
- [Documentation](#documentation)
- [Example](#example)


This package contains a pure-Python MDB client library.

### Requirements
- Python >= 3.9.0
- [MDB](https://blockpointdb.com/) >= 1.0

### Installation

Package is uploaded on [PyPI](https://pypi.org/project/mdb-bp/0.0.1/).

Install with pip:

```
$ python3 -m pip install mdb-bp
```

### Documentation

bSQL documentation is available online:https://bsql.org/

For support, please refer to [StackOverflow](https://stackoverflow.com/questions/tagged/mdb-bp).

### Example

The following example makes use of a simple blockchain, inserts a value, and reads that value.

```python

from mdb_bp import driver

# Connect to the database
conn = driver.connect(
    username="user",
    password="password",
    connection_protocol="tcp",
    server_address="216.27.61.137",
    server_port=8080,
    database_name="master",
    parameters={"interpolateParams": True},
)

# Prepare a statement
stmt = conn.prepare(
    "CREATE BLOCKCHAIN user TRADITIONAL ("
    + "id uint64 PRIMARY KEY AUTO INCREMENT,"
    + " first_name string size = 25 PACKED,"
    + " last_name string size = 50 PACKED,"
    + " age uint8,"
    + " username string size=30 PACKED UNIQUE)")

# Execute the statement.
resp = stmt.exec()
print(resp)

# Run an insertion and handle error
xact = conn.begin()

# Insert a value non-atomically
try:
    result = xact.exec(
        "INSERT user (first_name, last_name, age, username) "
        + "VALUES (\"it's NOT CHABOY\", \"Smith\", 45, \"NOT CHABOY\")")
    print(result)
    xact.commit()

except Exception as err:
    # Rollback the transaction if there was a failure
    print(err)
    xact.rollback()

# Query from the blockchain
rows = conn.query("SELECT * FROM user")

# Print the rows
itr = iter(rows)

for row in itr:
    print(row)

# Store a file
store_file_resp = conn.store_file(
    "space",
    "test_files/space.png",
    "png"
)
print(store_file_resp)

# Export a file 
export_file_resp = conn.export_file(
    "space",
    "test_files/out_space.png",
    "png"
)
print(export_file_resp)
```

## Resources 
- bSQL documentation: https://bsql.org/
- DB-API 2.0: https://www.python.org/dev/peps/pep-0249/