semvec/pypi-packages huggingface dataset:
pathlib-artifactory 0.4.1
Backport of pathlib ABCs
Requires Python: >=3.9

===================
pathlib-artifactory
===================

|pypi| |docs|

Python client for Artifactory.


.. |pypi| image:: https://img.shields.io/pypi/v/pathlib-artifactory.svg
    :target: https://pypi.python.org/pypi/pathlib-artifactory
    :alt: Latest version released on PyPi

.. |docs| image:: https://readthedocs.org/projects/pathlib-artifactory/badge
    :target: http://pathlib-artifactory.readthedocs.io/en/latest
    :alt: Documentation
crackie 1.0.2
A simple, silly library to generate combinations
Requires Python: >=3.5

=======
crackie
=======

A simple, silly library to generate combinations.

I wrote this when I forgot part of a password, and decided to try run ~500,000
combinations on the parts I remembered. It worked! Also I decided to publish it
because I had never created a Python package before, so this would learn me
something.


Usage
=====

Say you have forgotten a password, but remember the basics of it. For example,
you remember that it was made up of two words, with some characters altered.
The words could be "verd" and "uberous", and the alterations could be things
like random capital letters, numbers instead of letters, etc. Something that
could be modeled like this::

  variations = [
      {"V", "v"},
      {"E", "e", "3"},
      {"R", "r"},
      {"D", "d"},
      {"", "-", "_", " "},
      {"U", "u"},
      {"B", "b", "8"},
      {"E", "e", "3"},
      {"R", "r"},
      {"O", "o", "0"},
      {"U", "u"},
      {"S", "s", "5", "$"},
      {"", "!", "1"},
  ]

Then you can use this library to generate all possible combinations, such as
"VERDUBEROUS", "V3rd_ubEr0U5" or "v3rd ub3r0U5!".

You'll need a way to test the passwords. For example, if it's a GnuPG passphrase
that you have forgotten, you can use this code to test a single password::

  def try_password(password):
      p = Popen(
          ['gpg', '--pinentry-mode', 'loopback', '--decrypt', '--passphrase', password],
          stdout=PIPE,
          stdin=PIPE
      )
      p.communicate(input)
      p.returncode == 0

And then use the generator ``each_possible_combination`` to do exactly that
(testing each possible combination). Like this::

  from crackie import each_possible_combination

  for candidate in each_possible_combination(variations):
      candidate_string = ''.join(candidate)
      if try_password(candidate_string):
          print("Found the password!", candidate_string);
          break
exabyte-api-client 2025.9.13.post0
Exabyte Python Client for RESTful API
Requires Python: >=3.6

[![PyPI version](https://badge.fury.io/py/exabyte-api-client.svg)](https://badge.fury.io/py/exabyte-api-client)

This package provides access to Exabyte.io [RESTful API](https://docs.mat3ra.com/rest-api/overview/).

# Installation

We recommend creating a virtual environment before installing:

```bash
virtualenv my-virtualenv
source my-virtualenv/bin/activate
```

Install using pip:

- from PyPI:

```bash
pip install exabyte-api-client
```

- from source code in development mode:

```bash
git clone git@github.com:Exabyte-io/exabyte-api-client.git
cd exabyte-api-client
pip install -e .
```

# Examples

[exabyte-api-examples](https://github.com/Exabyte-io/exabyte-api-examples) repository contains examples for performing most-common tasks in the Exabyte.io platform through its RESTful API in Jupyter Notebook format.

# Testing
A Virtualenv environment can be created and the tests run with the included `run-tests.sh` script.
To run the unit tests in Python 3, you can:
```
./run-tests -t=unit
```

To run the integration tests in Python 2, you can:
```
./run-tests -p=python2 -t=integration
```
(assuming you have a `python2` binary in your PATH environment).

Note that the integration tests require a REST API service against which the live tests will run. See `tests/integration/__init__.py` for the environment variable details.


© 2020 Exabyte Inc.
vllm-df11 0.0.1
Dfloat11 plugin for vLLM
Requires Python: <3.14,>=3.9

# vLLM x DFloat11
---

## 📦 Installation

```bash
pip install vllm-df11
```

**Dependencies:**
- vLLM >= 0.9.0
- CUDA-compatible GPU (A100, H100, H200, RTX, etc.)

You do not need `nvcc` or a `C/C++` compiler to install this package.
However, a CUDA-enabled GPU is required to use `dfloat11` with `vLLM`.

---

## 🚀 Usage

Enable the plugin by setting the environment variable:

```python
import os

os.environ["VLLM_PLUGINS"] = "df11"

from vllm.plugins import load_general_plugins 

load_general_plugins()

from vllm import LLM, SamplingParams

df11_model_path = "/path/to/dfloat11/e.g./llama3.1-8b-it-df11"

llm = LLM(
    model=df11_model_path,
    load_format="df11",
    dtype="bfloat16"  
)

prompts = ["Explain Huffman coding and describe its applications."]

sampling_params = SamplingParams(
    temperature=0.6,
    top_p=.95,
    max_tokens=64,
)

outputs = llm.generate(prompts, sampling_params=sampling_params)

for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text
    print(f"Prompt: {prompt}")
    print(f"Generated: {generated_text}")
    print(" 🌳🦖🗜️📦🌲 " * 5)
```


## 📚 Reference

If you use this plugin in your research or deployment, please cite our paper.
pyPebble 0.1.0
Multi purpose N-body sim
Requires Python: >=3.7

# PyPebble: An N-Body Simulation Toolkit

PyPebble is a Python model to handle N-body problems, specifically geared towards gravitational simulations (with more features planned for the future). This code is still under development.
Currently, inputs and outputs are configured to use the following units:
- Distance: parsecs
- Mass: solar masses
- Time: megayears

----------------------------------------

## Installation

Using pip:
```bash
pip install pyPebble
```
Clone this repository and then install manually with:
```bash
pip install -e .
```
------------------------------------------------------

## Usage

### Creating a System
You can define the properties of particles directly by passing arrays of positions, velocities, and masses:

from pypebble import Pebbles
```python
system = Pebbles(positions, velocities, masses)
```
Alternatively, you can create a disc of particles using the built-in generator:
```python
system = Pebbles().create_disc(
    n_particles=100,
    r_max=10,
    center=[0, 0],
    ang_vel=0.05,
    v_sigma=None,
    total_mass=None,
    particle_mass=None,
    distribution="uniform"
)
```
### Setting up the Simulation
With a system defined, initialize the simulation using setup:
```python
simulation = system.setup(
    softening=1e-2,
    bounds=20,
    smooth_len=10,
    t_start=0,
    t_finish=50,
    nsteps=1000,
    Enable_GPU=True,
    save_output=None
)
```
### Live Animation
```python
simulation.start_animation()
```

### Running the Simulation
Run with:
```python
simulation.run()
```
The simulation currently saves output data (time, position, velocity, and mass) to an .h5 file.
Future improvements will include better ways to run and visualize simulations.

--------------------------------------------------------------

## To do
- Support for multiple unit systems
- Additional initial condition generators
- General Optimisations
- GUI 
- Energy conservation checks
- Multiprocessing option for simulation
- Multithreading for writing to file
- Allow simulations beyond a 2D plane
- Realistic velocity and density distributions

-------------------------------------------------------------

## License
MIT License.
inventree-common-data 0.3.5
Selection Data for common use cases
Requires Python: >=3.9
Keywords: inventree, inventree-plugin, inventree-common-data

# inventree-common-data

This simple plugin provides Common Data for InvenTree selection lists.
The goal is to reduce the burden of adopting InvenTree and remove the need to maintain a separate repository and automations for common data by different organisations.

Data is provided for the following sysstems / schemes:
- RAL Colors
- UN/LOCODE / ISO 3166-1

Feel free to request additional data sets in the [plugin discussion](https://talk.invenhost.com/t/plugin-discussion-inventree-common-data/43).

## Setup

1. Install
Install this plugin in the webinterface with the packagename `inventree-common-data`

2. Enable
Enable the plugin in the plugin settings. You need to be signed in as a superuser for this.
**The server will restart if you enable the plugin**

3. Configure
Enable `Auto-Sync` to start the automatic creation and maintenance of selection lists. This is disabled by default as it pushes changes to the database.

## Helpful Links

- [Discussion thread for this plugin](https://talk.invenhost.com/t/plugin-discussion-inventree-common-data/43)
- [InvenTree Documentation on selection lists](https://docs.inventree.org/en/stable/part/parameter/#selection-lists)

## Technical Details

The plugin does not use custom models to provide maximum deployment flexibility and supports all releases starting with InvenTree 0.16.0 through to current master.

Source data is kept in yaml format. It is technically possible to ship data-only plugins, that would still be orchestrated by this plugin. This is however not officially documented right now and only used in-house as there are a few foot-guns with this approach if you do not have proper performance monitoring in place.

Due to this data delivery design, there is no internet connection required after plugin install so private PyPI caches (if you have a company-mandated proxy for example) can be used without problems.