semvec/pypi-packages huggingface dataset:
pyntendo 0.0.8
A Nintendo Entertainment System (NES) emulator in Python and Cython
Requires Python: >=3.6

# Pyntendo

    pip install pyntendo

A Nintendo Entertainment System (NES) emulator written in Python and Cython.
* All core components are implemented, including audio, and the most important mappers.
* Performant (runs at 60fps on modern machines)
* Fully headless operation is supported
  * NumPy-based input/output
  * Very limited external dependencies (really just NumPy)
  * See [Headless Demo](Headless%20Demo.ipynb) for a minimal example
* Pure Python/Cython, fully compatible with CPython (>3.6)

Although most games I have tested seem to run without issues, there are still some open issues that would improve
performance and accuracy and probably make some hard to emulate games work or work better.
* Several popular(ish) mappers are not implemented (along with lots of less popular ones)
* Some fine timing is not quite right, which might cause issues in some sensitive games
* This is not a cycle-accurate emulator, so sub-instruction level timing is not correctly emulated, and some parts of
  other systems are not emulated in a cycle-correct way
* See my [devnotes](devnotes.md) for known issues and planned work

I would like to give huge thanks and kudos to everyone who contributed to the amazing [NESDev Wiki](wiki.nesdev.com)
and all the other fantastic sources (most listed in the code), tests and forums for NES emulator development and 6502
progamming.  Without these resources it would have been impossible to develop this emulator.

### Usage

Basic usage:

    from nes import NES
    nes = NES("my_rom.nes")
    nes.run()

### Screenshots

Here are some screenshots of the emulator in action: Super Mario Brothers, Donkey Kong, MegaMan

<img src="/img/mario.png" height="300">
<img src="/img/donkeykong.png" height="300">
<img src="/img/megaman.png" height="300">

### Dependencies

Depends on the following libraries for key functionality:
* numpy (optional?)
  * headless operation
  * (possibly also required by pygame surfarray, used in rendering)
* pygame (optional)
  * timing
  * rendering
  * input
  * (without pygame, only headless operation is possible)
* pyaudio (optional)
  * audio playing
  * sync to audio
* pyopengl (optional)
  * OpenGL rendering
  * (not essential; can use SDL rendering via pygame)

### License

Distributed under the MIT License (see [here](LICENSE))
noodlewrapper 0.1
A wrapper used for meme generating using Discord API
Requires Python: >=3.8

Noodles API wrapper
===================
##### Created by Kabir Ghai (CypherGuy)

An extension module for [discord.py](https://pypi.org/project/discord.py/ "discord.py PyPi page") used as a meme-editor and welcome banners.

Notices:
-------

* This module was designed for [discord.py](https://pypi.org/project/discord.py/ "discord.py PyPi page") 1.7+ but may work with older versions, use at your own risk however.

Installation:
-------------

###### Install with pip:
```
pip install noodleswrapper
```

###### Sample code with `lisastage`:
```
#Headers (Authentication) is optional.. for now.
import discord
import noodleswrapper
from noodleswrapper import noodle

intents = discord.Intents.all() #Allow all the intents
client = commands.Bot(command_prefix = '!', intents=intents)

@client.command()
async def lisastage(ctx):
    text = noodle.lisastage('test') #'test' is what you want it to say
    await ctx.send(file = text) #This should return a neat image.
```

Links:
------

* [My website](https://frenchnoodles.xyz/api)
findmaxima2d 0.0.4
Python module for detecting maxima (or minima) peaks in 2-D grayscale images.

# Python 2-D Maxima finding algorithm (findmaxima2d) recreated from implementation in ImageJ/Fiji

This is an efficient 2-D maxima finding algorithm (based on previous implementation in ImageJ/Fiji), it requires a local maxima image as input (see below) as well as a grayscale image. When called, the find_maxima algorithm prunes the local maxima based on the ntol (noise tolerance parameter). It processes the local maxima in the following way:
* Scan the neighbourhood of each maxima and determine whether there are any surrounding peaks which are higher. If there are, skip this maxima.
* If there are pixels in the neighbourhood within a noise tolerance (ntol) of the maxima, add them to the list to be scanned, spreading out like a flood fill algorithm, until the neighbourhood is exhausted
    * If the pixels are equal to the maxima, mark this maxima as equal. 
    * If the pixels are less than maxima but greater than maxima minus the noise tolerance, mark as listed.
* Mark all pixels considered as 'processed' as long as they are included within a valid peak region. Reset all others.
* From the regions containing a peak, calculate the best pixel to be considered as maxima based on minimum distance calculation with all those considered equal.


## Installation

```shell
$ python3 -m pip install findmaxima2d

```

## Usage

The module is imported as follows.

```shell
>>> from findmaxima2d import find_maxima
```
The first stage in the maxima finding algorithm is to find the local maxima, this can be achieved in different ways but usually represents the identification of the maximum pixel in each 3x3 neighbourhood (in the default case). Here is some typical code:
```shell
import numpy as np
from scipy import ndimage
def find_local_maxima_np(img_data):
    #This is the numpy/scipy version of the above function (find local maxima).
    #Its a bit faster, and more compact code.
    
    #Filter data with maximum filter to find maximum filter response in each neighbourhood
    max_out = ndimage.filters.maximum_filter(img_data,size=3)
    #Find local maxima.
    local_max = np.zeros((img_data.shape))
    local_max[max_out == img_data] = 1
    local_max[img_data == np.min(img_data)] = 0
    return local_max.astype(np.bool)
 ```

With the find_local_maxima_np function in place it is then possible to find the maxima in an image E.g.:

```shell
img = Image.open('002eggs.png')
ntol = 10 #Noise Tolerance.
img_data = np.array(img).astype(np.float64)

t1 = time.time()


#Should your image be an RGB image.
if img_data.shape.__len__() >2:
    img_data = (np.sum(img_data,2)/3.0)
    
if np.max(img_data) >255 or np.min(img_data)<0:
    print ('warning: your image should be scaled between 0 and 255 (8-bit).')

#Finds the local maxima using maximum filter.
local_max = find_local_maxima_np(img_data)

#Finds the maxima.
y,x,regs = find_maxima(img_data,local_max.astype(np.uint8),ntol)
 ```
The find_maxima function outputs the local maxima coordinates (y,x) and also the pixel regions associated with each maxima (regs).