semvec/pypi-packages huggingface dataset:
stringindexsplit 0.10
simplifies the process of splitting a list of strings at specified character indices
License: MIT
Keywords: string,split


# simplifies the process of splitting a list of strings at specified character indices

## Tested against Windows 10 / Python 3.10 / Anaconda

## pip install stringindexsplit


## Description:

The SplitStringsAtIndices package is a Python utility that simplifies the process of splitting a 
list of strings at specified character indices. 
Whether you're working with text data in data analysis, natural language processing, or text processing tasks, 
this package provides a handy tool to efficiently split strings and extract substrings based on your requirements.

## Key Features:

### Flexible Input: 

Accepts a variety of input formats, including lists, tuples, and NumPy arrays, making 
it compatible with different data structures.

### Precise Splitting: 

Specify the exact character indices at which you want to split your strings, 
giving you full control over the extraction process.

### Efficient Processing: 

Utilizes NumPy for efficient array manipulation, 
ensuring fast and optimized splitting of strings.


### 2D NumPy Output: 

Returns a 2D NumPy array where each row contains the split strings, 
facilitating further analysis and manipulation.
Why Choose SplitStringsAtIndices?


```python

split_list_of_strings_at_indices(
    strings: Union[list, tuple, np.ndarray], splitlist: Union[list, tuple, np.ndarray]
) -> np.ndarray:
r"""
Splits a list of strings at specified character indices.

:param strings: List of strings to be split.
:type strings: Union[list, tuple, np.ndarray]

:param splitlist: List of indices at which to split the strings.
:type splitlist: Union[list, tuple, np.ndarray]

:return: 2D NumPy array where each row contains the split strings.
:rtype: np.ndarray

Example usage:
>>> from stringindexsplit import split_list_of_strings_at_indices
>>> stringlist = '''For most Unix systems, you must download and compile the source code. The same source code archive can also be used to build the Windows and Mac versions, and is the starting point for ports to all other platforms.'''.split()
>>> splist = split_list_of_strings_at_indices(
...     stringlist,
...     splitlist=(
...         0,
...         2,
...         3,
...         6,
...         7,
...     ),
... )
>>> print(splist)

[['Fo' 'r' '' '' '']
 ['mo' 's' 't' '' '']
 ['Un' 'i' 'x' '' '']
 ['sy' 's' 'tem' 's' ',']
 ['yo' 'u' '' '' '']
 ['mu' 's' 't' '' '']
 ['do' 'w' 'nlo' 'a' 'd']
 ['an' 'd' '' '' '']
 ['co' 'm' 'pil' 'e' '']]

```
seedrandom 2.3.1
Proof-of-concept seeded RNG lib
License: MIT
Requires Python: >=3.7,<4.0
Keywords: random,seed,seeded,number,generator,hash,int,float,bool,bytes,rng,deterministic

# seedrandom
Deterministic seeded RNG

[![Python Version](https://img.shields.io/pypi/pyversions/seedrandom.svg?color=yellow&style=flat-square)](https://www.python.org/downloads/)
[![GitHub Licence](https://img.shields.io/github/license/BananaLoaf/seedrandom.svg?color=blue&style=flat-square)](https://github.com/BananaLoaf/seedrandom/blob/master/LICENSE)
[![Package Version](https://img.shields.io/pypi/v/seedrandom.svg?color=green&style=flat-square)](https://pypi.org/project/seedrandom/)


### Installation / Updating
```
pip install seedrandom
pip install --upgrade seedrandom
```
Or
```
pip install git+https://github.com/BananaLoaf/seedrandom.git
pip install --upgrade git+https://github.com/BananaLoaf/seedrandom.git
```

### Usage

```python
from seedrandom import SeededRNG
rng = SeededRNG(b"Test", b"values", hash_func=hashlib.sha512)  # any hash func from hashlib
```

Generating random values:
```python
rng.randint(a=0, b=1000)  # 893
rng.randfloat(a=0, b=100, step=0.1)  # 89.3
rng.randbool()  # False
rng.randbyte()  # b'\xbf'
```

```SeededRNG``` can be converted to and from ```int``` or ```bytes```:
```python
bytes(rng)
int(rng)

rng1 = SeededRNG.from_bytes(b'\xbb\x9a\xf3\xe3\x1d\xfcA\xcc\xc5\x93S\x9a\xec:\x9a\x08z\x88\x85\x99\xf7\xea\x91\xb6x\x00\xfb\x82"\xc2$K', hash_func=hashlib.blake2s)
rng2 = SeededRNG.from_int(13391421701272821393603640485300504071883816826531413055648909144818643814535822212998295950921452703111178763035507290455800978052021014498426299707601814, hash_func=hashlib.sha512)
```

```ordered``` parameter can be used:
```python
rng1 = SeededRNG(b"Hello", b"world")
rng2 = SeededRNG(b"world", b"Hello")
rng1 == rng2  # True

rng1 = SeededRNG(ordered=(b"Hello", b"world"))
rng2 = SeededRNG(ordered=(b"world", b"Hello"))
rng1 == rng2  # False

rng1 = SeededRNG(b"Hello", b"world", ordered=(b"spanish", b"inquisition"))
rng2 = SeededRNG(b"world", b"Hello", ordered=(b"spanish", b"inquisition"))
rng1 == rng2  # True

rng1 = SeededRNG(b"Hello", b"world", ordered=(b"spanish", b"inquisition"))
rng2 = SeededRNG(b"Hello", b"world", ordered=(b"inquisition", b"spanish"))
rng1 == rng2  # False
```
pywhy-stats 0.1
Statistical methods for Python
License: MIT
Requires Python: >=3.8,<3.11
Keywords: independence testing,causal statistics,conditional independence

[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![CircleCI](https://circleci.com/gh/py-why/pywhy-stats/tree/main.svg?style=svg)](https://circleci.com/gh/py-why/pywhy-stats/tree/main)
[![unit-tests](https://github.com/py-why/pywhy-stats/actions/workflows/main.yml/badge.svg)](https://github.com/py-why/pywhy-stats/actions/workflows/main.yml)
[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
[![codecov](https://codecov.io/gh/py-why/pywhy-stats/branch/main/graph/badge.svg?token=H1reh7Qwf4)](https://codecov.io/gh/py-why/pywhy-stats)

# PyWhy-Stats

Pywhy-stats serves as Python library for implementations of various statistical methods, such as (un)conditional independence tests, which can be utilized in tasks like causal discovery.

# Documentation

See the [development version documentation](https://py-why.github.io/pywhy-stats/dev/index.html).

Or see [stable version documentation](https://py-why.github.io/pywhy-stats/stable/index.html)

# Installation

Installation is best done via `pip` or `conda`. For developers, they can also install from source using `pip`. See [installation page](TBD) for full details.

## Dependencies

Minimally, pywhy-stats requires:

    * Python (>=3.8)
    * numpy
    * scipy
    * scikit-learn

## User Installation

If you already have a working installation of numpy and scipy, the easiest way to install pywhy-stats is using `pip`:

    # doesn't work until we make an official release :p
    pip install -U pywhy-stats

To install the package from github, clone the repository and then `cd` into the directory. You can then use `poetry` to install:

    poetry install

    # if you would like an editable install of pywhy-stats for dev purposes
    pip install -e .

# Contributing

We welcome contributions from the community. Please refer to our [contributing document](./CONTRIBUTING.md) and [developer document](./DEVELOPING.md) for information on developer workflows.
mojodojo 0.0.3
The Mojo Dojo
License: MIT
Requires Python: >=3.10.10
Keywords: mojo dojo

# The Mojo Dojo

### 1. Install LLVM

```
sudo apt install llvm
echo 'export LLVM_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer' >> ~/.bashrc
```

### 2. Find libpython path for your env

Assuming env located at `~/miniconda3`

```
python3 -c 'import pathlib; sorted({print(x) for x in (pathlib.Path.home() / "miniconda3/envs").rglob("lib/*") if "libpython" in x.name})'
```

### 3. Export env

Replace `<full_path_to_libpython.so>` with your env's libpython path

```
echo 'export MOJO_PYTHON_LIBRARY="<full_path_to_libpython.so>"' >> ~/.bashrc
source ~/.bashrc
```

### 4. Install Modular CLI / Mojo

Replace `<your key>` with key provided at [developer.modular.com/download](https://developer.modular.com/download)

```
curl https://get.modular.com | MODULAR_AUTH=<your key> sh -
modular install mojo
echo 'export MODULAR_HOME="$HOME/.modular"' >> ~/.bashrc
echo 'export PATH="$MODULAR_HOME/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
```

### 5. Activate env and run

```python
from python import Python as py

fn main() raises:
    let np = py.import_module("numpy")
    print(np.random.randn(3,7))
```
atom-torch 0.0.2
atom - Pytorch
License: MIT
Requires Python: >=3.6,<4.0
Keywords: artificial intelligence,deep learning,optimizers,Prompt Engineering

[![Multi-Modality](agorabanner.png)](https://discord.gg/qUtxnK2NMf)

# Atom
Atom is a finetuned LLAMA to create better LLMS through Pytorch Data!




## Installation

You can install the package using pip

```python
git clone https://github.com/jquesnelle/yarn
cd Atom
pip install -e .
```

### Training

To train the models, run `accelerate config` and enable DeepSpeed acceleration. `deepspeed/zero3.json` was the configuration file used for training.

```sh
# ./train.sh
```

The tokenized training data is available on [Hugging Face](https://huggingface.co/datasets/emozilla/pg_books-tokenized-bos-eos-chunked-65536) and was derived from the [pg19](https://huggingface.co/datasets/emozilla/pg19) dataset.

### Evaluation

To reproduce the evaluations, install [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) with `pip install git+https://github.com/EleutherAI/lm-evaluation-harness` and then run the two provided scripts.

```sh
# ./eval.sh
# ./eval-harness.sh
```

### Citation

```
@misc{peng2023yarn,
      title={YaRN: Efficient Context Window Extension of Large Language Models}, 
      author={Bowen Peng and Jeffrey Quesnelle and Honglu Fan and Enrico Shippole},
      year={2023},
      eprint={2309.00071},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
```