semvec/pypi-packages huggingface dataset:
jupyviv 0.1.2
Edit and run Jupyter Notebooks with plain text editors like Neovim while live viewing them with Vivify 
Requires Python: >=3.9

# Jupyviv

Jupyviv is a solution for working with and running Jupyter Notebooks from plain
text editors such as Neovim while using
[Vivify](https://github.com/jannis-baum/Vivify) as a live viewer of the full
Notebook in the browser.

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/jannis-baum/assets/refs/heads/main/Jupyviv/showcase-dark.gif">
  <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/jannis-baum/assets/refs/heads/main/Jupyviv/showcase-light.gif">
  <img alt="Showcase" src="https://raw.githubusercontent.com/jannis-baum/assets/refs/heads/main/Jupyviv/showcase-dark.gif">
</picture>

> [!NOTE]
> Jupyviv is very new. I have been using it myself in my daily workflow for a
> few months now but there may be bugs that make it hard for you to use it. If
> this happens, don't hesitate to open an issue, we'll find a solution and fix
> it!

## Features

Aside from allowing you to **use your favorite editor with Jupyter Notebooks**,
the main benefit of Jupyviv comes from the fact that computation is fully
decoupled from file handling and your editor:

- Edit and render your Notebooks locally and optionally run computation on a
  different machine through an SSH tunnel
- Disconnect and keep running: No need to keep the your local machine connected
  or even running to have the remote keep computing and saving all outputs. This
  is something Jupyter Notebooks [can't
  do](https://stackoverflow.com/a/36845963)
- Almost no setup on remote: Just install Jupyviv and the Kernel you need, open
  the SSH tunnel and you are good to go. No need to even clone your repository
  there or configure anything

## Install

```sh
pip install jupyviv
```

## Usage

Using Jupyviv requires [Vivify](github.com/jannis-baum/Vivify) and a plugin for
integration with your editor. See below for a list of existing editor
integration.

Jupyviv itself is made up of two components:

- Agent, responsible for computation
- Handler, responsible for handling files locally, and communication between the
  Agent, your editor, and Vivify

The Handler is always run locally where your editor and Vivify are as well, and
should be taken care of by your editor plugin. The Agent can be automatically
launched and managed by the Handler, or run separately (optionally on a
different machine).

To run the Agent either way, you need the Jupyter Kernel for the respective
language installed, e.g. `pip install ipykernel` for Python. If you want to run
the agent separately, use `jupyviv agent --help` for more information.

### Existing editor integration

- for Neovim: [jupyviv.nvim](https://github.com/jannis-baum/jupyviv.nvim)
pybioclip 2.1.1
Python package that simplifies using the BioCLIP foundation model.
Requires Python: >=3.10

# pybioclip


[![PyPI - Version](https://img.shields.io/pypi/v/pybioclip.svg)](https://pypi.org/project/pybioclip)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pybioclip.svg)](https://pypi.org/project/pybioclip)

-----

Command line tool and python package to simplify using [BioCLIP](https://imageomics.github.io/bioclip/), including for taxonomic or other label prediction on (and thus annotation or labeling of) images, as well as for generating semantic embeddings for images. No particular understanding of ML or computer vision is required to use it. It also implements a number of performance optimizations for batches of images or custom class lists, which should be particularly useful for integration into computational workflows.

## Documentation
See the [pybioclip documentation website](https://imageomics.github.io/pybioclip/) for requirements, installation instructions, and tutorials.

## License

`pybioclip` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

## Citation

Our code (this repository):
```
@software{Bradley_pybioclip_2025,
author = {Bradley, John and Lapp, Hilmar and Campolongo, Elizabeth G.},
doi = {10.5281/zenodo.13151194},
month = sept,
title = {{pybioclip}},
version = {2.1.1},
year = {2025}
}
```

BioCLIP paper:
```
@inproceedings{stevens2024bioclip,
  title = {{B}io{CLIP}: A Vision Foundation Model for the Tree of Life}, 
  author = {Samuel Stevens and Jiaman Wu and Matthew J Thompson and Elizabeth G Campolongo and Chan Hee Song and David Edward Carlyn and Li Dong and Wasila M Dahdul and Charles Stewart and Tanya Berger-Wolf and Wei-Lun Chao and Yu Su},
  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  year = {2024}
}
```

Also consider citing the BioCLIP code:
```
@software{bioclip2023code,
  author = {Samuel Stevens and Jiaman Wu and Matthew J. Thompson and Elizabeth G. Campolongo and Chan Hee Song and David Edward Carlyn},
  doi = {10.5281/zenodo.10895871},
  title = {BioCLIP},
  version = {v1.0.0},
  year = {2024}
}
```
hippogryph 0.2.0
Multiblock structured mesh generation with Python
Requires Python: >=3.10

# hippogryph

[![PyPI - Version](https://img.shields.io/pypi/v/hippogryph.svg)](https://pypi.org/project/hippogryph)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/hippogryph.svg)](https://pypi.org/project/hippogryph)

-----

**Table of Contents**

- [Overview](#overview)
- [Installation](#installation)
- [About the Name](#about-the-name)
- [License](#license)

## Overview

`hippogryph` is a Python package for the generation of mapped, multiblock structured grids. A structured grid is a grid for which there is a relationship between the physical space coordinates $x$, $y$, and $z$ and the three indices $i$, $j$, and $k$ and a multiblock grid is constructed from a set of subgrids ("blocks") with potentially different connections between the coordinates and the indices. A "mapped" grid is a grid for which there is a transformation $f$ such that the nodal locations are determined by applying this mapping to the indices

$$\vec{x}(i,j,k) = f(i,j,k),$$

where the $\vec{x} = (x, y, z)$ are the nodal coordinates. While it is possible to write many (if not all) structured grid generation schemes in this form, the focus here is on mappings that are known beforehand and not computed using the numerical calculations that are commonly used within the field of numerical grid generation. The grid is first constructed in index space using primitive shapes, and then the physical space grid is constructed from a specified mapping. Currently, the focus is on tensor-product grids where $x=f(i)$, $y=f(j)$, and $z=f(k)$, though more mappings may be added in the future.

## Installation

```console
pip install hippogryph
```

## About the Name

Many years ago, the ancestor of this code generated overset grids, also called chimera grids, with all the hole cutting, trilinear interpolation, and so on. Very little of that code remains, with the exception of the grid stretching calculations. The chimera is a fire-breathing creature from Greek mythology with the head of a lion, the body of goat, and the tail of a serpent so it made sense to call the original code something along those lines. The hippogryph (or hippogriff) is half eagle and half horse, so that's what was chosen. 

## License

`hippogryph` is distributed under the terms of the [BSD-3-Clause](https://spdx.org/licenses/BSD-3-Clause.html) license.