Saravanan666/pypi-org huggingface dataset:
Package: pyeditdistance
pyeditdistanceA pure, minimalist Python library of various edit distance metrics. MIT-licensed, zero dependencies.Implemented methods:Levenshtein(iterative and recursive implementations)Normalized Levenshtein (usingYujian-Bo[1])Damerau-LevenshteinHamming distanceLongest common subsequence (LCS)Levenshtein and Damerau-Levenshtein distances use the Wagner-Fischer dynamic programming algorithm [2].Some basic unit tests can be executed usingpytestInstallationpip install pyeditdistanceOptional (user-specific):pip install --user pyeditdistanceUsagefrompyeditdistanceimportdistanceasds1="I am Joe Bloggs"s2="I am John Galt"# Levenshtein distanceres=d.levenshtein(s1,s2)# => 8# Normalized Levenshteinres=d.normalized_levenshtein(s1,s2)# => 0.4324...# Damerau-Levenshteins3="abc"s4="cb"res=d.damerau_levenshtein(s3,s4)# => 2# Hamming distances5="abcccdeeffghh zz"s6="bacccdeeffhghz z"res=d.hamming(s5,s6)# => 6# Longest common subsequence (LCS)s7="AAGGQQERqer"s8="AaQERqer"res=d.longest_common_subsequence(s7,s8)# => 7ReferencesL. Yujian and L. Bo, "A normalized Levenshtein distance metric,"
IEEE Transactions on Pattern Analysis and Machine Intelligence (2007).https://ieeexplore.ieee.org/document/4160958R. Wagner and M. Fisher, "The string to string correction problem,"
Journal of the ACM, 21:168-178, 1974.
Package: pyeditline
This is a package which is a replacement for GNU Readline for use as shell-completion support. It is designed to:link to libedit.so on the host system
(This covers most *BSD based systems and Linux if you install libedit2 package)if no host libedit.so is available, libedit will be directly compiled into the extension itselfAll code is released under the BSD-3 license, which makes this an alternative in cases where GNU-based readline is a problem.UsageAfter a standard, uneventful installation, you should automatically have tab-completion using editline.  This is configured in a sitecustomize.py file added to your install or virtual-env.This extension has more extensive features than readline such as:tab-completion of imports by defaulttab-completion across arrays (so you can see/pick a valid index)tab-completion across dictionaries (displays available keys)Right-side promptsArbitrary input/output/error streams so you can have multiple interpreters on a single Python instance which are fully independent. (‘readline’ uses C globals so you are stuck with just one instance)The system is broken down in 3 components:_editline.so:the C interface to libediteditline.py:a Python subclass of _editline which implements much of the string parsing/manipulationlineeditor.py:a general module which extends rlcompleter’s functionality and provides additional features.Again, by default this is entirely hidden.InstallationHandy tips for installation.  99.9% of folks will be able to use the default install (… by SDIST!).  It will customize your build based on finding stuff.In the (odd) case where you have libedit.so and youreallywant to have editline use the built-in version (say, your distro’s libedit.so is borked) you can adjust the installer.Run the pip install like this:pip install --global-option="build" --global-option="--builtin-libedit"  pyeditlineThat will bypass the use of your local libedit.so.  (… and if anyone has a better way to do this, I’m all ears.)Gory Details?Have a look at the README in the source repo or inreadthedocs.io.
Package: pyeditorconfig
pyeditorconfigNoteThis module was created by @Akuli due to the lack of maintanence of the normaleditorconfigmodule. I simply added it to PyPI and made a few changes to the code. All credit goes to @Akuli.DescriptionThis module is a simple implementation of theEditorConfigfile format. It is designed to be simple and easy to use. You use theget_config()method with a path as an argument and a dict with the configuration will be returned.Installationpip install pyeditorconfigDocumentationget_config(path)This method takes an absolute path as an argument and returns a dict with the configuration. If there is no configuration file, it will return an empty dict.ArgumentTypeDescriptionpathos.path.abspathorstrThe absolute path to the file. The str must also be the absolute path or it will not work.Example:fromosimportpathfrompyeditorconfigimportget_configprint(get_config(__file__))print(get_config(path.abspath("examples.py")))# Both print the cofig of this file.
Package: pyeditorjs
pyEditorJSA minimal, fast, Python 3.6+ package for parsingEditor.jscontent.FeaturesHandles all out-of-the-box Editor.js elements;Optional sanitization via thebleachlibrary;Checks whether the data is valid (e. g.: a header can't have more than 6 levels), and raisesEditorJsParseErrorif data is malformed;Uses Editor.js's class names for styles, so the output will be consistent with WYSIWYG (seeEditor.js's example styleandstyles documentation)InstallationpipinstallpyeditorjsOptional:installbleachfor clean HTML:pipinstallbleachUsageQuickstartfrompyeditorjsimportEditorJsParsereditor_js_data=...# your Editor.js JSON dataparser=EditorJsParser(editor_js_data)# initialize the parserhtml=parser.html(sanitize=True)# `sanitize=True` requires `bleach` to be installedprint(html)# your clean HTMLObtain texts only (for creating audio-only version, for example)WARNING:This does not sanitize the texts! Please, callbleach.clean(...)directly. This also doesn't obtain text from bold texts, markers, etc... - you should useBeautifulSoupfor this.#import bleachfrompyeditorjsimportEditorJsParsereditor_js_data=...# your Editor.js JSON dataparser=EditorJsParser(editor_js_data)# initialize the parserall_texts=[]forblockinparser:text=getattr(block,'text',None)iftext:all_texts.append(text)# all_texts.append(bleach.clean(text))print(all_texts)DisclaimerThis is a community-provided project, and is not affiliated with the Editor.js team.
It was created in my spare time. I cannot make sure that it will receive consistent updates.Because of this, PRs, bug reports and suggestions are welcome!
Package: py_edl_editor
py_edl_editorA python EDL (Edit Decision List) GUI, based on the EDL library
by Simon Hargreaveshttps://pypi.org/project/edl/which is usingpytimecode.
Also using the cdl_convert library by Sean Wallitsch:https://github.com/shidarin/cdl_convertWork in progress, so collaboration welcome.Installation:pip install py_edl_editorUsage without EDL:edl_editorUsage with EDL:edl_editor [path_to_edl] [optional framerate]
edl_editor path_to_edl.edl 24Accepted framerate values ['60', '59.94', '50', '30', '29.97', '25', '24',
'23.98'].Dependencies:PySide2
cdl_convert
opentimelineio
timecode
edl(The MIT License)Copyright © 2021 Thomas Weckenmanntweckenmann0711@gmail.comPermission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the ‘Software’), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: pyEDM
Empirical Dynamic Modeling (EDM)This package provides a Python/Pandas DataFrame interface to thecppEDMlibrary forEDM analysis.  Introduction and documentation are are avilableonline, or in the packageAPI docs. A Jupyter notebook interface is available atjpyEDM.Functionality includes:Simplex projection (Sugihara and May 1990)Sequential Locally Weighted Global Linear Maps (S-Map) (Sugihara 1994)Multivariate embeddings (Dixon et. al. 1999)Convergent cross mapping (Sugihara et. al. 2012)Multiview embedding (Ye and Sugihara 2016)InstallationPython Package Index (PyPI)Certain MacOS, Linux and Windows platforms are supported with prebuilt binary distributions hosted on PyPIpyEDM.Command line using the Python pip module:python -m pip install pyEDMManual InstallIf a pre-built binary distribution is not available the user can build the cppEDM library, then install the Python package using pip. On OSX and Linux this requires g++. On Windows, the mingw-w64 GCC is available as inMSYS2.Note theLAPACKlibrary is required to build cppEDM and pyEDM. As of version 1.15.1, LAPACK is not required on Windows.OSX and LinuxDownload pyEDM:git clone https://github.com/SugiharaLab/pyEDMBuild cppEDM library:cd pyEDM/cppEDM/src; makeBuild and install package:cd ../..; python -m pip install . --userWindowsIf a Windows binary is not available, these suggestions may be useful.mingw-w64 GCC is available inMSYS2.Prior to version 1.15.1,gfortranandOpenBLASlibraries are required.Download pyEDM:git clone https://github.com/SugiharaLab/pyEDMBuild cppEDM library:cd pyEDM\cppEDM\src; makeAdjust paths to find gfortran and openblas libraries (pyEDM/pyEDM/etc/windows/libopenblas.a). You may need to rename libEDM.a to EDM.lib, and openblas.a to openblas.lib.Build and install package inpyEDM\:python -m pip install . --userUsageExample usage at the python prompt:>>>importpyEDM>>>pyEDM.Examples()ReferencesSugihara G. and May R. 1990.  Nonlinear forecasting as a way of distinguishing
chaos from measurement error in time series.Nature, 344:734–741.Sugihara G. 1994. Nonlinear forecasting for the classification of natural
time series.Philosophical Transactions: Physical Sciences and
Engineering, 348 (1688) : 477–495.Dixon, P. A., M. Milicich, and G. Sugihara, 1999. Episodic fluctuations in larval supply.Science 283:1528–1530.Sugihara G., May R., Ye H., Hsieh C., Deyle E., Fogarty M., Munch S., 2012.
Detecting Causality in Complex Ecosystems.Science 338:496-500.Ye H., and G. Sugihara, 2016. Information leverage in interconnected
ecosystems: Overcoming the curse of dimensionality.Science 353:922–925.
Package: pyedr
This repository hosts the source files for both the Pyedr and Panedr packages.pyedrandpanedrare compatible with Python 3.6 and greater.PyedrPyedr provides a means of reading aGromacs EDRbinary XDR file and
return its contents as a dictionary ofnumpyarrays. Pyedr exposes
the following functions:edr_to_dict: returns a dictionary of NumPy arrays keyed by the energy
type from a given path to an EDR file.read_edr: parses an EDR file and returns the energy terms
in a nested listget_unit_dictionary: Returns a dictionary that holds the units of each
energy term found in the EDR file.PanedrPanedr uses the Pyedr library to read aGromacs EDRbinary energy XDR file
and returns its contents as apandasdataframe. Panedr exposes the
following functions:edr_to_df: which gets the path to an EDR file and returns a
pandas DataFrame.get_unit_dictionary: Returns a dictionary that holds the units of each
energy term found in the EDR file.ExampleUsingpyedr:importpyedr# Read the EDR filepath='ener.edr'dic=pyedr.edr_to_dict(path)# The `verbose` optional parameter can be set to True to display the# progress on stderrdic=pyedr.edr_to_dict(path,verbose=True)# Get the average pressure after the first 10 nspressure_avg=dic['Pressure'][dic['Time']>10000].mean()# Get the units of the EDR entriesunit_dict=pyedr.get_unit_dictionary(path)unit_dict["Temperature"]# returns "K"Usingpanedr:importpanedr# Read the EDR filepath='ener.edr'df=panedr.edr_to_df(path)# The `verbose` optional parameter can be set to True to display the# progress on stderrdf=panedr.edr_to_df(path,verbose=True)# Get the average pressure after the first 10 nspressure_avg=df['Pressure'][df['Time']>10000].mean()# Get the units of the EDR entriesunit_dict=panedr.get_unit_dictionary(path)unit_dict["Temperature"]# returns "K"InstallYou can installpyedrandpanedrusingpip:pipinstallpyedr# installing panedr automatically installs pyedrpipinstallpanedrIf you are usingcondaandconda-forge, you can install with:condainstall-cconda-forgepyedr# install panedr automatically installs pyedrcondainstall-cconda-forgepanedrTestsThepyedrandpanedrrepositories contains a series of tests.
If you downloaded or cloned the code from the repository, you can run
the tests. To do so, installpytest, and, in the directory of the
panedr source code, run:Forpyedr:pytest-vpyedr/pyedr/testsForpanedr:pytest-vpanedr/panedr/testsLicensePyedr and Panedr translate part of the source code of Gromacs into Python.
Therefore, Panedr is distributed under the same GNU Lesser General
Public License version 2.1 as Gromacs. See thelicensefor more details.
Package: pyedu
The Python Educational Suite (PyEDU) is a flask application for guided Python exercise creation and completion. It
was created for the Python I and Python II lectures at the Chair for remote sensing and landscape information systems
at the Univeristy of Freiburg, but will however work with other exercises as well.The application is meant to be run from the localhost so that the exercise code is run in a local Python environement.
Before running it on a remote server, one has to make sure that no harmful code is included in the exercises before
running the code. However, the local application can connect to a local or remote database. For Python I and II these
remote connections are already included in an encrypted file. As the user has the decryption key, the connection can
be used. In the supplementary folder is Jupyter notebook which can create such a file for other remote locations.InstallationAlthough the project will be on PyPI, the installation using git favored. One of the next updates will included
a version check and auto-update function, which will be based on git and might not work when PyEDU is installed
using pip. It can be installed using:gitclonehttps://github.com/mmaelicke/pyedu.gitcdpyedupipinstall-rrequirements.txtpythonsetup.pyinstallUsing remote connectionsIn order to use a remote connection you’ll need a file with the decryption key in it. The connection and keys are in the
pyedu/enc folder. To use a remote connection as default, rename the .enc file you wish to use to ‘remote.enc’ and
place the key as ‘remote.key’ into the enc folder. Then the default flask settings will use this connection as
the default connection.
For one of the next updates, there will be the possibility to enter the cleartext key during the start process. Then
the user cannot manually decrypt the enc file anymore.Starting the applicationIn order to start the application, in the pyedu/pyedu folder use:pythonmanage.pyrunserverIf you like to use another flask configuration, like with enabled debug mode or a local connection, you can use the -c
(–config) flag:pythonmanage.py-clocal_devrunserverOnce the server is running, the application can be accessed with your browser and activated Javascript at:http://locahost:5000With one of the next versions, the application will be able to create a shortcut on Windows or a executable symlink on
Linux for starting the application.SecurityPlease note, that this application is not made for remote usage and still under active development. If you decide to
run this application with a remote database, please note that it is possbile to read the database connection and
connect externally. To come around external assingment injection, the application will include a different assign
route with a future release, that will shift the solution check to a remote REST API and therefore make the student
db user a read only db user.
Package: pyedurov3
EduROV server packageThis package contains a companion computer code for use with the eduROV 4 hardware. The package is called pyedurov3. It is supposed to run on a Raspberry Pi 3 or 4.UseTo install, runpip install pyedurov3.If you got the warningThe script normalizer is installed in * which is not on PATH., callsource ~/.profile.To run the server, runpyedurov3.To start the server at boot, runsudo pyedurov3 --runatstartup.Seepyedurov3 --helpfor more options.Setting up Raspberry Pi for EduROV with a fresh image-Install the officialRaspberry Pi ImagertoolInsert your SD card into a card readerUse the tool to install Raspberry PI OS (32-bit) onto the cardDon't forget to configure the image to use SSH before writing itInsert sd card to Raspberry PiConnect via ssh to raspberrypi.localVia raspi-config:Under Interface OptionsEnable cameraEnable Serial Port:We do not want a login shell to be available.We do want the serial port hardware to obe enabled.Allow the raspberry pi to restart and reconnect the ssh session.For pyedurov3 to run at startup, we'll need to install and run it as sudo.Install pyedurov3 withsudo pip install pyedurov3Callsudo pyedurov3 --runatstartup --name=yournameto set server to start at boot with "yourname" as the advertising name.Building package (and tips for developers)For development, you will have to build modified versions of the package from source.
Make sure the newest version of pip is installed:pip install --upgrade buildThen navigate into the upper pyedurov3 folder and runpython -m build(you might have to use sudo for that).In development it can be helpful to quickly reinstall the package without debendencies. A helpful command is this:
python3 -m pip install --upgrade --force-reinstall --no-deps dist/pyedurov3-0.0.0.tar.gz.
The source code can alos be run from the run.py file so you don't have to rebuild the package every time you change something. Just navigate into the upper pyedurov3 folder and typepython3 -m run.py
Package: pyee
pyeepyee supplies aEventEmitterobject that is similar to theEventEmitterclass from Node.js. It also supplies a number of subclasses
with added support for async and threaded programming in python, such as
async/await.DocsAutogenerated API docs, including basic installation directions and examples,
can be found athttps://pyee.readthedocs.io.DevelopmentSeeDEVELOPMENT.md.ChangelogSeeCHANGELOG.md.ContributorsSeeONTRIBUTORS.,md.LicenseMIT/X11, seeLICENSE.
Package: pyee2
pyee2pyee2 is theprimus/eventemitter3EventEmitter implementation ported to python with inspiration fromjfhbrook/pyee.pyee2:Does not raise or emit an error event when your listener raises an error and no one is listening for the "error" event.
That is to say pyee2 catches all errors raised by event listeners and only emits an error if there are listeners for the "error" event.The only time an exception is raised from an "emit" function is ifEventEmitter.raising_emitis used to emit the event.Does not not emit an event when a new listener is added or removed.Only supports function or functions that return awaitables (coroutine, future, task) as event listeners.
The test for awaitableness is done via "inspect.isawaitable"frompyee2importEventEmitteree=EventEmitter()@ee.on("event")defhandler(arg,data=3):print(f"handler called arg={arg}data={data}")ee.emit("event",1,data=2)
Package: pyeebls
This is a module that wraps Geza Kovacs’ eebls.f. Taken from Daniel
Foreman-Mackey’spython-blsmodule, and broken out for easier use by other
packages. This is used by theastrobasemodule.eebls.fKovacs, Zucker & Mazeh 2002, A&A, Vol. 391, 369http://arxiv.org/abs/astro-ph/0206099http://www.konkoly.hu/staff/kovacs/eebls.fpython-blsForeman-Mackey, D., Angus, R., et al. 2012https://github.com/dfm/python-bls.gitpyeeblsBhatti, W., et al. 2017https://github.com/waqasbhatti/pyeeblsInstallationThis package is available from PyPI:https://pypi.python.org/pypi/pyeeblsYou’ll need numpy installed, along with a Fortran compiler:(venv)$ pip install numpy # in a virtualenv
# or use dnf/yum/apt install numpy to install systemwide

## you'll need a Fortran compiler to install pyeebls!         ##
## on Linux: dnf/yum/apt install gcc gcc-gfortran             ##
## on OSX (using homebrew): brew install gcc && brew link gcc ##Then, install pyeebls using pip (preferably in a virtualenv or use the –user
flag):(venv)$ pip install pyeeblsOr download the tarball from PyPI, extract the files, and run setup.py:(venv)$ python setup.py installDocumentationThere’s only one function to use in this module.def pyeebls.eebls(times, mags, workarr_u, workarr_v,
                  nfreq, freqmin, stepsize,
                  nbins, minduration, maxduration):Calculates the BLS spectrum for the input times and mags arrays.ParameterstimesndarrayA numpy array containing the times of the measurements.magsndarrayA numpy array containing the mags or fluxes to use as measurements.workarr_u,workarr_vndarrayNumpy arrays that must be the same size as times, used as temp
workspaces by the Fortran function.nfreqintThe number of frequencies to search for the best period.freqminfloatThe minimum frequency to use.stepsizefloatThe stepsize in frequency units to use while searching.nbinsintThe number of bins to use when phasing up the light curve at a
single test period.mindurationfloatThe minimum transit duration in phase units to consider when testing for
a transit.maxdurationfloatThe minimum transit duration in phase units to consider when testing for
a transit.ReturnsA sequence of results:(power, bestperiod, bestpower, transdepth,
 transduration, transingressbin, transegressbin)powerndarrayA numpy array containing the values of the BLS spectrum at each tested
frequency.bestperiodfloatThe period at the highest peak in the frequency spectrum.bestpowerfloatThe power at the highest peak in the frequency spectrum.transdepthfloatThe depth of the transit at the best period.transdurationfloatThe length of the transit as a fraction of the phase. This is the
so-called ‘q’ parameter.transingressbinintThe phase bin index for the start of the transit.transegressbinintThe phase bin index for the end of the transit.See Alsothe comments at the top of eebls.f in this packagethekblsmodule inastrobasefor a high-level serial and parallelized
interface to this moduleLicenseThe license for the Python files is the MIT License. eebls.f is provided by
G. Kovacs; it appears to be re-distributable, but please make sure to cite
Kovacs, et al. 2002 if you use this implementation.
Package: pyeem
# PyEEM[![PyPi version](https://img.shields.io/pypi/v/pyeem.svg‘pypi version’)](https://pypi.org/project/pyeem/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyeem.svg)](https://pypi.org/project/pyeem/)
[![Test](https://github.com/drewmee/PyEEM/workflows/Test/badge.svg)](https://github.com/drewmee/PyEEM/actions?query=workflow%3ATest)
[![Read the Docs](https://readthedocs.org/projects/pyeem/badge/?version=latest)](https://pyeem.readthedocs.io/)
[![codecov](https://codecov.io/gh/drewmee/PyEEM/branch/master/graph/badge.svg?token=RAPG3XDZ6H)](https://codecov.io/gh/drewmee/PyEEM)
[![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/drewmee/PyEEM/master?filepath=docs%2Fsource%2Ftutorials%2Fnotebooks)
[![License](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/drewmee/PyEEM/blob/master/LICENSE)Python library for the preprocessing, analysis, and visualization of Excitation Emission Matrices (EEMs).## InstallationInstall via pip:$ pip install pyeem [–upgrade]## DocumentationFull documentation can be found [here](https://pyeem.readthedocs.io/).## Dependencies for Local DevelopmentIf you wish to build the local documentation or run unit tests, there are a few additional dependencies. Those can be installed by:pip install -e “.[docs, tests]”## LicenseThis library is licensed under the MIT license. The full text of the license can be found in this repository at LICENSE.txt.