semvec/pypi-packages huggingface dataset:
BraTS 0.0.1
A small example package
Requires Python: >=3.8

[![PyPI version brats-algorithms](https://badge.fury.io/py/brats-algorithms.svg)](https://pypi.python.org/pypi/brats-algorithms/)
[![Documentation Status](https://readthedocs.org/projects/brats-algorithms/badge/?version=latest)](http://brats-algorithms.readthedocs.io/?badge=latest)
[![tests](https://github.com/BrainLesion/brats-algorithms/actions/workflows/tests.yml/badge.svg)](https://github.com/BrainLesion/brats-algorithms/actions/workflows/tests.yml)

# brats-algorithms

Top performing algorithms from the Brain Tumor Segmentation (BraTS) challenges, providing state-of-the-art models for brain lesion segmentation.

## Features

- Access to top-performing algorithms from recent BraTS challenges.
- Easy-to-use inference API.
- Extensive documentation and examples. (TODO!)

## Installation

With a Python 3.10+ environment, you can install `PACKAGE_NAME` directly from [PyPI](https://pypi.org/project/PACKAGE_NAME/):

```sh
pip install PACKAGE_NAME
```

### Docker and NVIDIA Container Toolkit Setup

To run `PACKAGE_NAME` in a Docker container with GPU support (required for most algorithms), ensure you have Docker and NVIDIA Docker installed. Instructions:
- **Docker**: Installation instructions on the official [website](https://docs.docker.com/get-docker/)
- **NVIDIA Container Toolkit**: Installation instructions on the official [GitHub page](https://github.com/NVIDIA/nvidia-container-toolkit) 

## Use Cases and Tutorials

*TODO*

## Contributing

We welcome contributions from the community, including bug reports, feature requests, and code contributions. For more information on how to contribute, please see our [CONTRIBUTING.md](CONTRIBUTING.md) file.

## License
*TODO*
qptools 1.0.3
Fast quadratic programming tools (with CUDA support)
Requires Python: >=3.8

# qptools

Fast quadratic programming tools.

[中文](README.zh-CN.md) | [English](README.md)

## Platforms

- **Windows**: To Do
- **Linux**: Supports CPU and CUDA versions
- **MacOS**: Supports CPU version

## Dependencies

- `setuptools`
- `pybind11`
- `numpy`
- [CUDA Toolkits](https://developer.nvidia.com/cuda-toolkit) for CUDA supports

## Installation

### CPU version

Install the package without CUDA support

```bash
pip install qptools
```

### CUDA version

```bash
export CUDA_HOME=(your cuda path)
export USE_CUDA=1
pip install qptools
```


## Solving Quadratic Programming Problems

### `qp1`: Basic Quadratic Programming

$$
\min_{x} \frac12 x^TPx+q^Tx \\
\text{s.t. } lb \leq x \leq rb, \\
Gx \leq h
$$

where $P$ is a $n\times n$ positive definite matrix, $q$ is an $n$-dimensional vector, $G$ is a $g\times n$ matrix, $h$ is a $g$-dimensional vector, and $lb,rb$ are $n$-dimensional vectors defining the lower and upper bounds for variable $x$.

### `qp2`:  Quadratic Programming with Standardized Variables

$$
\min_{x} \frac12 x^TPx+q^Tx \\
\text{s.t. } lb \leq \frac{x}{\text{sum}(x)} \leq rb, \\
Gx \leq h
$$

where $P$ is a $(n,n)$ positive definite matrix, $q$ is an $n$-dimensional vector, $G$ is a $(g,n)$ matrix, $h$ is a $g$-dimensional vector, and $lb,rb$ are $n$-dimensional vectors defining the lower and upper bounds for standardized variable $\frac{x}{\sum(x)}$.

## Example

- **Python (CPU):** [./example/cpu.ipynb](./example/cpu.ipynb)
- **Python (CUDA):** [./example/cuda.ipynb](./example/cuda.ipynb)
- **C++ (CPU):** [./c/core/test/test.cpp](./c/core/test/test.cpp)
- **C++ (CUDA):** [./c/core/test/test.cu](./c/core/test/test.cu)

## References

1. Nesterov, Y., & Todd, M. J. (1997). Self-scaled barriers and interior-point methods for convex programming. Mathematics of Operations Research, 22(1), 1-42.

2. Nesterov, Y., & Todd, M. J. (1998). Primal-dual interior-point methods for self-scaled cones. SIAM Journal on Optimization, 8(2), 324-364.

3. Mehrotra, S. (1992). On the implementation of a primal-dual interior point method. SIAM Journal on Optimization, 2(4), 575-601.
smart-buildings-rating-calculator 0.0.2
The calculation to generate a smart building rating
Requires Python: ==3.11

# Smart building rating calculator
The calculation to generate a Smart Building Rating (SBR) and SBR 'archetype'

## python-template

Centre for Net Zero's template for Python projects.

Tools:

* [Pipenv](https://github.com/pypa/pipenv) for dependency management
* [Pytest](https://github.com/pytest-dev/pytest/) for testing
* [Mypy](https://mypy.readthedocs.io/en/stable/) for type checking
* [Flake8](https://flake8.pycqa.org/en/latest/) for linting
* [isort](https://github.com/PyCQA/isort) and [black](https://github.com/psf/black) for formatting

Github Actions workflows:
* `test_and_lint.yaml` runs checks on a Ubuntu Github-hosted runner.

## Python Setup

You need to [set up your Python environment](https://docs.google.com/document/d/1Tg0eKalqOp-IJEeH7aShc9fYF5zn95H6jxEk25BLLUE/) first.

1. Clone this repo.
2. Run `make setup` in your terminal.

In step 2 this will:

* Run `pipenv sync --dev` to install dependencies.
* Install your local pre-commit environment which will be used to maintain code standards
* Check the tests work by running `pipenv run pytest`

## Performing SBR calculation

Main SBR calcuation is done with the `sbr_score` (`src/smart_building_rating_calculator/calculate_sbr_score.py`) function which takes in user inputs, and outputs:
1) SBR value (between 0 and 100)
2) SBR rating (A-G)
3) Flex Archetype (see `src/smart_building_rating_calculator/flexer_enums.py`).

Inputs must have datatypes as defined in `src/smart_building_rating_calculator/inputs.py`
- Most inputs are `bool` type (True/False)
- Others are StrEnum type e.g., `charger_power` must have a value of `EVChargerPower("3 kW")`, `EVChargerPower("7 kW")`, `EVChargerPower("22 kW")`, or `EVChargerPower("None")`
- Upon calling `sbr_score`, correct input datatypes are automatically checked for. An error is raised if input datatypes are incorrect.

Example of how to call `sbr_score` in python:

```ruby
from src.smart_building_rating_calculator.calculate_sbr_score import sbr_score
from src.smart_building_rating_calculator.inputs import (
    BatterySize,
    EVChargerPower,
    HeatingSource,
    HotWaterSource,
    SolarInverterSize,
)
sbr_val, sbr, flex_archetype = sbr_score(
        smart_meter=True,
        smart_ev_charger=True,
        charger_power=EVChargerPower("7 kW"),
        smart_v2g_enabled=True,
        home_battery=True,
        battery_size=BatterySize("8kWh or greater"),
        solar_pv=True,
        pv_inverter_size=SolarInverterSize("4 kW or less"),
        electric_heating=True,
        heating_source=HeatingSource("Heat Pump"),
        hot_water_source=HotWaterSource("Heat Battery / Electric Hot Water Tank"),
        secondary_heating=True,
        secondary_hot_water=True,
        integrated_control_sys=True)
```
easy-passgen 0.1.0
An easy to use password generator

# Easy Password Generator

Tool for generating random passwords. You can choose if you want just letters or letters and special characters.

## Installation

You can install the package using `pip3`:

```python
pip3 install easy_passgen
```

## Use

```python
from easy_passgen import Generator

# Create an instance of the Generator
gen = Generator(12, True) # 12 is the length of the password, and True indicates that you want special characters

# Generate password
password = gen.generate()

#Generate and print password
gen.generate_and_print()
```