semvec/pypi-packages huggingface dataset:
bswrapper 0.2.2
An easy to use API Wrapper for the Brawl Stars API
Requires Python: >=3.12

# Brawl Stars Wrapper (BSWrapper) - v0.2.2

## What is BSWrapper?

BSWrapper is a user friendly API wraper for the [Brawl Stars API](https://developer.brawlstars.com). It aims to make pulling all information found in the API as easy as possibly without needing to use a 3rd party API.

## Requirements

- Python 3.12 or higher

## How do I install it?

To install BSWrapper, simply run:

```bash
pip install bswrapper
```
or in your requirements.txt, enter it as:
```txt
bswrapper>=0.2.2
```

## How to use BSWrapper

### Example 1: Player Data:

```py
from bswrapper import BSClient

bs = BSClient("API_TOKEN")

player = bs.get_player("#TAG")

print(player.name)
print(player.tag)
print(player.trophies) # current trophies
print(player.club.name) # if they are in a club, if not it just shows 'None'
print(player.club.tag) # if they are in a club, if not it just shows 'None'
print(player.highest) # highest trophies
print(player.explevel)
print(player.solo) # amount of solo victories

# NOTE: this is all of properties so far in the wrapper
```

### Example 2: Club Data:

```py
from bswrapper import BSClient

bs = BSClient("API_TOKEN")

club = bs.get_club("#TAG")

print(club.name)
print(club.tag)
print(club.trophies) # total trophies
print(club.required) # required trophies
print(club.type) # this will print either: open, inviteOnly, closed, unknown
print(club.description) # the club description/bio seen in the game

# NOTE: this is all of properties so far in the wrapper
```
refactx 0.1.2
Refactx package
Requires Python: >=3.8

ReFactX is a scalable method that enables LLMs to access external knowledge without depending on retrievers or auxiliary models. It uses constrained generation with a pre-built prefix-tree index. During inference, to acquire external knowledge, the LLM generates facts with constrained generation which allows only sequences of tokens that form an existing fact.

<!--- BADGES: START --->
[![ISWC 2025](https://img.shields.io/badge/ISWC-2025-brightgreen)][#iswc-paper-package]
[![Arxiv](https://img.shields.io/badge/arXiv-2508.16983-B31B1B.svg)][#arxiv-paper-package]

[#iswc-paper-package]: https://doi.org/10.1007/978-3-032-09527-5_16
[#arxiv-paper-package]: https://arxiv.org/abs/2508.16983

<!--- BADGES: END --->

## Install and Try

```bash
pip install refactx[torch]
```

Quick example (print package version)

```python
import refactx
print(refactx.__version__)
```

### Cite
```
@InProceedings{10.1007/978-3-032-09527-5_16,
      author="Pozzi, Riccardo
      and Palmonari, Matteo
      and Coletta, Andrea
      and Bellomarini, Luigi
      and Lehmann, Jens
      and Vahdati, Sahar",
      editor="Garijo, Daniel
      and Kirrane, Sabrina
      and Salatino, Angelo
      and Shimizu, Cogan
      and Acosta, Maribel
      and Nuzzolese, Andrea Giovanni
      and Ferrada, Sebasti{\'a}n
      and Soulard, Thibaut
      and Kozaki, Kouji
      and Takeda, Hideaki
      and Gentile, Anna Lisa",
      title="ReFactX: Scalable Reasoning with Reliable Facts via Constrained Generation",
      booktitle="The Semantic Web -- ISWC 2025",
      year="2026",
      publisher="Springer Nature Switzerland",
      address="Cham",
      pages="290--308",
      isbn="978-3-032-09527-5",
      doi="10.1007/978-3-032-09527-5_16",
      url="https://doi.org/10.1007/978-3-032-09527-5_16"
}
```
icoco 2.0.6
ICoCo Python implementation
Requires Python: <4,>=3.6
Keywords: couping, medcoupling, salome, c3po

# ICoCo API - Version 2 (02/2021)

**WARNING: This API should not be changed!!**

ICoCo stands for **Interface for Code Coupling**. This is a norm that a code may choose
to implement to facilitate its coupling with other ICoCo-compliant codes.

See https://github.com/cea-trust-platform/icoco-coupling for full reference.

Practically ICoCo is provided as a main abstract C++ class (ICoCo::Problem) that a code has
to derive to implement the norm. This can be only a partial implementation as some methods
are not relevant to all the codes (especially the I/O methods of the API).

This package implements the abstract class {class}`icoco.problem.Problem` in Python following the
specifications of the c++ version.

The Python implementation proposed is based on {mod}`medcoupling` implementation for fields and {mod}`mpi4py` for MPI
communication. Nevertheless, it is possible to use other implementation of such concepts within this
package.
AssertMixins 1.0.0
Library of testing helper mixins.
Requires Python: >=3.7

# A library of mixin classes containing assertion methods

Example of use:

    # -*- coding: utf-8 -*-
    import unittest, assert_mixins
    
    class SampleTestCase(unittest.TestCase, assert_mixins.ElementaryMixin):
        def test_thing_has_length_two(self):
            self.assertLength([3, 4], 2, msg="Length is different from two!")
agentkernel-standalone 1.1.0
A standalone multi-agent system framework
Requires Python: >=3.11
Keywords: agent, git, llm

<p align="center">
  <img
    src="https://raw.githubusercontent.com/ZJU-LLMs/Agent-Kernel/main/assets/agentkernel_logo.png"
    width="400"
  />
</p>

# Agent-Kernel Standalone

**Agent-Kernel Standalone** is a lightweight, self-contained Multi-Agent System (MAS) development framework for local environments. It provides the same modular microkernel architecture as the distributed version but runs entirely on a single machine — no Ray or external services required.

---

## 🚀 Installation

### 1. Requirements

- Python ≥ 3.11

### 2. Install from PyPI

You can install Agent-Kernel Standalone directly from PyPI using `pip`.

```bash
pip install agentkernel-standalone
```

**Installing with Optional Features**

Agent-Kernel Standalone comes with optional dependencies for web services and storage solutions. You can install them as needed.

- `web` → Installs `aiohttp`, `fastapi`, `uvicorn`
- `storages` → Installs `asyncpg`, `pymilvus`, `redis`
- `all` → Installs both `web` and `storages`

To install the package with these extras, use the following format:

```bash
# Install with web features
pip install "agentkernel-standalone[web]"

# Install with storage features
pip install "agentkernel-standalone[storages]"

# Install all optional features
pip install "agentkernel-standalone[all]"
```
agentkernel-distributed 1.1.0
A distributed multi-agent system framework
Requires Python: >=3.11
Keywords: agent, git, llm, ray

<p align="center">
  <img
    src="https://raw.githubusercontent.com/ZJU-LLMs/Agent-Kernel/main/assets/agentkernel_logo.png"
    width="400"
  />
</p>

# Agent-Kernel Distributed

**Agent-Kernel Distributed** is a distributed Multi-Agent System (MAS) development framework designed to support large-scale environments using **Ray** for distributed execution. It is ideal for coordinating multiple intelligent agents running across different nodes or processes.

---

## 🚀 Quick Start

### 1. Requirements

- `Python ≥ 3.11`

### 2. Install from PyPI

You can install Agent-Kernel Distributed directly from PyPI using `pip`.

```bash
pip install agentkernel-distributed
```

> The distributed package depends on Ray and will install it automatically.

**Installing with Optional Features**

Agent-Kernel Distributed comes with optional dependencies for web services and storage solutions. You can install them as needed.

- `web` → Installs `aiohttp`, `fastapi`, `uvicorn`
- `storages` → Installs `asyncpg`, `pymilvus`, `redis`
- `all` → Installs both `web` and `storages`

To install the package with these extras, use the following format:

```bash
# Install with web features
pip install "agentkernel-distributed[web]"

# Install with storage features
pip install "agentkernel-distributed[storages]"

# Install all optional features
pip install "agentkernel-distributed[all]"
```
helicalwheel 0.1.2
Helical wheel representations of peptide sequences.
Requires Python: >=3.13

# helicalwheel: Helical Wheel Representation of Alpha-Helices

## Description

Creates a two-dimensional top-down view of an alpha-helix sequence. The advantages of this package are:
* Easy rotations of the diagram are possible
* Sequences longer than 18 amino acids are split into multiple diagrams and plotted next to each other
* Easy readibility due to increasing line thickness connecting the AA corresponding to their position in the helix
* Alternative helices (e.g. 3<sub>10</sub>) can be drawn by adjusting the input angle

**Important**: This package does **not** predict whether a peptide sequence will form an alpha helix. The graph only visualizes the arrangement of residues **assuming** an alpha helix is present. We recommend first using AlphaFold or other structure prediction tools, and then using this package to visualize the predicted alpha helices.

Built by Jann Staebler, PhD student (Institute of Virology, University of Zurich)

## Dependencies

* NumPy
* Pandas
* Matplotlib

## Installation

The source code can be found on GitHub: https://github.com/jastaeb/helicalwheel

Python package index at: https://pypi.org/project/helicalwheel/

Helicalwheel can be installed as follows:
```python
python -m pip install -U pip
python -m pip install -U helicalwheel
```

## Usage

```python   
#%% Load helixvis
import helicalwheel as hw

#%% Input sequence
# Section of a predicted alpha helix of the assembly-activating protein of Adenovirus-associated virus serotype 2
aap2_seq = "LVWELIRWLQAVAHQWQTIT" 

# Creating a dataframe with helix coordinates
df_wt=hw.helix_coordinates(aap2_seq)

#%% Plotting
first_pos=21 # indicate the first alpha-helix residue position in the total protein sequence

# Entire helix
wt_plot_1 = hw.helixplot(df_wt, first_pos=first_pos)
# Two individual plots figure assembly
wt_plot_1 = hw.helixplot(df_wt.iloc[0:10], legend=False, first_pos=first_pos)
wt_plot_2 = hw.helixplot(df_wt.iloc[10:], legend=False, first_pos=first_pos)
```


## License
MIT