semvec/pypi-packages huggingface dataset:
dictionary-diff 0.0.2
Get and apply diffs of python dictionaries
Requires Python: >=3.8

# dict-diff
Dict diff is a python module that lets you get and apply diffs of python dictionaries

## Examples
Use `diff = diff(original_dict, another_dict)` to get the diff between the dictionaries

Use `another_dict = apply_diff(original_dict, diff)` to get back `another_dict`

## Installation

### PyPI
This package is available on [PyPI](https://pypi.org/project/dictionary-diff/). Use `pip install dictionary-diff` to install it

## Contributing
Open an [issue](https://github.com/JanLukasGithub/dict-diff/issues) or a [pull request](https://github.com/JanLukasGithub/dict-diff/pulls)
git-timewarp 0.0.2
time travel to a previous git commit
Requires Python: >=3.6

# git-timewarp

Oftentimes it's neccessary to go back to a previous commit. Perhaps you broke sometime and want to see where, or perhaps you want to benchmark an old version of a function. It's easy to `git checkout`, but what if you want to use two different versions of a function _in the same script_? Or use your latest testing/benchmarking code to run your old function? Fear not! `git-timewarp` allows you to temporarily import modules from a specified commit, performing all the git magic under the hood.

Here's how you use it. First, import the `GitTimeWarp` object. And the (current) version of a function you want to test.


```python
from git_timewarp import GitTimeWarp
from test import test_func
```

Let's see the output of the current function


```python
print(test_func())
```

    new function output


Great. But what was the output of that function at an earlier commit? By entering a `GitTimeWarp` object, we can time travel to discover what it was. All in the same script!


```python
with GitTimeWarp("a704acc5f651331645ee5850ff1cda0539cc23df") as tw:
    from test import test_func
    print(test_func())
```

    old function output


Zounds! A ghost has appeared!

How does this work, you ask? The `GitTimeWarp` object simply checks out the old code in the `timewarps/` folder (remember to add to your `.gitignore`!). It then modifies `sys.path` and does some more spicy python magic to ensure all imports in the block will reference the code in this other folder.
Amirtha-Project-12345 0.0.2
A small example package
Requires Python: >=3.6


# Make sure you have upgraded version of pip
Windows
```
py -m pip install --upgrade pip
```

Linux/MAC OS
```
python3 -m pip install --upgrade pip
```

## Create a project with the following structure
```
packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── setup.cfg
├── src/
│   └── example_package/
│       ├── __init__.py
│       └── example.py
└── tests/
touch LICENSE
touch pyproject.toml
touch setup.cfg
mkdir src/mypackage
touch src/mypackage/__init__.py
touch src/mypackage/main.py
mkdir tests
```

## pyproject.toml 

This file tells tools like pip and build how to create your project

```
[build-system]
requires = [
    "setuptools>=42",
    "wheel"
]
build-backend = "setuptools.build_meta"
```
build-system.requires gives a list of packages that are needed to build your package. Listing something here will only make it available during the build, not after it is installed.

build-system.build-backend is the name of Python object that will be used to perform the build. If you were to use a different build system, such as flit or poetry, those would go here, and the configuration details would be completely different than the setuptools configuration described below.


# Setup.cfg setup
Using setup.cfg is a best practice, but you could have a dynamic setup file using setup.py

```
[metadata]
name = example-pkg-YOUR-USERNAME-HERE
version = 0.0.1
author = Example Author
author_email = author@example.com
description = A small example package
long_description = file: README.md
long_description_content_type = text/markdown
url = https://github.com/pypa/sampleproject
project_urls =
    Bug Tracker = https://github.com/pypa/sampleproject/issues
classifiers =
    Programming Language :: Python :: 3
    License :: OSI Approved :: MIT License
    Operating System :: OS Independent

[options]
package_dir =
    = src
packages = find:
python_requires = >=3.6

[options.packages.find]
where = src

```
# Running the build
### Make sure your build tool is up to date
Windows
```
py -m pip install --upgrade build
```
Linux/MAC OS
```
python3 -m pip install --upgrade build
```


### Create the build
```
py -m build
```













### References
https://packaging.python.org/tutorials/packaging-projects/
CelestPlotter 1.0
RA and Dec Conversion and Plotter package

Use this package to make converting Right Ascension and Declination values to degrees(from HMS and DMS) way easier. Simply use InNCon.Convert(...) to convert the parameters into degrees. This package also has a plotting function CelSphere.Plot() to plot the RA and Declination values on the Celestial Sphere, complete with the representation of the Equatorial Plane and vector marking the Vernal Equinox.
tf14-cli 0.0.3
This contains a CLI for AWS terraform
Requires Python: >=3.7

# Terraform 14 CLI: KISS Style

## Summary
This is the design and implementation of providing simple and reliable terraform (`tf14`) commands for devs ops that build, commit and push `.tf` files. Terraform has hidden functionalities that devs may not be familar with. It shouldn't be the dev's responsibility to remember multiple commands every time they make a commit to terraform servers. That's why I decided to create a bash program orchestrated by python for devs to only remember a few commands.

```
Usage: tf14 [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  apply  Apply tf14 data to server.
  clean  Clean unnecessary tf14 files.
  edit   Edit the provided helper files.
  init   Test and fmt .tf code.
  plan   Make plans to local repo.
```  



## File Information
The main directory that requires attention is the __src/tf14__ directory:

- __api_methods.py__ - This files provides the users to see incoming messages by creating a global logger variable.

- __cli_utils.py__ - Creates essential utilities for `cli.py` that performs the system commands of the program.

- __cli.py__ - Bootstrap function for `cli_utils.py`. This file mainly interacts with the user by running the command `tf14`. 


## How do I run the Program?

NOTE : This code has only been tested on the latest Ubuntu operating system. Run on macOS at your own risk, but this program is not operational in Windows.   

## Running on Virtual Env (venv)

NOTE: You must have python3 installed to run these
commands. Infomation about python can be found [here](https://www.python.org/about/).

Follow these instructions if you want to run the files using venv

```
./build.sh

# run venv 
source tf14_env/bin/activate 

# use the program as intended
tf14 [OPTIONS]
```

### Cleaning Virtual Env (venv) & Dependencies
```
./clean.sh

# exit the virtual environment 
deactivate 
```

## Who do I talk to?

__Name__ - Rooklyn Kline<br>
__Email__ - rkline2@umbc.edu<br>