semvec/pypi-packages huggingface dataset:
radiometerAPI 1.0.9
API for radiometer
Requires Python: >=3.10
Keywords: radiometer

# RadiometerAPI

<h2> Создание экземпляра RadiometerAPI: </h2>

`radiometer_api = RadiometerAPI(server_address: str, token: str, verify_ssl: bool, session: ClientSession | None = None)` <br />
<br />
`server_address` - адрес сервера <br />
`verify_ssl` - включить/отключить проверку ssl сертификата<br />
`token` - авторизационный токен <br />
`session` - экземпляр aiohttp.ClientSession(loop=loop) с указанным циклом событий loop <br />

# Методы RadiometerAPI

<h2> Синхронные методы: </h2>

`get_measurement(id: int)` - возвращает информацию об измерении <br />
`get_measurement_with_data(id: int)` - возвращает информацию об измерении вместе с сырыми данными <br />
`get_measurements()` - возвращает информацию об измерениях <br />
`get_measurements_with_data()` - возвращает информацию об измерениях вместе с сырыми данными <br />
`get_devices()` - возвращает устройства <br />
`get_patients()` - возвращает пациентов <br />
`get_calibrations()` - возвращает калибровки <br />

<h2> Асинхронные методы: </h2>

`get_measurement_async(id: int)` - асинхронно возвращает информацию об измерении <br />
`get_measurement_with_data_async(id: int)` - асинхронно возвращает информацию об измерении вместе с сырыми данными <br />
`get_measurements_async()` - асинхронно возвращает информацию об измерениях <br />
`get_measurements_with_data_async()` - асинхронно возвращает информацию об измерениях вместе с сырыми данными <br />
`get_devices_async()` - асинхронно возвращает устройства <br />
`get_patients_async()` - асинхронно возвращает пациентов <br />
`get_calibrations_async()` - асинхронно возвращает калибровки <br />
torch-vggish-yamnet 0.2.1
torch_vggish_yamnet: PyTorch VGGish & YAMNet models
Requires Python: >=3.6

# Torch VGGish & YAMNet embedding models

**torch_vggish_yamnet** provides a ready-to-use PyTorch porting of AudioSet (Google) audio embedding models. The audio tagging models are trained from Models for AudioSet: A Large Scale Dataset of Audio Events: https://github.com/tensorflow/models/tree/master/research/audioset

This is a re-structured forked repository/project from ```torch_audioset``` (see References)

## Installation
PyTorch>=1.0 is required (dependecies are auto-installed).
```
pip install torch-vggish-yamnet
```

## Usage
```
from torch_vggish_yamnet import yamnet
from torch_vggish_yamnet import vggish
from torch_vggish_yamnet.input_proc import *

# Input signal (x_in) tensor conversion & ad-hoc patching
converter = WaveformToInput()
in_tensor = converter(x_in.float(), in_sr)
in_tensor.shape

# Models init
embedding_yamnet = yamnet.yamnet(pretrained=True)
embedding_vggish = vggish.get_vggish(with_classifier=False, pretrained=True)

# Embedding (forward)
emb_yamnet, _ = embedding_yamnet(in_tensor)  # discard logits
emb_vggish = embedding_vggish(in_tensor)

emb_yamnet.shape, emb_vggish.shape
```

## References
[1] AudioSet Official site: http://g.co/audioset

[2] 
```
@inproceedings{45857,
 title	    = {Audio Set: An ontology and human-labeled dataset for audio events},
 author	    = {Jort F. Gemmeke and Daniel P. W. Ellis and Dylan Freedman and Aren Jansen and Wade Lawrence and R. Channing Moore and Manoj Plakal and Marvin Ritter},
 year	      = {2017},
 booktitle	= {Proc. IEEE ICASSP 2017},
 address	  = {New Orleans, LA}}
```
[3] 
```
@incollection{45611,
title	      = {CNN Architectures for Large-Scale Audio Classification},
author	    = {Shawn Hershey and Sourish Chaudhuri and Daniel P. W. Ellis and Jort F. Gemmeke and Aren Jansen and Channing Moore and Manoj Plakal and Devin Platt and Rif A. Saurous and Bryan Seybold and Malcolm Slaney and Ron Weiss and Kevin Wilson},
year	      = {2017},
URL	        = {https://arxiv.org/abs/1609.09430},
booktitle	  = {International Conference on Acoustics, Speech and Signal Processing (ICASSP)}}
```

[4] torch_audioset GitHub repository: https://github.com/w-hc/torch_audioset/tree/master
fancylogging 0.0.4
hassle-free nicely-formatted console and file logging in Python
Requires Python: >=3.8

.. image:: https://img.shields.io/pypi/v/fancylogging
   :alt: PyPI - Version

Fancy Logging
=============

Introduction
------------

This Python module provides an advanced logging setup using `rich` for 
console logging and `python-json-logger` for file logging. It allows for
detailed and formatted logging, ideal for applications requiring high-level
logging capabilities.

Installation
------------
This module requires the following dependencies:

* `rich <https://pypi.org/project/rich/>`_
* `python-json-logger <https://pypi.org/project/python-json-logger/>`_

Usage
-----
Import ``setup_fancy_logging`` from the module and configure your logging setup
by specifying parameters like `base_logger_name`, `console_log_level`,
`file_log_level`, `log_file_path`, and others.

Example:


.. code-block:: python

  import logging
  from fancylogging import setup_fancy_logging

  log = logging.getLogger("test")

  if __name__ == "__main__":
      setup_fancy_logging(
          "test",
          console_log_level=logging.INFO,
          file_log_level=logging.DEBUG,
          file_log_path="logs/test.json",
          file_mode="w",
      )

      log.info("Info message")
      log.debug("Debug message")
      log.warning("Warning message")
      log.error("Error message")
      log.critical("Critical message")
      try:
          raise Exception("Raising a test exception")
      except Exception:
          log.exception("Exception message")
var-processor 0.0.2
Var_processor is a Python library that can automatically handle common variable operations in projects.
Requires Python: >=3.6

# Var_processor

Var_processor is a Python library that can automatically handle common variable operations in projects.

Now it supports automatic saving of specified variables when project exceptions or errors occur.

The project is currently under development, so let's look forward to more wonderful things together.

## Features

- Automatically saves specified local variables to a file.
- Support all types of variables.
- Support variables with the same name in different functions.

## Installation

Install using `pip`:

```shell
pip install var_processor --index-url https://pypi.org/simple  
```

## Usage
```python
from var_processor.functional import save_on_error

@save_on_error(vars=["a", "b", "c"])
def main():
    a = 10
    b = 20.0
    c = {}

    # Raise ZeroDivisionError
    # Variables `a`, `b`, `c` will be automatically saved.
    d = a / 0

if __name__ == "__main__":
    main()
```


```python
from var_processor.functional import pdb_on_error

@pdb_on_error
def main():
    a = "s"
    b = 1

    def a():
        a = "gg"
        tt = 1 / 0

    a()
    b = 1 / 0
    print("ss")


if __name__ == "__main__":
    main()
```
paramlogger 0.0.2
This library helps logging the inputs and outputs of a method just by adding a decorator on that method.
Requires Python: >=3.8

# paramlogger


[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

This library helps logging to file, the inputs parameters and output return values of a method just by adding a decorator on that method.

### Usage
Refer to [./demo.ipynb](./demo.ipynb) for examples on everything that's possible via this library.

### Official source code repo: 
```
git clone https://github.com/vivek-dani/paramlogger.git
```


### Citation

Please cite this software in your work as:

```
@misc{paramlogger-github,
   author = {Vivek Dani},
   title = {paramlogger: Library that helps logging to file, the inputs parameters and output return values of a method just by adding a decorator on that method.},
   url = {https://github.com/vivek-dani/paramlogger},
   version = {0.0.2},
   year = {2024}
}
```
thesisbot 0.1
A library for decision making using expert systems and text similarity
Requires Python: >=3.6

Title
===
Abstract:xxx
## Papar Information
- Title:  `paper name`
- Authors:  `A`,`B`,`C`
- Preprint: [https://arxiv.org/abs/xx]()
- Full-preprint: [paper position]()
- Video: [video position]()

## Install & Dependence
- python
- pytorch
- numpy

## Dataset Preparation
| Dataset | Download |
| ---     | ---   |
| dataset-A | [download]() |
| dataset-B | [download]() |
| dataset-C | [download]() |

## Use
- for train
  ```
  python train.py
  ```
- for test
  ```
  python test.py
  ```
## Pretrained model
| Model | Download |
| ---     | ---   |
| Model-1 | [download]() |
| Model-2 | [download]() |
| Model-3 | [download]() |


## Directory Hierarchy
```
|â€”â€” setup.py
|â€”â€” thesisbot
|    |â€”â€” decision_engine.py
|    |â€”â€” static
|        |â€”â€” css
|            |â€”â€” style.css
|        |â€”â€” js
|            |â€”â€” script.js
|    |â€”â€” templates
|        |â€”â€” index.html
|    |â€”â€” __init__.py
```
## Code Details
### Tested Platform
- software
  ```
  OS: Debian unstable (May 2021), Ubuntu LTS
  Python: 3.8.5 (anaconda)
  PyTorch: 1.7.1, 1.8.1
  ```
- hardware
  ```
  CPU: Intel Xeon 6226R
  GPU: Nvidia RTX3090 (24GB)
  ```
### Hyper parameters
```
```
## References
- [paper-1]()
- [paper-2]()
- [code-1](https://github.com)
- [code-2](https://github.com)
  
## License

## Citing
If you use xxx,please use the following BibTeX entry.
```
```
py9pfactotum 0.1.1
The factotum module implements a plan9port's auth(3) library.
Requires Python: >=3.9

py9pfactotum
============

py9pfactotum is Python's plan9port Factotum client. It also provides
the following extras:

- Helper functions that mirror plan9port's auth(3) library
- A [Keyring](https://pypi.org/project/keyring/) backend to connect
  to your running factotum server.

Usage
-----

In the current (alpha) state of maturity, the implementation is
incomplete. Currently enough is implemented to support the Keyring
backend (i.e., to read passwords from the running server).

When using the FactotumClient directly, arguments are passed as
keyword arguments, which are built into a key template internally:

```
from py9pfactotum import FactotumClient
c = FactotumClient()
c.getpass(server='mail.example.org', user='johndoe')
{ 'user': 'johndoe', 'passwd': 'insecure' }
```

As with the example above, the client provides high-level methods
that supply the correct 'proto' and 'role' attributes to the key
template. See factotum(4) for more information.

When using the auth(3) functions, the function signatures mirror
their plan9port counterparts, except that structures are replaced
with dictionaries.

```
from py9pfactotum import auth_getuserpasswd
c = auth_getuserpasswd(server='mail.example.org')
{ 'user': 'johndoe', 'passwd': 'insecure' }
```

Keyring
-------

The Keyring user interface is transparent, but that library must
be explicitly installed on the system (it is not a hard dependency
of py9pfactotum). Because factotum is not able to persist passwords
(or password deletions), attempts to use the Keyring to do so will
throw an error.
cm-text-sdk-python 2.0.4
Python SDK for text with CM.
Requires Python: >=3.6

# Text-sdk-python
![publish to PyPi](https://github.com/cmdotcom/text-sdk-python/workflows/publish%20to%20PyPi/badge.svg)
![PyPi](https://img.shields.io/pypi/v/cm_text_sdk_python
)

## A helper library to sending messages using python.
Want to send messages in your Python application? Then you are at the right address.
If you want to get all the functionalities, go to: [CM.com API Docs](https://docs.cmtelecom.com/bulk-sms/v1.0)

## Installing
Include the SDK by downloading the files manually or running the following command in a Python Shell.
```python3
    pip install cm_text_sdk_python
```

## Instantiate the client
Use your productToken which authorizes you on the CM platform. Get yours on CM.com

```python3
    from cm_text import TextClient

    client = TextClient(apikey=key)
```

## Send a message
By calling `SendSingleMessage` and providing message text, sender name, recipient phone number(s).

```python3
    client = TextClient(apikey=key)
    client.SendSingleMessage(message=message, from_='CM.com', to=Recipients)
```

## Sending multiple messages
By calling `AddMessage` and providing message text, sender name, recipient phone number(s) you can queue multiple messages. Send them by calling `send`.

```python3
    client = TextClient(apikey=key)
    client.AddMessage(message=message, from_='pythonSDK', to=Recipients)
    client.AddMessage(message=message2, from_='pythonSDK', to=Recipients2)
    response = client.send()
```

## Sending a rich message
By calling `AddRichMessage` and providing `Media`, message text, sender name, recipient phone number(s) you can queue multiple Rich messages. Send them by calling `send`.

```python3
    media = {
            "mediaName": "conversational-commerce",
            "mediaUri": "https://www.cm.com/cdn/cm/cm.png",
            "mimeType": "image/png"
        }

    client = TextClient(apikey=key)
    client.AddRichMessage(message=message, from_='pythonSDK', to=to, allowedChannels=allowedChannels, media=media)
    response = client.send()
```

## Sending a Whatsapp Template message
By calling `AddWhatsappTemplateMessage` and providing `Template`, sender name, recipient phone number(s) you can queue multiple Whatsapp Template messages. Send them by calling `send`.

```python3
    template_namespace = "Your-Template-Namespace"
    template_element_name = "Replace with Template Name"
    template = WhatsappTemplate(template_namespace, template_element_name)
    
    client = TextClient(apikey=key)
    client.AddWhatsappTemplateMessage(from_='pythonSDK', to=to, template=template)
    response = client.send()
```

See Examples folder for more examples.

## Sending Interactive Whatsapp message
See the [example file](examples/07_whatsapp_interactive_message.py) for an example.

## Get the result
Sending a message by calling `send` returns the response body. Response is of type: https://requests.readthedocs.io/en/master/user/quickstart/#response-content
```python3
    response = client.send()
```