Saravanan666/pypi-org huggingface dataset:
Package: pyl10n
PYL10NPyl10n is a localization (l10n) library for python, written in 2008-2010.BEWARE: This is old code, migrated to git. Previously, this was found at:https://code.osso.nl/projects/pyl10nSUMMARYPyl10n intends to replace the standard locale module which is not thread
safe (locale.setlocale() updates the entire process’ locale settings).
Pyl10n allows you to supply the language setting at conversion function
call time or through a callback function that allows you to have a
thread-specific language. E.g.  for Django you could passdjango.utils.translation.get_languagewhich gets the currently
selected language.Its a complement togettextsolutions that do not depend on
process-wide language settings.PORTABILITYPyl10n has been tested with python 2.5 through 2.7 on Debian/Ubuntu
Linux systems. It’s been known to work with Python 3 as well.Python support before 2.7 cannot be guaranteed. Python support for 3 is
not well tested.TODOThe generated locale files should be packaged separately so you don’t
need to fetch them when using pyl10n with only a handful of selected
languages.EXAMPLEImport pyl10n as locale:>>>importpyl10naslocaleHardcode the current thread locale.>>>locale.setlocale('nl_NL')>>>print(locale.currency(12345.67))€ 12345,67Usually you’ll want to set a function that returns the current thread
locale.>>>getlocale=lambda:'en_US'>>>locale.setlocalefunc(getlocale)>>>print(locale.format('%f',12345.67,True,True))12,345.67If you’re using your own locale files, you may set up the path like this:$lspath/to/locale/en/-1pLC_ADDRESS
LC_MEASUREMENT
LC_MESSAGES/
LC_MONETARY
LC_NAME
LC_NUMERIC
LC_PAPER
LC_TELEPHONE
LC_TIME>>>locale.setlocalepath('path/to/locale')>>>locale.setlocale('en')>>>locale.teldom2string((31,50,1234567))'(50) 1234567'>>>locale.setlocale('sv')>>>locale.teldom2string((31,50,1234567))'050-1234567'The data files are stored/read using pickle.TESTSA quick selftest can be run:$python-c'from pyl10n import selftest; selftest()'...Differences between the locale output and the pyl10n outputmaybe
attributed to an alternate/earlier source of locale date, or to custom
adjustments (improvements) by me (to the Dutch or English locale files).LIMITATIONSAs of this writing, it is not complete yet. It does implementformat()andcurrency()correctly (seehttp://bugs.python.org/issue1222) and it has most of the time
formatting support thatstrftime(3)specifies.In the near future (ha ha) it will support address formatting functions.Look at the lists of finished and unfinished functions in the source.
Package: pyl2h
Link2Home Protocoll implementationThis projects implements (part of) the propretiaryLink2Homecommunication protocol for monitoring and controlling devices from third party projects.:warning: This is under development and in very early stage!
:warning: This project is based on reverse engineering and is neither associated nor supported by the offical product. This is mere a workaround to the missing of an official open API or third party integrationsBasicsThe Link2Home protocol is relying on two major parts:Authenticated HTTP Calls to a backend hosted by the vendor. This is mainly for user profile portability, storing device metadata and discoveryUnauthenticated UDP Broad- and Unicasts for changing device state and announcing changesThis project currently relies solely on 2. and is operating solely within the local network.UsageWith importing theUDPServerclass, you've are able to access the data stream of device change updates, the current directory of known devices and sending command messagesfrom l2h import UDPServer

server = UDPServer()

def deviceCallback(deviceStatus):
    print("New Device Update: {}".format(deviceStatus))

devices = server.getDevices()
server.setStatus("192.168.1.3", 1, True)

server.listen(deviceCallback)Devices will be auto-discovered with their first state switch (i.e. when they are sending their first status update after the program has started), only after that, the library will be able to successfully communicate with the device. It is recommended that you trigger the devices manually (either by their physical buttons or via the official app) after having the server up to make autodiscovery work faster. Please Note: Apps currently also show up as devices.main.pyis also offering a CLI mode that will log status updates of devices and allow to alternate states of a device by it's IP supplied as an argument:python main.py --ip 192.168.1.3DevelopmentAs of now, this library has been developed and tested solely with a EMQ303WF-1 smart socket
Package: pyl4c
pyl4cThis is a collection of Python tools for managing, analyzing, and visualizing SMAP L4C data; running L4C Science; and working with related models in the Terrestrial Carbon Flux (TCF) framework. In particular:Working with data in EASE-Grid 2.0 projection (ease2.py;)Converting HDF5 geophysical variables to GeoTIFF format (spatial.py);Creating statistical summaries of SMAP L4C variables or other raster arrays (utils.py);Reproducing L4C operational model logic (science.py);Down-scaling 9-km SMAP fields to 1-km resolution (/apps/resample.py)Calibrating the L4C model (apps/calibration);Running the L4C model (apps/l4c);Aligning and summarizing SMAP L4C variables with TransCom regions (lib/transcom.py);The entire project is contained in thepyl4cmodule. Once installed:importpyl4cDocumentationRead the online documentation here.Setup and InstallationBecause this project is highly modular, it must be installed as a package in order to resolve module references/ paths.
Check outsetup.shfor an example of setting up the virtual environment prior to installation withpip.
Installation withpip, inside a virtual environment (virtualenv), is the recommendation.
Below, we install thepyl4clibrary in "development mode," which enables you to edit the source code.$pipinstall-e.Some extra features must be requested in order to have their dependencies installed.# To install support for calibration of L4Cpipinstall-epyl4c[calibration]# To install support for command line interfaces and the "scripts" folderpipinstall-epyl4c[cli]# To install support for reading netCDF4 filespipinstall-epyl4c[netcdf]# To install support for resampling L4C data by TransCom regionspipinstall-epyl4c[transcom]This will also install the project's dependencies.NOTE: Because the GDAL Python bindings can be difficult to install, I recommend installing them as binaries through your system's package manager.For instance, on Ubuntu GNU/Linux:sudoaptinstallpython3-gdalYou may encounter an error installingpyl4cfromsetup.py, depending on the version of the GDAL library you have installed. Seesetup.pyto check which version of GDAL that is expected. You can install a specific version of the GDAL Python bindings that is consistent with your system installation by:pipinstallGDAL==$(gdal-config--version)DependenciesThis package requires system support for HDF5 and the Geospatial Data Abstraction Library (GDAL).Python 3.5+GDAL (2.4+)HDF5Development headers for GDAL might also be necessary to get the Python bindings to install correctly. On Ubuntu GNU/Linux:# Install support for HDF5 (and the Python 3 bindings)sudoaptinstalllibhdf5-103libhdf5-devpython3-h5py# Install support for GDAL Python bindings (and the Python 3 bindings)sudoaptinstallgdal-binlibgdal-devpython3-gdalNOTE:For usingcalibrationtools, NetCDF (3 and 4) andnloptare required which, in turn, may require additional system libraries. On Ubuntu GNU/Linux:sudoaptinstalllibnlopt0NOTE:The basemap toolkit formatplotlibmust be installed separately:pipinstallgit+https://github.com/matplotlib/basemap.git
Package: pyl7plot
English |简体中文PyL7Plot🌍 Python3 binding for@AntV/L7PlotPlotting Library. Geospatial Visualization Chart Library Based on@AntV/L7. Inspired byPyG2Plot.Installation$pipinstallpyl7plotUsageRender to HTMLfrompyl7plotimportPlotdot=Plot("Dot")dot.set_options({"map":{"type":"mapbox","style":"light","center":[103.447303,31.753574],"zoom":7,},"autoFit":True,"source":{"data":[{"lng":103.715,"lat":31.211,"depth":10,"mag":5.8,"title":"M 5.8 - eastern Sichuan, China"},{"lng":104.682,"lat":31.342,"depth":10,"mag":5.7,"title":"M 5.7 - eastern Sichuan, China"},# ...],"parser":{"type":"json","x":"lng","y":"lat"},},"color":{"field":"mag","value":["#82cf9c","#10b3b0","#2033ab"],"scale":{"type":"quantize"},},"size":{"field":"mag",},"state":{"active":True},"scale":{"position":"bottomright"},"legend":{"position":"bottomleft"},"tooltip":{"items":["title","mag","depth"],},})# Render html filedot.render("dot.html")# Or render html string# dot.render_html()Render in Jupyterfrompyl7plotimportPlot,JSdot=Plot("Dot")dot.set_options({"map":{"type":"mapbox","style":"light","center":[103.447303,31.753574],"zoom":7,},"autoFit":True,"height":400,# set a default height in jupyter preview"source":{"data":[{"lng":103.715,"lat":31.211,"depth":10,"mag":5.8,"title":"M 5.8 - eastern Sichuan, China"},{"lng":104.682,"lat":31.342,"depth":10,"mag":5.7,"title":"M 5.7 - eastern Sichuan, China"},# ...],"parser":{"type":"json","x":"lng","y":"lat"},},"color":{"field":"mag","value":["#82cf9c","#10b3b0","#2033ab"],"scale":{"type":"quantize"},},"size":{"field":"mag",# Use JS API, you can use JavaScript syntax for callback."value":JS('''function({ mag }) {return (mag - 4.3) * 10;}''')},"state":{"active":True},"scale":{"position":"bottomright"},"legend":{"position":"bottomleft"},"tooltip":{"items":["title","mag","depth"],},})# Render in notebookdot.render_notebook()# Or render in jupyter lab# dot.render_jupyter_lab()More Online Examples PyL7plot inJupyter Lab.APIPlotPlot(plot_type: str): get an instance ofPlotclass.plot.set_options(options: object): set the options ofL7Plotinto instance.plot.render(path, env, **kwargs): render out html file by setting the path, jinja2 env and kwargs.plot.render_notebook(env, **kwargs): render plot on jupyter preview.plot.render_jupyter_lab(env, **kwargs): render plot on jupyter lab preview.plot.render_html(env, **kwargs): render out html string by setting jinja2 env and kwargs.协议MIT
Package: pyl7vp
English |简体中文PyL7VP🌍 Python3 binding for@AntV/L7VPgeospatial visual analysis tool.Installation$pipinstallpyl7vpUsageJupyter Notebook and JupyterLabimportpandasaspdfrompyl7vpimportL7VPl7vp_map=L7VP(height=600)# datadf=pd.DataFrame({'longitude':[105.005,104.602,103.665,105.275],'latitude':[32.349,32.067,31.29,32.416],'mag':[5.2,3.0,6.0,2.0]})# add dataset to mapl7vp_map.add_dataset({"id":"my_dataset","type":'local',"data":df})# Set configl7vp_map.set_config({"map":{"type":"Gaode","config":{"zoom":7,"center":[104.615357,32.068745],"style":'dark',},},})# display mapl7vp_map.show()Save to HTML Filefrompyl7vpimportL7VPl7vp_map=L7VP(height=600)# save to html filel7vp_map.save_to_html("map.html")User GuideQuick StartData FormatAPI DocumentPyL7VP in NotebookPyL7VP in Google ColabLocal DevelopmentInstall Jupyter# Using pippipinstalljupyter# or Using conda# conda install jupyterClone codegitclonehttps://github.com/antvis/L7VP.gitSetup jupyterInstall python modulecdbindings/pyl7vp# dev install from folder containing setup.pypipinstall-e.Start jupyter notebookcdnotebooks
jupyternotebookRelease a new versionUpdateversioninbindings/pyl7vp/pyl7vp/meta.py__version__="0.0.1"Build and publishpythonsetup.pyuploadLicenseApache-2.0
Package: pyla
pyla is a redis based storage system which can filter entries based on item’s
attributes.In it’s current version it stores the information of the entry in a sorted set
with all information present in the key.Why pyla?Say you have certain jobs that you want to schedule and every job has certain
attributes associated to it.frompylaimportentriesfrompylaimportfieldsclassJob(entries.Entry):id=fields.BaseField(primary=True)type=fields.BaseField(index=True)assigned_to=fields.BaseField(index=True)info=fields.BaseField(index=False)j=Job(id=1,type='create',assigned_to='dush',info='testing')j.save()on calling save on that particular entry you will have following sorted
sets available in redisjob
job:type:create
job:assigned_to:dushThen you have the following awesome filtering abilities:# Get all the jobsJob.objects.all()# Get jobs with type createJob.objects.filter(type='create')# Get jobs with either create or delete typeJob.objects.filter(type=['create','delete'])# Get jobs which are assigened to dushJob.objects.filter(assigned_to='dush')# Get jobs which are assigened to dush or spamJob.objects.filter(assigned_to=['dush','spam'])# Get jobs which are assigened to dush and are of type createJob.objects.filter(assigned_to='dush',type='create')# Get jobs which are assigened to dush and are of type create or deleteJob.objects.filter(assigned_to='dush',type=['create','delete'])# Get jobs which are assigened to dush or spam and are of type create or deleteJob.objects.filter(assigned_to=['dush','spam'],type=['create','delete'])You can have any number of filters over the fields which were set to index.
Obviously, the more indexes you have the slower your writes become.
Package: pylabber
pylabberpylabberis aDjangoproject designed to
provide the core functionality required to conduct neuroscientific research.For more information, see thedocumentation site.RequirementspylabberrequiresPostgreSQLas adatabase engine.Extensions may depend on external toolkits (e.g.django_mrirequiresFSL,FreeSurfer,SPM, etc.).Front-endFor a front-end project built on top ofpylabber, seevuelabber.
Package: pylabdevs-tspspi
Lab device base classesThis repository supplies some abstract base classes for various device families
that are used as basis for specific implementations. Those base classes provide
the frontend used by experimental scripts - the implementations are then
done in a device specific way by other packages.This package emerged from re-implementing different interfaces for different
devices from time to time to provide some kind of common base structure for
different devices.The base classes just implement basic parameter validation and provide a calling
convention. Changes should never break existing libraries.Currently implemented base classes:Power suppliesKA3005PSerialfor Korad KA3005P power supplies via serial interfacepydp832for Rigol DP832 power supplies via EthernetOscilloscopesRigol MSO5000for Rigol MSO5000 oscilloscopesFunction generators / Arbitrary waveform generatorsFY6900for FE FY6900Rigol DG832 (work in progress)Siglent SSG3021Xsinewave 9 kHz - 2.1 GHz generator (work in progress)Pressure gaugesPYBPG400for the RS232C interface of the INFICON BPG400 pressure gaugeVector network analyzersNanoVNA v2 (work in progress)Scanning Electron MicroscopesXL30 ESEM(work in progress)General purpose I/O devicesRasbperry PI GPIO under FreeBSDSPI busFreeBSD spigen interface
Package: pylabeador
Pylabeador: Automatic Syllabification of Spanish WordsInstallpip install pylabeadorUseYou can use it as a Python library:>>>importpylabeador>>>pylabeador.syllabify("silabear")['si','la','be','ar']And you can use it as a command line tool:$pylabeadorinteresantein-te-re-san-teAccuracyAutomatic syllabification without additional lexical or and semanticknowledgeof the words can only go so far.  This syllabifier does not have such knowledge. Because of this, words such astransatlántico, whose correct hyphenation istrans-a-tlán-ti-coor eventrans-at-lán-ti-co, end up being divided here intotran-sa-tlán-ti-co.  To hyphenate this correctly, it is necessary to know that the word without the prefix exists in Spanish with similar semantics to the one of the original word. This is better and further explained in this paper:Automatic syllabification for Spanish using lemmatization and derivation to solve the prefix’s prominence issueInspiration / Original sourceThis work is inspired by the excellent online toolSilabeador TIP. This tool considers the semantics of the words and correctly separates syllables in the presence of prefixes. They also provide a C++ library that performs the naive syllable separation thatpylabeadordoes. In fact,pyleabeadorstarted as a Python port of that library.
Package: pylabel
PyLabelPyLabel is a Python package to help you prepare image datasets for computer vision models including PyTorch and YOLOv5. It can translate bounding box annotations between different formats. (For example, COCO to YOLO.) And it includes an AI-assisted labeling tool that runs in a Jupyter notebook.Translate:Convert annotation formats with a single line of code:importer.ImportCoco(path_to_annotations).export.ExportToYoloV5()Analyze:PyLabel stores annotatations in a pandas dataframe so you can easily perform analysis on image datasets.Split:Divide image datasets into train, test, and val with stratification to get consistent class distribution.Label:PyLabel also includes an image labeling tool that runs in a Jupyter notebook that can annotate images manually or perform automatic labeling using a pre-trained model.Visualize:Render images from your dataset with bounding boxes overlaid so you can confirm the accuracy of the annotations.Tutorial NotebooksSee PyLabel in action in thesesample Jupyter notebooks:Convert COCO to YOLOConvert COCO to VOCConvert VOC to COCOConvert YOLO to COCOConvert YOLO to VOCImport a YOLO YAML FileSplitting Images Datasets into Train, Test, ValLabeling Tool Demo with AI Assisted LabelingFind more docs athttps://pylabel.readthedocs.io.About PyLabelPyLabel was developed by Jeremy Fraenkel, Alex Heaton, and Derek Topper as the Capstope project for the Master of Information and Data Science (MIDS) at the UC Berkeley School of Information. If you have any questions or feedback pleasecreate an issue. Please let us know how we can make PyLabel more useful.
Package: pylabeledrf
pylabeledrfpylabeledrf is a package to compute an extension of the Robinson Foulds tree topological distance between labeled topologies, where inner nodes are labeled with speciation or duplication events.From version 0.2 onwards, pylabeledrf includes two functions:computeLRF(), which computes exactly and efficiently the Labeled Robinson Foulds (LRF).computeELRF(), which is a heuristic to compute the edge-based Labeled Robinson Foulds (ELRF).CitationIf you use our package in your work, please consider citing:For LRF: Samuel Briand, Christophe Dessimoz, Nadia El-Mabrouk, Yannis Nevers,A linear time solution to the Labeled Robinson-Foulds distance problem, submittedFor ELRF: Samuel Briand, Christophe Dessimoz, Nadia El-Mabrouk, Manuel Lafond, Gabriela Lobinska,Extending the Robinson-Foulds distance to reconciled trees, APBC 2020 and BMC Genomics, in pressInstallationThe package requires Python 3 (>=3.6). The easiest way to install is usingpip, to install thepackage from
PyPI.pip install pylabeledrfDocumentationDocumentation is availablehere.Examplefrompylabeledrf.computeLRFimport*importdendropytaxa=dendropy.TaxonNamespace()# retrieve the test TP53 reconciled tree (from Ensembl compara 96)p53=dendropy.Tree.get_from_url('https://raw.githubusercontent.com/DessimozLab/pylabeledrf/master/test/p53.nhx','newick',taxon_namespace=taxa)t1=parseEnsemblLabels(p53)# introduce 5 random edits and compute the distancet2=mutateLabeledTree(t1,5)computeLRF(t1,t2)# randomise the labels and compute the distancet3=randomLabels(t1)computeLRF(t1,t3)LicenseCopyright 2019-2020 Christophe DessimozPermission 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: py-labeler
py_labelerThis project seeks to build a Python based GUI for manual labeling of
candidate pairs.Given two tables A and B, the goal of
EM is to discover the tuple pairs between two tables that refer to the
same real-world entities. There are two main steps involved in entity matching:
blocking and matching. The blocking step aims to remove obvious non-matching
tuple pairs and reduce the set considered for matching. Entity matching in
practice involves many steps than just blocking and matching. While performing EM
users often execute many steps, e.g. exploring, cleaning, debugging, sampling,
estimating accuracy, etc. Current EM systems however do not cover the entire
EM pipeline, providing support only for a few steps (e.g., blocking, matching), while
ignoring less well-known yet equally critical steps (e.g., debugging, sampling).
py_entitymatching seeks to support all the steps involved in EM pipeline.At the matching step, users would want to check and verify candidate pairs as matches
or non-matches. This is a manual process and this package py_labeler, provides a GUI to make this
process easier.The package is free, open-source, and BSD-licensed.Important linksProject Homepage:https://sites.google.com/site/anhaidgroup/projects/magellan/py_labeler_v0_1_1Code repository:https://github.com/anhaidgroup/py_labelerIssue Tracker:https://github.com/anhaidgroup/py_labeler/issuesDependenciesThe required dependencies to build the packages are:pandas (provides data structures to store and manage tables)pyqt5 (provides tools to build GUIs)jinja2 (provides templating for GUI)Platformspy_labeler has been tested on Linux, OS X and Windows.
Package: pylabels
pylabels is a Python library for creating PDFs to print sheets of
labels. It uses theReportLab PDF
toolkitto produce
the PDF.Basically, the user creates a set of specifications of the label sizes
etc, writes a callback function which does the actual drawing, and gives
these two items to a Sheet object. Items are then added to the sheet
using the add_label() method (or add_labels() to add all items from an
iterable).The callback function is called once for each item, being given a
ReportLab Drawing object representing the label, its width and height,
and the item to draw on the label. Any of the standard ReportLab drawing
methods can be used, with pylabels automatically adding a clipping path
around each label to prevent it interfering with other labels.Once all the items have been added, the labels can be saved as a PDF, or
a preview of a page can be saved as an image.Websitepylabels is hosted on GitHub athttps://github.com/bcbnz/pylabels/ExamplesThe following examples are available in the demos directory on GitHub:Basic- a introduction to the basic use of
pylabels.Partial pages- how to produce partial
pages (i.e., pages with some of the labels previously used).Background colours- examples of solid,
striped and hatched backgrounds of different colours on each label.Page background- how to add a background
image for each page.Padding- how to add padding to the labels.Nametags- creates a set of nametags from the
list of names in the names.txt file. Includes the use of two custom
fonts, font size selection, and centred text.Image preview- generates image previews of
two of the pages from the nametags demo.Demo fontsThe following fonts are used in the demo scripts and are included in the
demos folder:Judson Bold -http://openfontlibrary.org/en/font/judson(Open Font
License)KatamotzIkasi -http://openfontlibrary.org/en/font/katamotzikasi(GPL)LicenseCopyright (C) 2012, 2013, 2014, 2015 Blair Bonnettpylabels is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.pylabels is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
more details.You should have received a copy of the GNU General Public License along
with pylabels. If not, seehttp://www.gnu.org/licenses/.