semvec/pypi-packages huggingface dataset:
fizzbuzz-a-a-r-2 0.1.0
Setting up CI project
Requires Python: >3.9

# ExamFinalScripting
## Who made this project ?
### Group : 
    - Augustin Marie
    - Aya Najare
    - Remi Staelen

## Want to use this project ?
1. Fork / Clone
2. Create and activate a virtual environment **without poetry** 
#### Install venv 
```sh
$ py -m pip install --user virtualenv
```
#### Creating virtual env 
```sh
$ py -m venv env
```
#### Activating virtual env
```sh
$ .\env\Scripts\activate
```
3. Install requirements 
```sh
$  pip install -r requirements.txt
```
4. Install poetry 
```sh
$  pipx install poetry
```
5. Install poetry dependencies 
```sh
$  poetry install 
```
6. Activate virtual env **using poetry** 
```sh
$  poetry shell 
```


## Run the tests with poetry:
### Unit tests
Unit tests are made with the unittest, to launch them manually, run : 
```sh
$ poetry run python -m unittest discover
```

### Functional tests
Functional tests are made with behave, to launch them manually, run : 
```sh
$ poetry run behave
```

## CI made with
To manually run linters with poetry, you can use the following commands : 
### flake8
```sh
$ poetry run flake8 .
```
### Isort 
```sh
$ poetry run isort .
```
### Bandit 
```sh
$ poetry run bandit -r .
```
## Build & Publish with poetry
### Authentication 
```sh
$ poetry config http-basic.pypi <username> <password>
```
### Build & Publish 
```sh
$ poetry publish --build
```
traice 0.2.0
Tiny yet useful tool for consistent model training logs generation

# traice

Tiny yet useful tool for consistent model training logs generation.

# Installation

To install through pip use the following command:

```sh
pip install traice
```

The tool requires only `pandas` package to be installed. However, there is `environment.yml` file which can be used for the same environment which is used for developing the tool:

```sh
conda env create -f environment.yml
```

# Usage

The tool may be used as follows (see `examples/dummy.py`):

```py
from random import seed, uniform
from time import time, sleep

from traice import Traicer

traicer = Traicer()


def train_step():
    sleep(uniform(0, 1))


seed(17)

init_timestamp = time()

for i in range(1, 5):
    start_timestamp = time()
    train_step()
    traicer.push(i, uniform(0, 1 / i), (time_ := time()) - start_timestamp, time_ - init_timestamp)

print(traicer.df)
```

Essentially, it accumulates all `push` arguments in a list which is then converted to a dataframe. The example produces the following log (the last two columns may differ a bit):

```sh
   epoch      loss      time  cumulative_time
0      1  0.806691  0.522609         0.522609
1      2  0.144813  0.961565         1.484184
2      3  0.234740  0.767061         2.251254
3      4  0.027541  0.661659         2.912921
```

# Testing

To run test execute the following statement in your terminal:

```sh
python -m unittest discover test
```
HDF5eis 0.1.1rc2
A solution for handling big, multidimensional timeseries data from environmental sensors in HPC applications.
Requires Python: >=3.6

# HDF5eis Python API (read H-D-F-Size)
#### A solution for handling big, multidimensional timeseries data from environmental sensors in HPC applications.

HDF5eis is designed to
1. store primitive timeseries data with any number of dimensions;
2. store auxiliary and meta data in columnar format or as UTF-8 encoded byte streams alongside timeseries data;
3. provide a single point of *fast* access to diverse data distributed across many files; and
4. simultaneously leverage existing technology and minimize external dependencies.

```python
import hdf5eis

with hdf5eis.File("demo.hdf5", mode="w") as demo_file:
    # Add some random multidimensional timeseries data to the demo.hdf5 file.
    first_sample_time = "2022-01-01T00:00:00Z"
    sampling_rate = 100
    demo_file.timeseries.add(
        np.random.rand(32, 16, 8, 16, 32, 1000),
        first_sample_time, 
        sampling_rate,
        tag="random"
    )
    
    # Data can be efficiently retrieved using hybrid dictionary (with regular expression parsing)
    # and array metaphors.
    start_time, end_time = "2022-01-01T00:01:00Z", "2022-01-01T00:02:00Z"
    sliced_data = demo_file.timeseries["rand*", 8:12, ..., 0, start_time: end_time]
```

# Installation

```bash
>$ pip install hdf5eis
```
CtfReader 0.0.1
Package that helps to read the Ctf files in python
Requires Python: >=3.6

# Python Ctf Reader
## Installing

**To install this package you need to type this command
into console:**

```
pip install 
```

## Working

### First you need to import the library

```python
import 
```
or
```python
from import CtfFile
```

### Create a Ctf File
```python
file = CtfFile("path to ctf file")
```

Or

```python
file = .CtfFile("path to ctf file")
```

### Get all text from the file

```python
file.getText()
```

### Get all text by lines

```python
file.getAllLines()
```

### Read the file and print to console

```python
file.read()
```