semvec/pypi-packages huggingface dataset:
stackNqueue 0.1.3
simple stack and queue used DoublyCircularLinkedList

# *Welcome! stackNqueue*
stackNqueue is simple packages provides stack and queue made up DoublyCircularLinkedList.  
This packages includes *Stack.py*, *Queue.py*, *DoublyCircularLinkedList.py*  
*Stack.py* and *Queue.py* inherit the **DoublyCircularLinkedList class** from *DoublyCircularLinkedList.py*  

## **structure of packages**
![stackNqueue구조](https://github.com/dudasdaily/stackNqueue/assets/66531025/e5165028-ab00-49b1-b488-899d5a27f96b)

## **inital states**
![stackNqueue초기상태](https://github.com/dudasdaily/stackNqueue/assets/66531025/24080ce2-1e27-4000-8f0e-b3dfb68b50e1)


## **DoublyCircularLinkedList Methods**
|Method|works|
|------|-----|
|append(x)|리스트 끝에 x를 추가한다.|
|getNode(i: int)| i번째 인덱스의 노드를 반환한다.|
|printList()|리스트를 출력한다.|
|pop(i: int)|i번째 인덱스의 노드를 삭제하고 반환한다. 인자를 주지 않거나 -1을 줬을경우, 끝노드를 삭제하고 반환한다.|
|insert(i: int, x)|i번째 인덱스에 item으로 x를 가진 노드를 삽입한다.|

## **Stack Methods**
*Stack클래스는 DoublyCircularLinkedList클래스를 상속받는다*
|Method|works|
|------|-----|
|push(x)|x값을 가진 노드를 리스트 끝에 추가한다.|
|pop()|리스트의 끝 노드를 삭제하고 반환한다.|
|top()|리스트의 끝 노드를 반환한다|

## **Queue Methods**
*Queue클래스는 DoublyCircularLinkedList클래스를 상속받는다*
|Method|works|
|------|-----|
|enqueue(x)|x를 리스트의 첫번 째 front에 추가한다.|
|dequeue()|rear노드 즉, 리스트의 끝 노드를 삭제하고 반환한다.|
|rear()|첫번째로 추가된 리스트의 끝 노드 rear의 값을 반환한다.|

# **Example**
~~~from stackNqueue.DoublyCircularLinkedList import *
from stackNqueue.Stack import *
from stackNqueue.Queue import *

a = DoublyCircularLinkedList() # DoublyLinkedList 생성
a.append(1) # 1
a.insert(0, 3) # 3 -> 1
a.pop() # 3
a.pop(0) # []
a.printList() # print "there is no Item in List"

b = Stack() # Stack 생성
b.push(1) # 1
b.push(2) # 1 -> 2
b.push(3) # 1 -> 2 -> 3
b.printList() # print 1 -> 2 -> 3
print(b.pop()) # return 3
b.printList() # print 1 -> 2
print(b.top()) # print 2


c = Queue() # Queue 생성
c.enqueue(1) # 1
c.enqueue(2) # 2 -> 1
c.enqueue(3) # 3 -> 2 -> 1
print(c.dequeue()) # print 1
print(c.rear()) # print 2
~~~
mychef 0.1.1
A libre recipe recommendation app.
Requires Python: >=3.9

# mychef

---

[![builds.sr.ht status](https://builds.sr.ht/~loges/mychef.svg)](https://builds.sr.ht/~loges/mychef?)
[![PyPI - Version](https://img.shields.io/pypi/v/mychef.svg)](https://pypi.org/project/mychef)
[![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)

> Minimal, libre recipe recommendation app.

The goal is simple: enter in ingredients you have and get back tasty recipes.

## Features

- JSON API for adding recipes with an authenticated user.
- Offer CLI for managing users and app state.
- Expose configuration options through environment variables.

## Roadmap

- Web interface for managing recipes.
- Filtering of recipes based on ingredient input.
- Sample web scraper for uploading recipes.

## Quickstart

Install package:

```console
pip install mychef
```

Initialize application:

```console
mychef init
```

Add a user:

```console
mychef users add
```

Launch application server:

```console
mychef run
```

## Configuration

You can configure parts of the application in the shell environment. Here's an example `.env`:

```shell
# Logging
LOG_LEVEL="info"

# Database
DB_PATH="/./mychef.db"

# Security
SECRET_ALGORITHM="HS256"
SECRET_KEY="<generated-when-initializing-app>"
SECRET_KEY_N_BYTES=32
```

## Development

The easiest way to develop locally with `mychef` is to use [hatch](https://hatch.pypa.io/latest/). With `hatch`, you will have access to important helper scripts for running locally, linting, type-checks, testing, etc.

### Testing

Lint and check types with:

```console
hatch run types:check
```

Run test suite:

```console
hatch run test
```

### Database Management

To upgrade the local database to latest schema, run:

```console
hatch run db:upgrade
```

Now that the tables are created, you can add fixtures:

```console
hatch run db:fixtures
```

If you add or update a table, you can generate a migration script by running:

```console
hatch run db:migration
```

If the migration script wasn't generated, check to see if you imported the model to [env.py](src/mychef/migrations/env.py).

### Local Server

Run the application server locally with:

```console
hatch run dev
```

The server should reload on changes to the source code.

## License

`mychef` is distributed under the terms of the [AGPLv3](https://spdx.org/licenses/AGPL-3.0-or-later.html) license.
visualize-queue 0.0.1.2
visualize queue with matplotlib

# visualize_queue
this program visualize queue, so you can see and understand how queue makes work
this defaults to to 3 seconds per action. if you want to change time, change plt.pause()

# Example usage

if __name__ == "__main__":

    q1 = QueueVisualization()

    q1.enqueue(12)

    q1.enqueue(3)

    q1.dequeue()

    q1.enqueue(8)

    q1.dequeue()

    plt.show()
pyfineflow 1.1.3
python nodes server for fineflow

# pyfineflow

> fineflow的python节点后端

## usage

### install

```shell
pip install pyfineflow
```

### make a demo

create dir and files like this：

- pyfineflow-demo/
  - main.py
  - app.py
  - math_nodes.py

```python
# app.py
from pyfineflow.core import Fine
fine = Fine('pyserver', 'python后端')
```

```python
# math_nodes.py
import time
from datetime import datetime
from pathlib import Path
from pyfineflow.core import get_ctx
from app import fine


@fine.node(category='数学运算', name="相加")
def add(num1: int, num2: int) -> int:
    num = num2 + num1
    return num


@fine.node(category='数学运算', name="相减")
def sub(num1: int, num2: int = 2) -> int:
    num = num1 - num2
    return num


@fine.node(category='数学运算')
def 原路返回(num1: int, num2: int = 2) -> (int, int):
    return num1, num2
```

```python
# main.py
from app import fine


def init():
    import math_nodes
    _ = math_nodes


init()
fine.init_server(port=8081)

```

run it:

```shell
python main.py
```
chances 0.1.9
Chances

<img src=https://image.ibb.co/b1P0de/Screen_Shot_2018_09_30_at_4_36_27_PM.png align=left><br><br>

A python package that implements several pseudo, quasi, and true, including quantum random methods into a unified single-line command interface.

![Travis branch](https://img.shields.io/travis/autonomio/chances/master.svg)[![Coverage Status](https://coveralls.io/repos/github/autonomio/chances/badge.svg?branch=master)](https://coveralls.io/github/autonomio/chances?branch=master)

## methods

- Quantum
- Ambient sound
- Halton sequence
- Korobov matrix
- Latin hypercube
- Latin hypercube with Sudoku style constraint
- Improved Latin hypercube (very slow)
- Uniform mersenne
- Uniform cryptographically sound

## visualization

- 1d plot
- 2d plot

## todo

- test degree of randomness for each method
- add degree of randomness test methods
- add more random methods
- add shuffle function
- add support for strings