semvec/pypi-packages huggingface dataset:
logstack 0.0.7
logstack is a convenience package to communicate with a logstack server
Requires Python: >=3.8

# LogStack
[![Python 3.8](https://img.shields.io/badge/python-3.8-blue.svg)](https://www.python.org/downloads/release/python-380/)

`LogStack` is a convenience package to communicate with a `LogStack` server,
which is available as a `Docker` image [here](https://github.com/strativ-dev/log-collector).

## Getting Started
```bash
    pip install logstack
```

## Contributing
If you face any issues with project, please create and submit an issue,
detailing the problem and providing examples to reproduce the problem.

If you wish to contribute to the project via enhancements, please submit an
issue outlining how your suggested changes improves the project and the scope of
the change.
calculo 0.0.2
Cálculo
Requires Python: >=3.0

# Calculo

Descrição 
O pacote calculo pode ser utilizado para calcular o preço de venda de um produto, com base no valor que se deseja receber e a taxa cobrada pela máquina de cartão.

## Instalação

Utilize o gerenciador de pacotes [pip](https://pip.pypa.io/en/stable/) para instalar o pacote calculo.

```bash
pip install calculo
```

## Como utilizar

```python
from calculo import preco_com_taxa
preco_com_taxa.calcular(100.00, 2.79)
```

## Autor
Joelson Alves

## Licença
[MIT](https://choosealicense.com/licenses/mit/)
qublets 0.1.3
A quantum computing library for the rest of us
Requires Python: >=3.6

Qublets
===

Qublets is an approachable Quantum Computing Library written in Python using Intel's [intel-qs](https://github.com/iqusoft/intel-qs) Quantum Computing Simulator. The goal of the library is to make introductory quantum computing approachable at the undergraduate (or lower) level.

Setup
---

If you are on Unix, the easiest way to start using qublets is by installing the pre-compiled [pip module](https://pypi.org/project/qublets/):
```bash
pip install qublets
```

If you don't have [pip](https://pip.pypa.io/en/stable/installation/) installed, it takes 30 seconds and it will make your life managing Python deps much easier:

```bash
cd ~
curl https://bootstrap.pypa.io/get-pip.py > get-pip.py
python3 get-pip.py
```

If you are **not** on Unix or don't want to install pip, you can always [build from source](./build_from_source.md)

Getting Started
---

Qublets makes it easy to run simple quantum examples. Consider the classic "Superposition qubit" case:

```python
from qublets import QUInt

result = QUInt.zeros(1).hadamard().measure()
print(result)
```

As you can see, Qublets aims to be as readable as possible (although you can customize quite a bit later). Running the code above will yield a `1` 50% of the cases and a `0` the rest. That's it. You may also notice (most) Qublets operators are chainable and will return the object they operated on - this makes building circuits a breeze.

If you're familiar with quantum state names, you can make the above example even shorter by using a `|+〉`state:

```python
from qublets import QUInt

result = QUInt.pluses(1).measure()
print(result)
```

You may have noticed Qublets supports integers natively - in fact, it supports both unsigned and signed integers of any given size (that your computer can work with without combusting in flames). The example above easily generalizes to a 4-bit QInt:

```python
from qublets import QInt

result = QInt.pluses(4).measure()
print(result)
```
Now, you'd instead get a (mostly) uniformly random number between `-8` and `7`.

It wouldn't really be a quantum computing library if we didn't entangle some bits so let's do that quickly:
```python
from qublets import QUInt

q1 = QUInt.zeros(2)
q1[0].hadamard()
q1[1].c_negate(on=q1[0])
print(q1.measure())

# Or, just like before, we can use a shortcut
print(QUInt.fully_entangled(2).measure())
```

If you're familiar with quantum computing's ABCs, you'd likely be happy to see only `0` and `3` as the possible values of the measurements. That's because the classic `had`/`cnot` combo will give us a perfect `|Φ+〉`state (a bell pair) to work with. `fully_entangled`, on the other hand, will always entangle all the bits in a `QInt` using a chain of `cnot`s - which would be equivalent for only 2 bits.

Qublets also supports cross-q(u)int operations, built-in primitives, batch runs for your circuits, extracting probability amplitudes and more - you can find some inspirational samples in [docs/examples/](./docs/examples/)
spring-force 0.0.1
A tool for generating solutions and plots for Hooke Law and Harmonic Oscillation
Requires Python: >=3.5

# Spring Force Tool

Description. 
The package spring force is used to:
	- Find solutions of a force in Hooke's Law (F = -kx)
	- Find the Energy Solution for s spring in Hooke's Law
	- Find solutions of a Mechanical Harmonic Oscillator
	- Plot the function of force F(x) in Hooke's Law
	- Plot the function of a Harmonic oscillator as X(t)
	- Plot the function of Energy U(x) in Hooke's Law
	- Save image

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install spring_force
```

## Author
Egleidson Frederik

## License
Not needed