semvec/pypi-packages huggingface dataset:
discord-spotify 0.1.5
A Python package to retrieve detailed Spotify album images for Discord integration.
Requires Python: >=3.6
Keywords: discord spotify spotify-wrapper image

# DISCORD-SPOTIFY

[![Downloads](https://static.pepy.tech/badge/cbvx)](https://pepy.tech/project/cbvx)

A Python package to retrieve detailed Spotify album images for Discord integration.



`example.py`
```py
import discord
from discord.ext import commands
from discord_spotify import spotify

bot = commands.Bot(
    command_prefix=",",
    intents=discord.Intents.all(),
    allowed_mentions=discord.AllowedMentions.none()
)

@bot.command(name="spotify")
async def spotif(ctx: commands.Context, member: discord.Member = None):
    member = member or ctx.author
    client = spotify.Spotify(bot=bot, member=member)
    content, image, view = await client.get()
    await ctx.reply(content=content, file=image, view=view)

bot.run("token")
```
polywrap-plugin 0.1.2
Polywrap Plugin package
Requires Python: >=3.10,<4.0

Polywrap Plugin
===============
This package contains the runtime for the Polywrap plugin system.

Quickstart
----------

Imports
~~~~~~~

>>> from typing import Any, Dict, List, Union, Optional, cast
>>> from polywrap_manifest import AnyWrapManifest
>>> from polywrap_plugin import PluginModule
>>> from polywrap_core import InvokerClient, Uri

Define a plugin module
~~~~~~~~~~~~~~~~~~~~~~

>>> class GreetingModule(PluginModule[None]):
...     def __init__(self, config: None):
...         super().__init__(config)
...
...     def greeting(self, args: Dict[str, Any], client: InvokerClient, env: Optional[Any] = None):
...         return f"Greetings from: {args['name']}"

Create a plugin wrapper
~~~~~~~~~~~~~~~~~~~~~~~

>>> greeting_module = GreetingModule(None)
>>> manifest = cast(AnyWrapManifest, NotImplemented)
>>> wrapper = PluginWrapper(greeting_module, manifest)

Invocation
~~~~~~~~~~

>>> args = {
...     "name": "Joe"
... }
>>> result = wrapper.invoke(
...     uri=Uri.from_str("ens/greeting.eth"),
...     method="greeting",
...     args=args,
...     client=cast(InvokerClient, NotImplemented),
... )
>>> assert result.result == "Greetings from: Joe"
polywrap-wasm 0.1.2
Polywrap Wasm
Requires Python: >=3.10,<4.0

Polywrap Wasm
=============
This package contains the runtime for executing Wasm wrappers.

Quickstart
----------
The following code snippet demonstrates how to use the runtime to execute a Wasm wrapper.

Imports
~~~~~~~

>>> import os
>>> from typing import cast
>>> from polywrap_core import Uri, FileReader, InvokerClient
>>> from polywrap_wasm import WasmWrapper
>>> from polywrap_msgpack import msgpack_decode
>>> from polywrap_manifest import deserialize_wrap_manifest, AnyWrapManifest

Create a Wasm wrapper
~~~~~~~~~~~~~~~~~~~~~

>>> path_to_wrapper = os.path.join(os.path.dirname(__file__), "..", "tests", "cases", "simple")
>>> assert os.path.exists(path_to_wrapper)
>>> with open(os.path.join(path_to_wrapper, "wrap.wasm"), "rb") as f:
...     wasm_module = f.read()
>>> assert isinstance(wasm_module, bytes)
>>> with open(os.path.join(path_to_wrapper, "wrap.info"), "rb") as f:
...     manifest = deserialize_wrap_manifest(f.read())
>>> assert isinstance(manifest, AnyWrapManifest)
>>> wrapper = WasmWrapper(
...     cast(FileReader, NotImplemented),
...     wasm_module,
...     manifest
... )
>>> assert isinstance(wrapper, WasmWrapper)

Invocation
~~~~~~~~~~

>>> message = "Hello, World!"
>>> args = {"arg": message}
>>> result = wrapper.invoke(
...     uri=Uri.from_str("wrap://authority/path"),
...     method="simpleMethod",
...     args=args,
...     client=cast(InvokerClient, NotImplemented),
... )
>>> assert result.encoded is True
>>> assert msgpack_decode(cast(bytes, result.result)) == message
polywrap-test-cases 0.1.2
Wrap Test cases for Polywrap
Requires Python: >=3.10,<4.0

Polywrap Test Cases
===================
This package contains the utility functions to fetch the wrappers    from the wasm-test-harness repo.

Functions
---------

.. csv-table::
    :header: "function", "description"

    "get_path_to_test_wrappers", "Get the path to the test wrappers."
    "fetch_file", "Fetch a file using HTTP."
    "unzip_file", "Unzip a file to a destination."
    "fetch_wrappers", "Fetch the wrappers from the wasm-test-harness repo."
tw_invoice 2023.9.6
🇹🇼🧾 Python SDK for accessing Taiwan E-Inovice API
Requires Python: ~=3.7
Keywords: taiwan,tw,invoice,tax,taxation,tax-invoice,invoice-api

# 🇹🇼 Taiwan Invoice

[![PyPI](https://img.shields.io/pypi/v/tw_invoice?color=brightgreen&logo=pypi&logoColor=white)](https://pypi.org/project/tw_invoice)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/tw_invoice?color=brightgreen&logo=python&logoColor=white)
![PyPI - Downloads](https://img.shields.io/pypi/dm/tw_invoice?color=brightgreen)
![PyPI - License](https://img.shields.io/pypi/l/tw_invoice?color=brightgreen)

[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/tomy0000000/tw-invoice/test.yml?branch=main&logo=Github)](https://github.com/tomy0000000/tw-invoice/actions/workflows/test.yml)
[![Coverage](https://img.shields.io/codecov/c/github/tomy0000000/tw-invoice?color=brightgreen&logo=codecov&logoColor=white&token=ESgHfrrk6z)](https://codecov.io/gh/tomy0000000/tw-invoice)
[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/tomy0000000/tw-invoice/main.svg)](https://results.pre-commit.ci/latest/github/tomy0000000/tw-invoice/main)

[中文版 README](https://github.com/tomy0000000/tw-invoice/blob/main/README_zh.md)

SDK for Ministry of Finance, R.O.C. [E-invoice platform](https://www.einvoice.nat.gov.tw)

## Usage

See [Wiki](https://github.com/tomy0000000/tw-invoice/wiki)

## LICENSE and disclaimer

The source code is released under MIT license, versions with suffix b represent beta version, use at your own risk.

The author is not affiliated to MoF, or the platform in any kind.
polywrap-manifest 0.1.2
WRAP manifest
Requires Python: >=3.10,<4.0

Polywrap Manifest
=================
Polywrap Manifest contains the types and functions to de/serialize  Wrap manifests defined at https://github.com/polywrap/wrap.

Quickstart
----------

Deserialize WRAP manifest
~~~~~~~~~~~~~~~~~~~~~~~~~

>>> from polywrap_manifest import deserialize_wrap_manifest, WrapManifest_0_1
>>> from polywrap_msgpack import msgpack_encode
>>> raw_manifest = msgpack_encode({
...     "version": "0.1.0",
...     "type": "interface",
...     "name": "test-interface",
...     "abi": {},
... })
>>> manifest = deserialize_wrap_manifest(raw_manifest)
>>> assert isinstance(manifest, WrapManifest_0_1)
RobustGibbs 0.0.7
Package for Gibbs Sampling with Robust Statistics.
Requires Python: >=3.7

# RobustGibbs Package

`Robust_Gibbs` is a package that allows users to sample from the parameters posteriors when only some robust statistics of the data are available. The paper that describe all the theory of the methods can be found on arXiV (https://arxiv.org/abs/2307.14973). 

## Main functions

We propose here three mains functions named `Gibbs_med_MAD`, `Gibbs_med_IQR` and `Gibbs_Quantile` to cover the case when we observe the pairs (median, MAD) or (median, IQR) or a sequence of quantiles. 


## Install

Install via clone the repository and install via pip

```shell
git clone https://github.com/???
pip install .
```

## Use

Here, we sample from the posterior of parameters of a normal distribution using the couple of conjuguate couple Normal-InverseGamma. 

```python
# CODE
```

## Available distributions/likelihoods
* Normal distribution (`distribution="normal"`)
* Cauchy distribution (`distribution="cauchy"`)
* Weibull distribution (`distribution="weibull"`)
* Translated distribution (`distribution="translated_weibull"`)

## Available location priors
* Normal (`par_loc="normal"`)
* Cauchy (`par_loc="cauchy"`)
* Gamma (`par_loc="gamma"`)

## Available scale priors
* Gamma (`par_scale="gamma"`)
* Jeffreys (`par_scale="jeffreys"`)

## Available shape prior
* Gamma (`par_shape="gamma"`)
light-distribution-analysis 0.2.0.1
Analyze the flux of images based on wavelength and frequency
Keywords: light distribution analysis flux wavelength frequency images

# Light-Distribution-Analysis

For more details, you can visit the [Documentation](https://github.com/SweatyCrayfish/light-distribution-analysis).

## Overview

Light-Distribution-Analysis is a Python package designed for the analysis of light distribution in images. The package utilizes OpenCV, NumPy, and Matplotlib to enable in-depth yet simple analysis of the flux and power in images based on their wavelength and frequency representations.

## Features

- Convert RGB images to wavelength and frequency representations.
- Apply edge detection on images.
- Calculate the flux and power of images.
- Save processed images in various forms, including original, wavelength, frequency, and power images.
- Calculate similarity scores based on flux and power.
- Plot power images.
- Export flux and power data to a CSV file for further analysis (feature planned).

## Installation

To install Light-Distribution-Analysis, run the following command in your terminal:

```bash
pip install light-distribution-analysis
tracuni 0.4.18a0
Convenient library to plug in tracer to incoming and outgoing points and extract data from there
Requires Python: >=3.5.3
Keywords: jaeger zipkin tracer

========
trac_uni
========






Convenient library to plug in tracer to incoming and outgoing points and extract data from there



Features
--------

* TODO

Credits
-------

This package was created with Cookiecutter_ and the `audreyr/cookiecutter-pypackage`_ project template.

.. _Cookiecutter: https://github.com/audreyr/cookiecutter
.. _`audreyr/cookiecutter-pypackage`: https://github.com/audreyr/cookiecutter-pypackage


=======
History
=======


v0.0.2 (2018-12-24)
-------------------
- Bump version: 0.0.1 → 0.0.2   - finally tox works with all versions in
  PyCharm environment   - starter tests for type and constants.
- Bump version: 0.0.1 → 0.0.2.
- Refab:   - entry point rename. 
- Feat:   - python 3.4 compatible named tuples for library options   -
  starter constant   - tested. 
- Refab:   - some basic test to make 100% coverage.
- Chore:   - move interpreter version requirements from Pipfile into
  setup.py   - turn on live log for py.test   - return standard
  environment names in tox setup   - set interpreter location for 'py-
  charm' in tox setup   - fix python path passed in tox setup   - edit
  doc according to 2 previous items. 
- Wip: 


v0.0.1 (2018-12-21)
-------------------
- Bump version: 0.0.0 → 0.0.1   Project prepared for coding the tests.
  
- Chore:   - put into project current source to refab and test.
  
- Chore:   - changelog by git commits generation tool. [Konstantin
  Goncharov]
- Docs:   - short list what have been done to provide tooling.
  
- Chore:   - add make scripts for devpi   - setup docs generation with
  browser refresh on changes   - all make commands works. [Konstantin
  Goncharov]
- Feat:   - add primitive test   - satisfy flake8. [Konstantin
  Goncharov]
- Chore:   - return template dev deps. 
- Chore:   - install bumpversion dep   - move pipfile loca index example
  in main file   - add make script to generate requirements(_dev).txt.
  
- Chore:   - add devpi to make local repo builds   - describe how to add
  devpi   - provide files for run test in devpi environment. [Konstantin
  Goncharov]


v0.0.0 (2018-12-20)
-------------------
- Chore:   - add description how to create this scaffolding   - zeroed
  version. 
- Chore:   - initialize python envs and deps. 
- Chore:   - start from template.
polywrap-msgpack 0.1.2
WRAP msgpack encoder/decoder
Requires Python: >=3.10,<4.0

Polywrap Msgpack
================

polywrap-msgpack adds ability to encode/decode to/from msgpack format.

It provides msgpack_encode and msgpack_decode functions
which allows user to encode and decode to/from msgpack bytes

It also defines the default Extension types and extension hook for
custom extension types defined by WRAP standard

Quickstart
----------

Encoding-Decoding Native types and objects
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

>>> from polywrap_msgpack import msgpack_decode, msgpack_encode
>>> dictionary = {
...     "foo": 5,
...     "bar": [True, False],
...     "baz": {
...         "prop": "value"
...     }
... }
>>> encoded = msgpack_encode(dictionary)
>>> decoded = msgpack_decode(encoded)
>>> assert dictionary == decoded
>>> print(decoded)
{'foo': 5, 'bar': [True, False], 'baz': {'prop': 'value'}}
    
Encoding-Decoding Extension types
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

>>> from polywrap_msgpack import msgpack_decode, msgpack_encode, GenericMap
>>> counter: GenericMap[str, int] = GenericMap({
...     "a": 3,
...     "b": 2,
...     "c": 5
... })
>>> encoded = msgpack_encode(counter)
>>> decoded = msgpack_decode(encoded)
>>> assert counter == decoded
>>> print(decoded)
GenericMap({'a': 3, 'b': 2, 'c': 5})