semvec/pypi-packages huggingface dataset:
daisytuner 0.2.4
A cloud-connected compiler pass for performance optimization
Requires Python: >=3.8

<p align="center"><img src="figures/daisy.png" width="300"/></p>

<a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a> 
[![CI](https://github.com/daisytuner/daisytuner/actions/workflows/tests.yml/badge.svg)](https://github.com/daisytuner/daisytuner/actions/workflows/tests.yml)
[![codecov](https://codecov.io/gh/daisytuner/daisytuner/branch/main/graph/badge.svg?token=44PO0BWG36)](https://codecov.io/gh/daisytuner/daisytuner)

Daisy is a cloud-connected optimization pass for *stateful dataflow multigraphs (SDFG)*. Daisy's optimization is based on the [similarity-based transfer tuning algorithm](https://dl.acm.org/doi/abs/10.1145/3577193.3593714), which fuzzy matches loop transformations from customizable databases using *performance embeddings*.

Installing Daisy is as simple as

```bash
pip install daisytuner
```

### Profiling-Augmented Embeddings

By default, Daisy computes embeddings of loop nests from static features of the SDFG. In order to produce more accurate embeddings, Daisy can additionally use profiling features, which can be automatically computed using the [daisytuner-likwid](https://github.com/daisytuner/daisytuner-likwid) extension. The plugin also enables a variety of further features like automatic roofline modeling. 

### Citation

If you use Daisy, cite us:

```bibtex
@inproceedings{10.1145/3577193.3593714,
    author = {Tr\"{u}mper, Lukas and Ben-Nun, Tal and Schaad, Philipp and Calotoiu, Alexandru and Hoefler, Torsten},
    title = {Performance Embeddings: A Similarity-Based Transfer Tuning Approach to Performance Optimization},
    year = {2023},
    isbn = {9798400700569},
    publisher = {Association for Computing Machinery},
    address = {New York, NY, USA},
    url = {https://doi.org/10.1145/3577193.3593714},
    doi = {10.1145/3577193.3593714},
    booktitle = {Proceedings of the 37th International Conference on Supercomputing},
    pages = {50–62},
    numpages = {13},
    keywords = {compilers, autotuning, performance optimization, peephole optimization, transfer tuning, embeddings},
    location = {Orlando, FL, USA},
    series = {ICS '23}
}
```
MovingBot 0.0.1
a script for simulating a object with a direction that can move in said direction
Requires Python: >3

https://github.com/XKMR/PythonMovingBot
# PythonMovingBot
this is a script for simulating a object with a direction that can move in said direction


## demo:
```py
#this is a demo program


try:
    while(True):
        smturn("right")
        print(displayCurrentPlace(currentX, currentY, currentDirection))
        sleep(0.5)
        for i in range(11): 
            smforward(1)
            print(displayCurrentPlace(currentX, currentY, currentDirection))
            sleep(0.1)
except KeyboardInterrupt:
    print("X: ",currentX," Y: ",currentY)
    print("pointing at ", currentDirection)
```

## functions:
turn():
turnes the object by 90 degrees clockwise or counterclockwise
arguments should be: "CC/CW", the current direction
returns: the new direction ("up" , "down" , "left" , "right")

### forward():
adds or subtracts an amount based on the inputed steps to/from X and Y
(moving the object in the direction that is's looking in)
arguments: the current X, the current Y, the current direction, a number of steps
returns: the new x,y

### smturn():
simplifies the turn command by removing the need for inputing the current direction
requires the turn() function to work, requires a variable named "currentDirection" to work
arguments: "left"/"right"
variables required to work: currentDirction
functions required to work: turn()
returns: 0

### smforward():
simplifies the turn command by removing the need for inputing anything other than the amount
of steps that is going to be taken.
arguments: int
variables required to work: currentX, currentX, currentDirection
functions required to work: forward()
returns: 0

### displayCurrentPlace():
makes a 20x20 "screen" that will display the place and direction of the object.
note that this needs some improvements
arguments:
variables needed to work: currentX, currentX, currentDirection
returns: 0

variables:
currentX: the current position of the object on the X axis
currentY: the current position of the object on the Y axis
currentDirection: the current direction of the object ("up","down","left","right")
this-cmd-be-boring-af 0.1.0
A little tool to show subway surfers, family guy funny moments and other entertaining clips in console
Requires Python: >=3.10,<4.0

# This CMD be boring AF
A little tool to show subway surfers and family guy clips in console using ASCII art.

## Installation
```bash
pip install this-cmd-be-boring-af
```

## Usage
You can find everything you need about usage in the help menu:
```bash
this-cmd-be-boring-af --help
```
MovingBot-XKMR 0.0.1
a script for simulating a object with a direction that can move in said direction
Requires Python: >3

https://github.com/XKMR/PythonMovingBot
# PythonMovingBot
this is a script for simulating a object with a direction that can move in said direction


## demo:
```py
#this is a demo program


try:
    while(True):
        smturn("right")
        print(displayCurrentPlace(currentX, currentY, currentDirection))
        sleep(0.5)
        for i in range(11): 
            smforward(1)
            print(displayCurrentPlace(currentX, currentY, currentDirection))
            sleep(0.1)
except KeyboardInterrupt:
    print("X: ",currentX," Y: ",currentY)
    print("pointing at ", currentDirection)
```

## functions:
turn():
turnes the object by 90 degrees clockwise or counterclockwise
arguments should be: "CC/CW", the current direction
returns: the new direction ("up" , "down" , "left" , "right")

### forward():
adds or subtracts an amount based on the inputed steps to/from X and Y
(moving the object in the direction that is's looking in)
arguments: the current X, the current Y, the current direction, a number of steps
returns: the new x,y

### smturn():
simplifies the turn command by removing the need for inputing the current direction
requires the turn() function to work, requires a variable named "currentDirection" to work
arguments: "left"/"right"
variables required to work: currentDirction
functions required to work: turn()
returns: 0

### smforward():
simplifies the turn command by removing the need for inputing anything other than the amount
of steps that is going to be taken.
arguments: int
variables required to work: currentX, currentX, currentDirection
functions required to work: forward()
returns: 0

### displayCurrentPlace():
makes a 20x20 "screen" that will display the place and direction of the object.
note that this needs some improvements
arguments:
variables needed to work: currentX, currentX, currentDirection
returns: 0

variables:
currentX: the current position of the object on the X axis
currentY: the current position of the object on the Y axis
currentDirection: the current direction of the object ("up","down","left","right")
mojipack 2.0.0
Encode binary data into fun emoji strings!
Requires Python: >=3.8
Keywords: emoji,encoding

# Mojipack

Encode any collection of bytes into a fun square of emojis. It's like base64, but more colourful!

```
📦‌💖‌🌺‌🦋‌🌈‌🥰‌😂‌🐦‌🍩‌💵‌😢‌🦄
🍎‌🍎‌🍎‌🍎‌🍎‌🐌‌⏰‌💪‌👌‌🎊‌💓‌💖
🎂‌💸‌🧡‌🌈‌🙃‌🎵‌👉‌🌷‌💓‌👉‌📢‌📺
🙃‌🐶‌💖‌🌻‌💸‌😢‌🚀‌💭‌🌈‌💰‌🙃‌🙃
🤗‌🐯‌🍀‌💫‌🤗‌😤‌💫‌💎‌🤧‌🎵‌📣‌📺
📺‌🤧‌🐯‌😤‌💘‌🙂‌🐻‌🌷‌😱‌😞‌🌞‌😹
👉‌🤭‌💪‌💪‌🚀‌💪‌💓‌🦋‌💰‌💰‌😱‌😱
😏‌🍎‌😢‌🤧‌🌺‌🌺‌🍓‌👌‌🤧‌💪‌🍀‌🦄
🦄‌⏰‌😚‌📢‌🌻‌😱‌🌈‌💭‌📌‌🤧‌📌‌😻
🎀‌💫‌🌷‌😤‌😱‌🤯‌🥴‌🤯‌📺‌🦄‌🥴‌🍓
🙃‌💋‌🐶‌🤗‌🍀‌🐯‌😢‌👉‌😹‌😐‌💫‌💘
🐌‌🍎‌😃‌🌷‌😃‌🤧‌🎵‌📌‌🤯‌👌‌🚀‌😄
😤‌🤭‌🌈‌😏‌😚‌💰‌💘
```

# Installation

Mojipack is on PyPI! So all you need to get started is to install it with pip:
```shell
pip install mojipack
```

# Usage

Here is how you create a mojipack encoded payload. The example uses msgpack for inner encoding. You could also use UTF-8
encoded json if you don't want to install more packages.
```python
import mojipack
import msgpack

data = msgpack.packb(
    {
        "name": "Jane Doe",
        "age": 21,
        "city": "New York",
        "is_student": False
    },
    use_bin_type=True
)

output = mojipack.encode(data)

print(output)
```

Decoding is just as simple:
```python
import mojipack
import msgpack

MOJIPACK_MESSAGE = "📦‌💖‌🌺‌🦋‌🌈‌🥰‌😂‌🐦‌🍩‌ ..."

data = mojipack.decode(MOJIPACK_MESSAGE)

print(
    repr(
        msgpack.unpackb(data)
    )
)
```
pyoctonion 3.12
Octonion Number System

# pyoctonion

## Octonion in Python

##### Authors: Charith Atapattu & Kalpa Thudewaththage

In this project, we introduce Python Library for octonions. There is a Python Library for facilitating algebra in quaternions called "pyquaternion". However, no python Library for doing algebraic operations in octonions. We introduce this "pyoctonion" library for researchers who need calculations in octonions. Due to lack of commutativity and Associativity, manual simpliflication is always time consuming and might go wrong. This package will certainly help to check octonionic identities and work with wide range of problems in octonions.

![PyPI](https://i.ibb.co/txc6QhY/oct-graph.jpg)

## Installation

Install from [PyPI](https://pypi.org/project/pyoctonion)
Please visit the pyoctonion homepage for full information and the latest documentation. **Designed for Python 2.7+ and 3.0+**

`$ pip install pyoctonion`

## Quick Start

Run the following for a basic overview. A copy of this example can be found in [demo.ipynb](./demo/demo.ipynb).

### Basic Usage

In your code, simply import the Octonion object from the pyoctonion module:

```python
from pyoctonion import Octonion
```

## Octonion Features

### Define Octonion objects

Define a,b,c Octonions.

```python
a = Octonion(1,2,3,4,5,6,7,8)
b = Octonion(1,3,5,7,9,2,4,6)
c = Octonion(8,7,6,5,4,3,2,1)

#printing octonion objects values
print(a)
print(b)
print(c)
```

#### output

```
+1.0000 +2.0000i +3.0000j +4.0000k +5.0000l +6.0000il +7.0000jl +8.0000kl
+1.0000 +3.0000i +5.0000j +7.0000k +9.0000l +2.0000il +4.0000jl +6.0000kl
+8.0000 +7.0000i +6.0000j +5.0000k +4.0000l +3.0000il +2.0000jl +1.0000kl
```

### Addition

```
a + b
```

#### output

```
+2.0000 +5.0000i +8.0000j +11.0000k +14.0000l +8.0000il +11.0000jl +14.0000kl
```

### Subtraction

```
a - b
```

#### output

```
+0.0000 -1.0000i -2.0000j -3.0000k -4.0000l +4.0000il +3.0000jl +2.0000kl
```

### Multiplication

```
a * b
```

#### output

```
-181.0000 -48.0000i -17.0000j -40.0000k +83.0000l +0.0000il +35.0000jl +4.0000kl
```

### Division

```
a / b
```

#### output

```
+0.8281 +0.2353i +0.1041j +0.2172k -0.3303l +0.0543il -0.0950jl +0.0543kl
```

### Norm

```
a.norm
```

#### output

```
14.2828568570857
```

### Conjugation

```
a.conjugate
```

#### output

```
+1.0000 -2.0000i -3.0000j -4.0000k -5.0000l -6.0000il -7.0000jl -8.0000kl
```

### Inverse

```
a.inverse
```

#### output

```
+0.0049 -0.0098i -0.0147j -0.0196k -0.0245l -0.0294il -0.0343jl -0.0392kl
```

### Power

```
a ** 3
```

#### output

```
-608.0000 -400.0000i -600.0000j -800.0000k -1000.0000l -1200.0000il -1400.0000jl -1600.0000kl
```

### Real Part

```
a.x_0
```

#### output

```
1
```

### Similary, we can obtain coeficient of imaginary units

#### Example 1:

```
a.x_1
```

#### output

```
2
```

#### Example 2:

```
a.x_7
```

#### output

```
8
```
troyalab 0.1.6
A library to use for Troyalab development boards for Python
Requires Python: >=3.9.2


# Installation ![Static Badge](https://img.shields.io/badge/https%3A%2F%2Fgithub.com%2Ftroyalab-fatih%2FBG96_RASPBERY_PI) 

The easiest way to install troyalab is to download it from [`PyPI`](https://pypi.org/project/troyalab/). It's going to install the library itself and its prerequisites as well.

```shell
$ pip install troyalab
```

Secondly, you can install troyalab from its source code.

```shell
$ git clone https://github.com/troyalab-fatih/BG96_RASPBERY_PI
$ cd troyalab
$ pip install -e .
```

----

 Import 
----

Then you will be able to import the library and use its functionalities.

```python
import troyalab.RPi_Shield
```

You can connect to the card by typing which port your Troyalab RPi Shield is connected to.

```python
troyalab = troyalab.RPi_Shield.BG96("/dev/ttyS0")
```

Then you need to adjust the GPIO settings to get your card up.
And you are ready.
```python
troyalab.setupGPIO()
troyalab.powerUp()
troyalab.getHardwareInfo()
```

---



---

### Verison Descriptions

| Version | 0.1.6        |
| ------- |--------------|
| Author  | Fatih Furkan |
| Date    | 13.08.2023   |
| Raspi   | 4 - Model B  |
| Python  | 3.9.2        |
#### Verison Descriptions
- Git and PyPI pulled to the same version.