semvec/pypi-packages huggingface dataset:
vllmlp 0.0.2
Collections of Logits Processors for VLLM
Requires Python: >=3.10

# vllmlp

`vllmlp` is a collection of Logits Processors for VLLM. Currently, it contains the following processors:

- `vllmlp/qwen/NoCJKLogitsProcessor`: A Logits Processor that prevents CJK characters from being generated in the output. ONLY works with QWen2.5 models.

## Installation

```bash
pip install vllmlp
```
Pytolith 0.0.9.dev0
A simple package for reading Halo tag files.
Requires Python: >=3.10

A simple python library for reading (and perhaps writing in the future) Halo 2 tag files. Allows for tags to be introspected on any platform without the hassle of using the official tools.

SemVer may eventually be used but for now the API is unstable and subject to change at any time. Tag layouts are [defined in XML](https://github.com/num0005/Halo2TagLayouts) in a separate repository and are compiled into a pickled format during package installation. The package license does not cover this layout metadata.

# Sample usage

```python
from Pytolith import TagSystem
import os

# initialize new tag system using layouts packaged with Pytolith
system = TagSystem()

MY_H2EK_TAGS_FOLDER = r"T:\SteamLibrary\steamapps\common\H2EK\tags"
BRUTE_TAG_PATH = r"objects\characters\brute\brute.biped"

path = os.path.join(MY_H2EK_TAGS_FOLDER, BRUTE_TAG_PATH)

# load the brute tag
tag1 = system.load_tag_from_path(path)
# inspect the feign_death_chance setting
print(tag1.fields.feign_death_chance)
```

If you want to edit the XML definitions first clone `https://github.com/num0005/Halo2TagLayouts` into a local path:

```shell
T:\> git clone https://github.com/num0005/Halo2TagLayouts
Cloning into 'Halo2TagLayouts'...
remote: Enumerating objects: 156, done.
remote: Counting objects: 100% (156/156), done.
remote: Compressing objects: 100% (96/96), done.
remote: Total 156 (delta 60), reused 156 (delta 60), pack-reused 0 (from 0)
Receiving objects: 100% (156/156), 384.26 KiB | 11.64 MiB/s, done.
Resolving deltas: 100% (60/60), done.
```

And then set the custom definitions when constructing the `TagSystem` object:

```python
from Pytolith.Definitions import Definitions
from Pytolith import TagSystem

custom_defintions = Definitions()
custom_defintions.load_from_xml(r"T:\Halo2TagLayouts")

system = TagSystem(tag_definitions=custom_defintions)
```

You will now be using the tag definitions from `T:\Halo2TagLayouts` instead of the ones packaged with the library.

# Using the package without install

Install the package using `pip` is the recommended way to use it, but if you are unable to to that or want to avoid installing it during development you can load the package directly. For instance `setup.py` does it like so:

```python
root_directory = pathlib.Path(os.path.abspath(__file__)).parent
sys.path.append(str(root_directory/"src"))
import Pytolith
```

This depends on the tag definitions being located in the `Data` folder. Make sure you initialize git submodules if you are doing this.


# Performance

Using PyPy is recommended as the tracing compiler provides a ~2x speed up on tag loading.

Installed packages include autogenerated tag readers which provide a minor (~10%) speed-up when using CPython. These can only be used if you use the tag definitions packaged with the library. See `code_generator.py` and `setup.py` for details on how the "fast loaders" are generated.

Installed packages also use `pickle`'d tag definitions, this provides a modest speed-up on first tag load.
dataExploreBetter 0.7
Dataset visualization package
Requires Python: >=3.6

This package provides data visualiazation on dataset
To install press pip install dataExplore
To run please call
from dataExplore.builder import Builder
import seaborn as sns
tips = sns.load_dataset("tips")
print(tips.head())
b=Builder(tips)
d=b.getExplorer()
fortify-getorcreateapp 0.2.15
Get a fortify application and version ids, create if they don't exist
Requires Python: >=3.6

![](https://img.shields.io/badge/Standard%20Security%20Action-gold?style=for-the-badge&logo=trendmicro&logoColor=red&link=https%3A%2F%2Ftrendmicro.atlassian.net%2Fwiki%2Fspaces%2Frdsecpub%2Fpages%2F616997839%2FStandard%2BSecurity%2BGitHub%2BActions)

# fortify-getorcreateapp

Support Library for creating and querying fortify versions and applications.

## Installation

```pip install fortify-getorcreateapp```

## Command line Usage

As a python library with a cli entry point, the functionality can be easily accessed through CLI:

```
$fortify-getorcreateapp --h

usage: fortify-getorcreateapp [-h] [--jid JID] app_name version_name

Print Fortify application and version ids of given fortify application name and version names. Create version and application if they don't exist. Requires
environment variables 'FORTIFY_TOKEN' and 'FORTIFY_URL' to be set. FORTIFY_TOKEN must be an automation token for a (service) account capable of creating a
version and assign users to versions. FORTIFY_URL is the base url for the fortify service (e.g. https://codescan-ssc.mycompany.com/ssc) . It does not include the
path to the api endpoing e.g. 'api/v1'.

positional arguments:
  app_name      application name
  version_name  version name

options:
  -h, --help    show this help message and exit
  --jid JID     PDG_XXXXXX - identifier added to version description, used to synchronized with dashboard. Please set manually if not set upon creation. Consult
                #rdsec with this message if needed.
```

## Build

```make```

## Contribute

This is part of the Standard github actions and as such it is subject to the same process (no direct writes, PRs reviewed by GRC). If you have a contribution please fork and submit a PR.


## FAQ

A: "Why is this not simply part of the github action that uses it?"

B: Because the functionality is used across other projects and scripts, it's right encapsulation is a library.
MITgcmutils 0.2.1
Python utilities for MITgcm

# MITgcmutils

Python utilities for the MIT General Circulation Model,
[MITgcm](http://mitgcm.org).

This package is developed as a part of MITgcm on
[github](https://github.com/MITgcm/MITgcm/tree/master/utils/python/MITgcmutils).

It is documented in the MITgcm
[manual](http://mitgcm.rtfd.io/en/latest/utilities/utilities.html#mitgcmutils).
magiccionary 0.1.4
Add your description here
Requires Python: >=3.10

# Magiccionary

A Python utility package for powerful dictionary manipulation, allowing you to easily remove or keep specific keys in nested dictionaries.

## Installation

```bash
pip install magiccionary
```

## Features

- Deep dictionary manipulation
- Support for nested structures including lists and dictionaries
- Wildcard key matching using "*"
- List traversal using "[]" notation

## Usage

### Remove Keys

Remove specific keys from nested dictionaries while preserving the original structure:

```python
from magiccionary import remove_keys

# Simple key removal
data = {"a": 1, "b": 2, "c": 3}
result = remove_keys(data, ["c"])
# result = {"a": 1, "b": 2}

# Nested key removal
data = {
    "a": {
        "b": {
            "c": 3,
        }
    },
    "d": 4,
}
result = remove_keys(data, [["a", "b", "c"]])
# result = {"a": {"b": {}}, "d": 4}

# Using wildcards and list traversal
data = {
    "a": {
        "list": [
            {"x": 1, "y": 2},
            {"x": 3, "y": 4}
        ]
    }
}
result = remove_keys(data, [["a", "list", "[]", "x"]])
# result = {"a": {"list": [{"y": 2}, {"y": 4}]}}
```

### Keep Keys

Keep only specific keys in nested dictionaries:

```python
from magiccionary import keep_keys

# Simple key retention
data = {"a": 1, "b": 2, "c": 3}
result = keep_keys(data, ["a", "b"])
# result = {"a": 1, "b": 2}

# Nested key retention
data = {
    "a": {
        "b": 2,
        "c": 3,
    }
}
result = keep_keys(data, [["a", "b"]])
# result = {"a": {"b": 2}}
```

## Key Path Syntax

- Use strings for top-level keys: `["key_name"]`
- Use arrays for nested paths: `[["parent", "child", "grandchild"]]`
- Use `"*"` as a wildcard to match any key at that level
- Use `"[]"` to traverse list elements

## Features

- Non-destructive operations (original dictionaries are not modified)
- Support for deeply nested structures
- Wildcard key matching
- List traversal support
- Type-safe operations

## License

MIT

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.
tidal2tidal 0.0.0.1
A command line tool for transferring liked tracks, albums, artists and playlists between Tidal accounts.
Requires Python: >=3.8

# tidal2tidal

A command line tool for transferring liked tracks, albums, artists and playlists between Tidal accounts.

## Installation

From PyPI:

```bash
pip install tidal2tidal
```

## Usage

1. Run `tidal2tidal` in your terminal.
2. A link will appear, open it and follow the instructions to log in with account A (source).
3. Log in to account B (destination), the same way as in step 2.
4. Wait for data to be transferred over from account A to account B.
beaver_cli 0.1.6
CLI application for Beaver project
Requires Python: <4.0,>=3.12

# Beaver

Beaver is a command-line application that combines typing practice with algorithm learning. Inspired by Monkeytype and LeetCode, it provides a fun and educational way to improve your coding skills and typing speed by having you type out classical algorithms in a Text User Interface (TUI) environment.


## Features

- **Typing Practice with Algorithms**: Improve your typing speed and accuracy by typing out actual algorithm code.
- **Algorithm Refresh**: Revisit and reinforce your understanding of classical algorithms and data structures.
- **TUI Frontend**: Enjoy an intuitive and distraction-free typing experience in your terminal.

## Installation

Beaver is available on [PyPI](https://pypi.org/project/beaver/). You can install it using `pip`:

```bash
pip install beaver_cli
```

## Usage
After installing, you can start using Beaver directly from your terminal.

### Starting a Session
To begin a typing session, simply run:
```bash
beaver_cli
```

### Screenshots
![screenshot](docs/screenshot.png)


### License
This project is licensed under the GNU GENERAL PUBLIC LICENSE.
nave-visualization 1.11
A Python package for visualizing environmental data, specifically evapotranspiration, leaching risk,

# Nave Visualization

This Python package provides functions for visualizing environmental data, such as evapotranspiration, leaching risk, and precipitation/irrigation data. It works with geospatial datasets, processes them, and generates maps and visualizations, primarily outputting results as PDF files.

## Package components

This package contains the following modules:

- `nave_visualization_core`: Main module, including functions for date generation, loading datasets, and creating environmental maps.
- `test`: A jupyter notebook that demos all the functions in nave_visualization_core.



### Example Usage

```python
import nave_visualization_core as nave

# Example function call
nave.build_evapotranspiration_map(twr_block, output)

```


Prerequisites
-----
This package is compatible with Python 3.6 and above. You can download the latest version of Python from [python.org](https://www.python.org/downloads/).
This package depends on several Python libraries. You can install them using pip:

- geopandas â€” For working with geospatial data.
- matplotlib â€” For creating static, animated, and interactive visualizations in Python.
- numpy â€” A library for numerical operations.
- pandas â€” For data manipulation and analysis.
- shapely â€” For geometric operations and analysis.
- xarray â€” For working with labeled multi-dimensional arrays.
- rasterio â€” For reading and writing geospatial raster data.

To install the dependencies, you can install them manually:
 - Install them manually:

     ```bash
     pip install geopandas 
     pip install matplotlib 
     pip install numpy 
     pip install pandas 
     pip install shapely 
     python -m pip install "xarray[complete]"
     pip install rasterio
     ```


Installing nave_visualization
-----------------------

Packages can only be imported if they are located in a directory on the PYTHONPATH (which you can view in python using ``sys.path()``).

Packages installed using the command line tool ``pip`` are added to this path.


```bash
pip install nave-visualization

```


License
-------
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
aceCommon 0.1.0
A collection of common utility functions
Requires Python: >=3.6

# aceCommon

A collection of common utility functions for Python projects.

## Installation and Usage

```bash
pip install aceCommon
from aceCommon import create_file_path_string

example_path = create_file_path_string(list_of_dir=['subdir', 'file.txt'])

print(path)
```