semvec/pypi-packages huggingface dataset:
kivy-garden.ebs.marquee 3.1
Marquee text widget for Kivy
Keywords: Kivy kivy-garden

Marquee Text Widget for Kivy
============================

[![Github Build Status](https://github.com/ebs-universe/kivy_garden.ebs.marquee/workflows/Garden%20flower/badge.svg)](https://github.com/ebs-universe/kivy_garden.ebs.marquee/actions)

This provides a Marquee Text widget for Kivy. 

This widget is part of the EBS widget collection for Kivy. It is written in 
mostly Python and depends on the EBS core widgets and widget infrastructure package. 
For more information, see [kivy_garden.ebs.core](https://github.com/ebs-universe/kivy_garden.ebs.core)

See https://kivy-garden.github.io/ebs.flower/ for the rendered flower docs.

Please see the garden [instructions](https://kivy-garden.github.io) for 
how to use kivy garden flowers.


CI
--

Every push or pull request run the [GitHub Action](https://github.com/kivy-garden/flower/actions) CI.
It tests the code on various OS and also generates wheels that can be released on PyPI upon a
tag. Docs are also generated and uploaded to the repo as well as artifacts of the CI.


TODO
-------

* add your code

Contributing
--------------

Check out our [contribution guide](CONTRIBUTING.md) and feel free to improve the flower.

License
---------

This software is released under the terms of the MIT License.
Please see the [LICENSE.txt](LICENSE.txt) file.

How to release
===============

See the garden [instructions](https://kivy-garden.github.io/#makingareleaseforyourflower) for how to make a new release.
fral 1.0.0
Fast Random Access Log
Requires Python: >=3.8

# Fast Random Access Log (FRAL)
FRAL is a concurrency-friendly log structure allocated over shared memory. Reads are random access and writes
are non-blocking. The current shared-memory framework uses memory-mapped files. The core engine is written in C++ and 
Python bindings are provided for higher level and less performance-constrained usage. Utilizing Python's 
struct library can easily extend the log to a language-agnostic shared memory framework as demonstrated [here](./fral/demo). 
Early workings for syncing FRALs over standard networking (using gRPC and Protobuf) in a non-intrusive and reliable way are also provided.
To normalize virtual memory addressing, allocation offsets from the start of the contiguous shared-memory space are 
stored in a fixed-sized array (see below).

![offset diagram](./misc/offsets.png)

Experimental findings show that the FRAL engine allows for completion of the parallel
production and consumption of log entries at a nanosecond scale. With two writers and a
single reader, the C++ implementation showed to support writing and reading over five million
100-byte log entries per second. Additionally, the FRAL engine saw a ~60x performance multiple over a [similar interface](./fral/testing/performance/engine_sqlite.h) 
written with SQLite. 

For more detail on the implementation and performance, see [this presentation](./misc/FRAL.pdf).


## Example Usage
The following simple usage is shown using two processes in parallel. Both the C++ and Python examples 
yield the below standard output:
```
TEST
TEST
DEST
```
### C++
```cpp
// Appender Process
auto ralA = fral::FRAL("test.bin");
const char *TEST_STR = "TEST";

auto blob = (char *) ralA.allocate(strlen(TEST_STR) + 1);
strcpy(blob, TEST_STR);
printf("%s\n", blob);

ralA.append(blob);
```
```cpp
// Reader Process
auto ralB = fral::FRAL("test.bin");

for(;;){
    auto blob2 = (char *) ralB[0];
    if(blob2){
        break;
    }
}

printf("%s\n", blob2);
blob2[0] = 'D';

auto blob3 = (char *) ralB[0];
printf("%s\n", blob3);
```

### Python
```Python
# Appender Process
ral_A = FRAL("test.bin")
test_bytes = "TEST".encode()

test_blob = ral_A.allocate(len(test_bytes))
test_blob[:len(test_bytes)] = test_bytes
print(bytes(test_blob).decode())
ral_A.append(test_blob)
```
```Python
# Reader Process
ral_B = FRAL("test.bin")

while True:
    test_blob2 = ral_B[0]
    if test_blob2:
        break
        
print(bytes(test_blob2).decode())
test_blob2[0:1] = 'D'.encode()

test_blob3 = ral_B[0]
print(bytes(test_blob3).decode())
```
### Performance Testing
#### Single Process Write Performance (1GB)
Testing the performance of writing 1GB with various allocation sizes and only one writer:
![Single Process Write Performance](./misc/write_test.png)
#### Multiprocess Write and Read Performance
Testing the performance of writing and reading 1GB with various allocation 
sizes and multiple writers:
![Producer-ConsumerLatency](./misc/pc_test_latency.png)
![Producer-ConsumerThroughput](./misc/pc_test_throughput.png)
streamlit-component-square-fill-cropper-webdevserv 0.0.1
streamlit_component_square_fill_cropper
Requires Python: >=3.6

# Streamlit - Component Remove bg - Demo

Streamlit Component Remove bg 

[![Streamlit App](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://webdevserv-portfolio-idoia-icodeidoia-portfolio-9kblei.streamlit.app/LIVE_Remove_Bg_app)
lolla 0.1.2
Local Ollama CLI
Requires Python: >=3.10.0

# Lolla

## Description

Lolla is a simple, easy to use, and lightweight Python binary for using Ollama's API. It is designed to be used in the terminal and can be used to make AI inference using Ollama's API.

## Installation

To install Lolla, simply run the following command:

```bash
pip install --user lolla
```

or with an isolated environment:

```bash
python -m venv ~/bin/lolla_venv
~/bin/lolla_venv/bin/pip install lolla

ln -s ~/bin/lolla_venv/bin/lolla ~/bin/lolla
```

## Usage

To use Lolla, simply run the following command :

```bash
lolla --help
```

## Contributing

To contribute to LaFlem, simply fork the repository and create a pull request. Please make sure to include a detailed description of your changes. Here are the things I will check during the review :

- Is CHANGELOG.md have been updated (**required**)
- Is the lint score did not decrease (**required**)
- Is the test coverage did not decrease (**required**)
- Is the documentation have been updated (**if required**)
- If tests have been added (**optional**)

### Development

This repository uses [Taskfile](https://taskfile.dev) to manage the development tasks. To see the available tasks, run the following command:

```bash
task --list
```