semvec/pypi-packages huggingface dataset:
beautifyPlot 0.2
A simple matplotlib wrapper to avoid writing multiple plt. statements.
Requires Python: >=3.8

# beautifyPlot

A simple matplotlib wrapper to avoid writing multiple plt. statements.   

## Installation

`pip install beautifyPlot`


## Usage 

matplotlib code:

```python
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0,100,1)
y = x**3

plt.plot(x,y,label='y=f(x)')
plt.title("test plot")
plt.xlim([0,10])
plt.ylim([0,1000])
plt.legend(fontsize=15)
plt.tight_layout()
```


Using beautifyPlot

```python
from beautifyPlot.bplt import beautifyPlot
import numpy as np
x = np.arange(0,100,1)
y = x**3

plt.plot(x,y,label='y=f(x)')

plotArgs = {
    'title'           : ['test plot'], ## Use list to pass a set of arguments to the function
    'xlim'            : [0,10],
    'ylim'            : [0,1000],
    'legend'          : {'fontsize':15, 'loc':'best'}, ## Use dictionary to specify arguments
    'tight_layout'    : [] ## Leave list empty if there is nothing to pass
}
beautifyPlot(plotArgs)

## Next steps: Save plotArgs as JSON or use the same plot arguments in a different subplot/plot.
```


Using beautifyPlot (with shorthand notation)

```python
from beautifyPlot.bplt import beautifyPlot
import numpy as np
x = np.arange(0,100,1)
y = x**3

plt.plot(x,y,label='y=f(x)')

plotArgs ={
    't'   : ['test plot'],
    'xl'  : [0,10],
    'yl'  : [0,1000],
    'l'   : {'fontsize':15, 'loc':'best'},
    't_l' : []
}
beautifyPlot(plotArgs)

```





## Built-in shorthand notations

|shorthand| command |
| ------- | --------|
|"l"     | plt.legend|
|"t_p"   | plt.tick_params|
|"t_l"   | plt.tight_layout|
|"t"     | plt.title|
|"xl"    | plt.xlim|
|"yl"    | plt.ylim|
|"xt"    | plt.xticks|
|"yt"    | plt.yticks|
|"xlab"  | plt.xlabel|
|"ylab"  | plt.ylabel|
|"xs"    | plt.xscale|
|"ys"    | plt.yscale|
spasmlang 0.2.1
Simple Python Assembly Language
Requires Python: >=3.8
Keywords: assembly,development,python

# spasmlang

[![PyPI - Version](https://img.shields.io/pypi/v/spasmlang.svg)](https://pypi.org/project/spasmlang)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/spasmlang.svg)](https://pypi.org/project/spasmlang)


## Synopsis

`spasmlang` is a **s**imple **P**ython **as**se**m**bly **lang**uage. It is
essentially a high-level interface on top of the [bytecode][bytecode] package
that allows you to generate bytecode from a simple assembly-like syntax.

-----

**Table of Contents**

- [Installation](#installation)
- [Usage](#usage)
- [Examples](#examples)
- [License](#license)


## Installation

```console
pip install spasmlang
```


## Usage

The `spasmlang` package provides a single class, `Assembly`, that allows you to
generate bytecode from a simple assembly-like syntax. See the [examples](#examples)
below for a taste of its API.

You can also use the `spasm` command-line utility to compile assembly files
directly to Python bytecode:

```console
spasm example.pya  # generates example.pyc
```


## Examples

This is how the classic "Hello, World!" program looks like, targeting the
CPython 3.12 bytecode:

```python
from spasm import Assembly

asm = Assembly()
asm.parse(
    r"""
    push_null
    load_const          print
    load_const          "Hello, World!"
    call                1
    return_value
    """
)
exec(asm.compile())
```

This is how you can compile the file `example.pya` to `example.pyc` to create
a "Hello, World!" module, again targeting CPython 3.11:

```
# example.pya
    resume      0
    push_null
    load_name   $print
    load_const  "Hello, spasm!"
    precall     1
    call        1
    pop_top
    load_const  None
    return_value
```

Compile the assembly code with (assuming that you have installed `spasmlang`
with CPython 3.11)
    
```console
spasm example.pya
```

and then execute the generated module with e.g.
    
```console
python3.11 -m example
```

This example shows how to create a module that exports a `greet` function that
takes one argument, targeting CPython 3.11:

```
# greet.pya

code greet(who)
    resume                      0
    load_global                 (True, "print")
    load_const                  "Hello, "
    load_fast                   $who
    format_value                0
    build_string                2
    precall                     1
    call                        1
    return_value
end

    resume 0
    load_const                  .greet
    make_function               0
    store_name                  $greet
    load_const                  None
    return_value
```

Again, compile the assembly code with

```console
spasm greet.pya
```

and test it with

```console
$ python3.11 -c "from greet import greet; greet('spasmlang')"
Hello, spasmlang
```


## License

`spasmlang` is distributed under the terms of the
[MIT](https://spdx.org/licenses/MIT.html) license.


[bytecode]: https://github.com/MatthieuDartiailh/bytecode
eimutils 0.0.6
This project is a wrapper library to call utility functions.
Requires Python: >=3.9

# deutils
deutils offeres a set of commonly used python fuctions for use with Glue Jobs and Lambda.

# Functions

## get_secret(secret_name, region):
This function allows the look up of a sceret from aws secrets manager. It returns the key value pairs in a dictionary object.

## delogging
Several small helper functions for formatting logs. Right now its simple prints but it will extend to write to 
CloudWatch.

## s3_helper
The functions aggregate base functions into composite calls. For instance combining get_secret with connect_to_ftp. 
The new function get_ftp_connection_from_secret takes a secret as an input and returns a ftp connection to minimise
lines of code in the users call.

When you need to build a layer: https://awstip.com/create-aws-lambda-layers-using-cloud-9-694895903ca5

### Change Log:
| User       | Date       | Comment                                                                     |
|------------|------------|-----------------------------------------------------------------------------|
| ffortunato | 11/01/2023 | Describing Overall package.        |
  

[Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
MyCloudflareAPI 0.1
A command line tool for managing Cloudflare DNS records via the Cloudflare API.
Requires Python: >=3.6


# MyCloudflareAPI

`MyCloudflareAPI` is a Python package that provides a command-line interface for managing Cloudflare DNS records. It allows you to easily list, create, and update DNS zones and records, and fetch public IP addresses.

## Installation

To install `MyCloudflareAPI`, clone the repository and install the package using pip.

```bash
git clone http://example.com/MyCloudflareAPI
cd MyCloudflareAPI
pip install .
```

## Usage

The `mca_cli` command is the primary interface for interacting with the Cloudflare API. Below are the available actions and their usage.

### List DNS Zones

List all DNS zones associated with your Cloudflare account.

```bash
mca_cli --action list_zones
```

### Output Simba Zone Information

Print information about the 'simbawimba.com' DNS zone.

```bash
mca_cli --action output_simba_zone
```

### Get DNS Record ID by Name

Retrieve the DNS record ID for a specified DNS record name.

```bash
mca_cli --action get_dns_id --name [RECORD_NAME]
```

### Get Zone ID

Obtain the zone ID for a given DNS zone.

```bash
mca_cli --action get_zone_id --zone [ZONE_NAME]
```

### Create New DNS Record

Create a new DNS record in a specified zone.

```bash
mca_cli --action create_record --zone [ZONE_NAME] --type [RECORD_TYPE] --name [RECORD_NAME] --content [CONTENT]
```

### Update Existing DNS Record

Update an existing DNS record with new details.

```bash
mca_cli --action update_record --zone [ZONE_NAME] --record_id [RECORD_ID] --type [RECORD_TYPE] --name [RECORD_NAME] --content [CONTENT]
```

### Get Public IP

Fetch the public IP address of the current machine.

```bash
mca_cli --action get_public_ip
```

### Update Public IP Record

Update the DNS record with the current machine's public IP address.

```bash
mca_cli --action update_ip --zone [ZONE_NAME] --name [RECORD_NAME]
```

## Configuration

Before using `MyCloudflareAPI`, ensure you have set your Cloudflare API key in the `.env` file located in the root directory of the project.

```env
API_KEY_CLOUDFLARE=your_api_key_here
```

## License

This project is licensed under the [GPL-3.0 License](LICENSE.md).

## Support

If you encounter any problems or have any queries, please open an issue on the [GitHub issue tracker](http://example.com/MyCloudflareAPI/issues).