semvec/pypi-packages huggingface dataset:
roboformer 0.0.1
Using toolformer for Embodied AI
Requires Python: >=3.10

# Roboformer

Roboformer, the embodied toolformer.

## Getting Started

### Requirements

- Python 3.10 or above
- PyTorch 2.0 or above

### Installation

Install using Pip:

> **Warning**
> This method doens't work yet.

```bash
pip install roboformer
```

Install from source:

```bash
git clone git@github.com:codekansas/roboformer.git
cd roboformer && pip install -e '.[dev]'
```

## Training a model

Train a model for a given config:

```bash
roboformer train configs/roboformer.yaml
```
base-x 1.3
Encoding/decoding of any given alphabet with any base using bitcoin style
Requires Python: >=3.10

# basex

Encoding/decoding of any given alphabet with any base using bitcoin style leading zero compression

This is a port of js base-x package from [`cryptocoinjs/base-x`](https://github.com/cryptocoinjs/base-x).

**WARNING:** This module is **NOT RFC3548** compliant,  it cannot be used for base16 (hex), base32, or base64 encoding in a standards compliant manner. 

## Example

Base58

``` python
from basex import basex

BASE58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
bs58 = basex(BASE58)

decoded = bs58.decode('5Kd3NBUAdUnhyzenEwVLy9pBKxSwXvE9FMPyR4UKZvpe6E3AgLr')

print(decoded)
# => bytearray(b'\x80\xed\xdb\xdc\x11h\xf1\xda\xea\xdb\xd3\xe4L\x1e?\x8fZ(L )\xf7\x8a\xd2j\xf9\x85\x83\xa4\x99\xde[\x19\x13\xa4\xf8c')

print(bs58.encode(decoded))
# => 5Kd3NBUAdUnhyzenEwVLy9pBKxSwXvE9FMPyR4UKZvpe6E3AgLr
```

### Alphabets

See below for a list of commonly recognized alphabets, and their respective base.

Base | Alphabet
------------- | -------------
2 | `01`
8 | `01234567`
11 | `0123456789a`
16 | `0123456789abcdef`
32 | `0123456789ABCDEFGHJKMNPQRSTVWXYZ`
32 | `ybndrfg8ejkmcpqxot1uwisza345h769` (z-base-32)
36 | `0123456789abcdefghijklmnopqrstuvwxyz`
58 | `123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz`
62 | `0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`
64 | `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`
67 | `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~`


## How it works

It encodes octet arrays by doing long divisions on all significant digits in the
array, creating a representation of that number in the new base. Then for every
leading zero in the input (not significant as a number) it will encode as a
single leader character. This is the first in the alphabet and will decode as 8
bits. The other characters depend upon the base. For example, a base58 alphabet
packs roughly 5.858 bits per character.

This means the encoded string 000f (using a base16, 0-f alphabet) will actually decode
to 4 bytes unlike a canonical hex encoding which uniformly packs 4 bits into each
character.

While unusual, this does mean that no padding is required and it works for bases
like 43. 


## LICENSE [MIT](LICENSE)
A direct derivation of the base58 implementation from [`bitcoin/bitcoin`](https://github.com/bitcoin/bitcoin/blob/f1e2f2a85962c1664e4e55471061af0eaa798d40/src/base58.cpp),  generalized for variable length alphabets.
charlogger 1.2.1
A logging library for Python.

# charlogger
A logging library for Python.

I've been using this myself for a while, and I thought that I may as well release it.

It's filled with bad code, but now that it is public, I'll probably improve it over time.

![logger example](https://cdn.upload.systems/uploads/26K4Jvvo.png)

## Installation
You can install charlogger with `pip install charlogger`.

## How to use

### Simple example
```python
import charlogger

logger = charlogger.Logger()
logger.info("What a great logging library!")
```

### Advanced example
```python
import charlogger

# All parameters are optional.
logger = charlogger.Logger(
    debug=True, # Whether to enable the output of debug logs
    default_prefix="your prefix",
    color_text=False, # Whether to have the info text be colored
    log_file_patj=open("log.txt", "a"), # The file to put logs in
    indent_level=8, # The indentation of the text when output.
    centered=True # Whether to center text in the console.
)

logger.info("What a great logging library!")
```

### My personal configuration (best)
```python
import charlogger

logger = charlogger.Logger(
    debug=True,
    default_prefix="<TIME> | WORKER-001",
    color_text=True
)
logger.info("What a great logging library!")
```

## More in-depth documentation

### `defaultPrefix`
When initializing a Logger, you have the option of `default_prefix`.

For now, if you add `"<TIME>"` anywhere in that string, it will replace it with the time of the logging.

For instance, the following code will print `18:26:15 | hi! | i > What a great logging library! `
```python
import charlogger

logger = charlogger.Logger(
    debug=True,
    defaultPrefix="<TIME> hi!"
)
logger.info("What a great logging library!")
```

### Logging methods

Possible arguments
```python
import charlogger

logger = charlogger.Logger()
logger.info("What a great logging library!") # i > What a great logging library! 
logger.info(title="DOCUMENTATION", data="What a great logging library!") # i > [DOCUMENTATION] What a great logging library! 
```

All possible methods
```python
import charlogger

logger = charlogger.Logger()
logger.info("What a great logging library!")
logger.warn("What a great logging library!")
logger.error("What a great logging library!")
logger.debug("What a great logging library!")
logger.valid("What a great logging library!")
logger.invalid("What a great logging library!")
logger.plus("What a great logging library!")
logger.paid("What a great logging library!")
```

Special methods
```python
import charlogger

logger = charlogger.Logger()

# I can't imagine this one being all that useful. It's more there for my personal projects that use it,
logger.choice(1, "Option 1") # 1 > Option 1 

# Will wait for user input in the console.
name = logger.ask("What is your name?") # ? > What is your name? > 
print(name)
```
arc4 0.4.0
A small and insanely fast ARCFOUR (RC4) cipher implementation of Python
Keywords: ARCFOUR,cipher,cryptography,RC4

arc4
====

.. image:: https://github.com/manicmaniac/arc4/actions/workflows/test.yml/badge.svg
   :target: https://github.com/manicmaniac/arc4/actions/workflows/test.yml
   :alt: Test

.. image:: https://api.codeclimate.com/v1/badges/e7c21db66865a6d487d0/test_coverage.svg
   :target: https://codeclimate.com/github/manicmaniac/arc4/test_coverage
   :alt: Test Coverage

.. image:: https://api.codeclimate.com/v1/badges/e7c21db66865a6d487d0/maintainability.svg
   :target: https://codeclimate.com/github/manicmaniac/arc4/maintainability
   :alt: Maintainability

.. image:: https://readthedocs.org/projects/arc4/badge/?version=latest
   :target: https://arc4.readthedocs.io/en/latest/?badge=latest
   :alt: Documentation Status

A small and insanely fast ARCFOUR (RC4) cipher implementation of Python.

* Strongly focused on performance; entire source code is written in C.
* Thread-safety; you can improve further performance with multi-threading.
* Easily installable; single file with no dependency, pre-built wheels provided.

Benchmark
---------

Below is benchmark metrics against 3 major RC4 implementations.

.. image:: https://gist.githubusercontent.com/manicmaniac/991d0c197e1cb62eec81edec65363187/raw/benchmark.svg
   :alt: Benchmark

The whole benchmark code is in ``./benchmark.py``.

.. note::

   arc4 supports multi-threading but it is too fast to ignore the overhead of context-switching, in most cases.

Install
-------

Install from PyPI

.. code:: sh

   pip install arc4

Or clone the repo and do install

.. code:: sh

   git clone https://github.com/manicmaniac/arc4.git
   cd arc4
   python setup.py install

Usage
-----

.. code:: python

   >>> from arc4 import ARC4
   >>> arc4 = ARC4(b'key')
   >>> cipher = arc4.encrypt(b'some plain text to encrypt')

Because RC4 is a stream cipher, you must initialize RC4 object in the beginning of each operations.

.. code:: python

   >>> arc4 = ARC4(b'key')
   >>> arc4.decrypt(cipher)
   b'some plain text to encrypt'

Documents
---------

Here is the API reference.

https://arc4.readthedocs.io/en/latest/

Testing
-------

.. code:: sh

   python -m unittest discover

License
-------

This software is under the MIT License.
data-watch-sdk 0.0.1b1
Data Watch Python SDK
Requires Python: >=3.7

# Data Watch


## SDK

The [data-watch](https://pypi.org/project/data-watch/) allows users to programmatically access our APIs and data.

### Installation

Set the following environment variables for your username and password for [Algora Labs](https://app.algoralabs.com/).

```text
ALGORA_USER=<username>
ALGORA_PWD=<password>
```

## Help

If you need any help or have feedback, please email us at [support@algoralabs.com](mailto:support@algoralabs.com).
commutation-Spuriosity1 0.0.1
A library for doing noncommutative operator algebra
Requires Python: >=3.7

# Commutation Station for Operator Elimination

A proof assistant tool for the busy physicist, to be used in evaluating large commutator expressions.
This package does symbolic algebra on noncommutative objects. 

The relevant objects for most purposes are `CommutatorAlgebra`, `Expression` and `Term`. An `Expression` is a list of `Term`s, together with standard vector space operations.



# TODO
 - Export functionality for easier copying into Mathematica or similar
 - Input validation / standardisation of symbol types
 - change fundamental type from strings to objects: restrict purpose of Term to single terms
 - Implement use of anticommutator algebra
 - Scalar subclass of Term (in general, import sympy to simplify scalar coefficients?



# Future

## `Term` class functionality
`Term.as_latex()`
`Term.as_mathematica()`
`Term.__str__()`
`Constant(Term)`
does NOT have any built-in multiplier: this nastiness is handled by the new `Expression` class
`Expression.as_latex()`
`Expression.as_mathematica()`
internal structure: `[([1],[t1, t2]),([3/4 ka k2], [t3, t4])] -> t1 t2 + t3 t4