semvec/pypi-packages huggingface dataset:
arrowspace 0.25.14
Python bindings for ArrowSpace (Rust) providing graph-based similarity search, signal graphs, and spectral methods for vector data.
Requires Python: >=3.12
Keywords: vector-search, spectral-analysis, graph-signal, similarity-search, machine-learning

# pyarrowspace

Python bindings for [`arrowspace-rs`](https://github.com/Mec-iS/arrowspace-rs).

`arrowspace` is a database for vectors supported by a graph representation and a key-value store. The main use-cases targeted are: AI search capabilities as advanced vector similarity, graph characterisation analysis and search, indexing of high-dimensional vectors. Design principles described in [this article](https://www.tuned.org.uk/posts/010_game_changer_unifying_vectors_and_features_graphs).

For labs and tests please see [tests/](https://github.com/tuned-org-uk/pyarrowspace/tree/main/tests)

## Installation
From PyPi:
```
pip install arrowspace
```
or any other way of installing a Python library.

If you have cargo installed, to compile the libraries involved (from crates.io): 
```
pip install maturin[patchelf]
maturin develop
```

## Tests
Simple test:
```
python tests/test_0.py
```
Test with public QA dataset:
```
python tests/test_1_quora_questions.py
```
There are other tests but they require downloadin a dataset separately or fine-tuning the embeddings on a given dataset. Give it a try and let me know!

## Simplest Example

```python
from arrowspace import ArrowSpaceBuilder
import numpy as np

items: np.array = np.array(
    [[0.1, 0.2, 0.3], [0.0, 0.5, 0.1], [0.9, 0.1, 0.0]],
    dtype = np.float64
)

graph_params: dict = {
    "eps": 1.0,
    "k": 6,
    "topk": 3,
    "p": 2.0,
    "sigma": 1.0,
}

# Create an ArrowSpace instance, returning the computed
# signal graph and lambdas
aspace, gl = ArrowSpaceBuilder().build(graph_params, items)

# Search comparable items
# defaults: k = nitems, alpha = 0.9, beta = 0.1
query: np.array = np.array(
    [0.05, 0.2, 0.25],
    dtype = np.float64
)

tau: float = 1.0
hits: list = aspace.search(query, gl, tau)

# Search returns a list of `(index, score`) tuples, where
# expected value from the code above show the first index
# having the top score, i.e., being nearest.

print(hits)
# [ (0, 0.989743318610787), (1, 0.7565344158360029), (2, 0.22151940739207396) ]
```
PyCBC 2.8.6
Core library to analyze gravitational-wave data, find signals, and study their parameters.
Requires Python: >=3.9
Keywords: ligo, physics, gravity, signal processing, gravitational waves

![GW150914](https://raw.githubusercontent.com/gwastro/pycbc-logo/master/pycbc_logo_name.png)

[PyCBC](http://pycbc.org) is a software package used to explore astrophysical sources of gravitational waves.
It contains algorithms to analyze gravitational-wave data,
detect coalescing compact binaries, and make bayesian inferences from gravitational-wave data.
PyCBC was used in the [first direct detection of gravitational waves](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.116.061102) and
is used in flagship analyses of LIGO and Virgo data.

PyCBC is collaboratively developed by the community and is lead by a team of GW astronomers with the
aim to build accessible tools for gravitational-wave data analysis.

The PyCBC home page is located on github at

 * https://pycbc.org/

Documentation is automatically built from the latest master version

 * https://pycbc.org/pycbc/latest/html/

For the detailed installation instructions of PyCBC

 * https://pycbc.org/pycbc/latest/html/install.html

Want to get going using PyCBC?

 * [Try out our tutorials](https://github.com/gwastro/PyCBC-Tutorials). No software installation required and these can run entirely from the browser.

Quick Installation
```
pip install pycbc
```

To test the code on your machine
```
pip install pytest "tox<4.0.0"
tox
```

If you use any code from PyCBC in a scientific publication, then please see our [citation guidelines](http://pycbc.org/pycbc/latest/html/credit.html) for more details on how to cite pycbc algorithms and
programs.

For the citation of the ``pycbc library``,  please use a bibtex entry and DOI for the
appropriate release of the PyCBC software (or the latest available release).
A bibtex key and DOI for each release is avaliable from [Zenodo](http://zenodo.org/).

[![DOI](https://zenodo.org/badge/31596861.svg)](https://zenodo.org/badge/latestdoi/31596861) [![Build Status](https://travis-ci.org/gwastro/pycbc.svg?branch=master)](https://travis-ci.org/gwastro/pycbc)
[![PyPI version](https://badge.fury.io/py/PyCBC.svg)](https://badge.fury.io/py/PyCBC) ![PyPI - Downloads](https://img.shields.io/pypi/dm/pycbc) [![Anaconda-Server Badge](https://anaconda.org/conda-forge/pycbc/badges/version.svg)](https://anaconda.org/conda-forge/pycbc) [![Anaconda-Server Badge](https://anaconda.org/conda-forge/pycbc/badges/downloads.svg)](https://anaconda.org/conda-forge/pycbc)
[![astropy](http://img.shields.io/badge/powered%20by-AstroPy-orange.svg?style=flat)](http://www.astropy.org/)
onnxifier 2.0.1
An Open Neural Network Exchange (ONNX) Optimization and Transformation Tool.
Requires Python: >=3.11

# ONNXifier
A simple tool to convert any IR format to ONNX file.

[![Checked with pyright](https://microsoft.github.io/pyright/img/pyright_badge.svg)](https://microsoft.github.io/pyright/)

| Framework | Status |
|:----------|:-------|
| OpenVINO  |  ✅    |
| ONNXRuntime | ✅  |

- ✅: well supported
- 🪛: partially supported
- 🚧: developing

## Usage

1. Install from PyPI
```shell
pip install onnxifier
```

2. Convert IR using CLI
```shell
onnxify model.xml
```

```
usage: onnxify input_model.xml [output_model.onnx]

onnxify command-line api

options:
  -h, --help            show this help message and exit
  -a [ACTIVATE ...], --activate [ACTIVATE ...]
                        select passes to be activated, activate L1, L2 and L3 passes if not set.
  -r [REMOVE ...], --remove [REMOVE ...]
                        specify passes to be removed from activated passes.
  -n, --no-passes       do not run any optimizing passes, just convert the model
  --print [PRINT]       print the name of all optimizing passes
  --format {protobuf,textproto,json,onnxtxt}
                        onnx file format
  -s, --infer-shapes    infer model shapes
  -c CONFIG_FILE, --config-file CONFIG_FILE
                        specify a json-format config file for passes
  -u, --uncheck         no checking output model
  --check               check optimized model with random inputs
  --checker-backend {onnx,openvino,onnxruntime}
                        backend for accuracy checking, defaults to openvino
  -v OPSET_VERSION, --opset-version OPSET_VERSION
                        target opset version, defaults to 19
  -vv [{DEBUG,INFO,WARNING,ERROR,CRITICAL}], --log-level [{DEBUG,INFO,WARNING,ERROR,CRITICAL}]
                        specify the level of log messages to be printed, defaults to INFO
  -R, --recursive       recursively optimize nested functions
  --nodes [NODES ...]   specify a set of node names to apply passes only on these nodes
```

To print pass information:

```shell
onnxify --print all
onnxify --print fuse_swish
onnxify --print l1
```


## TODO

- [ ] [**OV**] Add [Loop](https://docs.openvino.ai/2024/documentation/openvino-ir-format/operation-sets/operation-specs/infrastructure/loop-5.html) support.
- [ ] [**OV**] Add [NMS](https://docs.openvino.ai/2024/documentation/openvino-ir-format/operation-sets/operation-specs/sort/non-max-suppression-9.html) support.
- [ ] [**OV**] Add [If](https://docs.openvino.ai/2024/documentation/openvino-ir-format/operation-sets/operation-specs/condition/if-8.html) support.
- [ ] [**ONNX**] Support to optimize [If](https://onnx.ai/onnx/operators/onnx__If.html).


## Contribute

1. pyright type checking

```
pip install -U pyright
pyright onnxifier
```

2. mypy type checking

```
pip install -U mypy
mypy onnxifier --disable-error-code=import-untyped --disable-error=override --disable-error=call-overload
```

3. pre-commit checking

```
pip install -U pre-commit
pre-commit run --all-files
```
dmt-magic 1.1.2
Jupyter Magic zur Integration des E-Assessment-Systems Data Management Tester (DMT)
Requires Python: >=3.9

# DMT-Magic

DMT-Magic ist eine IPython-Erweiterung, die das Jupyter Magic Command **dmt** zur Verfügung stellt, mit dem das E-Assessment-Tool DMT (Data Management Tester) an Notebooks angebunden werden kann.

## Initialisiserung im Jupyter Notebook 

- ``%load_ext dmt`` zum Laden der Erweiterung
- ``%dmt url=<url>`` zur Angabe der URL, unter der die Instanz von DMT erreichbar ist

## Aufruf einer Aufgabe

- ``%dmt <taskid>`` (Line Magic) zur Darstellung einer Aufgabe (referenziert über TaskId)
- ``%%dmt <taskid>`` (Cell Magic) zur Übergabe des Zellinhalts als Nutzerlösung