semvec/pypi-packages huggingface dataset:
autodistill-grounded-edgesam 0.1.0
Model for use with Autodistill
Requires Python: >=3.7

**⚠️ This is an example README for use in creating a Base Model. You will need to adjust this document for the model you are using.**

<div align="center">
  <p>
    <a align="center" href="" target="_blank">
      <img
        width="850"
        src="https://media.roboflow.com/open-source/autodistill/autodistill-banner.png"
      >
    </a>
  </p>
</div>

# Autodistill Grounded EdgeSAM Module

This repository contains the code supporting the Grounded EdgeSAM base model for use with [Autodistill](https://github.com/autodistill/autodistill).

[EdgeSAM](https://github.com/chongzhou96/EdgeSAM), introduced in the "EdgeSAM: Prompt-In-the-Loop Distillation for On-Device Deployment of SAM" paper, is a faster version of the Segment Anything model.

Grounded EdgeSAM combines [Grounding DINO](https://blog.roboflow.com/grounding-dino-zero-shot-object-detection/) and EdgeSAM, allowing you to identify objects and generate segmentation masks for them.

Read the full [Autodistill documentation](https://autodistill.github.io/autodistill/) to learn more about Autodistill.

## Installation

To use Grounded EdgeSAM with autodistill, you need to install the following dependency:

```bash
pip3 install autodistill-grounded-edgesam
```

## Quickstart

```python
from autodistill_clip import CLIP

# define an ontology to map class names to our GroundingDINO prompt
# the ontology dictionary has the format {caption: class}
# where caption is the prompt sent to the base model, and class is the label that will
# be saved for that caption in the generated annotations
# then, load the model
from autodistill_grounded_edgesam import GroundedEdgeSAM
from autodistill.detection import CaptionOntology
from autodistill.utils import plot
import cv2

# define an ontology to map class names to our GroundedSAM prompt
# the ontology dictionary has the format {caption: class}
# where caption is the prompt sent to the base model, and class is the label that will
# be saved for that caption in the generated annotations
# then, load the model
base_model = GroundedEdgeSAM(
    ontology=CaptionOntology(
        {
            "person": "person",
            "forklift": "forklift",
        }
    )
)

# run inference on a single image
results = base_model.predict("logistics.jpeg")

plot(
    image=cv2.imread("logistics.jpeg"),
    classes=base_model.ontology.classes(),
    detections=results
)

# label a folder of images
base_model.label("./context_images", extension=".jpeg")
```

## License

This repository is released under an [S-Lab License 1.0](LICENSE) license.

## 🏆 Contributing

We love your input! Please see the core Autodistill [contributing guide](https://github.com/autodistill/autodistill/blob/main/CONTRIBUTING.md) to get started. Thank you 🙏 to all our contributors!
plaquette 0.1.1.post0
An all-encompassing quantum error-correction software package
Requires Python: >=3.10
Keywords: Quantum error correction,qec,quantum computing,fault tolerance

``plaquette``: an all-encompassing fault-tolerance software package
===================================================================

.. image:: https://readthedocs.org/projects/plaquette-qec/badge/?version=stable
    :target: https://docs.plaquette.design/en/stable/?badge=stable
    :alt: Documentation Status

.. figure:: docs/index_code.png
    :align: right
    :alt: Distance-5 rotated planar code

``plaquette`` is a fully featured and easy-to-use library for studying quantum
error correction and fault tolerance.

The library features numerous quantum error correction codes, hardware-relevant
error models and versatile decoders that can be used together seamlessly,
and it is tailored to  accommodate both newcomers and experienced users alike!

Installation
------------

``plaquette`` is a pure Python package, so it can be easily installed via
``pip``::

   pip install plaquette

Documentation
-------------

Live pre-compiled documentation is available `here <https://docs.plaquette.design/>`_.

Alternatively, the documentation can be built from the ``master`` branch by::

   make -C docs clean html

and the build files will be available in the ``docs/_build/html`` directory.

Need help? Want to contribute?
------------------------------

``plaquette`` is under heavy development, so it might have some rough corners that need
polishing. If you encounter something you think (or the docs say) should work but does
not, just open an `issue <https://github.com/qc-design/plaquette/issues/new>`_
or, if you also want to share a solution, a
`pull request <https://github.com/qc-design/plaquette/compare>`_! See
our `development standard <https://docs.plaquette.design/en/latest/dev/index.html>`_ to
have an idea of how to match your suggestions to the codebase.

Want to simply share feedback or you're unsure how to do something? Open a new
`discussion <https://github.com/qc-design/plaquette/discussions/new/choose>`_!


Supporters
----------

``plaquette`` is developed and maintained by `QC Design <https://www.qc.design/>`_.
``plaquette`` is also supported by the German Ministry of Education and Research
(BMBF) via project `PhotonQ <https://www.photonq.de/>`_.
Faizur-URL 1.0
A Python module for URL shortening with various services BY Faizur

URL shortening module made by Faizur. This module supports 10 URL shortening services:
1. TinyURL
2. Bitly
3. Ow.ly
4. is.gd
5. v.gd
6. turl.ca
7. qr.cx
8. bc.vc
9. adf.ly
10. nullpointer.at
itkdb-browser 0.2.0
TUI browser for ITk Production DB using itkdb
Requires Python: >=3.8

# itkdb-browser v0.2.0

[![Actions Status][actions-badge]][actions-link]
[![Documentation Status][rtd-badge]][rtd-link]

[![PyPI version][pypi-version]][pypi-link]
[![Conda-Forge][conda-badge]][conda-link]
[![PyPI platforms][pypi-platforms]][pypi-link]

[![GitHub Discussion][github-discussions-badge]][github-discussions-link]
[![Gitter][gitter-badge]][gitter-link]

<!-- prettier-ignore-start -->
[actions-badge]:            https://github.com/kratsg/itkdb-browser/workflows/CI/badge.svg
[actions-link]:             https://github.com/kratsg/itkdb-browser/actions
[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/itkdb-browser
[conda-link]:               https://github.com/conda-forge/itkdb-browser-feedstock
[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
[github-discussions-link]:  https://github.com/kratsg/itkdb-browser/discussions
[gitter-badge]:             https://badges.gitter.im/https://github.com/kratsg/itkdb-browser/community.svg
[gitter-link]:              https://gitter.im/https://github.com/kratsg/itkdb-browser/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge
[pypi-link]:                https://pypi.org/project/itkdb-browser/
[pypi-platforms]:           https://img.shields.io/pypi/pyversions/itkdb-browser
[pypi-version]:             https://img.shields.io/pypi/v/itkdb-browser
[rtd-badge]:                https://readthedocs.org/projects/itkdb-browser/badge/?version=latest
[rtd-link]:                 https://itkdb-browser.readthedocs.io/en/latest/?badge=latest

<!-- prettier-ignore-end -->

## Install me

```
python -m pip install itkdb-browser
```

## Run me

```
itkdb-browser
```

or

```
python -m itkdb_browser
```

The login screen will pick up the same variables that [itkdb][itkdb-link] picks
up.

[itkdb-link]: https://pypi.org/project/itkdb/
llm-director 0.1.0
A light-weight Python library 🐍 for deploying DAG chains of customizable Large Language Model operations. Leveraging the asyncio framework, LLM-Director allows developers to create, manage, and orchestrate actions and processes in an efficient and scalable manner. With its unique structure and integration with FastAPI, LLM-Director offes a robust solution for building applications, API endpoints, and workflow automation systems.
Requires Python: >=3.10,<4.0

# LLM-Director
## Introduction 📖
A light-weight Python library 🐍 for deploying DAG chains of customizable Large Language Model operations. Leveraging the asyncio framework, LLM-Director allows developers to create, manage, and orchestrate actions and processes in an efficient and scalable manner. With its unique structure and integration with FastAPI, LLM-Director offes a robust solution for building applications, API endpoints, and workflow automation systems. 


## Quick Install⚡
To get started with LLM-Director, you can install the package using pip:

```bash
pip install llm-director
```

Ensure you have Python 3.7 or higher installed, as LLM-Director relies on the latest features of asyncio and FastAPI.

## What You Can Build With LLM-Director 🏗️
With LLM-Director, you can create a variety of applications and systems:

1. **Asynchronous Workflow Systems**: Design and execute complex workflows with asynchronous actions, enhancing the efficiency and responsiveness of your applications.

2. **API Endpoints**: Easily integrate with FastAPI to expose your workflows as RESTful API endpoints, allowing for seamless interaction with front-end applications or external systems.

3. **Automated Data Processing Pipelines**: Implement pipelines for data processing, where each step can be a distinct action, conditionally processed, and managed by the Director.

4. **Event-Driven Architectures**: Build systems that react to specific events, trigger actions, and handle a series of responses in an orderly and scalable manner.

## Documentation 📚
The LLM-Director library consists of several key components:

- Director: The central orchestrator that manages actions and listeners.
- Action: The basic unit of functionality, representing a single task or process.
- Blocks: Specialized actions such as Split, Condition, Termination, Merge, and Save, each serving a unique purpose in the workflow.
- FastAPI Integration: Methods to expose actions and workflows as API endpoints.

For detailed documentation, visit LLM-Director Documentation (Coming Soon!).

## Contributing 🤝
Please Contribute! I hope to grow this fast, as I think many people will benefit from this framework.
jsonschematomappings 0.0.2
Converts JSON schema to OpenSearch/ElasticSearch mappings
Requires Python: >=3.8

# jsonschematomappings

Convert JSON schema to OpenSearch/ElasticSearch mappings

## Install

From pypi:

```
pip install jsonschematomappings
```

From repository directory:

```
pip install -e .
```

If developing/running tests:

```
pip install -r requirements/requirements-test.txt
```

## Run

```
$ jsonschematomappings -h
usage: jsonschematomappings [-h] [--template TEMPLATE] json_schema

Convert a JSON schema document to an OpenSearch/ElasticSearch mappings document

positional arguments:
  json_schema          JSON schema document

optional arguments:
  -h, --help           show this help message and exit
  --template TEMPLATE  Template mappings document
```
sbss 0.0.1
Similarity-Based Stratified Splitting Algorithm

# Similarity Stratified Split

Implementation of the Similarity-Based Stratified Splitting algorithm described in [Similarity Based Stratified Splitting: an approach to train better classifiers](https://arxiv.org/abs/2010.06099).

## Overview

The authors propose a Similarity-Based Stratified Splitting (SBSS) technique, which uses both the output and input space information to split a dataset. Splits are generated using similarity functions among samples to place similar samples in different splits. This approach allows for a better representation of the data in the training phase. This strategy leads to a more realistic performance estimation when used in real-world applications.

## Install

<!-- **PyPI**
```bash
pip install sbss
``` -->

**Local**

```
git clone https://github.com/timothyckl/similarity-stratified-split.git
cd ./similarity-stratified-split
pip install -e .
```

## Usage

```python
import numpy as np
from scipy.spatial import distance
from sbss import SimilarityStratifiedSplit

def get_distances(x):
    distances = distance.squareform(distance.pdist(x, metric='euclidean'))
    return distances

# inputs are recommended to be normalized
X = np.random.rand(1000, 128)
y = np.random.randint(0, 10, (1000,))

n_splits = 3
s = SimilarityStratifiedSplit(n_splits, get_distances)

for train_index, test_index in s.split(X, y):
  print(f"Train indices: {train_index}\nTest indices: {test_index}")
  print("="*100)
```

## References

- Farias, F., Ludermir, T. and Bastos-Filho, C. (2020) Similarity based stratified splitting: An approach to train better classifiers, arXiv.org. Available at: https://arxiv.org/abs/2010.06099 (Accessed: 27 November 2023).