semvec/pypi-packages huggingface dataset:
pyscpi 0.5.3
A Python library for communicating with SCPI devices and a helper library for communicating with the Keysight's Smart Bench Essentials
Requires Python: >=3.7

# pyscpi

[![PyPI version](https://badge.fury.io/py/pyscpi.svg)](https://badge.fury.io/py/pyscpi)

A Python library for communicating with SCPI devices and a helper library for communicating with the Keysight's [Smart Bench Essentials](https://www.keysight.com/us/en/cmp/2021/keysight-smart-bench-essentials-test-instruments.html) educational equipment. The library communicates using multiple backends including PyVisa, USBTMC and socket communication. The library also provides helper functions for reading oscilloscope waveforms and plotting them.

## Using PyVisa and Keysight's IOLibrary

you need to install Keysight's IOLibrary and PyVisa.

## Using alternative methods including usb and ethernet

You can use USBTMC, a standard for communicating with instruments using USB using generic drivers. This method works both in Windows and WSL2. Alternatively, you can use the standard TCP/IP sockets to communicate with the instrument. However, you need to connect the instrument on the same network as your computer, either using a direct ethernet cable or a switch/router. If you are not using a router, then you may need to set the instrument's IP address manually or use a DHCP server for dynamic IP allocation. Further information can be found in the [here](https://danchitnis.github.io/pyscpi/connections/).

## Getting Started

### Installing

You can install the library using pip:

```bash
python -m pip install --upgrade pyscpi
```

### connecting to the instrument using PyVisa

```python
import pyvisa as visa

rm = visa.ResourceManager()
inst = rm.open_resource('<resource address>')

print(inst.query('*IDN?'))
```

### connecting to the instrument using USBTMC

```python
from pyscpi import usbtmc

inst =  usbtmc.Instrument(<VendorID>, <ProductID>)

print(inst.query("*IDN?"))
```

### connecting to the instrument using socket (driverless)

```python
from pyscpi import scpi

inst = scpi.Instrument('<IP address>', 5025)

print(inst.query('*IDN?'))
```

### Reading oscilloscope waveform

```python
from pyscpi.keysight import osc
import numpy as np

t, y1 = osc.readSingleChannel(inst, 1)
```

### Plotting oscilloscope waveform

```python
# %matplotlib ipympl
import matplotlib.pyplot as plt

plt.plot(t, y1)
plt.show()
```

### closing the connection

```python
inst.close()
```


## Acknowledgments

Thanks to [Keysight Education](https://www.keysight.com/us/en/industries/education.html) for providing the Smart Bench Essentials educational equipment.

[USBTMC](https://github.com/python-ivi/python-usbtmc) is used for communicating with the instruments using USB.
QST 0.1.2
A package to perform Quantum State Tomography
Requires Python: >=3.6

# Quantum State Tomography through Maximum Likelihood Estimation

This work is a culmanation of my graduate school masters project at Stony Brook University in the [Quantum Information Science & Technology Group](http://qit.physics.sunysb.edu/wordpress/) under Dr. Eden Figueroa to perform quantum state tomography through maximum likelihood estimation. You can read more about the work in the document ***Quantum_State_Tomography.pdf***. The main files to perform the simulation of quantum states, through ***Simulate_QST.py***, as well as to perform the maximum likelihood estimation of quantum states, through ***QST_MLE.py***, are described below.

### Simulate_QST.py (Simulations of Quantum Statistics)

Serves to simulate real world examples of quantum states that can be measured through techniques such as Optical Homodyne Detection.

It provides:

- An efficient way of simulating quadrature data for a given quantum state
- Can work with any arbitrary quantum state, including coherent states and (WORK IN PROGRESS) squeezed states

Usage:

The Jupyter Notebook ***Generate_Quadratures_Simulation.ipynb*** contains several working examples of how to easily generate different sets of quadrature data. Datasets from this notebook can be easily saved to a ***Data*** folder to be used for Maximum Likelihood Reconstruction. 

In order to use the functions in a different Python file, make sure to download the ***Simulate_QST.py*** file to the same folder as the new code and use the command:

    from Simulate_QST.py import *

The full list of functions, their usage, as well as some examples can be found within the above Python file.

### QST_MLE.py (Maximum Likelihood Estimation)

Serves to reconstruct the density matrix of a given quantum state, and can be used to extract amplitude and phase information. Our group has shown it to work with real data gathered in the lab through Homodyne Detection of several different coherent states.

It provides:

- A vectorized method of finding the most likely density matrix corresponding to a given set of quadrature data
- Visualizations of the Wigner distribution of the quantum state through [QuTiP](https://qutip.org/docs/4.0.2/guide/guide-visualization.html)

Usage:

The Jupyter Notebook ***MLE.ipynb*** contains an illustritive working example of how to reconstruct a density matrix given a set of quadrature data. It can easily be used in conjuction with the ***Generate_Quadratures_Simulation.ipynb***. 

In order to use the functions in a different Python file, make sure to download the ***MLE_Functions.py*** file to the same folder as the new code and use the command:

    from QST_MLE.py import *
    
The full list of functions, their usage, as well as some examples can be found within the above Python file.
AezaAPI 1.0.2
AezaAPI module
Requires Python: >=3.7
Keywords: aeza python

# AezaAPI

### Описание
Библиотека для использования API сервиса Aeza

### Методы

- <b>get_balance</b> - Узнать баланс
- <b>invoice_card</b> - Пополнить баланс картой
- <b>invoice_qiwi</b> - Пополнить баланс через Qiwi
- <b>status_server</b> - Статус серверов
- <b>add_api_key</b> - Создание API-ключа
- <b>get_api_key</b> - Получение списка API-ключей
- <b>add_ssh_key</b> - Добавление SSH-ключа
- <b>get_ssh_key</b> - Получение списка SSH-ключей
- <b>get_my_server</b> - Получение информации приобретённых серверов
- <b>get_product</b> - Получение списка продуктов
- <b>get_total_product</b> - Количество продуктов
- <b>ordering_service</b> - Покупка сервера

### Примеры

```python
from ApiAeza import aeza

TOKEN = aeza.AuthAeza('API-KEY')


def test() -> str:
    """Функция проверит баланс,
       если он меньше 50 рублей,
       то создаcт счёт на сумму 500 рублей
       при этом метод сразу возвращает ссылку для оплаты."""
    if TOKEN.get_balance() < 50:
        return TOKEN.invoice_card(500)
    return 'Всё хорошо'
```

<b>Покупка сервера</b>

```python
from ApiAeza import aeza

TOKEN = aeza.AuthAeza('API-KEY')


def test() -> str:
    """Покупка сервера."""
    return TOKEN.ordering_service(1, # Количество
                                  'mount', # Срок (hour, mount, quarter_year, year, half_year)
                                  'NameServer', # Имя сервера
                                  3, # ID сервера (Можно узнать методом get_product)
                                  25, # os
                                  True) # Автопродление
```

###Начало работы

Для начала работы импортируйте библиотеку, предварительно установив её
```
pip install ApiAeza
```
```python
from ApiAeza import aeza
```
Далее инициализируйте API-ключ
```python
TOKEN = aeza.AuthAeza('API-KEY')
```
Все методы делаются через переменную в которой вы инициализировали токен
```python
TOKEN.get_my_server()
```
twitchypy-irc 0.1.1
Allows you to connect to Twitch IRC and send and receive messages.
Requires Python: >=3.8,<4.0

## Python Twitch IRC Library

This is a simple Python library for connecting to the Twitch IRC chat and sending/receiving messages.

### Twitch

This is the main class for the Twitch IRC client and has the following methods:

- `__init__(self, user: str = "justinfan12345", token: str = "oauth:1234567890")`: Initializes the client with the given
  username and OAuth token.
- `join(self, channel: str) -> None`: Joins the given channel.
- `part(self, channel: str) -> None`: Leaves the given channel.
- `connect(self) -> None`: Connects to the Twitch IRC server.
- `close(self) -> None`: Closes the connection to the Twitch IRC server.
- `send_message(self, channel: str, message: str) -> None`: Sends a message to the given channel.
- `send_reply(self, message_id: str, channel: str, reply: str) -> None`: Sends a reply to the given message.
- `read(self) -> Generator[TwitchPrivateMessage, None, None]`: Reads messages from the Twitch IRC server.

### TwitchPrivateMessage

This class represents a Twitch private message and has the following attributes:

- `badges` (set): A set of strings representing the badges the user has.
- `color` (str): The color of the user's username in the chat.
- `display_name` (str): The user's display name.
- `first_message` (bool): Whether this is the user's first message in the chat.
- `message_id` (str): The ID of the message.
- `mod` (bool): Whether the user is a moderator.
- `broadcaster` (bool): Whether the user is the broadcaster.
- `returning_chatter` (bool): Whether the user has been in the chat before.
- `room_id` (int): The ID of the room.
- `subscriber` (bool): Whether the user is a subscriber.
- `turbo` (bool): Whether the user has Twitch Turbo.
- `user_id` (int): The ID of the user.
- `name` (str): The user's name.
- `channel` (str): The channel the message was sent to.
- `message` (str): The contents of the message.

### Usage

To use this library, create a `Twitch` instance and call its methods to connect to the Twitch IRC chat and send/receive
messages.

```python
from twitch import Twitch

client = Twitch(user="your_username", token="your_oauth_token")
client.connect()
client.join("your_channel")
client.send_message("your_channel", "Hello, world!")
for message in client.read():
    print(message)
client.close()
```

### Contributing

All contributions are welcome! Please open an issue or pull request if you have any suggestions or find any bugs.

### License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
lingvue 0.0.1
LingVue is a user-friendly language analysis and visualization toolkit that enables researchers, data analysts, and enthusiasts to explore language data and extract valuable insights. With its advanced visualization tools and algorithms, SpråkSyn makes it easy to analyze large language data datasets and create new ones for further analysis.
Requires Python: >=3.7

# LingVue

*A toolkit for analyzing and visualizing language data.*

---

LingVue is a user-friendly language analysis and visualization toolkit that enables researchers, data analysts, 
and enthusiasts to explore language data and extract valuable insights. With its advanced visualization tools and 
algorithms, TextTrove makes it easy to analyze large language data datasets and create new ones for further analysis.
texttrove 0.0.1
TextTrove is a user-friendly language analysis and visualization toolkit that enables researchers, data analysts, and enthusiasts to explore language data and extract valuable insights. With its advanced visualization tools and algorithms, SpråkSyn makes it easy to analyze large language data datasets and create new ones for further analysis.
Requires Python: >=3.7

# TextTrove

*A toolkit for analyzing and visualizing language data.*

---

TextTrove is a user-friendly language analysis and visualization toolkit that enables researchers, data analysts, 
and enthusiasts to explore language data and extract valuable insights. With its advanced visualization tools and 
algorithms, TextTrove makes it easy to analyze large language data datasets and create new ones for further analysis.
spraksyn 0.0.1
SpråkSyn is a user-friendly language analysis and visualization toolkit that enables researchers, data analysts, and enthusiasts to explore language data and extract valuable insights. With its advanced visualization tools and algorithms, SpråkSyn makes it easy to analyze large language data datasets and create new ones for further analysis.
Requires Python: >=3.7

# SpråkSyn

*A toolkit for analyzing and visualizing language data.*

---

SpråkSyn is a user-friendly language analysis and visualization toolkit that enables researchers, data analysts, and enthusiasts to explore language data and extract valuable insights. With its advanced visualization tools and algorithms, SpråkSyn makes it easy to analyze large language data datasets and create new ones for further analysis.