semvec/pypi-packages huggingface dataset:
BanelePackage 0.0.1
This is a simple python package that is built for concatinating string and thus performing mathematics computations.
Keywords: python,numbers,strings


# BanelePackage

This is my first straightforward package for performing mathematics computations like summing digits etc, and also concatinating strings

## Instalation

To instal this package just run the following command:

```shell
pip install BanelePackage
```

```py


from BanelePackage import numbers, strings

# output
print("The sum of the two numbers is: ", numbers.add(4, 2))
print("The product of the two numbers is: ", numbers.mult(4, 2))
print("The difference of the two numbers is: ", numbers.sub(2, 4))
print("The quotient of the two numbers is: ", numbers.div(2, 4))


print("The two strings combined yields: ",
      strings.concatenate("BaneleOf", "@stro"))
print("The string in reverse: ", strings.reverseString("Banele"))

```
bole 0.0.13
Cascading configuration manager and logger for python (yaml, json)
Keywords: configuration config log yaml json

# bole
Cascading configuration manager and logger for python (yaml, json)

###### Why bole?
Bole = "trunk of a tree" = "log" :)

# BETA

Bole is a python configuration manager that has,
1. Loads configurations from `yaml, json`
2. Allows inheritance - child folder can load config from parent folder.
3. Allows imports - allows specifying config loading paths (and globs)
4. Has an easy to use cli.

# Install

Just install the pip [package](https://pypi.org/project/bole/),

```shell
pip install bole
```

# Configuration

## Example

```yaml
settings:
    inherit: True # If true, allow inherit parent folders.
environments:
    test:
        my_value: 22
    dev: 
        my_value: 42

my_value: 0
some_col:
    a: 
    - b: 0
```

To view this configuration just run (in the config folder),
```shell
bole config view
```

To get the result of `my_value`, run,
```shell
bole config get my_value # or
bole config get some_col.a[0].b
```

## Built in keywords and structures.

The following keywords are reserved (default values presented)

```yaml
settings:
    inherit: False # If true, allow inherit parent folders.
    inherit_siblings: True # If true allow inherit configuration files in the same source directory.
    allow_imports: True # If false dose not allow imports.
    use_deep_merge: True # Merge configurations via deep merge. If false, Only root keys are merged (and overwritten)
    concatenate_lists: True # When merging, append the merged list to the current one.
imports:
    - "**/*.config.yaml" # Recursively import all .config.yaml
    - path: my-config.yaml
      required: False # this item is not required.
      recursive: null # Applies if glob. Import recursively.
environments:
    [env name]:{ config overrides (any) }

```

## Example configuration

Example configuration with inheritance can be found in [tests](tests/test_files/root).

# Contribution

Feel free to ping me in issues or directly on LinkedIn to contribute.

# Future implementation

We plan to support multiple python version per environment.

Looking for help on this subject.

# Licence

Copyright ©
`Zav Shotan`, `Patrick Huber`, and other [contributors](graphs/contributors).
It is free software, released under the MIT licence, and may be redistributed under the terms specified in `LICENSE`.
elements-pay 1.0.3
The Elements Pay Python SDK
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*

# Elements Python SDK

Python bindings for the Elements API.

## Installation

You can install this package from source:

```bash
python setup.py install
```

## Configuration

This library requires you to configure the API key:

```python
import elements
elements.api_key = "my_api_key"
```

You may connect to the sandbox by configuring the base url:

```python
import elements
elements.api_base = elements.API_SANDBOX
```

## Usage

```python
import elements

# To create an authorized charge
authorized_charge = elements.Charge.create(
    amount=300000,
    currency="USD",
    payment_method_id="PM-XXXX",
)

# Access model attributes like object fields
authorized_charge.amount # 30000
authorized_charge.currency # "USD"
authorized_charge.captured # False


# To capture a charge
captured_charge = elements.Charge.capture(
    "CH-pV4rzxf9yRoWaPeJL2C47JoC",
    amount=300000
)

# To create a client token
client_token = elements.ClientToken.create(external_customer_id="foo").client_token

# To retrieve a payment method
payment_method = elements.PaymentMethod.retrieve(
    "PM-XXXX",
    external_customer_id="cus_ext_id"
)
```

Please refer to our REST API docs for detailed API usage.

## Development and Testing

First, set up the virtualenv for development by:

```bash
make
```

Then you may run tests like so:

```bash
make test
```

If you want to test for a specific Python version, supply the version like so (you must have the corresponding version installed first):

```bash
TOX_ARGS="-e py38" make test
```

To run the formatter, do

```bash
make fmt
```

For adhoc testing, you may start a Python REPL and import elements, you may test your changes with a local or a sandbox
environment by setting the `api_base` and `api_key`:

```python
import elements
elements.api_base = "http://localhost:3000"
elements.api_key = "my_api_key"
```