Saravanan666/pypi-org huggingface dataset:
Package: eyed3
StatusAbouteyeD3is a Python tool for working with audio files, specifically MP3 files
containingID3metadata (i.e. song info).It provides a command-line tool (eyeD3) and a Python library
(import eyed3) that can be used to write your own applications or
plugins that are callable from the command-line tool.For example, to set some song information in an mp3 file calledsong.mp3:$ eyeD3 -a Integrity -A "Humanity Is The Devil" -t "Hollow" -n 2 song.mp3With this command we’ve set the artist (-a/--artist), album
(-A/--album), title (-t/--title), and track number
(-n/--track-num) properties in the ID3 tag of the file. This is the
standard interface that eyeD3 has always had in the past, therefore it
is also the default plugin when no other is specified.The results of this command can be seen by running theeyeD3with no
options.$ eyeD3 song.mp3
song.mp3      [ 3.06 MB ]
-------------------------------------------------------------------------
ID3 v2.4:
title: Hollow
artist: Integrity
album: Humanity Is The Devil
album artist: None
track: 2
-------------------------------------------------------------------------The same can be accomplished using Python.import eyed3

audiofile = eyed3.load("song.mp3")
audiofile.tag.artist = "Token Entry"
audiofile.tag.album = "Free For All Comp LP"
audiofile.tag.album_artist = "Various Artists"
audiofile.tag.title = "The Edge"
audiofile.tag.track_num = 3

audiofile.tag.save()eyeD3is written and maintained byTravis Shirkand is licensed under
version 3 of theGPL.FeaturesPython package (import eyed3) for writing applications and plugins.eyeD3: Command-line tool driver script that supports plugins.Easy ID3 editing/viewing of audio metadata from the command-line.Plugins for: Tag to string formatting (display), album fixing (fixup),
cover art downloading (art), collection stats (stats),
and json/yaml/jabber/nfo output formats, and more included.Support for ID3 versions 1.x, 2.2 (read-only), 2.3, and 2.4.Support for the MP3 audio format exposing details such as play time, bit
rate, sampling frequency, etc.Abstract design allowing future support for different audio formats and
metadata containers.Get StartedPython >= 3.7 is required.Forinstallation instructionsor more completedocumentationseehttp://eyeD3.nicfit.net/Please post feedback and/or defects on theissue tracker, ormailing list.
Package: eyeditor
EYEEYE is a Qt based text/code editor designed to be customizable/scriptable.
It uses Scintilla as the base text widget. It currently supports:tabbed, multi-split, multi-window GUIsyntax coloringproject/directory level editing preferencesrecursive grep integrationPython scriptabilityCustomizabilityBy default, EYE provides a basic UI with a tabbed window with one editor.
A few widgets and plugins are available but not enabled by default.At startup, Python scripts contained in the user configuration directory are run.
These scripts can use the EYE API to configure the app as you want.They can:enable built-in plugins (like automatic syntax coloring when a file is opened) and featurescreate actions on keyboard shortcuts or react on other eventscustomize the menus/toolbars or the rest of the UImake complete pluginsAll of this is doable through the full Python API, the EYE API and the Qt components upon which EYE is based.What plugins are available?simple recursive grep searchbackward/forward file navigationsyntax coloring based on file extensionthemingmacro recording/replay“project”-wide indentation style (with support for.editorconfig)file-line bookmarks (not saved on quit though)autocompletion with YouCompleteMeWhat plugins are planned?build system launch with error annotations in the source codesemantic source coloring with clang apicontrolling a debuggermore features for easing navigation and searchWhere is the documentation?The documentation is built with sphinx in the docs dir and can beconsulted online.
It is also a work-in-progress.VersionEYE is currently in alpha state, say 0.0.1. When it’s stable, it will usesemantic versioning, for better plugins compatibility.
Package: eyedlog
eyedlogA tool to make the log display more elegant.InstallationpipinstalleyedlogUsageRecommended usagefromeyedlogimportget_loggerlogger=get_logger('pretty.log')logger.info('some text')Advanced usagefromeyedlogimportColoredLoggerlogger=ColoredLogger('pretty.log')logger.info('some text')pythonsetup.pysdistbdist_wheel
twineuploaddist/*
Package: eyedropper
EyedropperEasily get color codes on your computer.DescriptionThis script copies the hex (#xxxxxx) color code from the pixel under the mouse's cursor to the clipboard.Once it's run, you can paste the result anywhere (Ctrl+V).Installation>pipinstalleyedropperUsageOn Windows, hit Win+R, type eyedropper and hit enter. Now the hex color code for the pixel that is under the cursor is saved on your clipboard for pasting anywhere.LinksRepository:https://github.com/umluizlima/eyedropperReferences:Al Sweigart's:Automate The Boring Stuff:https://automatetheboringstuff.com/pyautogui:https://pyautogui.readthedocs.io/en/latest/pyperclip:https://pyperclip.readthedocs.io/en/latest/introduction.htmlLicensingDistributed under the MIT license. SeeLICENSEfor more information.
Package: eyefi
The EyeFi cards include both some 2-8GB of SDHC storage and anembedded microprocessor with WiFi (802.11bgn) that can upload
images as soon as they have been captured. While the software
bundled with the cards is closed and Win/OSX only, the protocol
is decently clean SOAP (like XML RPC via HTTP) and can be
implemented with twisted and soappy.After associating with one of the configured wireless networks,
the card authenticates a session with the server. The shared
secret needs to be obtained from the settings of the Win/OSX
application. The server can cope with multiple cards that are
identified by their MAC address. After authentication, the card
pushes the images that have not yet been posted to the server.
The server unpacks the tarred bundle (optionally in a directory
per MAC address). It then resolves the wireless networks that were
logged by the card at the time the picture was taken into a
geolocation using the Google API. The geolocation data is stored
in an XMP sidecar. Finally, you can trigger your own scripts
on complete upload, extraction and tagging.
Package: eye-game
A Python Module for Parsing Gaze Direction❖ IntroductionThis module is used to parse human gaze direction. Given an image containing a human face, the module will return its gaze direction.❖ UsageYou need to install it first by running commandpip install eye_game, then import and use it!importeye_gameeye_game.get_gaze_direction(image_path)❖ Dependencies{
    "face_recognition",
    "opencv-python",
    "pillow",
    "numpy"
}
Package: eyegrade
Eyegradeuses a webcam to grade multiple choice question (MCQ) exams.
Needing just a cheap low-end webcam, it aims to be a low-cost
and portable solution available to everyone, on the contrary to other
solutions based on scanners.The main features of Eyegrade are:Grading exams:
Using a webcam, the graphical user interface of
Eyegrade allows you to scan and grade your students' exams.
Eyegrade is able to recognize not only the answers to the questions,
but also the identity of the student
by using its hand-written digit recognition module.
The whole process is supervised by you so that you can detect
and fix any potential error of the image recognition system.Exporting grades:
Grades can be exported inOffice Open XMLformat
(.XLSX files that can be read from Microsoft Excel
LibreOffice, Google Docs and other spreadsheet software)
as well as theCSV (comma-separated
values)format.Typesetting exams: Although you can create your exams with other tools,
Eyegrade integrates an utility to creating MCQ exams. It is able to
create your exams in PDF format.  Eyegrade can automatically build
several versions of the exam by reordering questions and choices
within questions.
TheLaTeX document preparation systemmust be installed in your system in order to use this feature.For more information about Eyegrade you can visit:Its website:https://www.eyegrade.org/Its blog:https://www.eyegrade.org/blog/Its documentation:https://www.eyegrade.org/documentation/Its source code at GitHub:https://github.com/jfisteus/eyegradeThe downloads page, for pre-built binary files:https://www.eyegrade.org/download/Eyegrade is fully functional and has been used in courses at
Universidad Carlos III de Madrid and other institutions since 2010.The program is free software, licensed under the terms of theGNU General Public License (GPL)
version 3or any later version.Bug reports, feature requests and pull requests are welcome at the
Github repository:https://github.com/jfisteus/eyegradeAn article describing an earlier version of Eyegrade has been
published by the Journal of Science Education and Technology:Jesus Arias Fisteus, Abelardo Pardo and Norberto Fernández García,Grading Multiple Choice Exams with Low-Cost and Portable
Computer-Vision Techniques.
Journal of Science Education and Technology,
volume 22, issue 4 (August 2013), pages 560-571.doi:10.1007/s10956-012-9414-8.Note for developers: the Eyegrade repository contains two main
branches,masteranddevelopment. Themasterbranch will be
placed at the latest stable release of Eyegrade. Thedevelopmentbranch will receive commits of yet-to-be-released features. If you
plan to submit pull-requests, base your work on the development branch
in order to facilitate their integration.
Package: eye-keyboard
# eye-keyboardExtending webcam-eyetracker for use a keyboard with pupilsThe keyboard layout is shown below:|       | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 ||-------|---|---|---|---|---|---|---|---|---|| **1** | A | B | C | D | E | F | G | H | I || **2** | J | K | L | M | N | O | P | Q | R || **3** | S | T | U | V | X | W | Y | Z |   |
Package: eyekit
Eyekit is a Python package for analyzing reading behavior using eyetracking data. Eyekit aims to be entirely independent of any particular eyetracker hardware, experiment software, or data formats. It has an object-oriented style that defines three core objects – the TextBlock, InterestArea, and FixationSequence – that you bring into contact with a bit of coding.Is Eyekit the Right Tool for Me?You want to analyze which parts of a text someone is looking at and for how long.You need convenient tools for extracting areas of interest from texts, such as specific words, phrases, or letter combinations.You want to calculate common reading measures, such as gaze duration or initial landing position.You need support for arbitrary fonts, multiline passages, right-to-left text, or non-alphabetical scripts.You want the flexibility to define custom reading measures and to build your own reproducible processing pipeline.You would like tools for dealing with noise and calibration issues, and for discarding fixations according to your own criteria.You want to share your data in an open format and produce publication-ready vector graphics.InstallationEyekit may be installed usingpip:$pipinstalleyekitEyekit is compatible with Python 3.8+. Its main dependency is the graphics libraryCairo, which you might also need to install if it's not already on your system. Many Linux distributions have Cairo built in. On a Mac, it can be installed usingHomebrew:brew install cairo. On Windows, it can be installed usingAnaconda:conda install -c anaconda cairo.Full documentation and a usage guide is available here
Package: eyelogic-sdk
Python Binding for EyeLogic Eye Tracking DevicesThis is the python wrapper for the EyeLogic eye tracking API. It offers the possibility to connect you with your device from any custom application.Download and installThe EyeLogic python SDK is available via the Python Package Index (PyPI), and can be installed through pip.pip install eyelogic-sdkYou can also download the EyeLogic SDK directly from theeyelogic homepage. The SDK contains also bindings to other languages as well as a user manual and API description.UsageIn your python script, import the eyelogic SDK:from eyelogic.ELApi import *In the__main__section, the application implements its control flow. It consists of the following code lines:api = ELApi("Demo Client")This constructs a new instance of the ELApi class. The instanciation will automatically "initialize" the library. Hence, it will also be automatically be "deinitialized" whenever the api object gets out of scope, e.g. at the end of the program.resultConnect = api.connect()Connects to the EyeLogic server. Check for the return value in order to find out whether the connection was established successfully.resultTracking = api.requestTracking(0)Starts the tracking of the device. The parameter 0 specifies the frame-rate mode. If your device is capable of multiple frame-rate modes (60Hz, 120Hz, 250Hz), you can also enter a different number. The list of available frame-rates is given to the callback onDeviceConnected( ). Usually, the frame-rate mode 0 is the default (the highest available speed mode of your system).resultCalibrate = api.calibrate(0)Performs a calibration. This method blocks until the calibration was performed (or aborted). The parameter 0 denotes the type of calibration.At the end of your recording, close the connection:api.disconnect()
Package: eyeon
A simple CLI program to watch an html file and css for changes and reload the browser when a change is saved to either file.InstallationInstall from PyPI:pip install eyeoneyeOn is also available on Anaconda.org:conda install -c jmorrison eyeonUsageJust pass the html file you want to reload and watch as the first argument and the css file you want to watch as the second argument. If either file changes the html file passed in the first argument will be automatically reloaded in the browser or a browser will launch if not already opened.:eyeon index.html style.css
Package: eyepie
eyepyUse Python to import, analyse and visualize retinal imaging data.Theeyepypython package provides a simple interface to import and process OCT volumes. Everything you import with one of our import functions becomes anEyeVolumeobject which provides a unified interface to the data. TheEyeVolumeobject provides methods to plot the localizer (fundus) image and B-scans as well as to compute and plot quantifications of voxel annotations such as drusen. Check out thedocumentation, especially theCookbookchapter, for more information.FeaturesImport Data (Heyex-E2E, Heyex-VOL, Heyex-XML, Topcon-FDA, B-Scan collections,RETOUCH Challenge,AMD Dataset from Duke University)Analyze OCT volumes (compute and quantify drusen)Visualize OCT volumes with annotations and quantificationsSave and load EyeVolume objectsGetting StartedInstallationTo install the latest version of eyepy runpip install -U eyepie. It iseyepieand noteyepyfor installation with pip.Getting StartedWhen you don't hava a supported OCT volume at hand you can check out our sample dataset to get familiar witheyepy.fromeyepy.dataimportloadev=load("drusen_patient")If you have data at hand use one of eyepys import functions.# Import HEYEX E2E exportev=ep.import_heyex_e2e("path/to/file.e2e")# Import HEYEX XML exportev=ep.import_heyex_xml("path/to/folder")# Import HEYEX VOL exportev=ep.import_heyex_vol("path/to/file.vol")# Import Topcon FDA exportev=ep.import_topcon_fda("path/to/file.fda")# Import volume from Duke public datasetev=ep.import_duke_mat("path/to/file.mat")# Import volume form RETOUCH challengeev=ep.import_retouch("path/to/volume_folder")Related Projects:OCT-Converter: Extract raw optical coherence tomography (OCT) and fundus data from proprietary file formats. (.fds/.fda/.e2e/.img/.oct/.dcm)eyelab: A GUI for annotation of OCT data based on eyepyProjects by theTranslational Neuroimaging LaboratoryLibOctDataLibE2EOCT-MarkerUOCTEUnofficial continuation ofhttps://bitbucket.org/uocte/uocteOCTAnnotateheyexReaderOCTExplorerIowa Reference Algorithm
Package: eyepy
eyepyUse Python to import, analyse and visualize retinal imaging data.Theeyepypython package provides a simple interface to import and process OCT volumes. Everything you import with one of our import functions becomes anEyeVolumeobject which provides a unified interface to the data. TheEyeVolumeobject provides methods to plot the localizer (fundus) image and B-scans as well as to compute and plot quantifications of voxel annotations such as drusen. Check out thedocumentation, especially theCookbookchapter, for more information.FeaturesImport Data (Heyex-E2E, Heyex-VOL, Heyex-XML, Topcon-FDA, B-Scan collections,RETOUCH Challenge,AMD Dataset from Duke University)Analyze OCT volumes (compute and quantify drusen)Visualize OCT volumes with annotations and quantificationsSave and load EyeVolume objectsGetting StartedInstallationAttention:If you want to use a version prior to 0.12.0 you have to install from theeyepiename instead. This is because we usedeyepieas a package name on PyPI until the previous owner of theeyepyname on PyPI was so kind to transfer it to us.To install the latest version of eyepy runpip install -U eyepy. (It iseyepiefor versions < 0.12.0)Getting StartedWhen you don't hava a supported OCT volume at hand you can check out our sample dataset to get familiar witheyepy.fromeyepy.dataimportloadev=load("drusen_patient")If you have data at hand use one of eyepys import functions.# Import HEYEX E2E exportev=ep.import_heyex_e2e("path/to/file.e2e")# Import HEYEX XML exportev=ep.import_heyex_xml("path/to/folder")# Import HEYEX VOL exportev=ep.import_heyex_vol("path/to/file.vol")# Import Topcon FDA exportev=ep.import_topcon_fda("path/to/file.fda")# Import volume from Duke public datasetev=ep.import_duke_mat("path/to/file.mat")# Import volume form RETOUCH challengeev=ep.import_retouch("path/to/volume_folder")Related Projects:eyeseg: A python package for segmentation of retinal layers and drusen in OCT data.OCT-Converter: Extract raw optical coherence tomography (OCT) and fundus data from proprietary file formats. (.fds/.fda/.e2e/.img/.oct/.dcm)eyelab: A GUI for annotation of OCT data based on eyepyProjects by theTranslational Neuroimaging LaboratoryLibOctDataLibE2EOCT-MarkerUOCTEUnofficial continuation ofhttps://bitbucket.org/uocte/uocteOCTAnnotateheyexReaderOCTExplorerIowa Reference Algorithm
Package: eyes-common
Applitools Eyes SDK For Images and Playwright
Proxy package that additionally installsplaywrightpackage.Change log.InstallationInstall the eyes-playwright SDK.pip install eyes-playwrightUsagePlease check the applitools website for usage instructions:Playwright Eyes tutorial:https://applitools.com/tutorials/quickstart/web/playwright/pythonPython Images API documentation:https://applitools.com/docs/api-ref/category/images-python
Package: eyesim
eyesimThis is a simulator for theeyesyvisual synth. Its purpose is to allow you to develop new eyesy visualization modes when you're too lazy to get out of bed and plug in audio, video, and power cables.The simulator is a command line tool. As input, you give it a path to the mode folder containing amain.pyfile conforming to theeyesy API. You can also give it a path to an audio file to use. Currently, only 16 bit WAV are usable. The audio file input is optional.InstallpipinstalleyesimUsageYou can run a test mode by supplying "test" as the path.eyesim--mode-foldertestHowever, normally you would invoke it like:eyesim--mode-folder"/path/to/S - Nice Mode/"--audio-file"/path/to/song.wav"When the simulator is running, pressing the space bar to toggle visibility of the sliders and buttons that simulate the knobs on the physical eyesy device.The full command line usage is:$eyesim--help
usage:eyesim[-h]-mMODE_FOLDER[-aAUDIO_FILE][-wWIDTH][-tHEIGHT]Starteyesysimulation

optionalarguments:-h,--helpshowthishelpmessageandexit-mMODE_FOLDER,--mode-folderMODE_FOLDERpathtofoldercontainingmode'smain.pyscript-aAUDIO_FILE,--audio-fileAUDIO_FILEpathtoaudiofiletoplay(optional)-wWIDTH,--widthWIDTHwindowwidthinpixels-tHEIGHT,--heightHEIGHTwindowheightinpixelsCaveatsThe eyesy code runs Python 2, and all the stock modes are Python 2. But, this package is written in Python 3. I did this in order to use the pygame widgets package and to use the latest scipy for reading wav files. The result is that you might find your mode or a stock mode breaks. In my experience, this is almost always due to one of two things:a Python 2 style print statement, i.e.,print "foo"rather thanprint("foo")assumed integer division, i.e., assuming1/2results in an integerThe latter is easily fixed by explicitly using integer division (the//operator), which is compatible with both Python 2 and 3. Or, you can explicitly convert to int byint(1/2).Referenceseyes OS:https://github.com/critterandguitari/EYESY_OS/stock eyes modes:https://github.com/critterandguitari/EYESY_Modes_Pygame
Package: eyes-playwright
Applitools Eyes SDK For Images and Playwright
Proxy package that additionally installsplaywrightpackage.Change log.InstallationInstall the eyes-playwright SDK.pip install eyes-playwrightUsagePlease check the applitools website for usage instructions:Playwright Eyes tutorial:https://applitools.com/tutorials/quickstart/web/playwright/pythonPython Images API documentation:https://applitools.com/docs/api-ref/category/images-python
Package: eyes-robotframework
Applitools Eyes SDK For Robot FrameworkInstallationInstall the eyes-robot SDK:pip install eyes-robotframeworkDocsComplete guide to using Eyes with the Robot frameworkKeyword documentation.Configuration file overviewRobot Framework SDK example repo:https://github.com/applitools/robotframework-quickstartRobot Framework autocompletion pluginsIntelliJ (PyCharm and friends)Recommended - most full supporthttps://plugins.jetbrains.com/plugin/17424-intellibot-patchedRobotFramework language server based(pip install robotframework-lsp)
These plugins have issues with auto-completion of check settings keywords.IntelliJ (PyCharm and friends)https://plugins.jetbrains.com/plugin/16086-robot-framework-language-serverVSCodehttps://marketplace.visualstudio.com/items?itemName=robocorp.robotframework-lsp
Package: eyes-selenium
Applitools Eyes SDK For Images and Selenium/Appium WebDrivers
Proxy package that additionally installsseleniumandAppium-Python-Clientpackages.Change log.InstallationInstall the eyes-selenium SDK.pip install eyes-seleniumUsagePlease check the applitools website for usage instructions:Python Images API documentation:https://applitools.com/docs/api-ref/category/images-pythonSelenium Python example:https://applitools.com/resources/tutorial/selenium/python#step-2Python Appium native example:https://applitools.com/resources/tutorial/appium/native_python#step-2Python Appium web example:https://applitools.com/resources/tutorial/appium/python#step-2
Package: eye-vision
Eye VisionEye Vision provides a simple but powerful python library for Computer Vision. It uses
well know libraries like OpenCv and Matplotlib. Typical usage
often looks like this::import ziso
from ziso import read
from ziso import view

# to read the image in the rgb color scale
file = read.rgb("test.jpg")
# to view the image
view.im(file)

# to view the easter egg in the library
from ziso import zenSpeedYour favourite libraries compressed:OpenCVMatplotlibetcNote:Things to expect and know:Easy implementationRapid ScalabilityPortabilityRead the Docs:-> Urls arehttps://eye-vision.readthedocs.ioEye-vision webpage:->https://simbatmotsi.github.io/eye-vision/Personal webpage:->http://bit.ly/simbatmotsi