semvec/pypi-packages huggingface dataset:
hdytto 0.2.1
Add not pythonic syntax into your python.
License: MIT
Requires Python: >=3.8
Keywords: shell commands alias

# hdytto: How do you turn this on

A library adding new syntax into your Python.
i.e. It is NOT Pythonic :)

* [Compatibility](#compatibility)
* [Getting Started](#getting-started)
  * [REPL](#repl)
* [hdytto Reference](#hdytto-reference)
  * [Increment / Decrement](#increment--decrement)
  * [do...while](#dowhile)
  * [Comment](#comment)
  * [const](#const)

## Compatibility

* Python >=3.8

## Getting Started

Install from [PyPI](https://pypi.org/project/hdytto/):

```bash
$ pip install hdytto
```

This library cannot be used by `import hdytto` as in other libraries, but the usage is simple. At first, make `sitecustomize.py`:

```python
from hdytto import register_hdytto
register_hdytto()
```

Set the environmental variable `PYTHONPATH` the path to the directory containing the `sitecustomize.py` (e.g. `export PYTHONPATH=.`).
Then, run `main.py`:

```
# coding: hdytto

a = 5
print(a++)
print(a)
```

The output will be

```
5
6
```

### REPL

Additionally, make `.pythonrc.py`:

```python
import sys
import sitecustomize
sys.stdin.reconfigure(encoding='hdytto')
```

Set the environmental variable `PYTHONSTARTUP` the path to this `.pythonrc.py` (e.g. `export PYTHONSTARTUP=.pythonrc.py`).
Then, type `python`:

```
$ python
>>> a = 5
>>> a++
5
>>> do:
...     b = ++a
...     while b < 10
...
>>> b
10
```

## hdytto Reference
### Increment / Decrement
#### Syntax

```
x++
++x
x--
--x
```

#### Example

```
# coding: hdytto
a = 5
print(a++)
print(++a)
b = 10 - --a
print(b--)
```

Output:
```
5
7
4
```

### do...while
#### Syntax

```
do:
    statement
    while condition
```

#### Example

```
# coding: hdytto
do:
    a = 5
    while a < 3
do:
    b = a * 2
    while a++ < 10:
        pass
    while b <= 20
print(b)
```

Output:
```
22
```

### Comment
#### Syntax

```
/* */
```

#### Example

```
# coding: hdytto
a = /* foo */ 10
print(a)
if a == 10:
    b = 5
    /*b = 10
print(a - 20)*/
print(b)
```

Output:
```
10
5
```

### const
#### Syntax

```
const name = value
```

#### Example

```
# coding: hdytto

import time

def foo(x, const y):
    y = 20
    print(x + y)

print('long time process here.')
const a = 30
time.sleep(a) # a process requiring long time

foo(1, 2)
```

Output:
```
  File "main.py", line 6
    y = 20
         ^
SyntaxError: invalid assignment to const y

SyntaxError: encoding problem: hdytto
```

This is `SyntaxError`, so does not require running the process requiring long time.

#### Caution
hdytto's `const` only prohibits `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`, `**=`, `//=`, `@=`, `:=`, otherwise is allowed (e.g. `const l = []` and `l.append(5)` is allowed).
time-tracker-cli 1.0.1
time-tracker-cli is a Python script that allows you to track the time spent working in your projects or tasks.
License: MIT
Requires Python: >=3.6,<4.0
Keywords: time,tracking,productivity,time tracking


<p align="center">
  <img height=180 src="./readme_assets/logo.png">
</p>

It's a Python script that allows you to track the time spent working in your projects or tasks.
At the moment, this script doesn't have external dependencies so it's ready to run.

#### Installation: 

`$ pip install time-tracker-cli`

#### How to use:

**Help menu:**

`$ time-tracker-cli -h`

```
usage: time-tracker-cli [-h] [-p PATH] [-r] project

positional arguments:
  project               project name

optional arguments:
  -h, --help            show this help message and exit
  -p PATH, --path PATH  Path to the JSON data file
  -r, --report          Calculate and display a report of the time spent in the project
```

**Start/end working session**:

`$ time-tracker-cli -p "~/Documents/my_project_time_tracker_data.json" "my_project"`

The file or project within the file will be created automatically if it doesn't exist.


#### Behavior

The script saves "timestamps" for the working sessions in a JSON file with the following structure:

```
{
   "projects": [
       {
           "project_name": "a_project_name",
           "sessions": [
              {
                  "start": "dd/mm/yy - H:M:S" ,
                  "end": "dd/mm/yy - H:M:S"
              }
           ]
       }
   ]
}
```
Unfinished sessions will have a `null` value in the `end` field.

#### Report

To calculate the time spent working in a project, run:

```
$ time-tracker-cli -r -p "~/Documents/my_project_time_tracker_data.json" "my_project" 

Time spent working on project: 'my_project'
1 day, 7:52:19
Ongoing sessions: True
Time spent in ongoing session: 0:04:10.492647
```

#### TODO:

- [x] Add more functions to estimate the time spent working in a project (total, mean per day).
- [x] Add an argument to request a "report" of the time spent working in a project.
- [x] Add more documentation.
- [x] Add a simple GUI (optional). 
- [ ] Define behavior for unfinished sessions.

#### GUI version

Check out [Time Tracker](https://github.com/pazitos10/time-tracker)
stdbuf 1.1.0
Size and time aware deduplicated asynchronous buffer.
License: MIT
Requires Python: >=3.7,<4.0

# Stdbuf

[![CI][ci-image]][ci-url]
[![codecov][codecov-image]][codecov-url]

[ci-url]: https://github.com/dikuchan/stdbuf/actions/workflows/ci.yaml
[ci-image]: https://github.com/dikuchan/stdbuf/actions/workflows/ci.yaml/badge.svg

[codecov-url]: https://codecov.io/gh/dikuchan/stdbuf
[codecov-image]: https://codecov.io/gh/dikuchan/stdbuf/branch/master/graph/badge.svg?token=EWNC1RJZOK

Size and time bounded asynchronous buffer with deduplication. 

Buffer's content is flushed when either maximum size or time since
the first insertion reaches the specified limits.

Inspired by [ClickHouse buffer engine](https://clickhouse.com/docs/en/engines/table-engines/special/buffer/). Used for
the same purpose.

### Note

Multiple concurrent consumers are not supported.

### Usage

```python
import asyncio
import time

from stdbuf import Stdbuf


async def produce(buf: Stdbuf[int]):
    for i in range(2 ** 16):
        await buf.put(i)
        # Duplicates are ignored.
        await buf.put(i)


async def consume(buf: Stdbuf[int]):
    while True:
        start = time.perf_counter()
        # Get data at least every 2 seconds.
        # May return earlier if full.
        data = await buf.get()
        elapsed = time.perf_counter() - start
        assert len(data) <= 16
        assert elapsed <= 0.5 + 1e-2


async def main():
    with Stdbuf(16, 0.5, True) as buf:
        done, pending = await asyncio.wait({
            asyncio.create_task(produce(buf)),
            asyncio.create_task(consume(buf)),
        },
            return_when=asyncio.FIRST_COMPLETED,
        )
        for task in pending:
            task.cancel()


if __name__ == "__main__":
    asyncio.run(main())
```
pyjr 0.1.1
Functions and Classes for assisting with ETL.
License: MIT

# pyjr

An assistance package for ETL, model development and validation.

[![PyPI](https://img.shields.io/pypi/v/pyjr?color=brightgreen&logoColor=lightgrey)](https://pypi.org/project/pyjr/)

## Description
*Project is not complete.*

## Getting Started
*Project is not complete.*

### Installing
The package can be accessed via pip install.

    pip install pyjr

### Future Work
* ~~Plot classes have not been vetted.~~
* Add arg parse to plot classes.
* ~~Documentation of classes and functions.~~
* Update to TimeSeries, Tuning and Features.
* Test all model classes and functions.
* Add to self-contained functions.

### Changelog
* 0.0.1 - *Initial Release*
  * This serves as a quick release to utilize the basic functionality.
* 0.0.2 - *Working Release*
  * This release has passed a cursory review. 
* 0.0.3 - *Plot Release*
  * This release adds improved plotting capabilities.
* 0.0.4 - *Plot Release+*
  * This release adds documentation to the plot classes.
* 0.0.5 - *Functional Release*
  * This release allows subpackages.
* 0.0.6 - *Class Updates*
  * This release adds Stat class, for rapid stat gathering.
* 0.0.7 - *Package Restructure*
  * This release intro's a new file structure.
* 0.0.8 - *Hot Fix*
  * Hotfix Release
* 0.0.9 - *Another Hot Fix*
  * Forgot to add folder to setup.py.
* 0.1.0 - *Functionality Updates*
  * Add ax to plots, cleaned up typing and tested models.
keras-flower 0.3
A Simple Flower classification package trained on DenseNet201
License: MIT

# Keras Flower

[![status](https://api.travis-ci.com/bhanuchander210/keras_flower.png)](https://travis-ci.com/github/Bhanuchander210/keras_flower) [![coverage](https://img.shields.io/codecov/c/github/bhanuchander210/keras_flower)](https://app.codecov.io/gh/Bhanuchander210/keras_flower)

A Simple Flower classification package using DenseNet201.

- Classes   : [104 classes of flowers](keras_flower_labels.txt)
- Training Data Set : [Petals to the Metal - Flower Classification on TPU](https://www.kaggle.com/c/tpu-getting-started)


#### Usage

- Use pip install to install this package

```
pip install keras_flower
```

- To get all prediction results

```
import keras_flower as kf
predictions = kf.predict_by_path("file/to/predict.png")
print(predictions)
```

Sample output:

```text
[1.4414026e-06 1.6031330e-06 1.6295390e-06 1.1156463e-06 2.7592062e-06
...
 1.1587109e-06 4.1556059e-06 1.0784672e-05 6.0254356e-06]
```


- To get top prediction result with [flower labels](https://github.com/Bhanuchander210/keras_flower/blob/master/keras_flower_labels.txt)

```
import keras_flower as kf
for predicted, score in kf.predict_name_by_path("/path/to/file.png"):
    print(predicted, score)
```

Sample output:


```text
sunflower 0.99960905
```

#### Validation

- Data set : [102 Category Flower Dataset](https://www.robots.ox.ac.uk/~vgg/data/flowers/102/index.html)
- No of images : **8189**
- Overall accuracy : **0.9715**
- confusion matrix : [102flowers_confusion_matrix.csv](https://github.com/Bhanuchander210/keras_flower/blob/master/102flowers_confusion_matrix.csv)
- classification report : [102flowers_classification_report.txt](https://github.com/Bhanuchander210/keras_flower/blob/master/102flowers_classification_report.txt)
- classification report summary:
```text
                           precision    recall  f1-score   support
                micro avg       0.97      0.97      0.97      8189
                macro avg       0.95      0.94      0.94      8189
             weighted avg       0.97      0.97      0.97      8189
```
#### Demo

![demo](https://raw.githubusercontent.com/Bhanuchander210/keras_flower/master/demo.gif)