semvec/pypi-packages huggingface dataset:
qmate 0.0.2
Create asynchronous and asynchronous task
Keywords: events, tasks, queue, schedules, scheduling, event loops

# QMate
Create asynchronous and asynchronous task queues that run on a schedule... symantically.

## Examples


### Full Example
#### Run the function ```PrintSomething``` every quarter of every minute:
```py
from qmate import Queue, Task
import time


def PrintSomething(text):
    print(text)


queue = Queue(True)
queue.schedule(
    Task(
        func=PrintSomething,
        name='Print Something',
        at=["00", "15", "30", "45"],
        args=["Working"]
    )
)

while True:
    time.sleep(0.001)
```

#### `Queue.schedule` takes a single task or a list of tasks.
```py
queue.schedule(
    [
        Task(
            func=PrintSomething,
            name='Quarterly Print',
            at=["00", "15", "30", "45"],
            args=["Working"]
        ),
        Task(
            func=PrintSomething,
            name='10PM Print',
            at=["22:00:00"],
            args=["It's 10PM."]
        )
    ]
)

``` 

## Task Time Parameters
`Every` cannot be combined with other time parameters.  `At`, `On`, and `During` can be combined.  `At` is required, unless using `Every`.


### On

Run tasks on specific days.  If empty, run everyday.
```py
on=["Sunday", "Monday"] # on Sundays and Mondays
on=["everyday"] # on everyday of the week
```
---
### At
Run tasks at certain times.
```py
at=["17:30:00"] # at 5:30 PM
at=["30:00"] # at 30 minutes past every hour
at=["15", "45"] # at a quarter past and a quarter till every hour
```
---
### During
Run tasks during specfic months.  If empty, run every month.
```py
during=["May", "July"] # during the months of may and july
```
---
### Every
Run tasks on certain intervals.  Max time: `23:59:59`
```py
every=["3:30:00"] # every 3 hours, 30 minutes
every=["03:00"] # every 3 minutes
every=["30"] # every 30 seconds
```
---
### Examples

#### Create a task to ```PrintSomething``` everyday of the week at 10AM and 10PM, during the month of September:
```py
Task(
    func=PrintSomething,
    name='Print Something',
    on=["Everyday"],
    at=["10:00:00", "22:00:00"],
    during=["September"],
    args=["Working"]
)
```

#### Create a task to ```PrintSomething``` on Saturday and Sunday ten minutes past every hour:
```py
Task(
    func=PrintSomething,
    name='Print Something',
    on=["Saturday", "Sunday"],
    at=["10:00"],
    during=["September"],
    args=["Working"]
)
```

#### Create a task to run every 10 seconds and pass it multiple arguments:
 Acceptable formats: 23:59:59, 59:59, 59
```py
Task(
    func=MultipleArgument,
    name='Run every 10 seconds',
    every=["10"],
    args=["Houston", 713]
)
```
database3d 0.1.0
SQL based library for building and visualising finite element models.
Requires Python: >=3.8

# About the project
Scpyce is an SQL based library for building and visualising finite element models.

_For more information on the project structure, please refer to the [Documentation](https://github.com/nicbencini/scpyce/tree/main/docs)_.

# The solver
Sign Convention:
- Positive values represent upward forces
- Negative values represent downward forces
- Clockwise moments are positive moments
- Counter Clockwise moments are negative moments

Units:
- Force: kN
- Moment: KNm
- Distance: m
- Area: m^2
- Density kN/m^3
- Moment of inertia: m^4
- Youngs Modulus: MPa
- Embodied carbon: kgCO2e/m^3
- Coefficient of thermal expansion : 1/c

# Getting started
_For examples on how to use the solver, please refer to the [Examples](https://github.com/nicbencini/scpyce/tree/main/examples)_.

# Contributing
Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are greatly appreciated.

If you have a suggestion that would make this better, please fork the repo and create a pull request. You can also simply open an issue with the tag "enhancement". Don't forget to give the project a star! Thanks again!

# License
Distributed under the MIT License. See LICENSE.txt for more information.

# Contact
Email: nicbencini@gmail.com
LinkedIn: [Nicolo Bencini](https://www.linkedin.com/in/nicolo-bencini/)
quickeeg 0.0.14
This package provides a quick and easy pipeline to process EEG files and generate a report. It is a wrapper for mne.
Requires Python: >=3.7

# Quick EEG

Quick EEG is an open-source python package to make processing EEG simpler. It is a wrapper for MNE that streamlines processing pipelines.

Official documentaton and official release of package on pip to come.

## Example Code

Example use case, which can be found in quickeeg/quickeeg_main.py

```python
import os
import sys
sys.dont_write_bytecode = True
import numpy as np

from helpers.preprocessing import Preprocessing
from helpers.report import Report

if __name__ == '__main__':

    ###########################################
    ############## Example usage ##############
    ###########################################

    #Subject information
    path = os.path.join('quickeeg','data')
    id = 'participant_001'

    #Create pipeline
    pipeline = ['load_data',
                'rereference',
                'filter',
                'notch_filter',
                'ica',
                'marker_cleaning',
                'epoching',
                'baseline_correction',
                'averaging']

    #Processing parameters
    target_markers = {'11': [f'{i}' for i in range(11, 20)],
                      '21': [f'{i}' for i in range(21, 30)],
                      '31': [f'{i}' for i in range(31, 40)]}
        
    params = {'pipeline':               pipeline,
              'file_path':              os.path.join(path, id),
              'find_files_by_marker':   's11',
              'reference_channels':     'average',
              'bp_filter_cutoffs':      [0.1, 50],
              'notch_filter_freq':      60,
              'ica_components':         20,
              'eog_channel':            ['1L', '1R'],
              'target_markers':         target_markers,
              'epoching_times':         [-.2, .8],
              'baseline_times':         [-.2, 0]}

    #Run the pipeline
    preprocessing = Preprocessing(**params)
    preprocessing.process()

    electrodes=list(np.arange(0,len(preprocessing.raw.ch_names)))
    preprocessing.plot_erp(electrode_index=electrodes, save_plot=True)

    #Build the report
    reader_note = ' '.join(['This report was produced by the QuickEEG package.'])
    
    custom_text = ['## Note for the reader', 
                    reader_note]
    
    report = Report(preprocessing)
    report.build_report(custom_text)
```
patoka 0.2.16
A collection of Jupyter Lab widgets for IBM Qiskit
Requires Python: >=3.9

# Patoka

Patoka is a collection of Jupyter Lab widgets for IBM Qiskit

[Website](https://see-mike-out.github.io/patoka/)

## User-side installation

`pip install patoka`

## Usage

Refer to notebooks in the `demos` directory.

## Developers

### Vertual environment

Run `source bin/activate`

### Install libraries

1. For Python:
 `pip install -e .`

2. For Node:
 `npm i`

### Running the dev version widget server

Run: `npm run dev`

Then, import the loader functions from `patoka.widgets_dev` (e.g., `from patoka.widgets_dev import getCircuitViewer`).

### Bug report

Please use issues. Because the production version cannot attribute to Javascript source files, please run with the dev version.

## Citation

[Preprint](https://arxiv.org/abs/2502.00202)

```latex
@inproceedings{kim:patoka2025,
 title        = {Toward Human-Quantum Computer Interaction: Interface Techniques for Usable Quantum Computing},
 author       = {Kim, Hyeok and Jeng, Mingyoung J. and Smith, Kaitlin N.},
 year         = 2025,
 booktitle    = {ACM Proc. CHI},
 doi          = {10.1145/3706598.3713370}
}
```
namegiver 0.1.4
AI-based Character Name Generator
Requires Python: >=3.6

# Namegiver: AI-based Character Name Generator

A lightweight, OpenAI-powered Python library for generating **unique fictional character names** based on user-provided prompts. Designed for writers, game developers, and world-builders.

## Features
**AI-Generated Names** â€“ Distinctive names based on user descriptions.  
**Ensures Name Distinctiveness** â€“ Avoids generating names too similar to previous ones.  
**Supports CLI & API** â€“ Use from the terminal or integrate into Python projects.  
**Economy Mode** â€“ Uses GPT-3.5 by default; switch to GPT-4 if needed.  
**Token Usage Tracking** â€“ Monitor OpenAI API token consumption.  

## Installation

### 1. Install via pip
```bash
pip install namegiver
```

This will install the package and all its dependencies.

### 2. Set Up API Key
Create a `.env` file in your project directory:

```ini
OPENAI_API_KEY=your-api-key-here
ECONOMY_MODE=True
```

Alternatively, set it in your shell:

```bash
export OPENAI_API_KEY="your-api-key-here"
export ECONOMY_MODE="True"
```

## Usage

### 1. Using the Python API
```python
from namegiver import generate_unique_name, get_token_usage

past_names = ["Elwin", "Alvin", "Elvin"]

# Generate a unique name while avoiding past names
print(generate_unique_name("sci-fi bounty hunter", past_names))

# Show token usage
print("Token Usage Report:", get_token_usage())
```

### 2. Using the CLI

#### Generate a Name
```bash
namegen "medieval knight"
```

Example Output:
```
Sir Aldrin of Westmere
```

#### Specify Maximum Token Length
```bash
namegen "steampunk engineer" --max-tokens 5
```

Example Output:
```
Brasswick
```

#### Avoid Similar Names
```bash
namegen "elf warrior" --past-names Legolas Thranduil Elrond
```

Example Output:
```
Faerion
```

#### Check Token Usage
```bash
namegen --report
```

Example Output:
```yaml
Token Usage Report: {'total_tokens_used': 50}
```

## Configuration

### Environment Variables

| Variable | Default | Description |
|----------|---------|-------------|
| OPENAI_API_KEY | (Required) | Your OpenAI API key |
| ECONOMY_MODE | True | If True, uses gpt-3.5-turbo. Set to False for GPT-4 |

## How It Works
- The library queries OpenAI's LLM to generate a name.
- If `past_names` is provided, it asks OpenAI to avoid those names.
- After generation, the name is checked using Levenshtein distance to prevent near-duplicates.
- If the generated name is too similar, the system regenerates up to 5 times.

## Development

### Run Locally
Clone the repo and install dependencies:

```bash
git clone https://github.com/yourusername/namegiver.git
cd namegiver
pip install -e .
```

### Run Tests
Run the test suite with:

```bash
pytest tests/
```

## Contributing
Contributions are welcome! Submit issues or pull requests.

## License
This project is licensed under the MIT License.
brain-rot 0.1
Python based Brainrot language'.
Requires Python: >=3.6

# BrainRot - Custom Python Syntax Extension

BrainRot is a Python-based language extension that allows you to use `brainrot` instead of `def` for defining functions. It also enables importing and executing `.brainrot` files as if they were regular Python modules.

## Features
- Define functions using `brainrot` instead of `def`.
- Import `.brainrot` files directly into Python.
- Automatically transpiles BrainRot code into valid Python.
- Installable via `pip` from GitHub.

---

## Installation
To install BrainRot from GitHub, run:
```sh
pip install git+https://github.com/Shane-Develops/Brainrot.git
```

---

## Usage

### 1. Create a `.brainrot` File
Create a file called `example.brainrot` and define a function using `brainrot`:
```mog
brainrot sigma():
    rizz("That's a very sigma code!")

sigma()
```

### 2. Import and Execute
Save the file in the same directory as your Python script. Then, in a Python script, import the `.brainrot` file like a normal module:
```python
import brain_rot
import example  # Automatically converts and executes example.brainrot
```
When executed, this will print:
```
Hello from BrainRot!
```

---

## How It Works
- The BrainRot import system finds `.brainrot` files and processes them.
- It replaces `brainrot` with `def`, making the code valid Python.
- The modified code is then compiled and executed seamlessly.

---

## Project Structure
```
brain_rot/
â”‚â”€â”€ brain_rot/
â”‚   â”‚â”€â”€ __init__.py
â”‚   â”‚â”€â”€ brain_rot_importer.py
â”‚â”€â”€ examples/
â”‚   â”‚â”€â”€ example.brainrot
â”‚â”€â”€ setup.py
â”‚â”€â”€ README.md
â”‚â”€â”€ .gitignore
```

---

## Contributing
Feel free to contribute by submitting issues or pull requests on GitHub!

---

## License
This project is licensed under the MIT License.