semvec/pypi-packages huggingface dataset:
proof-of-weights 0.0.5
SDK for validators from various subnets to publish their reward function inputs to validators within the omron subnet.
Requires Python: >3.6

<div align="center">

# **Omron SN2 (𝜏, β)**

[![Discord Chat](https://img.shields.io/discord/308323056592486420.svg?logo=discord)](https://discord.gg/bittensor)

### Proof of Inference

[Documentation](https://docs.omron.ai/) • [X](https://twitter.com/omron_ai) • [Inference Labs](https://twitter.com/inference_labs) • [Explorer](https://taostats.io/) • [Dashboard](https://wandb.ai/inferencelabs/omron)

</div>

Omron represents a significant stride in enhancing the Bittensor network, aiming to create the world's largest peer-to-peer **Verified** Intelligence network, by building a Proof-of-Inference system for the Bittensor network. This initiative aligns with the Opentensor foundation's criteria for innovative subnet solutions. zk-ML allows AI models to be converted into a unique 'fingerprint,' a circuit that can be used to verify that a model's prediction was generated by a specific AI model, thereby providing what we term as Proof-of-Inference.

## Proof of Weights SDK

The proof of weights SDK allows validators from various subnets to publish their reward function inputs to validators within the omron subnet.

## Usage

The proof of weights SDK is available on PyPI as `proof-of-weights` (https://pypi.org/project/proof-of-weights/).

```python
import proof_of_weights
proofs = proof_of_weights.Proof_Of_Weights(wallet_name: str, wallet_hotkey: str, omron_validator_ss58: str, netuid: int, network: str = "finney")
proofs.submit_inputs(reward_function_inputs: list)
proofs.get_proof()
```
tinytroupe 0.0.1
This is a placeholder for the TinyTroupe library.
Requires Python: >=3.10

# TinyTroupe PyPI placeholder

This is a dummy placeholder package to reserve the name `tinytroupe` on PyPI. Currently,
TinyTroupe is not officially available on PyPI, so you can't use `pip install` 
to install it. We do hope to make it available on PyPI in the future, which is why this
placeholder exists.

## So how do I actually install TinyTroupe?
To actually install TinyTroupe, **please go to our GitHub repository** at 
https://github.com/microsoft/tinytroupe and follow the 
instructions found there. If you do that, the GitHub version will override 
this PyPI placeholder, since it has a higher version number.
functionmonitor 0.1.7
A tool for monitoring and managing asynchronous function execution.
Requires Python: >=3.6

# functionmonitor

![Demo](demo.gif)

Python's standard function calls are **synchronous** and **blocking**, executing each function sequentially and waiting for each to complete before moving on. This design can be a limitation, especially with I/O-bound or long-running operations.

**`functionmonitor`** is designed specifically for use in **Jupyter notebooks** to enable easy, asynchronous function execution. By running functions in separate threads, you can manage multiple tasks concurrently within the interactive Jupyter environment, allowing for:

- **Concurrent function execution**, freeing up the main thread to continue processing other tasks.
- **Real-time monitoring** of each function's progress.
- **Automatic result assignment** to variables in the global namespace for easy access as soon as functions complete.

## Key Features

- **Execute Functions Concurrently**: Run functions in separate threads, improving efficiency by enabling asynchronous execution.
- **Easy Result Access**: Results are assigned to global variables with the same name as the task key if the `create_variables` parameter is enabled.
- **Supports Any Callable**: Works with any callable (function, lambda, etc.), allowing for flexible function management.


## Installation

To install `functionmonitor`, simply use pip:

```bash
pip install functionmonitor
```

## Usage Overview

1. **Basic Structure**  
   `functionmonitor` behaves similarly to a dictionary, where each task is stored with a task name as the key and the result as the value. Once a task completes, its result is directly accessible.

2. **Using Callables**  
   Any callable can be assigned to `functionmonitor`, allowing functions, lambda expressions, and more to run asynchronously. Prefixing the callable with `lambda` prevents immediate execution, enabling background processing.

```python
import functionmonitor
fm = functionmonitor.get_fm(create_variables=True)
fm[{var}] = lambda: {func()}
```
pulserver 0.1.12
A PyPulseq-based client/server MR sequence design toolbox.
Requires Python: >=3.10
Keywords: pulseq, mri, sequence-design, pulse-sequences, mri-sequences

Pulserver
=========
|Coverage| |CI/CD| |License| |Codefactor| |Sphinx| |PyPi| |Black| |PythonVersion|

.. |Coverage| image:: https://codecov.io/gh/INFN-MRI/pulserver/graph/badge.svg?token=qtB53xANwI 
 :target: https://codecov.io/gh/INFN-MRI/pulserver

.. |CI/CD| image:: https://github.com/INFN-MRI/pulserver/workflows/CI-CD/badge.svg
   :target: https://github.com/INFN-MRI/pulserver

.. |License| image:: https://img.shields.io/github/license/INFN-MRI/pulserver
   :target: https://github.com/INFN-MRI/pulserver/blob/main/LICENSE.txt

.. |Codefactor| image:: https://www.codefactor.io/repository/github/INFN-MRI/pulserver/badge
   :target: https://www.codefactor.io/repository/github/INFN-MRI/pulserver

.. |Sphinx| image:: https://img.shields.io/badge/docs-Sphinx-blue
   :target: https://infn-mri.github.io/pulserver

.. |PyPi| image:: https://img.shields.io/pypi/v/pulserver
   :target: https://pypi.org/project/pulserver

.. |Black| image:: https://img.shields.io/badge/style-black-black

.. |PythonVersion| image:: https://img.shields.io/badge/Python-%3E=3.10-blue?logo=python&logoColor=white
   :target: https://python.org

Pulserver is a high-level wrapper over PyPulseq. It is designed to 
improve MR sequence code organization and provide a bridge
between different Pulseq interpreter representations while providing
a familiar interface to PyPulseq user.

It also provide a server-based interface to enable online sequence design
routines, e.g., using the MR scanner as a client.

Features
--------



Installation
------------
Pulserver can be installed via pip:

.. code-block:: bash

    pip install pulserver

Development
-----------
If you want to modifiy the Pulserver code base:

.. code-block:: bash

    git clone https://github.com/INFN-MRI/pulservert.git
    pip install -e ./pulserver

Usage
-----

TODO: add quick example

Testing
-------
To run the tests, execute the following command in the terminal:

.. code-block:: bash

     pytest .

License
-------
This project is licensed under the MIT License.

Contributing
------------
Contributions are welcome! Please fork the repository and submit a pull request.
carrottransform 0.3
Carrot somple transformer, input rules and data csvs, output OMOP
Requires Python: >=3.9

# carrot-transform

TODO: 
* Document carrot-transform 
* Add more comments in-code
* Handle capture of ddl and json config via the command-line as optional args

Reduction in complexity over the original CaRROT-CDM version for the Transform part of *ETL* - In practice *Extract* is always 
performed by Data Partners, *Load* by database bulk-load software.

Statistics

External libraries imported (approximate)

carrot-cdm      61
carrot-transform 12
koolstof 0.31
Miscellaneous tools for marine carbonate chemistry

# koolstof

![Tests](https://github.com/mvdh7/koolstof/workflows/Tests/badge.svg)
[![Coverage](https://github.com/mvdh7/koolstof/blob/main/.misc/coverage.svg)](https://github.com/mvdh7/koolstof/blob/main/.misc/coverage.txt)
[![PyPI version](https://img.shields.io/pypi/v/koolstof.svg?style=popout)](https://pypi.org/project/koolstof/)
[![Conda Version](https://img.shields.io/conda/vn/conda-forge/koolstof.svg)](https://anaconda.org/conda-forge/koolstof)
[![DOI](https://img.shields.io/badge/DOI-10.5281%2Fzenodo.3999292-informational)](https://doi.org/10.5281/zenodo.3999292)
[![Docs](https://readthedocs.org/projects/koolstof/badge/?version=latest&style=flat)](https://koolstof.readthedocs.io/en/latest/)
[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

Miscellaneous tools for marine carbonate chemistry and other such things.

**Install:**

    pip install koolstof
    
**Import:**

```python
import koolstof as ks
```

**Find current version:**

```python
ks.hello()
```

**Citation:**

> Humphreys, M. P., Delaigue, L. and Ourradi, Y. (2024).  Miscellaneous Python tools for marine carbonate chemistry: koolstof.  *Zenodo*.  [doi:10.5281/zenodo.3999292](https://doi.org/10.5281/zenodo.3999292).
snapdiff 0.1.2
A package for comparing snapshots of data and tracking differences when function change
Requires Python: >=3.7

# snapdiff

Here's the README content as one continuous Markdown block:

---

# snapdiff

`snapdiff` is a Python package for capturing snapshots of function input and output data to track changes over time. It’s designed for use in testing and debugging, allowing you to compare function results across different runs and log any differences.

## Features

- **Snapshot Mode**: Saves a snapshot of function inputs and outputs.
- **Diff Mode**: Compares current function outputs with previously saved snapshots, logging differences.
- **Customizable Diff Functions**: Use built-in or custom diff functions to handle comparisons.
- **Logging**: Configurable logging options to monitor differences across function runs.

## Installation

Install snapdiff using `pip`:

```
pip install snapdiff
```

## Basic Usage

### Setting Up Snapshots

Decorate a function with `@snapper(mode="snap")` to take a snapshot of inputs and outputs. This is useful for capturing a function's behavior for later comparisons.

```
from snapdiff import snapper

@snapper(mode="snap")
def example_function(a, b):
    return a + b

# Taking a snapshot
example_function(2, 3)
```

### Comparing with Snapshots

Switch to `mode="diff"` to check if the function’s behavior has changed compared to the previous snapshot.

```
from snapdiff import snapper

@snapper(mode="diff")
def example_function(a, b):
    return a + b

# This will compare the result of the current call with the saved snapshot
example_function(2, 3)
```

If there’s any difference in input or output, it will be logged.

## Advanced Usage

### Custom Diff Functions

You can supply a custom diff function for cases where the built-in `DeepDiff` does not suit your needs.

```
from snapdiff import snapper

def custom_diff(a, b):
    return {"difference": a - b} if a != b else {}

@snapper(mode="diff", diff_func=custom_diff)
def example_function(a, b):
    return a * b

example_function(4, 5)
```

### Logging Options

To enable or disable logging to a file, use the `log_to_file` parameter when initializing the `Snapper` decorator.

```
from snapdiff import snapper

@snapper(mode="diff", log_to_file=False)
def example_function(a, b):
    return a ** b
```

## Configuration

`snapdiff` allows configuration using a YAML file named `snapdiff_config.yaml` to specify default directories for snapshots, log files, and subtype-specific options.

## License

MIT License

---

For full documentation and examples, visit the [GitHub repository](https://github.com/ahmedhindi/snapdiff).
hirsch 0.1
Abstracted, continuous, and normalised of version of the Hirsch index (h-index) from academic writing for use as a statistical measure of even distribution
Requires Python: >=3.7

# Hirsch 🦌
Python implementation of the familiar discrete Hirsch index (h-index) from academic writing, with an abstracted continuous version for use as a statistical measure of even distribution

## Installation

```
pip install hirsch
```

## Usage

### Discrete

Get the h-index of some discrete data, e.g. the number of citations an author has received on their papers:

```
from hirsch import hirsch
citations = [0, 1, 1, 2, 1, 6, 5, 13, 14, 10, 59, 145, 68]
h = hirsch(citations)
```
![discrete](https://github.com/user-attachments/assets/7e68faed-53b0-4f09-8c32-18ba9d6dc62d)

### Continuous

Calculate a continuous h-index for some normalised and binned data, e.g. fractional populations:

```
from hirsch import hirsch
fractions = [0.1,0.5,0.6,0.3,0.2,0.5,0.4]
h = hirsch(fractions, continuous=True)
```
![continuous](https://github.com/user-attachments/assets/5627e6c6-ac3a-4bdf-b069-b38d233d5aed)

Calculate a continuous h-index for a set of samples from known populations (continuous=True assumed):

```
from hirsch import hirsch
samples = [1,2,3,4,10,20,10]
populations = [10,10,10,10,20,30,40]
h = hirsch(samples, populations)
```
remotedatalogger 1.0.0
Please do not use this library
Requires Python: >=3.6

MIT License

Copyright (c) 2024 André Buck Miedzinski

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
danidisp 0.1.5
My own package: every useful function I want to use


        Package contains:

        - xor(a: bytes, b: bytes) -> bytes
        - dlog(n: int, b: int, mod: int) -> int
        - base_conv(n: str, bs: int = 10, be: int = 10) -> str
        - @clock
        - sprint(string: str, gap: float = 0.03, new_line: bool = True) -> None
        - sinput(prompt: str) -> str
cprspy 0.1.0
Circle-Point-Round Source Pure Python Package
Requires Python: >=3.6

# 圈点圆

#### 介绍
《圈点禅》
圈点圈点圈点点，圈圈点点圈圈点。点点圈圈点点圈，点圈点圈点圈圈。
圈圈点，点点圈，圈圈点点点点圈。点点圈，圈点点，点圈点圈圈点点。
《波粒间》
粒是点，波是圈，圈点不分混沌间。物质粒子实体纤，能量波动信息牵。
何理可证波论定？何物能认粒在先？波粒二象本互谦，实则圈点阴阳天。
《圈点圆》：用圈点来构建一切圆满的科学与艺术。

#### 软件架构
软件架构说明


#### 安装教程

1.  xxxx
2.  xxxx
3.  xxxx

#### 使用说明

1.  xxxx
2.  xxxx
3.  xxxx

#### 参与贡献

1.  Fork 本仓库
2.  新建 Feat_xxx 分支
3.  提交代码
4.  新建 Pull Request


#### 特技

1.  使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
2.  Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com)
3.  你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目
4.  [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目
5.  Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help)
6.  Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)
google-colab-tor-proxy 0.1.0
A tool for installing and configuring Tor and Privoxy.
Requires Python: >=3.6

# tor_privoxy_setup

A Python package to install and configure Tor and Privoxy for anonymized browsing.

## Installation

```bash
pip install google_colab_tor_proxy

## Usage

To use the package in your Python script, you can do the following:

```python
import google_colab_tor_proxy import tor_proxy_setup

tor_proxy_setup()
```

This will install and configure Tor and Privoxy for you.

## Example

Here is an example of how to use the package in a script:

```python
import requests
from google_colab_tor_proxy import tor_proxy_setup

tor_proxy_setup()

proxies = {
    'http': 'http://localhost:8118',
    'https': 'http://localhost:8118',
}

response = requests.get('http://httpbin.org/ip', proxies=proxies)
print(response.json())
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.