semvec/pypi-packages huggingface dataset:
ausmints_calculator 0.2.1
A calculator that can do basic arithmetic operations via the objects

# Calculator

This calculator is a library than can be used for simple arithmetic operations.
A calculator object should be created from the Calculator class defined inside the module. The object will have a "memory" attribute which will be operated upon and returned by the Calculator methods.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install ausmints_calculator.

```bash
pip install ausmints_calculator
```

## Usage

```python
from ausmints_calculator import Calculator

calc = Calculator()

calc.memory # returns 0
calc.add(5) # returns 5
calc.squared() # returns 25
calc.reset_memory() # returns 0
```

For more extensive examples see the [test](https://github.com/TuringCollegeSubmissions/jausmi-DT.1.1/blob/master/tests/test_calculator.py) file

## Docker
A Dockerfile is added that can be used to create python 3.8 environment with the calculator module already installed

## Roadmap
- A functionality that saves and remembers the "memory" variable between sessions could be created.
- Functionality that allows the user to save various results into a different memory variable (maybe a dict type). These values could be later accessed and set as active.

## [Changelog](https://github.com/TuringCollegeSubmissions/jausmi-DT.1.1/blob/master/CHANGELOG.md)


## License
[MIT](https://choosealicense.com/licenses/mit/)
parkr-OlliePugh 0.0.1
A  lightweight basic neural networks library in Python
Requires Python: >=3.6

# Parkr 
## A light weight neural network library

[![Python package](https://github.com/OlliePugh/parkr/actions/workflows/python-package.yml/badge.svg?event=push)](https://github.com/OlliePugh/parkr/actions/workflows/python-package.yml)

Parkr was created for my second year AI methods module at university.

It is very basic to get a neural network up and running and getting results quickly.

## Examples

### Creating the network

To create a network you just need to specify how many input nodes, how many output nodes, a vector that contains the amount of nodes in each hidden layer, and the activation function you want to use.

```
my_network = Network(6, [4,4], 2, ActivationMethods.TANH)
```

This will create a network with 6 input nodes, 2 hidden layers, both with 4 nodes each and 2 output nodes and it will use the tanh activation function.

### Training the network

To train the network you must pass a tuple where the first element is the training data and the second is the expected values for that training data.

Then when calling the train method the network will updates its bias' and weights on those values.

```
training_data = np.array(
    [0.77,0.21,0.34,0.2,0.12,0.54],
    [0.43,0.12,0.65,0.12,0.76,0.34]
    )

expected_data = np.array(
    [1],
    [0]
    )

epochs = 10
my_network.train(epochs, (training_data, expected_data))
```

### Performing a forward pass on the network

To perform a forward pass on the network you simply pass it a vector with each element as an input vaule.

```
my_result = my_network.feed_forward([[0.54,0.32,0.12,0.46,0.68,0.43]])
```

### Saving and opening networks

Parkr supports saving networks to disk and loading them back in so that you do not have to retrain your network everytime it leaves memory.
#### Save
This will save the networks structure as a .json file 
```
my_network.save("my_network_on_disk")
```

#### Load
This will load the network from the .json file
```
my_loaded_network = Network.open("my_network_on_disk")
```

### Print
This will output the structure of the network along with the weights and bias' to the console.
```
my_network = Network(4,[6,2],2, ActivationMethods.SIGMOID)
my_network.print()
```
Would output the following
```
A(0) B(0) C(0) D(0) 

E(0.30882) F(-0.27833) G(0.74767) H(-0.20595) I(-0.54466) J(0.32999)

K(-1.64158) L(0.17655)

M(-0.02446) N(-0.23844)

A->E: 1.65803
A->F: 0.88988
A->G: -0.20031
A->H: 0.0684
A->I: 0.50825
A->J: 0.69463
B->E: 0.11407
B->F: 0.30879
B->G: -0.06734
B->H: 0.45021
```
PyNVTX 0.3.3
A thin python wrapper for the nvToolsExt (NVTX) library, using pybind11 ... with some bells and whistles thrown in for good measure.
Requires Python: >=3.6

# PyNVTX

A thin python wrapper for the nvToolsExt (NVTX) library, using pybind11. This
wrapper is meant to be as thin as possible -- so only provides minimal support.
Currently supported features are:
1. NVTX annotations: `nvtxRangePushA` and `nvtxRangePop`
2. Function decorator: `PyNVTX.annotate`
3. Automatic decorator generation `PyNVTX.annotate_all_methods(<class name>)`



## Installation

Ensure that the `nvcc` is in your `PATH` -- or alternatively ensure that the
`CUDAHOME` environment variable points to your local CUDA install. To install,
either
```
pip install PyNVTX
```
or clone this repo and
```
python setup.py install
```


### This Won't Break If You Don't Have CUDA

You know what would suck? If including `PyNVTX` required CUDA to be installed?
Why? There are loads of applications that support CUDA, if available. And
default to the CPU-only version otherwise. `PyNVTX` is the same. If `nvcc` in
not in your `PATH` (nor in your `CUDAHOME`), then you'll see this warning:
```
 *** WARNING: The nvcc binary could not be located in your $PATH. Either add it to your path, or set $CUDAHOME
```
(note that it will not warn you if you're installing with pip) and `PyNVTX`
will still install (it just won't do anything). You can check if a local
version of `PyNVTX` has been built with CUDA support by checking:
```python
PyNVTX.cuda_enabled # True if compiled with CUDA support
```



## NVTX Markers (`nvtxRangePushA` / `nvtxRangePop`)

```python
import PyNVTX as nvtx

nvtx.RangePushA("Doing some work")

# code to time goes here

nvtx.RangePop()
```


### Function Decorator

The `PyNVTX.annotate` will put `RangePushA` and `RangePop` the the beginning and of
the function call:
```python
import PyNVTX as nvtx

@nvtx.annotate("test_function")
def test():
    # You code goes here
```


### Automatic Instrumentation

The `PyNVTX.annotate_all_methods` will automatically decorate all methods in a
class, as well as all methods it inherits. A guard prevents accidentally
decorating any method twice. Eg.:
```python
import PyNVTX as nvtx

class MyClassA(object):
    def __init__(self):
        pass

    def f(self):
        pass

class MyClassB(MyClassA):
    def __init__(self):
        pass

    def g(self):
        pass


nvtx.annotate_all_methods(MyClassB)
```
Will instrument `MyClassB`'s `__init__`, as well as `f` and `g`, but _not_
`MyClassA`'s `__init__`.

Adding a class/method name to `PyNVTX.REGISTRY` will prevent it from being
instrumented by `PyNVTX.annotate_all_methods`. For example:
```python
nvtx.REGISTRY.add(MyClassB, "f") # note the method name is a string
nvtx.annotate_all_methods(MyClassB)
```
will not instrument `f`.



## Example Code

To get you started, take a look at `test/test-nvtx.py`
py-slippi-stats 0.0.2
A package for getting Slippi stats in Python
Requires Python: >=3.6

# py-slippi-stats

This program is an attempt at recreating the Slippi [stats](https://github.com/project-slippi/slippi-js/tree/master/src/stats) module of the original Slippi javascript package using [py-slippi](https://github.com/hohav/py-slippi). Most of it is just a translation of the slippi-js to python.

## Installation

Steps:

1. (Optional) Create a virtual environment and activate it. On Windows, this should work:

        py -m venv my-python-env
        source my-python-env/Scripts/activate

2. Run the following command to install py-slippi-stats:

        pip install py-slippi-stats

## Usage

Here is a basic example of usage:

    import slippi
    import slippistats

    game = slippi.Game('mygame.slp')
    stats = slippistats.overall.getGameStats(game)

    print(stats)