semvec/pypi-packages huggingface dataset:
NeuroDOT-py 1.2.0
An extensible Python toolbox for efficient optical brain mapping
Requires Python: >=3.8

NeuroDOT_py README


1. Installation:

	1. First, download Python. NeuroDOT_py is optimized for Python version 3.8.8: https://www.python.org/downloads/
	
	2. Download VSCode: https://code.visualstudio.com
	
	3. Download the Jupyter notebook extension for VSCode: launch your VS Code and type “jupyter notebook” in the extension search box. Select the first result (Jupyter) and click 'Install'.
	
	4. Install NeuroDOT_py using Pip: pip install neurodot_py


2. Geting Started
		
	1. The toolbox contains 4 folders: Data, neuro_dot, Support Files, and outputfiles/output_Images.
	
		1. The Data folder contains 10 data samples including both retinotopic mapping of visual cortex and mapping of hierarchical language processing with HD-DOT. There are also two example parameter files, 'params.txt,' and 'params2.txt' to be used with 'getting_started' (the NeuroDOT Preprocessing script).
             
		2. The neuro_dot folder contains the library, consisting of modules for each category of function involved in NeuroDOT_py (Analysis, File_IO, Light Modeling, Matlab   Equivalent Functions, Reconstruction, Spatial Transforms, Temporal Transforms, and Visualizations). There is also a function named DynamicFilter, which is used in 'getting_started.ipynb' to simplify visualizations for data pre-processing. There is also 'requirements.txt' which contains all of the necessary libraries to be installed to use NeuroDOT_py.	
		
		3. The Support Files folder contains necessary files for running NeuroDOT pipelines.
			- The A matrix file required for Reconstruction is too large to be posted on GitHub, so it can be downloaded from: https://www.nitrc.org/projects/neurodot/. Other A matrices will be added in the future.
	     
		4. The 'outputfiles' folder is created after running 'getting_started' and is where all of the images (.png) generated will be saved to.
	     
	2. 'getting_started.ipynb' is the Jupyter notebook for getting acquainted with NeuroDOT_Py. This is the file that you will open in VSCode/Jupter Notebook to run and manipulate the code.
github-reserved-names 2025.10.1
A list of paths that GitHub uses which aren't real users
Requires Python: >=3.10
Keywords: github, github api

=========================
``github-reserved-names``
=========================

|PyPI| |Pythons| |CI|

.. |PyPI| image:: https://img.shields.io/pypi/v/github-reserved-names.svg
  :alt: PyPI version
  :target: https://pypi.org/project/github-reserved-names/

.. |Pythons| image:: https://img.shields.io/pypi/pyversions/github-reserved-names.svg
  :alt: Supported Python versions
  :target: https://pypi.org/project/github-reserved-names/

.. |CI| image:: https://github.com/Julian/github-reserved-names/workflows/CI/badge.svg
  :alt: Build status
  :target: https://github.com/Julian/github-reserved-names/actions?query=workflow%3ACI

Usage
-----

A single ``set`` is exposed, containing the reserved names:

.. code:: python

    >>> import github_reserved_names
    >>> "sponsors" in github_reserved_names.ALL
    True


Source
------

The source of this data is the `npm github-reserved-names project <https://npm.im/github-reserved-names>`_

This module attempts to provide a mirror of that project as a Python module.

If you feel a path is missing, please file a pull request upstream and it will be pulled in here.
traceforest 0.1.7
High-performance Python profiler that generates interactive call tree visualizations to identify execution bottlenecks.
Requires Python: >=3.9

# TraceForest

> High-performance Python profiler that generates interactive call tree visualizations to identify execution bottlenecks.

[![Python Version](https://img.shields.io/badge/python-3.9+-blue.svg)](https://python.org)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

TraceForest is a blazing-fast Python profiler that captures function calls in real-time and presents them as beautiful, interactive tree visualizations. Perfect for identifying performance bottlenecks and understanding code execution flow.

## Features

- **Real-time profiling** - Captures function calls as they happen
- **Interactive trees** - Beautiful hierarchical visualizations
- **Modern web interface** - Clean, responsive design with dark theme
- **Detailed metrics** - Precise timing information for each function
- **Deep call analysis** - See the complete execution path
- **Persistent storage** - Save and share profiling sessions
- **Zero configuration** - Start profiling with just a few lines of code

## Quick Start

### Installation

```bash
pip install traceforest
```

### Basic Usage

```python
from traceforest import Profiler

# Create profiler instance
profiler = Profiler()

# Start profiling
profiler.start()

# Your code here
def slow_function():
    import time
    time.sleep(1)
    return "done"

result = slow_function()

# Stop profiling and view results
profiler.stop()
profiler.export()
```

### Web Visualization

After running `export()`, TraceForest will:
1. Generate a unique profiling session
2. Open your browser to view the interactive tree

## Detailed Usage

### Profiling Classes and Methods

```python
from traceforest import Profiler

class MyClass:
    def method_a(self):
        time.sleep(0.5)
        self.method_b()
    
    def method_b(self):
        time.sleep(0.2)

profiler = Profiler()
profiler.start()

obj = MyClass()
obj.method_a()

profiler.stop()
profiler.export()
```

## Web Interface

The web interface provides:

- **Interactive tree navigation** - Click to expand/collapse branches
- **Visual performance bars** - See relative execution times at a glance
- **Detailed timing information** - Precise millisecond measurements


## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
requisite_processor 0.2.6
Module for working with course requisite data and checking requisite satisfaciton.
Requires Python: <4.0,>=3.10

# Requisite Processor
The `RequisiteProcessor` class is designed to evaluate whether the prerequisite rules for a course are met given a list of completed courses and test score data.

## Prerequisite Data
This module can make use of any arbitrary prerequisite information given that it is formatted correctly. For more information on the necessary structure as well as the latest prerequsite data for UNM courses, see this repo:

https://lobogit.unm.edu/unm-data-analytics/requisite-data#

## Usage

### Initialization
Initialize the RequisiteProcessor with a dictionary of prerequisite rules.

```python
from requisite_processor.requisite_processor import RequisiteProcessor

prerequisite_rules = {
    "202310": {
        "MATH 1512": {
            "type": "course",
            "course": {"code": "MATH 1234"},
            "minimum_course_grade": "C"
        }
    }
}

processor = RequisiteProcessor(prerequisite_rules)
```

### Processor Methods
The RequisiteProcessor contains the following methods:
*availabile_academic_periods*:
Returns a list of all academic periods in the dataset.
```python
academic_periods = processor.availabile_academic_periods
print(academic_periods)  # Output: ['202310', '202380']
```

*latest_available_academic_period*:
Returns the most recent academic period.
```python
latest_period = processor.latest_available_academic_period
print(latest_period)  # Output: '202380'
```

*check_satisfaction*:
Checks if a student satisfies the prerequisites for a course in a specific academic period.

Parameters:

- course_code (str): Course to check prerequisites for.
- courses_taken (list[dict], optional): List of completed courses and grades. Defaults to [].
- test_scores (dict, optional): Test scores dictionary. Defaults to {}.
- academic_period (str, optional): Academic period. Defaults to the latest available.
- ignore_tests (bool, optional): Ignore test requirements. Defaults to False.
- ignore_grades (bool, optional): Ignore grade requirements. Defaults to False.

Returns:
RequisiteCheckResult object. The result of the prerequisite check.

See below for example usage.

### Example Prerequisite Satisfaction Check

```python
courses_taken = [{"code": "MATH 1250", "grade": "B"}]
test_scores = {"A01": 28}

result = processor.check_satisfaction(
    course_code="MATH 1512",
    courses_taken=courses_taken,
    test_scores=test_scores
)

print(result.satisfied)  # Output: True or False
```

## Future Work
- Write tests
- Allow for more customization in how requisites are processed.
- Write additional helper functions such as string representation of requirements, flattend requirements and more.
rokuvim 1.5.2
Keyboard-driven Roku remote for the terminal
Requires Python: >=3.8

```
 ██████╗  ██████╗ ██╗  ██╗██╗   ██╗██╗   ██╗██╗███╗   ███╗
 ██╔══██╗██╔═══██╗██║ ██╔╝██║   ██║██║   ██║██║████╗ ████║
 ██████╔╝██║   ██║█████╔╝ ██║   ██║██║   ██║██║██╔████╔██║
 ██╔══██╗██║   ██║██╔═██╗ ██║   ██║╚██╗ ██╔╝██║██║╚██╔╝██║
 ██║  ██║╚██████╔╝██║  ██╗╚██████╔╝ ╚████╔╝ ██║██║ ╚═╝ ██║
 ╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝ ╚═════╝   ╚═══╝  ╚═╝╚═╝     ╚═╝
```
#### Add Vim bindings to local network Roku devices
[![PyPI](https://img.shields.io/pypi/v/rokuvim.svg)](https://pypi.org/project/rokuvim/)

----

This project uses the Roku external control API
(https://developer.roku.com/docs/developer-program/debugging/external-control-api.md)

It automatically scans the local network for Roku devices and lets you control them from your terminal, using common Vim bindings.

Includes text input (insert mode), media control and device/media information.

----

Decided to revive this and fix some of the rendering issues.  Uses curses for rendering.

----

## Installation

### From PyPI
`pip install rokuvim`

### From source

```bash
git clone https://github.com/heheoppsy/RokuVim.git
cd RokuVim
pip install .
```

After installing, launch the remote with:  `rokuvim`

----

## Notes
Roku has disabled network remote support by default on newer devices.  You'll have to enable them.

From the home screen go to Settings > System > Advanced System settings > Control by mobile apps > Network Access and change the setting to "Enabled". A warning will come up, select "Yes, allow".

HTTP requests are handled with `requests`; no additional system libraries are required.
The curses UI requires a real TTY; some IDE terminals or non-interactive shells may fail.
facelooker 0.1.0
A tiny library to make the face landmarks detection easier.
Requires Python: >=3.10

# Facelooker

## Description
The Facelooker is a tiny Python library to provide some utilities for facial recognition and movement detection.
The main idea is to have a single instance of `Facelooker` class that runs the device camera and process all the
events automatically during the face recognition with OpenCV. All the movements and current pose are returned
in a single payload as a simple dictionary. This info can be consumed by any external consumer.

## How to Use

```python
from facelooker import Facelooker
from facelooker.strategy import DlibStrategy

PREDICTOR_PATH = "data/shape_predictor_68_face_landmarks.dat"

strategy = DlibStrategy(PREDICTOR_PATH)
facelooker = Facelooker(strategy, show_interface=True, show_debug_text=True)

facelooker.start() # Starts in a separated thread.

```

To load a predictor in `DlibStrategy`, you can [download the file here](https://huggingface.co/spaces/asdasdasdasd/Face-forgery-detection/blob/ccfc24642e0210d4d885bc7b3dbc9a68ed948ad6/shape_predictor_68_face_landmarks.dat). The facial recognition strategies are "under construction".
lrparse 0.1.8
Left/right substring extraction
Requires Python: >=3.8

# lrparse

**lrparse** is a tiny, fast Python library written in C for extracting substrings between *left* and *right* delimiters.

It provides two functions:
- `lr()`  – returns the **first** substring between delimiters.  
- `lrr()` – returns **all** substrings between delimiters.

---

##  Installation

```bash
pip install lrparse
```

##  Usage

```python
import lrparse

# lr() → first match between delimiters
print(lrparse.lr("pre[mid]post", "[", "]"))
# ['mid']

# lrr() → all matches between delimiters
print(lrparse.lrr("<a><b>c", "<", ">"))
# ['a', 'b']

# If delimiters don't exist, you get an empty list
print(lrparse.lr("hello world", "{", "}"))
# []

# If both delimiters are empty, the whole string is returned
print(lrparse.lr("abc", "", ""))
# ['abc']
```
mcp-url-downloader 0.1.0
MCP server that enables AI assistants to download files from URLs to the local filesystem
Requires Python: >=3.11
Keywords: mcp, download, url, file-download, ai-assistant

# MCP URL Downloader

A Model Context Protocol (MCP) server that enables AI assistants to download files from URLs to the local filesystem.

## Features

- Download single or multiple files from URLs
- File size validation (configurable, default 500MB)
- Automatic filename sanitization
- Unique filename generation to prevent overwrites
- Concurrent downloads with limits
- **Security**: SSRF protection, path traversal protection, MIME type validation

## Installation

```bash
# Using uvx (recommended)
uvx mcp-url-downloader

# Using pip
pip install mcp-url-downloader

# From source
git clone https://github.com/dmitryglhf/mcp-url-downloader.git
cd mcp-url-downloader
uv sync
```

## Configuration

### Claude Desktop

Add to your configuration file:

**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
**Windows**: `%APPDATA%/Claude/claude_desktop_config.json`

```json
{
  "mcpServers": {
    "url-downloader": {
      "command": "uvx",
      "args": ["mcp-url-downloader"]
    }
  }
}
```

## Usage

### `download_files`
Download multiple files from URLs.

### `download_single_file`
Download a single file with optional custom filename.

### Rate Limits

- Maximum 100 URLs per `download_files` request
- Maximum 10 concurrent downloads
- URL length limited to 2048 characters
- Timeout range: 1-300 seconds
- File size range: 1-5000 MB

## Development

```bash
# Run tests
uv run pytest

```
img-scrapr 0.1.1
Python package to download images from Google images
Requires Python: >=3.11
Keywords: image, scraper, selenium, web-scraper

# Python Image scraper using selenium
Image scraper to download images by a user given query in google images.

This is purely a learning exercise and is meant to be useful for dataset creation for training an image classifier model that will be made soon enough, that being said I hate image scraping so much.

Please note that as webscraping is a new field for me, claude was used in providing suggestions such as cookies handling functionality (mainly the idea of storing it in a pkl file) and it also helped with my learning journey for helping publish the package.

In version 0.1.1b (the current release version on PyPi) you will have slightly faster downloads (I hope) due to multithreading support (also new to this so please reach out to me if I have messed up). 

#### YOU CAN FINALLY INSTALL IT PEOPLE (still no tests though)

To install the package in terminal and run:

```bash 
pip install img-scrapr
```

Go into a folder (where you wish to store the images) using terminal and run:

```bash
scrape
```

Alternatively you can also run the following command in terminal (if scrape does not work or is assigned to another command already):

```bash
google-images-scraper
```

Once the program has begun follow the instructions in the terminal for the questions asked by the program 

Please note it does sometimes go off on the deep end with the images it downloads I am sorry I am working on it. I also know I should write tests and I will (soon).
print-arabic 0.1
A Python library to print Arabic text with proper bidirectional support
Requires Python: >=3.6
Keywords: arabic print display bidi bidirectional reshaper text

# Print Arabic

[![Twitter Follow](https://img.shields.io/twitter/follow/Al_Azwari?label=Follow&style=social)](https://twitter.com/Al_Azwari)
[![Downloads](https://pepy.tech/badge/print-arabic)](https://pepy.tech/project/print-arabic)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/print-arabic?style=plastic)](https://badge.fury.io/py/print-arabic)
[![PyPI version](https://badge.fury.io/py/print-arabic.svg)](https://badge.fury.io/py/print-arabic)

A Python library to print Arabic text with proper bidirectional support in terminals and consoles.

## Overview

`print-arabic` is a simple yet powerful utility that handles the complexity of displaying Arabic text correctly in Python applications. It combines Arabic text reshaping and bidirectional text rendering to ensure Arabic characters are displayed properly.

## Features

- Automatic Arabic text reshaping
- Bidirectional text support
- Simple, easy-to-use API
- Works in terminals and consoles

## Installation

Install using pip:

```bash
pip install print-arabic
```

## Usage

```python
import print_arabic

# Print Arabic text - direct usage
print_arabic("مرحبا بالعالم")

# Print mixed Arabic and English text
print_arabic("Hello مرحبا")

# Print Arabic with numbers
print_arabic("العدد ١٢٣٤٥")

# Alternative: use the function explicitly
print_arabic.print_arabic("النص العربي")
```

## How It Works

The library uses two key components:

1. **arabic-reshaper**: Reshapes Arabic text to connect letters properly
2. **python-bidi**: Applies the bidirectional algorithm for correct text direction

## Requirements

- Python 3.6 or higher
- python-bidi >= 0.4.2
- arabic-reshaper >= 2.1.3

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Author

Azwri (aazwri@gmail.com)

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Repository

https://github.com/azwri/print_arabic
stdlib-list 0.12.0
A list of Python Standard Libraries (2.7 through 3.14).
Requires Python: >=3.9

# stdlib-list

[![PyPI version](https://badge.fury.io/py/stdlib-list.svg)](https://badge.fury.io/py/stdlib-list)
[![Downloads](https://static.pepy.tech/badge/stdlib-list)](https://pepy.tech/project/stdlib-list)
[![CI](https://github.com/pypi/stdlib-list/actions/workflows/ci.yml/badge.svg)](https://github.com/pypi/stdlib-list/actions/workflows/ci.yml)

This package includes lists of all of the standard libraries for Python 2.6
through 3.14.

**IMPORTANT**: If you're on Python 3.10 or newer, you **probably don't need this library**.
See [`sys.stdlib_module_names`](https://docs.python.org/3/library/sys.html#sys.stdlib_module_names)
and [`sys.builtin_module_names`](https://docs.python.org/3/library/sys.html#sys.builtin_module_names)
for similar functionality.

## Installation

`stdlib-list` is available on PyPI:

```bash
python -m pip install stdlib-list
```

## Usage

```python
>>> from stdlib_list import stdlib_list
>>> libraries = stdlib_list("2.7")
>>> libraries[:10]
['AL', 'BaseHTTPServer', 'Bastion', 'CGIHTTPServer', 'ColorPicker', 'ConfigParser', 'Cookie', 'DEVICE', 'DocXMLRPCServer', 'EasyDialogs']
```

For more details, check out [the docs](https://pypi.github.io/stdlib-list/).

## Credits and Project History

This library was created by [@jackmaney](https://github.com/jackmaney),
and was maintained with the help of [@ocefpaf](https://github.com/ocefpaf) and
[@ericdill](https://github.com/ericdill) until
[version 0.8.0](https://github.com/pypi/stdlib-list/releases/tag/v0.8.0),
after which the primary maintainer
[archived the project](https://github.com/pypi/stdlib-list/commit/7bc9a32789221b4e23edcb6a2c1466e8234aabbb).

With the primary maintainer's approval, the project was transferred
from `jackmaney/python-stdlib-list` to `pypi/stdlib-list`, and was adopted
by new maintainers.

The README immediately prior to the maintainership transfer is
preserved at [`READMD.md.old`](./README.md.old).
ghot 0.2.0
GitHub Organization Tools
Requires Python: >=3.8

# GitHub Organization Tools

__GitHub Organization Tools (`ghot`)__ is a CLI tool designed to simplify the management of users and repositories
within a GitHub organization.

__Features__:

- Invite and remove users from your organization.
- Create, clone, pull or delete repositories.
- Create issues to multiple repositories.

## Installation
This tool can be installed via `pip`:

```bash
pip install ghot
```

## Quick Start Example
- Create a new [organization][org] in GitHub.

[org]: https://docs.github.com/articles/creating-a-new-organization-from-scratch

- Define a CSV file with the users and repositories.
    ```csv
    id,username,repo
    id1,user1,user1-repo
    id2,user2,user2-repo
    ```

    > - `id` is a custom identifier for the user.
    > - `username` is the GitHub username.
    > - `repo` is the repository name in the organization.
    >
    > Check the [documentation](https://joapuiib.github.io/github-organization-tools/) for more details!

- Invite users to the organization:
    ```bash
    ghot user invite my-org users.csv
    ```

- Let users accept the invitation and create their repositories — Or do it for them!
    ```bash
    ghot repo create my-org users.csv
    ghot repo invite my-org users.csv
    ```

- And clone the repositories!
    ```bash
    ghot repo clone my-org users.csv
    ```
treeplots 0.10.8
CLI tool to create tree views from a csv file with child-parent relationships.
Requires Python: <4.0.0,>=3.9.2

# plot-tree

## Description

plot-tree creates tree views from a csv file with child-parent relationships. 
It supports time-based snapshots and generates hierarchical data visuals in meraid, yaml, and text-tree formats.

## Setting Up the Project

1. Clone the repository:

   ```bash
   git clone <repository-url>
   cd plot-tree
   ```

1. Make sure base python verison is >=3.11
   - if base python is lower than 3.11, you can use conda to create a new environment with Python 3.11:

   ```bash
    conda create -n py311 python=3.11
    conda activate py311
    which python
   ```
   - then use poetry to create a new virtual environment with python 3.11
   ```bash
    poetry env use python3.11
   ```

1. Install Poetry if has not installed:
https://python-poetry.org/docs/#installation

   ```bash
    pipx install poetry
   ```

1. Install Python dependencies using Poetry:

   ```bash
   poetry install
   ```

   This command will install all Python packages specified in `pyproject.toml`, including:
   - `pyyaml` version ^6.0.1
   - `anytree` version ^2.12.1

## Run all the pytest unit tests
   ```bash
   poetry run pytest -v
   ```

## How to Run

1. Input: put the child and parent entries in [child_parent.csv](/child_parent.csv) by using the same format of the csv file
2. Run at project's root folder:

```bash
poetry run plot
```
![](/assets.run.gif)

3. Output: at folder [/output](/output)

## `treeplots` cli
```zsh
pip install treeplots
treeplots --help
treeplots -v
treeplots --example
treeplots
```

### cli publish
```zsh
poetry version patch
poetry version minor
poetry publish --build
poetry publish --build --dry-run
tox -e release
```