semvec/pypi-packages huggingface dataset:
lake-aha 0.0.4
Memory Generator based on Kratos: The God of War.
Requires Python: >=3.5

# lake

lake is a framework for generating synthesizable memory modules from a high-level behavioral specification and widely-available memory macros. lake also comprises a library of generalized hardware modules aimed at memory controller designs.

## Install
`git clone github.com/StanfordAHA/lake`

`cd lake && pip install -e .`

## Run a test
To run a test, you can simply generate the verilog and push through your favorite verilog simulator. Alternatively, lake uses the pytest framework for unit tests of constituent modules. These tests leverage [fault](https://github.com/leonardt/fault) and [verilator](https://www.veripool.org/wiki/verilator) for open source simulation. Tests should run and pass on Linux and MacOS.

## Documentation
Check out the [wiki](https://github.com/StanfordAHA/lake/wiki) of this github repo.
example-pkg-willygoodwill 1.0.4
A small example package
Requires Python: >=3.6

# Example Package

This is a simple example project. The goal of this project is to deliver Ikea price list. In order to do this the package parses ikea products and combine them all to the ultimate list with prices. You can find the full code here 

[Github code](https://github.com/WillyGoodwill/example_pkg).

# Console Usage
Type in console

`python3 -m example_pkg`

# Python Editor Usage
Type in python editor

`from example_pkg.mod1 import *`
`Furniture().parsing()`
lsystem-generator 1.0
Package for generating and rendering Lsystems
Requires Python: >=3.9

# Lsystem generator python lib

Current version: [1.0](https://pypi.org/project/lsystem-generator/1.0/)

This package enable to generate Lsystem representation by providing:

* Axioms (e.g. : "F")
* Rules of generation (e.g. F -> F+F--F+F)
* Generation (e.g. 2 for the second generation)
* Rules of display (using the [turtle analogy](http://mathforum.org/advanced/robertd/lsys2d.html))


## Installation

`pip install lsystem-generator==1.0`

## Usage

```
from lsystem.lsys_generator import Lsystem

if __name__=="__main__":
    lsys = Lsystem("F",("F", "F-Y-F"), ("Y", "Y+F+Y"))

    lsys.generate(2)
    image = lsys.render(("+",80), ("-",-80))
    image.show()

    lsys.generate(5)
    image = lsys.render(("+",60), ("-",-60))
    image.show()
```

note fore the user: after declaring a Lsystem, multiple generation `generate()` can be created and different representation can be obtained `render()`

`help(Lsystem)` gives a detailed documentation on how to create Lsystems, generate and render image representations

## Performance limits

The programm is performing at generate lsystem in the first 10-15 generation, depending on the lenght of the rule for generation and the number of axioms and rules.
At generation n+1 the lenght of the generated sequence  will be:

```
    l_1 = number of axioms in sequence_n * lenght of the rule for generation for each axiom + characters that are not axioms in the sequence_n  

    = sum(number of axiom i in sequence_n * lenght of the rule i for this axiom) + (lenght of the sequence - sum(number of axiom i in sequence_n))

    = sum((l / l_rule_i * occ_a_i) * l_rule_i) + (l - sum(l / l_rule_i * occ_a_i) )  
```

with:
* `l`: lenght of the sequence at generation n 
* `l+1`: lenght of the sequence at generation n
* `l_rule_i`: lenght of the rule i for generation
* `occ_a_i`: number of occurences of the axiom i in the rule i for generation
* `i`: index of the pair (axiom, rule) defined in the Lsystem

The RAM available will depend on the system and the python installation you are running the lib with, the maximum string length that can be generated and thus the number of generation that can be produced will vary.
If higher generation needs to be produced, a different implementation would be required.

## Development

After downloading the sources run `pip install -e .`
We recommand using a virtulanv to install pip dependencies

## Running unit test (in development mode)

To run the tests execute from the root folder:
`pytest --testdox`

if you encounter import difficulites, make sure the root directory, lsystem and tests dir are in the $PYTHONPATH. Run `source .env` to add them

## License

Shield: [![CC BY-SA 4.0][cc-by-sa-shield]][cc-by-sa]

This work is licensed under a
[Creative Commons Attribution-ShareAlike 4.0 International License][cc-by-sa].

[![CC BY-SA 4.0][cc-by-sa-image]][cc-by-sa]

[cc-by-sa]: http://creativecommons.org/licenses/by-sa/4.0/
[cc-by-sa-image]: https://licensebuttons.net/l/by-sa/4.0/88x31.png
[cc-by-sa-shield]: https://img.shields.io/badge/License-CC%20BY--SA%204.0-lightgrey.svg
avri-api 0.1.8
Unofficial wrapper around Avri endpoints
Requires Python: >=3.7

# Python Avri API

[![Build Status](https://dev.azure.com/timvancann/timvancann/_apis/build/status/timvancann.pyavri?branchName=master)](https://dev.azure.com/timvancann/timvancann/_build/latest?definitionId=1&branchName=master)
[![PyPI](https://img.shields.io/pypi/v/avri-api)](https://pypi.org/project/avri-api/)

Unofficial wrapper around the [Avri](https://avri.nl/) API, for automation purposes.

## Usage

```bash
pip install avri-api
```

Initialize the client with you `postal code` and `house number`. Optionally provide a `house_nr_extension` and/or a `country_code`.
```python
from avri.api import Avri
client = Avri('1234AB', 42)
```

Exposes the following functions:
- ```client.upcoming()``` returns first upcoming collecting day in a `Garbage` object
- ```client.upcoming_of_each()``` returns first upcoming collecting day for each garbage type in a `List[Garbage]` object
- ```client.all()``` returns all upcoming collecting days in a `List[Garbage]` object

Both `upcoming` and `upcoming_of_each` contain today's pickup.

### The `Garbage` object

Contains 
- `name`: The name of the garbage type, e.g. `plastic` or `gft`.
- `day`: A python datetime object representing the collecting date.

## In a long living process
Data is cached for `6` days before it's refreshed to reduce the number of API calls made.