semvec/pypi-packages huggingface dataset:
diffit 0.1.5
Diff-it: Spark Dataframe Differ
License: MIT
Requires Python: >=3

# Diff-it: Data Differ
- [Overview](#overview)
- [Prerequisites](#prerequisites)
  - [Extras for macOS](#extras-for-macos)
- [Getting Started](#getting-started)
- [(macOS Users) Upgrading GNU Make](#(macos-users)upgrading-gnu-make)
  - [Creating the Local Environment](#creating-the-local-environment)
  - [Local Environment Maintenance](#local-environment-maintenance)
- [Help](#help)
- [Running the Test Harness](#running-the-test-harness)
- [FAQs](#faqs)

## Overview
`diffit` will report differences between two data sets with similar schema.

Refer to [Diffit's documentation](https://loum.github.io/diffit/) for detailed instructions.

## Prerequisites
- [GNU make](https://www.gnu.org/software/make/manual/make.html)
- Python 3 Interpreter. [We recommend installing pyenv](https://github.com/pyenv/pyenv)
- [Docker](https://www.docker.com/)

## Getting Started
[Makester](https://loum.github.io/makester/) is used as the Integrated Developer Platform.

### (macOS Users only) Upgrading GNU Make
Follow [these notes](https://loum.github.io/makester/macos/#upgrading-gnu-make-macos) to get [GNU make](https://www.gnu.org/software/make/manual/make.html).
 
### Creating the Local Environment
Get the code and change into the top level `git` project directory:
```
git clone git@github.com:loum/diffit.git && cd diffit
```

> **_NOTE:_** Run all commands from the top-level directory of the `git` repository.

For first-time setup, get the [Makester project](https://github.com/loum/makester.git):
```
git submodule update --init
```

Initialise the environment:
```
make init-dev
```

#### Local Environment Maintenance
Keep [Makester project](https://github.com/loum/makester.git) up-to-date with:
```
git submodule update --remote --merge
```

## Help
There should be a `make` target to get most things done. Check the help for more information:
```
make help
```

## Running the Test Harness
We use [pytest](https://docs.pytest.org/en/latest/). To run the tests:
```
make tests
```

## FAQs
**_Q. Why do I get `WARNING: An illegal reflective access operation has occurred`?_**
Seems to be related to the JVM version being used. Java 8 will suppress the warning. To check available Java versions on your Mac try `/usr/libexec/java_home -V`. Then:
```
export JAVA_HOME=$(/usr/libexec/java_home -v <java_version>)
```

---
[top](#Diff-it-Data-Differ)
zinglplotter 1.0.0
Zingl Path Plotting
License: MIT
Keywords: plotting,raster

# zinglplotter
Zingl-Bresenham plotting algorithms.

The Zingl-Bresenham plotting algorithms are from Alois Zingl's "The Beauty of Bresenham's Algorithm" ( http://members.chello.at/easyfilter/bresenham.html ). They are all MIT Licensed and this library is also MIT licensed. In the case of Zingl's work this isn't explicit from his website, however from personal correspondence "'Free and open source' means you can do anything with it like the MIT licence[sic]."

These algorithms are error-carry-forward algorithms such that they use only integer math to plot pixel positions, and curves like quadratic and cubic beziers do not need to be turned into tiny lines or checked for how small a line should be used. They merely travel from one pixel to the next pixel carrying the error forward. 

# Functions

This library is a series of plot line generators converted from C++.

* plot_line(x0, y0, x1, y1)
* plot_quad_bezier_seg(x0, y0, x1, y1, x2, y2)
* plot_quad_bezier(x0, y0, x1, y1, x2, y2)
* plot_cubic_bezier_seg(x0, y0, x1, y1, x2, y2, x3, y3)
* plot_cubic_bezier(x0, y0, x1, y1, x2, y2, x3, y3)
* plot_line_aa(x0, y0, x1, y1)
* plot_line_width(x0: int, y0: int, x1: int, y1: int, wd: float)

These do Zingl-Bresenham algorithms for line, quad, cubic. The `_seg` function perform the draw but only for rational segments (no inversion points). The `_aa` function performs the same thing but in an anti-alias manner.

```python
from zinglplotter import plot_line
for x, y in plot_line(0, 0, 5, 8):
    print(f"({x},{y})")
```

Will result in:
``python
(0,0)
(1,1)
(1,2)
(2,3)
(3,4)
(3,5)
(4,6)
(4,7)
(5,8)
``

```python
from zinglplotter import plot_quad_bezier
for x, y in plot_quad_bezier(0, 0, 9, 4, 0, 10):
    print(f"({x},{y})")
```

Will result in:
``
(0,0)
(1,0)
(2,1)
(3,2)
(4,3)
(5,4)
(5,5)
(5,5)
(5,6)
(4,7)
(3,8)
(2,9)
(1,9)
(0,10)
``
sharedbuitinmutables 0.10
Shared list / set / dict across processes / environments
License: MIT
Keywords: shared,list,set,dict


# Shared list / set / dict across processes / environments

## pip install sharedbuiltinmutables

### Tested against Windows 10 / Python 3.11 / Anaconda 


## FILE 1 

```python
from sharedbuiltinmutables import MemSharedDict, MemSharedList, MemSharedSet, cfg

# dill/pickle protocol
cfg.protocol = 5

d = MemSharedDict({3: 323}, name="d1", size=1024)
l = MemSharedList([3, 323], name="l1", size=1024)
s = MemSharedSet({3, 6, 5}, name="s1", size=1024)

d[111] = 444
d.pop(3)
d[9] = lambda h: h * 3
# to clean up: d.cleanup()

```

## FILE 2 

```python
from sharedbuiltinmutables import MemSharedDict, MemSharedList, MemSharedSet, cfg

# dill/pickle protocol
cfg.protocol = 5

d = MemSharedDict(name="d1", size=1024)
# passing a value ( d = MemSharedDict({33:11,3:3} name="d1", size=1024) )
# won't do anything if
# the dict has already been created by another proc
#
# use instead:
# d = MemSharedDict(name="d1", size=1024)
# d.clear()
# d.update({33:11,3:3})
l = MemSharedList(name="l1", size=1024)
s = MemSharedSet(name="s1", size=1024)
# to clean up: d.cleanup()

```