semvec/pypi-packages huggingface dataset:
roborcon 0.5.0
A Minecraft server rcon-dependent library made only for Robocode school.
Requires Python: >=3.8


# roborcon

Module created to provide first lessons on Python And Minecraft (1.16.5 pref) for students in Robocode school.


## Usage/Examples
Example how to auto-build coliseum.
```python
from roborcon import Rcon

rcon = Rcon("server-ip", "rcon-password")
rcon.setPlayer("PlayerNickname")
rcon.setColiseumSize(15,5)
rcon.createColiseum()
```

Sets player nickname(required)
```python
rcon.setPlayer("PlayerNickname")
```
Execute any Rcon command.
```python
rcon.execute("give @a minecraft:diamond")
```
Get player position (array).
```python
x, y, z = rcon.getCoords()
```
Display title (bold red as default).
```python
rcon.title("TitleText")
```
Get all items list (to console).
```python
rcon.printItemNames()
```
Place blocks at position
```python
rcon.setBlock(x, y, z, "block name or id")
```
Fill cubic area around player.
```python
rcon.fill(area=5, "blockname", hollow=False, h=5)
```
Give player Armor, Sword with type
```python
rcon.giveArmor("Diamond")
```
Spawns mob around player or at specific position
(Set enemy to True if spawn around player, if False - spawning at specific position)
```python
rcon.spawnMob("mobname", x=0, y=0, z=0, enemy=True, params="")
```
Checks if player has died between checks
```python
rcon.checkDeath()
```
Change default params of coliseum size
```python
rcon.setColiseumSize(area, height)
```
Create coliseum around player
```python
rcon.createColiseum()
```
exclusiveAI 0.0.21
An inefficient (for the moment) neural network with numpy
Requires Python: >=3.9

This is a simple python library developed by Francesco Paolo Liuzzi and Paul Maximilian Magos for the Machine Learning course 
of the University of Pisa AI Master's Degree.

---

First time you clone the repo:
```bash
> python3 -m venv batNNvenv
> source batNNvenv/bin/activate
> pip install --upgrade pip
> pip install -r requirements.txt
```
Activate local env :
```bash 
> source batNNvenv/bin/activate
```
Build the library:
```bash
> python setup.py bdist_wheel
```
Install the library:
```bash
> pip install /dist/*.wheel
```
Once you have installed it you can call it like any other library: 
```{jupyter}
import batNNlib
from batNNlib import batNN
```
Notice that this installation, if performed this way, will install the library in the local env.
To install it in any other environment such as your global env, deactivate the local one and activate yours:
```bash
> deactivate

% conda activate myenv
or 
% pyenv activate myenv 
or etc...
```
DistroLab 0.2
A package for Gaussian and Binomial distributions
Requires Python: >=3.6

# DistroLab

## Introduction
DistroLab is a Python package for working with Gaussian and Binomial distributions. It provides functionality to calculate characteristics like mean, standard deviation, and to visualize the distributions.

## Installation
To install DistroLab, run the following command:

```commandline
pip install DistroLab
```


## Dependencies
- math
- matplotlib

## Usage
Here are some examples of how to use DistroLab:

### Working with Gaussian Distribution
```python
from distrolab import Gaussian

# Create a Gaussian distribution
gaussian = Gaussian(mu=10, sigma=2)

# Calculate mean and standard deviation
mean = gaussian.calculate_mean()
stdev = gaussian.calculate_stdev()

# Plot the histogram
gaussian.plot_histogram()

# Plot the probability density function
gaussian.plot_histogram_pdf()
```

### Working with Binomial Distribution
```python
from distrolab import Binomial

# Create a Binomial distribution
binomial = Binomial(prob=0.5, size=20)

# Calculate mean and standard deviation
mean = binomial.calculate_mean()
stdev = binomial.calculate_stdev()

# Plot the histogram
binomial.plot_data_histogram()

# Plot the probability density function
binomial.plot_distribution_pdf()
```


## License
This project is licensed under the [MIT License](license.txt)
odapt 1.2.0
File conversion package.
Requires Python: >=3.8

# odapt

[![Actions Status][actions-badge]][actions-link]
[![Documentation Status][rtd-badge]][rtd-link]

[![PyPI version][pypi-version]][pypi-link]
[![Conda-Forge][conda-badge]][conda-link]
[![PyPI platforms][pypi-platforms]][pypi-link]

[![GitHub Discussion][github-discussions-badge]][github-discussions-link]

<!-- SPHINX-START -->

<!-- prettier-ignore-start -->
[actions-badge]:            https://github.com/zbilodea/odapt/workflows/CI/badge.svg
[actions-link]:             https://github.com/zbilodea/odapt/actions
[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/odapt
[conda-link]:               https://github.com/conda-forge/odapt-feedstock
[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
[github-discussions-link]:  https://github.com/zbilodea/odapt/discussions
[pypi-link]:                https://pypi.org/project/odapt/
[pypi-platforms]:           https://img.shields.io/pypi/pyversions/odapt
[pypi-version]:             https://img.shields.io/pypi/v/odapt
[rtd-badge]:                https://readthedocs.org/projects/odapt/badge/?version=latest
[rtd-link]:                 https://odapt.readthedocs.io/en/latest/

The odapt library is a bridge between columnar file formats **ROOT, Parquet, Feather, and HDF5.** It aims to simplify file conversions in Python, replacing what is usually a multi-step process with one line of code, with builtin features for managing large datasets and choosing compression levels.

# Installation

odapt can be installed from [PyPI](https://pypi.org/project/odapt) using pip:

```bash
pip install odapt
```

# Getting started

```python
import odapt as od

# To merge two or more root files with TTrees,
# and add together any histograms:
od.hadd_and_merge("destination.root",
["ttree_file1.root", "ttree_file2.root"])


# To add merge files with only histograms:
od.hadd("destination.root",
["hist_file1.root", "hist_file2.root"])

```


<!-- prettier-ignore-end -->
workflow-rdf 0.0.4
pyiron jobs with RDF elements

# workflow-rdf

A collection of [pyiron](https://pyiron.org/) Jobs with RDF elements. Structures and jobs are automatically annotated using [CMSO](https://github.com/Materials-Data-Science-and-Informatics/cmso-ontology) and [PROV-O](https://www.w3.org/TR/2013/REC-prov-o-20130430/), allowing for querying of the generated data. 

## Installation

We strongly recommend creating a conda environment for the installation. [Mamba](https://mamba.readthedocs.io/en/latest/installation.html) can allow the creation of conda environments. If you have existing conda installation, you can do:

```
conda install -c conda-forge mamba
```

Once a conda distribution is available, the following steps will help set up an environment to use `pyscal_rdf`. First step is to clone the repository.

```
git clone https://github.com/pyscal/rdfjobs.git
```

After cloning, an environment can be created from the included file-

```
cd workflow_rdf
mamba env create -f environment.yml
```

This will create an environment called `rdfjobs`. It can be activated by,

```
conda activate workflow_rdf
```

then, install `workflow_rdf` using,

```
pip install .
```

## Using `workflow_rdf`

A detailed documentation is coming soon. Please check the [examples](examples/) folder for some examples.


## Acknowledgements

This work is supported by the [NFDI-Matwerk](https://nfdi-matwerk.de/) consortia.