semvec/pypi-packages huggingface dataset:
kedro-cache 0.1.1
A kedro-plugin that adds caching to kedro pipelines
License: MIT
Requires Python: >=3.8,<3.11
Keywords: kedro,caching,kedro-plugin,kedro-cache

# Kedro Cache

> :warning: _This plugin is still under active developement and not fully tested. Do not use this in any production systems. Please report any issues that you find._

## 📝 Description

`kedro-cache` is a [kedro](https://kedro.org/) plugin that plugin that enables the caching of data sets.
The advantage is that the data sets are loaded from data catalog and not recomputed if they have not changed.
If the input data sets or code have changed, the outputs are recomputed and the data catalog is updated.
This plugin works out of the box with any kedro project without having to change the code.
The logic on how to determine if the cached data set in the catalog should be used is described in the flow chart below.

![Caching Flowchart](static/img/caching_flowchart.svg)

**Disclaimer:** _The caching strategy determines if a node function has changes by simply looking at the immediate function body.
This does not take into account other things such as called function, global variable etc. that might also have changed._

## 🏆 Features

- Caching of node outputs in catalog
- No change to kedro project needed
- Integration with kedro data catalog
- Configuration via `config.yml` file

## 🏗 Installation

The plugin can be install with `pip`

```bash
pip install kedro-cache
```

## 🚀 Enable Caching

In the root directory of your kedro project, run

```bash
kedro cache init
```

This will create a new file `cache.yml` in the `conf` directory of your kedro project in which you can configure the `kedro-cache` module.
Although this step is optional as the plugin comes with default configurations.

Next let's assume that you have the following kedro pipeline for which you want to add caching.
There are two nodes.
One that reads data from a `input` dataset, does some computations and writes it to a `intermediate` dataset and one that reads the data from the `intermediate` dataset and writes it to the `output` dataset.

```python
# pipeline.py

def register_pipelines() -> Dict[str, Pipeline]:
    default_pipeline = pipeline(
        [
            node(
                func=lambda x: x,
                inputs="input",
                outputs="intermediate",
            ),
            node(
                func=lambda x: x,
                inputs="intermediate",
                outputs="output",
            ),
        ],
    )
    return {"__default__": default_pipeline}
```

In order to add logging we simply just have to register all used data sets in the data catalog.
Because if the first node want to use the cached output instead of recalculating it, it need to load it from the data catalog.
This is only possible if it was stored there.

```yaml
# catalog.yml

input:
  type: pandas.CSVDataSet
  filepath: input.csv

intermediate:
  type: pandas.CSVDataSet
  filepath: intermediate.csv

output:
  type: pandas.CSVDataSet
  filepath: output.csv
```

And that was it. Just by adding all files to the catalog you enabled caching.
disk-detective 0.4.0
Provides tools to analyze disks on byte level
License: MIT

# Description

Provides tools to analyze disks on byte level

# Available Tools

- Master Boot Record Examiner
  - Provides information and analysis of MBR

- FAT Examiner
  - Provides information and analysis of:
    -  FAT VBR
    -  FAT FSInfo
    -  FAT Directory Entry
    -  FAT Long Filename

# Under Construction

- Disk Usage Information
  - Overview of disk space usage based on MBR information

# Future Tools

- Extended Partition Analyser
  - Examines extended parititions

- File System Analyser
  - ext
  - NTFS
  

# Installation

`pip install disk_detective`

# Usage

**From command line:**

`python -m disk_detective --path PATH --mode {mbr,structure,fat-vbr,fat-fsinfo,fat-lfn,fat-dir-entry} [--offset OFFSET]`

| Option | Short | Type | Default | Description |
|---|---|---|---|---|
|--path | -p | String | - | Path to file (dd, raw) or <br> path to disk (\\.\PhysicalDrive0, /dev/sda, /dev/disk1)|
|--mode | -p | String | - | mbr = Examines the MBR <br> usage = Overview of disk space usage <br> fat-vbr = Examines FAT VBR <br> fat-fsinfo = Examines FAT FSInfo <br> fat-lfn = Examines Long Filename Entries <br> fat-dir-entry = Examines Directory Entries |
|--offset | -o | Int | - | The offset in bytes to start reading |

# Example

**Output for mode == mbr**

`python -m disk_detective -p path/to/example.dd -m mbr`

Please find the result [here](example/example-mbr.txt)

<hr>

**Output for mode == fat-vbr**

`python -m disk_detective -p path/to/example.dd -m fat-vbr -o 1048576`

Please find the result [here](example/example-fat-vbr.txt)

<hr>

**Output for mode == fat-fsinfo**

`python -m disk_detective -p path/to/example.dd -m fat-fsinfo -o 1049088`

Please find the result [here](example/example-fat-fsinfo.txt)

<hr>

**Output for mode == fat-lfn**

`python -m disk_detective -p path/to/example.dd -m fat-lfn`

Please find the result [here](example/example-fat-lfn.txt)

<hr>

**Output for mode == fat-dir-entry**

`python -m disk_detective -p path/to/example.dd -m fat-dir-entry`

Please find the result [here](example/example-fat-dir-entry.txt)


# License

MIT
pure-array 0.1.0
A pure python implementation of numpy array
License: MIT
Requires Python: >=3.6

# Pure Python array (pure_array)

A pure python implementation of the `array` data structure of [numpy](https://numpy.org/). This work is not intended to
be a replacement for numpy, but rather a possible alternative when numpy is not allowed. This implementation has the 
same syntax as numpy, but not all functions are implemented. 

## Installation

```bash
pip install pure_array
```

You can also install the development version from GitHub:

```bash
git clone https://github.com/ferranSanchezLlado/pure_array.git
cd pure_array
pip install -e .
```

## Usage

```python
import pure_array as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

assert a + b == np.array([5, 7, 9])
assert a * b == np.array([4, 10, 18])   
assert a.max() == 3
```

## Requirements

As can be seen from the `requirements.txt` there are no requirements for the package itself, but the tests 
(`requirements_dev.txt`) require [pytest](https://docs.pytest.org/en/stable/) and
[flake8](https://flake8.pycqa.org/en/latest/) can be used for linting.

## License

[MIT](https://choosealicense.com/licenses/mit/)

## Future work

- [ ] Implement boolean indexing
- [ ] Documentation
- [ ] Better static typing
- [ ] More tests
- [ ] More functions
MLMath 0.0.0rc1
Differentiable PDE solving framework for machine learning
License: MIT
Keywords: Differentiable,Simulation,Fluid,Machine Learning,Deep Learning

# Machine Learning Math

[**Homepage**](https://github.com/tum-pbs/MLM)
&nbsp;&nbsp;&nbsp; [**Documentation**](https://tum-pbs.github.io/MLM/)
&nbsp;&nbsp;&nbsp; [**API**](https://tum-pbs.github.io/MLM/mlm)
&nbsp;&nbsp;&nbsp; [<img src="https://www.tensorflow.org/images/colab_logo_32px.png" height=16> **Playground**](https://colab.research.google.com/drive/1zBlQbmNguRt-Vt332YvdTqlV4DBcus2S#offline=true&sandboxMode=true)

Work in progress.

## Installation
See the [installation Instructions](https://tum-pbs.github.io/MLM/Installation_Instructions.html).
To install the latest stable version of MLM:
```bash
$ pip install mlm
```