Saravanan666/pypi-org huggingface dataset:
Package: pylfgp
Package Documentation:Description:Crowdsourcing Utilizing Subgroup Structure of Latent Factor ModelingIn our project, we issue a Python implementation for learning from crowdsourcing data using a Latent Factor Gaussian Process (LFGP) model to predict the true labels for
multicategory classification tasks. The Latent Factor Gaussian Process model is a powerful way to deal with the noise in crowdsourced labels. The class includes methods for initializing task members, worker members, and various model parameters. It also provides functionalities for binary and multi-categorical crowdsourcing.FeaturesThe classLFGPincludes the following methods:Initialization of task membersInitialization of worker membersInitialization of binary parametersInitialization of orthogonal matricesUpdate of A and B (latent factors) for binary crowdsourcingBinary fit for model trainingInstallationYou can install this python package by first making sure that you have the Python 3.6 version or later. You can check your Python version by running the following command:python--versionInstall with pip
The easiest way to install lfgp is by using pip, Python's package installer.
Run the following command in your terminal:pipinstalllfgpFurthermore, the following packages are required for installation in order to use our code:operator - a built-in Python module providing functions corresponding to intrinsic operators.numpy - for numerical computations.ray - for parallel and distributed computing. The default chord for the ray package is 1.scipy - specifically scipy.stats for statistical computations.numpy_indexed - for advanced operations on numpy arrays.sklearn.cluster - specifically sklearn.cluster.KMeans for the k-means clustering algorithm.Our code also imports several functions (logistic_reg,label_swap,data_converter,multinominal_reg1,multinomial_reg2,cayley_transform) from a src.util module and DawidSkeneModel from src.dawid_skene_modelUsageHere's an example of how to use theLFGPclass:fromlfgpimportLFGPmodel=LFGP()model._binary_fit(data,scheme="mv",maxiter=100,epsilon=1e-3,verbose=0)Please refer to the in-code documentation and comments for more detailed information on how to use each method.
Package: pylfi
pyLFIpyLFI is a Python toolbox for likelihood-free inference (LFI) for estimating the posterior distributions of model parameters.This repository provides a Python library for kernel density estimation. In comparison to other Python implementations of kernel density estimation, key features of this library include:Support for weighted samplesA variety of kernels, including a smooth, compact kernel.Initial development is in progress, and there has not yet been a stable, usable release suitable for the public.
Package: pylfmap
# pylfmapThis code provides a python interface for the [LFmap](http://www.astro.umd.edu/~emilp/LFmap/LFmap_1.0.tar) galaxy radio sky map generator. For more about LFmap read [here](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.192.5753&rep=rep1&type=pdf). With the pylfmap class one can use all the features provided by the [healpy](https://github.com/healpy/healpy) (or other relevant python packages).## InstallThe most convenient install method is to use pip which retrieves the latest version of the software and also takes care of any missing dependencies:pip install pylfmapor install using the git:pip install git+https://github.com/F-Tomas/pylfmapAlternatively, clone the directory and run the setup.py:git clonehttps://github.com/F-Tomas/pylfmappython setup.py installDuring the installation, the original C++ LFmap will be downloaded, and on the first run, sky model data in the range from 30 to 80 MHz with 0.1 MHz spacing will be generated.## ExamplesCheckout theworking_example.ipynbjupyter notebook example.
Package: pylgnetcast
Python LG NetcastA Python 3 library and command line tool to control LG Smart TV running NetCast 3.0 (LG Smart TV models released in 2012) and NetCast 4.0 (LG Smart TV models released in 2013) via TCP/IP.This library was forked fromwokar/pylgnetcastand is primarily being developed with the intent of supportinghome-assistant.DependenciesPython 3requestspackage.API Usagefromxml.etreeimportElementTreefrompylgnetcastimportLgNetCastClient,LG_COMMAND,LG_QUERYwithLgNetCastClient('192.168.1.5','889955')asclient:client.send_command(LG_COMMAND.MUTE_TOGGLE)data=client.query_data(LG_QUERY.VOLUME_INFO)ifdata:print(ElementTree.tostring(data[0],encoding='unicode'))Command Line ToolPyLgNetCast also provides a simple command line tool to remote control a TV.The tool needs a pairing key to be allowed to send commands to your TV.
To get the pairing key just start the tool while your TV is on:python-mpylgnetcast--host<IPofyourTV>This will display the pairing key on your TV.To retrieve status information from your TV start the tool like:python-mpylgnetcast--host<IPofyourTV>--pairing_key<pairingkeyofyourTV>This will display information about the current channel, volume, 3D mode, etc. retrieved from your TV.If you want to send a command to your TV, for instance to turn the volume up, check the list of available commands in the pylgnetcast.py file.
The class LG_COMMAND defines all supported commands and volume up would be defined as 24.python-mpylgnetcast--host<IPofyourTV>--pairing_key<pairingkeyofyourTV>--command24
Package: pylgrum
PyLGRum - A Python Library for Gin RummyOverviewPyLGRum aims to be a comprehensive Python language library for the card gameGin Rummy.It currently includes:Classes that model the cards and collections of cards needed to play the game.Classes that model a game and the players in that game, supporting two operating modes:Asynchronousmode driven by a Game object that calls hooks in Player objects to advance the gameAnasynchronousmode appropriate for play through an APIMotivation & Project GoalsGin Rummy is a fine game and all, but I hope you have better things to do with your time than play a two-person card game against a computer opponent.So why PyLGRum?As somebody who both enjoys playing Gin Rummy and making things with software, I wanted a platform in which I could experiment at scale with different strategies for game play. Basically, I want a way to define and test different Gin Rummy playing algorithms. It also serves as a playground project for different programming and system design techniques.Current StatusPyLGRum is substantially complete and working, with the following open issues:The challenging player always starts the gameGame doesn't recognize end of game state yetTest coverage on TUI game/player is incompleteTechnical DocumentationThe PyLGRum package isthoroughly documented here.TODOsat some point:
- replace print statements in game play with non-terminal-assuming messages

maybe improvements:
- more pythonic in deck.py (lists)
- Card's *_val() methods ---> properties instead
- CardStack size(), peek() --> properties
Package: pylgtv
pylgtvLibrary to control webOS based LG Tv devicesRequirementsPython >= 3.3Installpip install pylgtvExamplefrompylgtvimportWebOsClientimportsysimportlogginglogging.basicConfig(stream=sys.stdout,level=logging.INFO)try:webos_client=WebOsClient('192.168.0.112')#webos_client.launch_app('netflix')forappinwebos_client.get_apps():print(app)except:print("Error connecting to TV")
Package: pylhc
PyLHC ToolsThis package provides tools for particle accelerator physics complementing the optics measurement analysis tools of theomc3 package.
It is a collection of useful scripts for the Optics Measurements and Corrections team (OMC) at CERN, with functionality for data analysis, corrections calculation, simulations management and machine information extraction.DocumentationAutogenerated docs viaSphinxcan be found athttps://pylhc.github.io/PyLHC/.General documentation of the OMC-Team is located athttps://pylhc.github.io/InstallingThis package isPython 3.7+compatible, and can be installed throughpip:python-mpipinstallpylhcAfter installing, scripts can be run with eitherpython -m pylhc.SCRIPT --FLAG ARGUMENTor by calling the Python files directly.For development purposes, we recommend creating a new virtual environment and installing from VCS in editable mode with all extra dependencies:gitclonehttps://github.com/pylhc/pylhc
python-mpipinstall--editable"pylhc[all]"Note:Some scripts access functionality only available on the CERN Technical Network.
To use those, you should make sure to install the relevant extra dependencies withpython -m pip install "pylhc[cern]".FunctionalityForced DA Analysis- Script to analyze forced DA. (forced_da_analysis.py)Machine Settings Info- Prints an overview over the machine settings at a given time. (machine_settings_info.py)KickGroup Information- Get information about KickGroups. (kickgroups.py)BSRT LoggerandBSRT Analysis- Saves data coming straight from LHC BSRT FESA class and allows subsequent analysis. (bsrt_logger.py&bsrt_analysis.py)BPM Calibration Factors- Compute the BPM calibration factors using ballistic optics. Two methods are available: using the beta function and using the dispersion. (bpm_calibration.py)LicenseThis project is licensed under theMITLicense - see theLICENSEfile for details.
Package: pylhc-submitter
PyLHC SubmitterThis package contains scripts to simplify the creation, parametrization and submission of simulation jobs to HTCondor clusters at CERN.See theAPI documentationfor details.InstallingNote: This package is availablethroughPyPIonLinux,WindowsandmacOSthroughconda-forgeonLinuxandmacOSInstallation is easily done viapip:python-mpipinstallpylhc-submitterOne can also install in acondaenvironment via theconda-forgechannel with:condainstall-cconda-forgepylhc_submitterAfter installing, scripts can be run with eitherpython -m pylhc_submitter.SCRIPT --FLAG ARGUMENTor by calling the Python files directly.See theAPI documentationfor details.FunctionalityHTCondor Job Submitter- Allows to generate jobs based on a templates and submit them to HTCondor. (job_submitter.py)AutoSix- Allows to generate and submit parametric SixDesk studies easily. (autosix.py)LicenseThis project is licensed under theMITLicense - see theLICENSEfile for details.
Package: pylhe
pylhe: Python LHE interfaceSmall and thin Python interface to readLes Houches Event (LHE)filesInstallTo installpylhefrom PyPI you can just dopython -m pip install pylheThe visualization capabilities require the external dependency ofGraphviz.Get startedThe example below provides a simple overview.
Full functionality can be inspected from the functions provided in thepylhemodule.importitertools# You can use LHE files from scikit-hep-testdatafromskhep_testdataimportdata_pathimportpylhelhe_file=data_path("pylhe-testlhef3.lhe")events=pylhe.read_lhe_with_attributes(lhe_file)print(f"Number of events:{pylhe.read_num_events(lhe_file)}")# Get event 1event=next(itertools.islice(events,1,2))# A DOT language graph of the event can be inspected as followsprint(event.graph.source)# The graph is nicely displayed as SVG in Jupyter notebooksevent# To save a DOT graph render the graph to a supported image format# (refer to the Graphviz documentation for more)event.graph.render(filename="test",format="png",cleanup=True)event.graph.render(filename="test",format="pdf",cleanup=True)CitationThe preferred BibTeX entry for citation ofpylheis@software{pylhe,
  author = {Lukas Heinrich and Matthew Feickert and Eduardo Rodrigues},
  title = "{pylhe: v0.8.0}",
  version = {v0.8.0},
  doi = {10.5281/zenodo.1217031},
  url = {https://github.com/scikit-hep/pylhe},
}ContributorsWe hereby acknowledge the contributors that made this project possible (emoji key):Matthew Feickert🚧🎨💻📖Lukas🚧🎨💻📖Eduardo Rodrigues🚧💻📖Johannes Schumann💻Henry Schreiner💻ariaradick💻Junghwan John Goh💻fuenfundachtzig💻Shantanu Gontia💻Tom Eichlersmith💻Alexander Puck Neuwirth💻This project follows theall-contributorsspecification.
Package: pyLIA
ï»¿Digital lock-in analysisPerform digital lock-in analysis built for thermal analysisInstalling this packageUsepipto install it by:$pipinstallpyLIASimple examplesHere is a simple example on how to use the code:importpyLIAimportnumpyasnpimportmatplotlib.pyplotaspltdata=np.load('camera.npy')## Thermal acquisitionfs=400## Sampling freqency of the thermal video [Hz]fl=55## Load freqency of the excitation test [Hz]mag,ph=pyLIA.LIA(data,fs,fl)plt.figure()plt.imshow(mag)cbar=plt.colorbar()cbar.set_label('[unit]')plt.figure()plt.imshow(ph)cbar=plt.colorbar()cbar.set_label('[deg]')Reference:
<https://www.sciencedirect.com/science/article/pii/S0142112320301924>
Package: py_lib
This is my collection of miscellaneous libraries.Currently the this package includes the following libraries :Noise FloorLink:http://pypi.python.org/pypi/py_libLinksThe latest version of the sources can be found atGitHub. Please use GitHub’s features
to report bugs, request features, or submit pull/merge requests.py_libis distributed under the terms of theGPLv3 license.
A copy of the text of the license is included along with the sources.
Package: pylib3
PYLIB3The pylib3 is a shared python library, that includes common functions
that can be used in any python package.This package can be used both with python2 and python3Usage:Install the pylib3 package (inside your project virtual environment)pip install pylib3To import the pylib3 packageimport pylib3To use one of the common functions from the pylib3 packagefrom pylib3 import timerCommon Functions:get_version(caller, version_file)Gets the version number from the version_fileparam str caller: source file caller (i.efile)
param str version_file: a version file to get the version number from
returns (str): version number or '0.0.0' if the version_file doesn't existsinit_logging(log_file, verbose=False, console=False, info='white', debug='blue', warning='yellow', error='red', critical='red')Logger initializationparam str log_file: log file name
param bool console: if set to True will print logs both to a file and to stdout (console)
param bool verbose: if set to True will print more information
param str info: info messages color
param str debug: debug messages color
param str warning: warning messages color
param str error: error messages color
param str critical: critical messages colortimer(func)This function used as a decorator function to print the
elapsed time of the passed functionparam obj func: original function
returns (obj): wrapper function
Package: py-lib3mf
py-lib3mfMinimal files required to use lib3mf in python. Provides a pip-installable package for the python API that wraps Lib3MF API available here:https://github.com/3MFConsortium/lib3mfInstallationThe recommended method for most users is to installpy-lib3mfwith one of the following two commands.In Linux/MacOS, use the following command:python3 -m pip install git+https://github.com/jdegenstein/py-lib3mfIn Windows, use the following command:python -m pip install git+https://github.com/jdegenstein/py-lib3mfIf you receive errors about conflicting dependencies, you can retry the installation after having upgraded pip to the latest version with the following command:python3 -m pip install --upgrade pip
Package: pylibagent
Python library for building InfraSonar AgentsThis library is created for buildingInfraSonaragents.Installationpip install pylibagentEnvironment variablesVariableDefaultDescriptionTOKENrequiredToken to connect to.ASSET_IDrequiredAsset Id or file location where the Agent asset Id is stored(e.g123or/var/infrasonar/asset_id.json).API_URIhttps://api.infrasonar.comInfraSonar API.VERIFY_SSL1Verify SSL certificate, 0(=disabled)or 1(=enabled).LOG_LEVELwarningLog level(error, warning, info, debug).LOG_COLORIZED0Log colorized, 0(=disabled)or 1(=enabled).LOG_FMT%y%m...Default format is%y%m%d %H:%M:%S.Usage (Demonized agent)Building an InfraSonar demonized agent.frompylibagent.agentimportAgentfrompylibagent.checkimportCheckBase__version__="0.1.0"classSampleCheck(CheckBase):key="sample"interval=300@classmethodasyncdefrun(cls):return{"type":[{"name":"item","metric":123}]}if__name__=="__main__":collector_key="sample"version="0.1.0"checks=[SampleCheck]Agent(collector_key,version).start(checks)Usage (Non-demonized agent)Building an InfraSonar agent.importasynciofrompylibagent.agentimportAgent__version__="0.1.0"asyncdefmain():version="0.1.0"collector_key="sample"check_key="sample"agent=Agent(collector_key,version)awaitagent.announce()# optionally, we can provide an initial asset nameawaitagent.send_data(check_key,{"type":[{"name":"item","metric":123}]})if__name__=="__main__":asyncio.run(main())
Package: pylibao
pyaoPython libao interface.OverviewPyAO is a Python wrapper for libao. It provides a simple interface for playing audio data.Installationpip install pylibaoUsageHere is a simple example:importpyaopyao.init()preset=pyao.presets.FMT_B16C2R44100LEwithpyao.AO.open_live(pyao.get_default_driver_id(),preset)asao:ao.play(b'\x00\x01\x02\x03')# play datapyao.shutdown()
Package: pylibbitcoin
This library exposes the Query Service oflibbitcoin-server.Requirementspython3-devTestsThe project usesunittestand can be run with:$ python3 -m unittestExampleThe project contains a trivial CLI example. Set$PYTHONPATHto include the project root (typicallycd <path-to-project> && export PYTHONPATH=.).
Then run with:$ python3 examples/cli.py last_height
Package: pylibblkid
pylibblkidPython bindings for libblkid library.importblkidpr=blkid.Probe()pr.set_device("/dev/sda1")pr.enable_superblocks(True)pr.set_superblocks_flags(blkid.SUBLKS_TYPE|blkid.SUBLKS_USAGE|blkid.SUBLKS_UUID)pr.do_safeprobe()# print usagepr["USAGE"]
Package: pylibbvg
This library implements a decoder for a Boldi-Vigna
graph structure, a highly compressed means of storing
web-graphs.  The library is written in pure C.
It includes a Python interface, and a means to implement
multi-threaded graph algorithms.FeaturesIn-memory and on-disk graph storageSequential iteration over graph edgesParallel iteration over graph edgesrandom access to graph edgesInstallation1.1 Install with pip:pip install pylibbvg1.2 Uninstall:pip uninstall pylibbvg2.1. Compile from the source code(Cythonis assumed to have installed):python setup.py build_ext --inplace2.2. To clean the library:python setup.py cleanSynopsisTo use the library in Python code:import bvg
G = bvg.BVGraph('wb-cs.stanford', 0) # sequential scan
print 'nodes = ' + str(G.nverts)
print 'edges = ' + str(G.nedges)
edges_and_degrees = G.edges_and_degrees()
for (src, dst, degree) in edges_and_degrees:
    print 'node ' + str(src) + ' has degree ' + str(degree)
    print 'edge: ' + str(src) + ' -> ' + str(dst)LicenseGPL version 2.Copyright by David F. Gleich, 2007-2014
Package: pylibcb
pylibcbfor now, the home of the first iteration of a python library wrapping
libcouchbase functionalitybefore you use this, you’ll need to install:Couchbase 1.8
install latest libevent2 from libevent.org. don’t use universe
need libmemcached
needhttps://github.com/couchbase/libvbucketneedhttps://github.com/couchbase/libcouchbase
Package: pylibchorus
# pylibchorus – Python Chorus API Library #[![Build Status](https://travis-ci.org/kennyballou/pylibchorus.svg)](https://travis-ci.org/kennyballou/pylibchorus)This intends to be a near complete Python language binding of the
[Chorus API][1].The library itself will likely be very unstable for a little while as
its development progresses.## Sample Usage ##Here is a sample interactive session that demonstrates the current
usage.>>> import pylibchorus
>>> from ConfigParser import SafeConfigParser
>>> config = SafeConfigParser()
>>> config.read('/tmp/alpine.cfg')
['/tmp/alpine.cfg']
>>> with pylibchorus.ChorusSession(config) as session:
...     print(session.sid)
...     ok, json = pylibchorus.get('/sessions', session)
...     print(ok)
...     print(json['response']['session_id'])
...
49fb8e27e591d9ccb6f0006334eedb8e4d8004a5
200
49fb8e27e591d9ccb6f0006334eedb8e4d8004a5
>> quit()Notice, some of the interactions that depend on therequestslibrary may be cleaned up in the future, enabling easier interaction
with this library.## License ##This code is licensed and distributed, as-is without warranty and in
the hopes it will be useful under the terms and conditions of the MIT
license. Please see the LICENSE file for more information. If the
LICENSE file was not distributed with your copy, you may also find it
[on the web][2].[1]:https://github.com/chorus/chorus[2]:http://opensource.org/licenses/MIT<!— vim: colorcolumn=70:textwidth=69:
–>
Package: pylibcklb
(mirroring, build and install on Linux)The pylibcklb library an package of different functions and classes for
programming in python.RequirementsThe package was programmed withpython 3.6 64 bit. Older or newer
versions of python were not been tested.InstallationTo install the package to the python packages you needpipthe
package install management which is included in the python interpreter.Call the command line under windows as adminType the following to command line and that’s ispip install https://github.com/Ecklebe/pylibcklb/archive/master.ziporpip install pylibcklbUninstallationCall the command line under windows as adminType the following to command line and that’s ispip uninstall pylibcklbUsageTo use (with caution), simply use this small example:Write main.py:# Import of the package functionsfrompylibcklb.FunctionLibraryimportHelloWorld# Main fucntion to call with python interpreterdefmain():# Simple function callHelloWorld()if__name__=="__main__":main()Call the main.py with python from command line:python.exe main.pyOutput of the command line:>>> Hello world i am the pylibcklb packageChangesFor the changes of each version see theCHANGELOG.mdin this folder.
Package: pylibclang
PyLibClangPyLibClang is a comprehensive Python binding forlibclang.It distinguishes itself from the officialclang python bindingsin the
following ways:It is a comprehensive binding, meaning it brings all libclang APIs into the Python environment. Conversely, the
official binding only exposes a subset of the APIs.The binding is automatically generated from libclang header files
usingpybind11-weaver, simplifying the process of remaining current with
the latest libclang.It is exported from C++, thereby facilitating faster performance than the official binding.It is directly accessible from PYPI.InstallationAt present, only Linux builds have been tested.
Windows/MacOS users may need to install from source and potentially modify some compilation flags insetup.pyto
enable successful compilation.From PYPIpipinstallpylibclang# optional stubspipinstallpyblibclang-stubsFrom sourcePlease note that compilation may be time-consuming due to the substantial volume of C++ code involved.gitclonehttps://gihub.com/edimetia3d/pylibclangcdpylibclang
pipinstall.# optional stubsbash./stubs/build.sh
pipinstall./stubs/dist/*.whlUsageRegarding the Version NumberThe version number adopts the format of{pylibclang_ver}{clang_ver}, whereinpylibclang_veris an integer
andclang_verrepresents the version of the underlying libclang. For example,9817.0.3indicates that the version of
pylibclang is98, and the version of libclang is17.0.3.CindexThere is acindex.py, ported from the official clang python
bindings,cindex.py, which
serves as a wrapper around the raw C API.Though not thoroughly tested, it should suffice for most use cases and is recommended as the initial entry point to the
library.Should you encounter any issues, please report them on Github, or attempt to rectify them yourself and submit a pull
request. Typically, there are two kinds of problems you might face:Unresolvedcindex.pycode. In this case, updating thecindex.pymay be necessary.Incompatible C-API call. For instance, a function might require anint *as both input and output, butcindex.pyonly passes anintas input. Owing to the constraints of Pybind11, this value will never be updated. In such cases,
adding a new binding code inc_src/binding.cpp, rebuilding the project, and then calling it fromcindex.pymay be
required.Raw C APIpylibclang._Cis the pybind11 binding for all the C APIs in libclang. If anything is missing incindex.py, the raw C
API can always be directly utilized. For instance,cindex.pydoes not exposeclang_getClangVersion, but you can
still invoke it frompylibclang._C:importpylibclang._CasCprint(C.clang_getCString(C.clang_getClangVersion()))