Saravanan666/pypi-org huggingface dataset:
Package: l3gd20-python
l3gd20-pythonPython library for the L3GD20 I2C 3-axis gyroscopeUsageInstall the Pythonsmbusmodule for your platform (sudo apt install python-smbusfor Debian or Ubuntu Linux)pip install l3gd20-pythonsudo l3gd20_testExample Codeimporttimeimportsmbusimportl3gd20i2c_channel=1bus=smbus.SMBus(i2c_channel)# Will raise OSError if device is not connecteddevice=l3gd20.L3GD20(bus)# Set range, 250 degrees/second is default# Supported:# RANGE_250DPS# RANGE_500DPS# RANGE_2000DPSdevice.set_range(l3gd20.RANGE_250DPS)# Wait for gyro to stabilizetime.sleep(0.5)whileTrue:# Returns x,y,z tuple with values in degrees/seconddata=device.read()print([round(v,2)forvindata])time.sleep(0.1)
Package: l3py
What is l3pyl3py is a free Open Source software package for computing gridded mass anomalies (Level 3 products)
from time variable gravity field solutions. It is tailored for products of the GRACE
mission and its successor GRACE-FO.The features of l3py are:File I/O for common data formats including GFC files and COARDS compliant netCDFBasic arithmetic operations for sets of potential coefficientsPropagation of spherical harmonic coefficients to gridded mass anomaliesSpatial filtering of potential coefficientsInstallationl3py is written for Python>=3.4 and only depends onnumpyandnetcdf4. To install
the package, first clone the repository or download the zip archive. In the root directory
of the package (i.e. the directory containing thesetup.pyfile), runningpip install .will install the package and its dependencies.API ReferenceA complete API reference of the module is available on readthedocs:https://l3py.readthedocs.io/en/latest.[![Documentation Status](https://readthedocs.org/projects/l3py/badge/?version=latest)](https://l3py.readthedocs.io/en/latest/?badge=latest)Licensel3py a free Open Source software released under the MIT license.If you wish to cite l3py in a publication, please use the following DOI.[![DOI](https://zenodo.org/badge/151739427.svg)](https://zenodo.org/badge/latestdoi/151739427)
Package: l3wrapper
A Python 3 wrapper around Live-and-Let-Live (L^3) classifier binaries implementing thescikit-learnestimator interface. The associative classifier was originally published in[1].When imported, the package looks forL^3compiled binaries in the user’s$HOMEdirectory. If they are not found, it downloads them.
If you mind letting the wrapper do this for you, you can download the binaries formacOS CatalinaorUbuntu 18.04.[1]Elena Baralis, Silvia Chiusano, and Paolo Garza. 2008. A Lazy Approach to Associative Classification. IEEE Trans. Knowl. Data Eng. 20, 2 (2008), 156–171.https://doi.org/10.1109/TKDE.2007.190677InstallationInstall usingpipwith:pip install l3wrapperOr,download a wheel or source archive from
PyPI.RequirementsThe package is dependent onnumpy,scikit-learn,tqdm, andrequests.UsageBy design, the classifieris intended for categorical/discrete attributes. Therefore, using subtypes ofnumpy.numberto fit the model is not allowed.Simple classificationA sample usage with theCar Evaluation dataset:>>> from l3wrapper.l3wrapper import L3Classifier
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> from sklearn.metrics import accuracy_score
>>> X = np.loadtxt('car.data', dtype=object, delimiter=',')
>>> y = X[:, -1]
>>> X = X[:, :-1]
>>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)
>>> clf = L3Classifier().fit(X_train, y_train)
>>> accuracy_score(y_test, clf.predict(X_test))
0.9071803852889667Column names and interpretable rulesUse thecolumn_namesandsave_human_readableparameters to obtain an interpretable representation of the model:>>> column_names = ['buying', 'maint', 'doors', 'persons', 'lug_boot', 'safety']
>>> clf = L3Classifier().fit(X_train, y_train, column_names=column_names, save_human_readable=True)The snippet will generate thelevel1andlevel2rule sets. An excerpt is:0 persons:4,safety:high,maint:low,buying:high acc 12 100.0 4
1 doors:2,buying:vhigh,safety:med,lug_boot:med unacc 11 100.0 4in the form:<rule_id>\t<antecedent>\t<class label>\t<support count>\t<confidence(%)>\t<rule length>Known limitationsfixedThe parallel training of multiple models cause failures (e.g. using ``GridSearchCV``, ``joblib`` or custom parallelism through ``multiprocessing`` with ``njobs>1``).The scikit-learn’s utilitycheck_estimatorstill doesn’t work, as
L3Classifier doesn’t support numerical input.CompatibilityThe underlyingL^3binaries are currently available formacOS and Ubuntu.The package is currently tested with Python 3.6+.LicenseThe MITLicense.Authorsl3wrapperwas written byg8a9.
Package: l3wtransformer
l3wtransformer==============> A word hashing method to reduce the dimensionality of the bag-of-words term vectors. It is based on letter n-gram. Given a word (e.g. good), it first adds word starting and ending marks to the word (e.g. #good#). Then, breaks the word into letter n-grams (e.g. letter trigrams: #go, goo, ood, od#). Finally, the word is represented using a vector of letter n-grams.[Huang et al.2013, Learning Deep Structured Semantic Models for Web Search using Clickthrough Data]---This implementation supports the transformation from **text into sequences of numbers**, with the numbers indicating the descending word frequency.For example:*Lorem ipsum dolor sit amet, consectetuer adipiscing elit...* is transformed into *23, 1, 80, 86, 47, 50001, 21, 59, 83, 93, 14, 50003, 4, 7*Also, after each word flags indicating lower case, upper case, mixed case or initial capitalization are added.### To doThere will be an implementation supporting the transformation from **text into bag-of-word vectors**.Install-------```pip install l3wtransformer```Usage-----```from l3wtransformer import L3wTransformerl3wt = L3wTransformer()l3wt.fit_on_texts(['First example.', 'And one more!'])l3wt.texts_to_sequences(['One example', '2nd exa.'])# [[5, 18, 17, 50001, 2, 10, 24, 6, 15, 20, 50003], [16, 50003, 2, 10, 50003]]```
Package: l5_shoppinglist
l5_shoppinglistgtk shoppinglist for librem5install and runinstall via pip (preferred!)python3 -m pip install --user l5_shoppinglistand simply run it with:python3 -m l5_shoppinglistthe convenient according desktop shortcut would be at:~/.local/share/applications/l5_shoppinglist.desktopwith the following content:[Desktop Entry]
Categories=Accessories
Comment=Libre shopping list
Exec=python3 -m l5_shoppinglist
Icon=software-installed-symbolic
Name=l5_shoppinglist
NoDisplay=false
Terminal=false
Type=Applicationprivacy - user data:as a privacy respecting app l5_shoppinglist makes no network connections.
no data gets collected or sent anywhere - the user is in full control.
the database is a simple json file which could be edited with a text editor.
it is stored at:~/.local/l5_shoppinglist/shoppinglist_db.jsonrunning the application without pip:clone the repository e.g. to~/opt/it can be started viapython3 ~/opt/l5_shoppinglist/l5_shoppinglist/__main__.pyto run it conveniently from the app drawer on librem5,
it is recommended add al5_shoppinglist.desktopfile to:~/.local/share/applicationsassuming the path of the__main__.pyfile is:/home/purism/opt/l5_shoppinglist/l5_shoppinglist/__main__.pythe .desktop would need the following content:[Desktop Entry]
Categories=Accessories
Comment=Libre shopping list
Exec=python3 /home/purism/opt/l5_shoppinglist/l5_shoppinglist/__main__.py
Icon=software-installed-symbolic
Name=l5_shoppinglist
NoDisplay=false
Terminal=false
Type=Application
Package: l9format
l9format pythonl9format is a schema declaration targeted at interoperability between network
recon tools used at LeakIX.This library is equivalent tol9formatwhich provides a Go implementation.Run the testspoetry install
poetry run pytest l9format/tests/test_l9format.pyInstallUse main branch for the moment:poetry add https://github.com/leakix/l9format-python#mainDocumentationfroml9formatimportl9formatl9format.L9Event.from_dict(res)VersioningThe versions will be synced withl9format,
suffixed by a number for bug fixes in the python implementation specifically.
For instance,1.3.1-0will be the first version for1.3.1and followhttps://github.com/LeakIX/l9format/releases/tag/v1.3.1. If a change is required
for the Python package, but is the same specification than the Go
implementation, the next release will be1.3.1-1.
The version can be verified usingimportl9formatl9format.__version__
Package: laaos
Log as append-only source packageLogs as append-only source: write your ML training results in Python without having to worry about crashes. Loading is a breeze: the logs are native Python code. The package supports unstructured data. The data can easily be imported into Jupyter Notebooks or elsewhere.InstallationTo install using pip, use:pip install laaosTo run the tests, use:python setup.py testAppend-only source logsStoring training results as Python dictionaries or JSON files is problematic because the formats are not append-only,
which means that you have to rewrite the file every time something changes. (Or you only write results at the end,
which does not play well with interruptions or intermediate failures.)Alternatively, we can simply write the operations that create a structure to a file in an append-only fashion.
If the data structure itself is growing and not mutated, this only increases file-size by a constant factor.The advantage of this library is that the file format is very simple: it's valid Python code.The only requirement is that you only store primitive types, lists, sets, dicts and immutable types.Custom wrappers can be added by registeringTypeHandlers when creating aStore. SeeWeakEnumHandlerandStrEnumHandler.Examplefromlaaosimportopen_file_store,safe_loadstore=open_file_store("test",suffix="",truncate=True)print("Output file: ",store.uri)store['losses']=[]losses=store["losses"]foriinrange(10):losses.append(1/(i+1))store.close()The resulting filelaaos/test.pycontains valid Python code:store={}store['losses']=[]store['losses'].append(1.0)store['losses'].append(0.5)store['losses'].append(0.3333333333333333)store['losses'].append(0.25)store['losses'].append(0.2)store['losses'].append(0.16666666666666666)store['losses'].append(0.14285714285714285)store['losses'].append(0.125)store['losses'].append(0.1111111111111111)It can be loaded either with:formlaaos.testimportstoreor with the more secure:safe_load('laaos/test.py')Slightly more sensible examplefromlaaosimportopen_file_storeinitial_data=dict(config=dict(dataset="MNIST",learning_rate=1e-4,seed=1337),losses=[])store=open_file_store("experiment_result",suffix="",initial_data=initial_data)ifstore["config"]!=initial_data["config"]:raiseValueError("Experiment mismatch!")print("Output file: ",store.uri)losses=store["losses"]foriinrange(len(losses),10):print("Epoch ",i)losses.append(1/(i+1))ifi%3==0:raiseSystemError("Preemption!")store.close()
Package: laapyCore
different utils and tools for projectscollecting python modules into library.needs VTKbrewinstallvtkinstall from pypipipinstalllaapyCoreinstall from sourceto work on project install source locally, activate venv and run (if mac run zsh version):pipinstall-e.[dev]pipinstall-e'.[dev]'usefromworking_toolsimporttettest setup statepythonsetup.pysdistcreate manifestcheck-manifest--create
gitaddMANIFEST.inbuild to uploadpythonsetup.pybdist_wheelsdist

twineuploaddist/*
Package: lab
Labis a Python package for evaluating solvers on benchmark sets.
Experiments can run on a single machine or on a computer cluster. The
package also contains code for parsing results and creating reports.TheDownward LabPython package facilitates running experiments for
theFast Downwardplanning system. It
uses the generic experimentation packageLab. Currently, Lab and
Downward Lab are distributed together.Code:https://github.com/aibasel/labDocumentation:https://lab.readthedocs.ioCite: please cite Downward Lab by using@Misc{seipp-et-al-zenodo2017,
  author =       "Jendrik Seipp and Florian Pommerening and
                  Silvan Sievers and Malte Helmert",
  title =        "{Downward} {Lab}",
  publisher =    "Zenodo",
  year =         "2017",
  howpublished = "\url{https://doi.org/10.5281/zenodo.790461}"
}Install LabLab requires Python 3.7+ and Linux (e.g., Ubuntu). We recommend installing
Lab in aPython virtual environment. This has the advantage
that there are no modifications to the system-wide configuration, and that
you can create multiple environments with different Lab versions (e.g.,
for different papers) without conflicts:# Install required packages, including virtualenv.
sudo apt install python3 python3-venv

# Create a new directory for your experiments.
mkdir experiments-for-my-paper
cd experiments-for-my-paper

# If PYTHONPATH is set, unset it to obtain a clean environment.
unset PYTHONPATH

# Create and activate a Python virtual environment for Lab.
python3 -m venv --prompt my-paper .venv
source .venv/bin/activate

# Install Lab in the virtual environment.
pip install -U pip wheel
pip install lab  # or preferably a specific version with lab==x.y

# Store installed packages and exact versions for reproducibility.
# Ignore pkg-resources package (https://github.com/pypa/pip/issues/4022).
pip freeze | grep -v "pkg-resources" > requirements.txtPlease note that before running an experiment script you need to
activate the virtual environment with:source .venv/bin/activateWe recommend clearing thePYTHONPATHvariable before activating the
virtual environment.
Package: lab2hub
lab2hubAdd links back to Jupyterhub(k8s) control panel.RequirementsJupyterLab >= 3.0Installpipinstalllab2hubContributingDevelopment installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the lab2hub directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmrunbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmrunwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm run buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseUninstallpipuninstalllab2hub
Package: lab3
LAB3lab3 is a redesign of the shared code repository. The core philosophy is to
centralize much of the analysis code that formerly lived in hard-to-maintain
scripts, and provide common frameworks to add new analysis methods. It's also
all in Python3!DocumentationTutorials for getting started, including installation instructions and the API
reference, are available here:https://losonczylab.gitlab.io/lab3/
Package: lab6
Description<hr>Р¤СѓРЅРєС†РёСЏ СЃРѕСЂС‚РёСЂРѕРІРєРё РІС‹Р±РѕСЂРѕРј.
РќР°РїСЂРёРјРµСЂ, РґР°РЅР° РїРѕСЃР»РµРґРѕРІР°С‚РµР»СЊРЅРѕСЃС‚СЊ -5,0,-1,100,2,-34.
РџРѕСЃР»Рµ РїСЂРѕС…РѕРґР° С‡РµСЂРµР· С„СѓРЅРєС†РёСЋ РѕРЅР° РїСЂРёРјРµС‚ РІРёРґ -34, -5, -1, 0, 2, 100.
Рў.Рµ. РґР»СЏ РєР°Р¶РґРѕР№ РїРѕР·РёС†РёРё РїРѕСЃР»РµРґРѕРІР°С‚РµР»СЊРЅРѕСЃС‚Рё РёС‰РµС‚СЃСЏ РјРёРЅРёРјР°Р»СЊРЅРѕРµ С‡РёСЃР»Рѕ,
Рё РѕРЅРѕ РјРµРЅСЏРµС‚СЃСЏ СЃ С‚РµРєСѓС‰РёРј С‡РёСЃР»РѕРј.
Package: labbench
Thelabbenchmodule provides API tools to support python scripting for laboratory automation.
The goal is to simplify the process of developing an experimental procedure into clear, concise, explainable, and reusable code.
These characteristics are necessary to scale up the complexity of large testbeds and experiments.Features include:Expedited development of python device wrappers, including specialized backends forpythonnet,pyvisa,pyserial,subprocess,telnetlibDescriptor-driven development: minimize the distance between programming manuals and python wrappers and apply calibrations transparentlyAutomated logging of simple device parameters into root CSV or sqlite root tables, pointing to relational data and metadata in json and plain-textSimplified multi-threaded concurrency tools for lab applicationsContainer objects for nesting device wrappers and snippets of test proceduresSupport for running experiments based on tables of test conditionsThe source code was developed at NIST to support complex measurement efforts. Examples of these projects include:NIST TN 1952: LTE Impacts on GPS(data)NIST TN 2069: Characterizing LTE User Equipment Emissions: Factor ScreeningNIST TN 2140: AWS-3 LTE Impacts on Aeronautical Mobile Telemetry(data)NIST TN 2147: Characterizing LTE User Equipment Emissions Under Closed-Loop Power ControlBlind Measurement of Receiver System Noise(data)Automated Testbed for Interference Testing in Communications Systems (code, data)StatusThe project is under ongoing developmentAPI changes have slowed, but deprecation warnings are not yet being providedSuggest pinning labbench dependency to an exact versionParts of the documentation are in need of updates, and others have not yet been writtenInstallationEnsure prerequisites are installed:python (3.9-3.12)pipfor package managementRecommended module installation:For python distributions based on anaconda:pip--upgrade-strategyonly-if-neededinstalllabbenchFor other python installations:pipinstalllabbenchResourcesSource codeDocumentationPyPImodule pagessmdevices: a collection of device wrappers implemented with labbenchContributingPull requestsandbug reportsare welcome!Inline documentation style conventionContributorsNameContactDan Kuester (maintainer)daniel.kuester@nist.govShane AllmanFormerly with NISTPaul BlanchardFormerly with NISTYao Mayao.ma@nist.gov
Package: labbook
InstallationUse pip or easy_install:% pip install labbookor% easy_install labbookOr download the source, extract the package then run:% python setup.py installBuildingThe distribution itself may be built as a zip archive (.zip)
and gzipped tarball (.tar.gz) using:% python setup.py sdist –formats=gztar,zipThis will place the distribution files in directory dist.  It uses the
MANIFEST.in file to determine which additional files on top of those
ending in .py to include (there’s an include syntax for patterns).
This package includes everything.Uploading to PyPIAfter making sure your author and maintainer information is ok and registered
with PyPI, you can upload the package for the world to download and use.% python setup.py sdist uploadRunning Unit TestsThe unit tests are based on the python module unnittest.  They are
located in the folder “test” and may be run with:% python runtests.py
Package: labcams
labcamsA package for video acquisition and automation of experimens, uses separate processes to record and store data.UsageOpen a terminal and typelabcams -hfor help.The first time you runlabcamsit will create a folder in the user home directory where the default preference file is stored.Configuration files:Configuration files ensure you always use the same parameters during your experiments.The configuration files are simplejsonfiles. There are 2 parts to the files.A section were each camera is specified and a part with general parameters.Available camera drivers:PCO- install pco.sdkAVT- install Vimba SDK and pymbaQImagingpointgrey- FLIR cameras - install SpinnakeropenCV- webcams and so onEach camera has its own parameters, there are some parameters that are common to all:recorder- the type of recordertiffffmpegopencvbinaryhaccel-nvidiaorintelfor use with ffmpeg for compression.'CamStimTrigger' - controls the arduino camera trigger, see the duino examples folder.UDP and ZMQ:labcamscan listen for UDP or ZMQ commands.To configure use the command"server":"udp"in the end of the config file.The port can be configured with"server_port":9999The UDP commands are:Set the experiment name -expname=EXPERIMENT_NAMESoftware trigger the cameras (this is software, multiple cameras are not in sync) -softtrigger=1Hardware trigger mode and save -trigger=1Start/stop saving -manualsave=1Add a message to the log -log=MESSAGEQuit -quit
Package: lab-converter
LAB Converter Python PackagePrerequisitesHex Conversion .csvIn order to convert lab values to a hex code for a given color, down loadthis csvcontaining hex codes mapped to the corresponding rbg value.Installationpip install lab-converterUsagefrom lab-converter import lab2hex

hex = lab2hex(52.9, 8.88, 54.53, hex_conversion_csv_path="./Base10_Hex.csv")

print(hex)
Package: labcsv
labcsv.pyYou can easily get the data you need columns fromlab.js.csv!Installationpip install labcsvHow to UseRead CSVfromlabcsvimportread_csv,DefaultHeaderNameasLHNamerlab=read_csv("tests/test.csv")#<- pathRead columns as any typedefault: "001" -> 1.0str type: "001" -> "001"rlab=read_csv("tests/test.csv",dtype={"Param2":str})*"Param2" is a header name*The specifications are the same as for pandas.Get columns dataThe return type is ndarry (get_column_values)values=rlab.get_column_values(LHName.SENDER)#n×1 size# orvalues=rlab.get_column_values([LHName.SENDER,LHName.RESPONSE,LHName.DURATION])# n×3 size# orvalues=rlab.get_column_values("Param1")#custom column name# orvalues=rlab.get_column_values([LHName.SENDER,"Param1"])#multipleThe return type is list (get_column_list)senders,time_commits=rlab.get_column_list([LHName.SENDER,LHName.TIME_COMMIT])print(senders)print(time_commits)nan to Empty Stringfromlabcsvimportread_csv,DefaultHeaderNameasLHNamerlab=read_csv("tests/test.csv")rlab.pandas_data.fillna('',inplace=True)#<---print(rlab.get_column_values("Param1"))You can use pandas functions.Get metameta=rlab.get_meta()print(meta["labjs_version"])print(meta["language"])print(meta["location"])
Package: labdiscoveryengine
LabDiscoveryEngineLabDiscoveryEngine is an evolved and modern RLMS building upon WebLabDeusto's experience.The official website of the LabDiscoveryEngine project ishttps://labdiscoveryengine.labsland.com/First stepsInstallation$ pip install labdiscoveryengineCreating an LDE deploymentFirst, you have to create an LDE deployment directory, where you will store the configuration. To create a simple example, run the following:$ lde deployments create -d /path/to/mydeploymentIf you want to use gunicorn (recommended), then run this:$ lde deployments add-gunicorn-script -d /path/to/mydeploymentAnd if you want to manage it with supervisor (recommended), run this and follow the installation instructions:$ lde deployments add-supervisor-config -d /path/to/mydeploymentFrom that moment, you will have a setup up and running, with four configuration files.Full documentationhttps://developers.labsland.com/labdiscoveryengine/en/stable/FundingThe LabDiscoveryEngine project operates under a cascade funding model, provided by the European Union-backed initiative, NGI Search. This funding approach not only empowers us financially but also aligns our objective to revolutionize the accessibility and discovery of educational labs with the broader goals of NGI Search.Funded by the European Union. Views and opinions expressed are however those of the author(s) only and do not necessarily reflect those of the European Union or European Commission. Neither the European Union nor the granting authority can be held responsible for them. Funded within the framework of the NGI Search project under grant agreement No 101069364.DevelopmentWhen developing LabDiscoveryEngine (not a remote laboratory, but when developing the RLMS itself), the easiest steps are:Start the web server in debug mode:$ . devrc
$ flask runStart the worker:$ python labdiscoveryengine/cli.py worker run(this is the equivalent to runninglde worker runwhen the labdiscoveryengine package is installed)In the folder tools there are scripts to test.