Saravanan666/pypi-org huggingface dataset:
Package: pixanalyzer
PixAnalyzerPixAnalyzer is a tool for quantifying the motion of objects.
It calculates pixel changes and quantifies the overall motion, which cannot be quantified by tracking or object recognition.InstallationStep1: Clone this repositoryStep2: InstallAnacondaStep3: Build an environment using the yaml fileIn Anacnda promptconda env create -f <path/to/environment.yml>Step4: Start PixAnalyzerIn Anacnda promptconda acitate pixanalyzer
  cd PixAnalyzer # Move to PixAnalyzer directory
  python -m pixanalyzerDemoIn the "test data" folder, there are analyze demo.mp4 and result.mp4 and other figures.AcknowledgementsWe thanks for PhD. Ryoya Tanaka for discussing.Release Note2023/10/XX First release (Ver. 1.0)FeedbackIf you have any feedback, please reach out to us by:Opening an issue in the repositoryE-mail:haya.m.yamano.neuro@gmail.comLicenseMIT
Package: pixano
Data-centric AI building blocks for computer vision applicationsUnder active development, subject to API changeInstalling PixanoAs Pixano requires specific versions for its dependencies, we recommend creating a new Python virtual environment to install it.For example, withconda:condacreate-npixano_envpython=3.10
condaactivatepixano_envThen, you can install the Pixano package inside that environment with pip:pipinstallpixanoUsing your datasetsPlease refer to our Jupyter notebooks forimportingandexportingyour datasets.Using the Pixano appsPlease refer to these links for using thePixano Explorerand thePixano Annotatorapps.ContributingPlease refer to theCONTRIBUTING.mdfor information on running Pixano locally and guidelines on how to publish your contributions.LicensePixano is licensed under theCeCILL-C license.
Package: pixcat
pixcatWORK IN PROGRESSDisplay images on akittyterminal
with optional custom/thumbnail/fit-to-screen resizing.Developed with the goal of being a more powerful alternative tokitty icat,
while also providing an usable Python 3.6+ API.UsageBasic CLI examples:pixcatfile.jpg

pixcatfit-screen--enlarge/tmp/abc.jpg

pixcatthumbnail--size128--alignleft'https://picsum.photos/480?random'pixcatresize--min-width1920--min-height1080\--max-width1920--max-height1080\~/images/wallpapers1.jpg2.pngThe commands and options have short forms too.Seepixcat --helpfor more information.Same examples using the Python package (no documentation yet):frompixcatimportImageImage("file.jpg").show()Image("/tmp/abc.jpg").fit_screen(enlarge=True).show()Image("https://picsum.photos/480?random").thumbnail(128).show(align="left")foriinImage.factory("~/images/wallpapers","1.jpg","2.png"):i.resize(1920,1080,1920,1080).show()InstallationRequires Python 3.6+, tested on GNU/Linux only.pip3install--upgradepixcat
Package: pixd
A Python port ofpixd, a tool for visualizing binary data using a colour palette. It is
in a lot of ways akin to a hexdump tool, except using coloured squares to
represent each octet.pixduses 24-bit color SGR escape sequences.  For a list of terminal
emulators with support for these, seeXVilka’s list of supporting terminal emulators.UsageTo install$pipinstallpixdTo display a file$python-mpixdpath/to/fileLicenseMIT license.  Enjoy!See alsopixdThe original C implementation byFireyFlyhexdmore conventional hexdump tool with colourful output, and also whatpixd’s
code is based on.
Package: pixe
pixeA digital helper to keep your files neat and tidy.In its most basic invocation:pixe <directory with files>pixewill copy all JPG files from a source directory into a new set of subdirectories based on capture date. These files will also be renamed based on said capture date and a calculated SHA1 hash.subdirectoriesSubdirectories will be created, as needed, in the destination folder to match the creation date of the files being processed and will take the following form:YYYY/Mrenamed filesEach file (whether moved or copied) will have a new name applied to it based on the following pattern:YYYYMMDD_hhmmss_<SHA1SUM>.jpgThe datetime info is taken from the image capture datetime. The SHA1SUM is calculated based on the image data only (does not include image metadata).exampleGiven a directory of images,dirAwhich contains a few image files:dirA
├── IMG_0001.jpg
├── IMG_0002.jpg
└── IMG_1234.jpgRunningpixe /path/to/dirAfrom within a second directory,dirBwould result in the following directory structure:dirB
├── 2021
│   └── 12
│       └── 20211225_062223_7d97e98f8af710c7e7fe703abc8f639e0ee507c4.jpg
└── 2022
    ├── 2
    │   └── 20220202_123101_447d306060631570b7713ea48e74103c68eab0a3.jpg
    └── 3
        └── 20220316_232122_321c7d6f5be8739a8974e4c3512e3226eb6704a7.jpgInstallation$ pip install pixeUsageUsage: pixe [OPTIONS] SRC

Options:
  -d, --dest TEXT              desired destination
  -r, --recurse                recurse into sub-directories (default: off)
  --parallel / --serial        process files in parallel (default: --parallel)
  --move, --mv / --copy, --cp  move files into DEST rather than copying
                               (default: --copy)
  --owner TEXT                 add camera owner to exif tags
  --copyright TEXT             add copyright string to exif tags
  --help                       Show this message and exit.Options-d, --dest TEXTThe base directory of where you want the processed files to end up. If this option is not specified,
the current working directory will be used.-r, --recursepixewill recurse into any subdirectories it finds beneath SRC. The default is to not recurse.--parallel / --serialShouldpixeprocess multiple files at once, in parallel using multiprocessing using all
available cores. If--serialis chosen one file will be processed at a time. The default is
to process files in parallel if there is more than one file specified for processing.--move, --mv / --copy, --cpBy default,pixewill copy files into DEST and leave the source files untouched. This can be
overridden by specifying--move.--ownerA string which will be inserted into the CameraOwnerName EXIF tag [0xa430]--copyrightA string which will be inserted into the Copyright EXIF tag [0x8298]
Package: pixee
Pixee is your automated product security engineerPixee fixes vulnerabilities, hardens code, squashes bugs, and gives
engineers more time to focus on the work that counts.The Pixee CLI brings the power of Pixee'sCodemodder frameworkto your local development environment. This provides a way for developers to try out Pixee before installing the GitHub app.Learn more athttps://pixee.ai!Get the most out of Pixee by installing the Pixeebot GitHub app athttps://app.pixee.ai. Or find us onGitHub Marketplace.Supported Systems:MacOS (usinghomebrew)Linux (coming soon!)InstallationMacOS (using homebrew)brew tap pixee/pixee
brew install pixeeUsageAfter installation, run thepixeecommand to see instructions and options.F.A.Q.What languages are supported for fixes?Currently we support codemods for Java and Python. Stay tuned for additional language support athttps://pixee.ai!What happens to my code?The Pixee CLI currently runs most detection and fixes locally to your own host machine. Any features that require network access to a third-party service (e.g. OpenAI) will require explicit opt-in. We promise to be transparent when this is the case.How can I install the GitHub application?Get the most out of Pixee by installing the Pixeebot GitHub app athttps://app.pixee.ai. Or find us onGitHub Marketplace.Where can I request features and report issues?For CLI feature requests and bug reports please use our GitHub issue tracker:https://github.com/pixee/pixee-cli/issuesContributingSeeCONTRIBUTING.md.
Package: pixel2svg
Aboutpixel2svg converts pixel art to SVG - pixel by pixel.PrerequisitesPython 2.xhttp://www.python.orgPython Imaging Library (PIL)http://www.pythonware.com/products/pil/svgwritehttp://pypi.python.org/pypi/svgwrite/InstallationUnzip the file, then at the command line runpython setup.py installUsageUsage: pixel2svg [--overlap] IMAGEFILE

Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  --squaresize=SQUARESIZE
                        Width and heigt of vector squares in pixels, default: 40
  --overlap             If given, overlap vector squares by 1pxRunningpixel2svg.py IMAGE.EXTwill process IMAGE.EXT and create IMAGE.svg.EXT can be any format (png, jpg etc.) that can be read by the Python
Imaging Library.Licensepixel2svg is licensed under the GPL. See the file COPYING for details.AuthorFlorian Berger
Package: pixel2svgpkg
pixel2svgpkgA Python package/fork from thepixel2svgproject byFlorian Berger.Developmentpoetry installpoetry shellTech StackPackaging and DevelopmentPoetryMypyisortBlackFlake8flake8-bugbearflake8-comprehensionspep8-namingflake8-builtinsBanditThis package was created withCookiecutterand thejoaopalmeiro/cookiecutter-templates/python-pkgproject template.NotesPoetry:poetry --version.Licenses.Exception:No module named 'virtualenv.activation.nushell'issue. Runpoetry self updateto update Poetry (to version 1.1.11).VS Code:Different python.defaultInterpreterPath by workspace not being savedissue. Setpython.defaultInterpreterPathinstead ofpython.pythonPathin thesettings.jsonfile. More infohere.ColorSpace(3-Color-Gradient).Gremlins tracker for Visual Studio Code: to identify characters that can be harmful because they are invisible or look like legitimate ones.pixel2svg-fork.
Package: pixela
PixelaPixelaAPI client for Python.Installation$ virtualenv --distribute pixela_sample
$ source pixela_sample/bin/activate
$ cd pixela_sample
$ pip install pixelaUsagefrom pixela import Pixela

client = Pixela(username='YOUR_NAME', token='YOUR_NAME')

# register
client.create_user(agree_terms_of_service=True, not_minor=True)

# create graph
client.create_graph(
    graph_id='test-graph',
    name='graph-name',
    unit='commit',
    type='int',
    color='shibafu',
    timezone='Asia/Tokyo',
)

# register value
from datetime import datetime

date = datetime.strptime('2018-10-21', '%Y-%m-%d')
res = self.client.create_pixel(graph_id='py-pixela', quantity=5, date=date)LICENSENEW BSD LICENSE.
Package: pixela2img
# pixela2imgCreate image files (or objects) from Pixela graphs.#### example* From this graph(<https://pixe.la/v1/users/pixela2img/graphs/pixela2img?date=20181229>)![](https://pixe.la/v1/users/pixela2img/graphs/pixela2img?date=20181229)* Create a `png` image below!![](https://github.com/ryosms/pixela2img/blob/master/docs/pixela2img-pixela2img-20181229.png?raw=true)## Support* Python 3.6+## UsageInstall using `pip`.```bash$ pip install pixela2img```Create a `png` image with cli.```bash$ python -m pixela2img -u pixela2img -g pixela2img -d 20181229$ open pixela2img-pixela2img-20181229.png```or Launch python interpreter and run command below```hello_pixela.pyfrom pixela2img import Pixela2Imgpixela = Pixela2Img()images = []images.append(pixela.convert(user='pixela2img', graph='pixela2img', date='20181201'))images.append(pixela.convert(user='pixela2img', graph='pixela2img', date='20181208'))images.append(pixela.convert(user='pixela2img', graph='pixela2img', date='20181215'))images.append(pixela.convert(user='pixela2img', graph='pixela2img', date='20181222'))images.append(pixela.convert(user='pixela2img', graph='pixela2img', date='20181229'))images[0].save('pixela.gif', save_all=True, append_images=images[1:], loop=0)```Created animation gif below!![](https://github.com/ryosms/pixela2img/blob/master/docs/pixela.gif?raw=true)## for Developer#### require* Python 3.7+* pipenv#### prepare1. clone (or fork) this repository.2. install dependencies with pipenv3. edit code!```bash$ git clone https://github.com/ryosms/pixela2img$ cd pixela2img$ pipenv install```
Package: pixel-adv
Hi guys!
This is my first game on pygame)
Here you can collect coins and find the exit of level.
Play the game with arrows and mouse.
In file “CONFIG.TXT” you can choose level of the game.
If you want to create level you can open your notepad and write something like this:
On first line you must write width of your level on second line write height.
(width must be equals height!)
then type enter
and you can start creating level:
“0”-brick wall
“~”-water
“ “-ground
“.”-grass
“F”-finish level
“1”-coin
Then you create level open file “CONFIG.TXT” and after line “MAP:” write name of the level file
I think you enjoy my game)
Write me on:mikhail.a.ushakov@gmail.comAnd don’t miss my website: pixelstudios.esy.es
Also you can subscribe me on social networks:
VK:http://vk.com/pixelstudioscompanyFacebook:https://www.facebook.com/groups/pixelstudioscompany/
Package: pixelart2tgs
pixelart2tgsSimple .gif to .tgs converter cli utility.WarningAfterupdate of Telegram with the addition of video stickers, this project lost all practical meaning. If you need to make animated stickers from GIFs after January 2022, useffmpeg.Some not so user friendly alternativesMattBas's lottiebodqhrohro's giftolottieInstallationpython -m pip install pixelart2tgsand then usage:python -m pixelart2tgsUsage examples$pixelart2tgs-iinput.gifinput.gif -> input.tgs$pixelart2tgs-ifirst.gif-isecond.gifsticker.tgs-yfirst.gif -> first.tgssecond.gif -> "sticker.tgsLicenseMIT License
Package: pixelartconv
PixelArtConv - Pixel Art ConverterPython script/package to quickly convert your image into a "pixel art" style. Image is downscaled and its color palette is reduced to only handful given colors.Created by Simon Ruzicka, 2023Result ShowcaseOriginal photo:Generated pixel-art image - originally 128 px in height, with manually specified color palette:You can find more examples on theGitHub project pageincluding the text color palettes.InstallationYou can install this package with the following command:pipinstallpixelartconvAlternatively, you can download this repository and install it manually by yourself.PrerequisitesFirst of all, make sure that the source image named[file_name].pngis located in your current working directory. In case the file is in another directory, include the relative path instead of[file_name]when launching the script.In addition, you can include a list of colors named[file_name].txt. In that case, the script parameter must be only the common name of the files - without any filename extension. Both files must be in one directory so that the script locates them both correctly.The optional list of colors must have the following format (in RGB):#00ff00
#ff00ff
...UsageYou can launch the script using the following commands:python -m pixelartconv [file_name]
python -m pixelartconv [file_name] [height]
python -m pixelartconv [file_name] [height] [width]The behavior of script is as follows:The resulting image will be 64 px in height - width will be automatically calculated from the original image ratio.The resulting image will have given height - width will be automatically calculated from the original image ratio.The resulting image will have given height and width.Imported packageAdditionally, you can import the package from your code/interactive shell and use theconvertfunction with following interface:defconvert(file_name:str,dims:tuple,palette_size:int=6)->float:"""Converts an image to a pixel-art style.:param file_name: Name of file(s) or their relative path.:param dims: Target size of the resulting image.:param palette_size: Amount of colors in case the palette has to be generated.:return: Time duration of conversion (seconds).:raise FileNotFoundError: Image not found on given path.:raise ValueError: File with this name was found but was invalid."""This will generate the image in the same way as if the script was launched. For example, the following snippet:importpixelartconvpixelartconv.convert("test_image",(80,120))will result in the same generated image as the terminal commandpython -m pixelartconv test_image 80 120.ResultsResulting image will be generated in the same directory as source files, named asresult.png. There will also be an upscaled version with height approximately equal to 512 pixels (so that the upscale factor is a whole number) namedresult_scaled.png. This generates only in case where this upscale would have an effect (when the factor is at least 2).
Package: pixel-artist
Pixel Artist: Turn images into beautiful pixelated imagesPixel Artistis a command line tool that allows the creation of pixelated
images with customizable levels of granularity (size of the visible pixels).
Turning images into beautiful works of art that bring back nostalgic feelings
from the early days of computer graphics is now easy as calling a single command.RequirementsPython 3.6+PillowcolormathFeaturesBlock granularityColor palettesColor spaces (RGB and L*a*b)Number of colorsInstallationLatest stable version From PyPI$pipinstalpixel-artistLatest development version$gitclonehttps://github.com/alexpnt/pixel-artist.git
$pipinstall-epixel-artistUsageusage: pixel-artist [-h] -f FILENAME [-p {3,8,9,24}] [-n NCOLORS] 
                    [-g GRANULARITY] [-l] [-v] [-s]

Pixel art

optional arguments:
  -h, --help            show this help message and exit
  -f FILENAME, --filename FILENAME
                        input filename
  -p {3,8,9,24}, --nbits {3,8,9,24}
                        number of bits of the palette, default=24
  -n NCOLORS, --ncolors NCOLORS
                        number of colors to use: 1-256, default=256
  -g GRANULARITY, --granularity GRANULARITY
                        granularity to be used (>0): a bigger value means bigger blocks, default=1
  -l, --lab             use *lab model, default=rgb
  -v, --verbose         show progress
  -s, --save            save the output imageExamples$pixel-artist-fimg/globe.jpg-g2-p3Inputimagedimensions->width=800,height=600Blockdimensions->width=2,height=2Griddimensions->width=400,height=300Fetching120000imageblocks
Buildingpixelatedimage:100.00%
Done$pixel-artist-fimg/tennessee.jpg-g4-n128-v

Inputimagedimensions->width=800,height=600Blockdimensions->width=5,height=4Griddimensions->width=160,height=150Fetching24000imageblocks
Buildingpixelatedimage:100.00%
Done$pixel-artist-fimg/lane.jpg-g4-n128-v

Inputimagedimensions->width=800,height=600Blockdimensions->width=5,height=4Griddimensions->width=160,height=150Fetching24000imageblocks
Buildingpixelatedimage:100.00%
DoneImplementation detailsThe pixel-artist command line tool works by dividing the image in equal sized blocks
and assigning them the average color of the block.
Optionally, the size of the blocks can be configured as well the available colors.ContributingGithub issuesare open for feature requests and bug reports. Feel free to submit apull requestwith your enhancement proposal.
Package: pixelart-tui
Pixel Art App In Terminal (Version 0.3)To start with Pixel Art you dont need fancy tools. In fact you can go with only terminal and mouse!With help of amazingTextualhere isPaintlike app that provides all features for creatingPixel Art.It works interminaland supportsmouseso you can use it like normal Window app without need to use shortcuts (like others teminal based Paint apps do).Installation with Pip [recommended]The easiest way to start is withpip:pip3installpixelart_tuiafter that you can use it like this:pixelart_tui
# or you can open existing image or pallete with:
pixelart_tui --pxl image_file.pxl --pal pallete_file.paland thats all!From sourceTo use you needPython 3.6+and you can start with command in terminal:pip3install-rrequirements.txt# orpython3-minstall-rrequirements.txtand then you can double-click onrun.sh(Linux/Mac) orrun.bat(Windows) to start or from terminal run:cdpixelart_tui
python3main.pyUsageThis TUI supports:PaintingChoosing RGB colorsPicking color from canvas8x8, 16x16 and 32x32 gridsSaving and loading images and paletts in custom formatTo save image you need to provide name and finish with.pxl, for examplemy_image.pxl. You can also import any image saved in this format.To save paletts you need to end name with.pal, for examplemy_palette.pal. You can also modify this pallete from text editor so you can usecolors in full 0-255 range, where normaly there normally you use only 16 of them.
Package: pixelate
Make your photos even worse. But it’s like pixel art.Works with Python ≥ 3.2. Use version 0.4 for Python 2.* projects.InstallationpipinstallpixelateUsageFrom CLI:pixelate--input=img/bps.jpg--output=img/bps.png--pixel-size=10pixelatearguments:–input– string – path to input image.–output– string – path to output image.–pixel-size– integer – pixel size.From Python code:frompixelateimportpixelatepixelate('img/bps.jpg','img/bps.png',10)Args:input_file_path: the path to the source image file to be processed.output_file_path: the path to the result file.pixel_size: pixel size.From this:To this:
Package: pixelate-redactor
pixelate-redactorRedact images with pixelsWorks with Python >= 2.6, Python >= 3.2.Installationpipinstallpixelate-redactorExamplepixelate-redactorpixelate-redactor\--input=img/example_img_original.png\--output=img/example_img_redacted.png\--pixel-size=10\--start-x=90\--start-y=180\--size-x=150\--size-y=150pixelate-redactor-boxespixelate-redactor\--input=img/example_img_original.png\--output=img/example_img_redacted.png\--pixel-size=10\--boxes=img/boxes.jsonwithimg/boxes.json:{"__box_name_1__":{"px":90,"py":180,"sx":150,"sy":150},"__box_name_2__":{"px":90,"py":180,"sx":150,"sy":150}}(the values are the same, to keep the same result from the single box example)px-> Position Xpy-> Position Ysx-> Size Xsy-> Size YResultsFrom this:To this:
Package: pixelator
PixelatorA simple python package to pixelate images given a color paletteFeaturesUsers can:Load in array data, image files or capture directly from a cameraPixelate images to a specific color palette and image resolutionAccess pixelated array data or write it back to an image fileTechnical Docshttps://connor-makowski.github.io/pixelator/pixelator.htmlSetupMake sure you have Python 3.6.x (or higher). You can download ithere.Installationpip install pixelatorGetting StartedImport the pixelator into your projectfrom pixelator import PixelatorSome important notes:All data is stored and processed as BGR (to match open cv2)EG: Provided pallettes should be in BGRExamplesLoad from a file:from pixelator import Pixelator
# Use the input filename provided
image = Pixelator(filename='./images/input.jpg')
# Pixelate the image to a 28x28 black and white array
pixelated_image = image.pixelate(
    width=28,
    height=28,
    palette=[[0,0,0],[255,255,255]]
)
# Write to `output.png` scaled up to a 300x300 image (to be easily viewed)
pixelated_image.write(filename='./images/output_test_1.jpg', width=300, height=300)Input:Output:Capture from a webcam:from pixelator import Pixelator
# Capture from a webcam since no data or filename is provided
image = Pixelator()

# Pixelate the image to a 64x64 black, white and multiple gray array
pixelated_image = image.pixelate(
    width=64,
    height=64,
    palette=[[0,0,0],[80,80,80],[160,160,160],[200,200,200],[255,255,255]]
)
# Write to `output.png` scaled up to a 500x500 image (to be easily viewed)
pixelated_image.write(filename='./images/output_test_3.jpg', width=300, height=300)Access Pixelator Data:from pixelator import Pixelator
# Use the input filename provided
image = Pixelator(filename='./images/input.jpg')
# Pixelate the image to a 28x28 black and white array
pixelated_image = image.pixelate(
    width=28,
    height=28,
    palette=[[0,0,0],[255,255,255]]
)
# Show pixelated image data
print(pixelated_image.data)
# Show Color Counts:
print(pixelated_image.get_color_counts())