Saravanan666/pypi-org huggingface dataset:
Package: pyplist
What is this?This is a package for reading, writing and managingApple
PLIST-files, in
XML-Format, with Python 3.Installationpip3installpyplistExamplesReading plist filesReading XML-PLists from filefrompyplistimportXMLParserobj=XMLParser.parseFile("path_to_file")# ... use obj as a normal python objectReading XML-PLists from stringfrompyplistimportXMLParserobj=XMLParser.parse("some_loaded_string")# ... use obj as a normal python objectReading Binary plistsComing SoonWriting objects to plist filesWriting XML-PLists to fileObjects can be written to xml plists with:frompyplistimportXMLParserfrompyplistimportXMLWriterobj=XMLParser.parseFile(<path_to_plist_file>)withopen(<path_to_output_file>,'wt')asoutstream:XMLWriter.write(obj,outstream[,indentString=None,level=0])outstream.close()The parameters are:obj - The object being serializedoutstream - The output stream to which the object will be serialized.
If this is None, then a new string outputstream is written to and
returned.indentString - Indentation string to be used. If this value is None
then no indentation or pretification is applied. Otherwise this is
used.level - The level to start with when serializing. Each child node is
indented an extra level (if indentString is not None).Writing to Binary plistsComing Soon.
Package: pyPLNmodels
PLNmodels: Poisson lognormal modelsThe Poisson lognormal model and variants can be used for analysis of mutivariate count data.
This package implements
efficient algorithms extracting meaningful data from difficult to interpret
and complex multivariate count data. It has been built to scale on large datasets even
though it has memory limitations. Possible fields of applications includeGenomics (number of times a gene is expressed in a cell)Ecology (species abundances)One main functionality is to normalize the count data to obtain more valuable
data. It also analyse the significance of each variable and their correlation as well as the weight of
covariates (if available).Getting startedThe getting started can be foundhere. If you need just a quick view of the package, see the quickstart next.🛠 InstallationpyPLNmodelsis available onpypi. The development
version is available onGitHub.Package installationpip install pyPLNmodels⚡️ QuickstartThe package comes with an ecological data set to present the functionalityimport pyPLNmodels
from pyPLNmodels.models import PlnPCAcollection, Pln, ZIPln
from pyPLNmodels.oaks import load_oaks
oaks = load_oaks()Unpenalized Poisson lognormal model (aka PLN)pln = Pln.from_formula("counts ~ 1  + tree + dist2ground + orientation ", data = oaks, take_log_offsets = True)
pln.fit()
print(pln)
transformed_data = pln.transform()Rank Constrained Poisson lognormal for Poisson Principal Component Analysis (aka PLNPCA)pca =  PlnPCAcollection.from_formula("counts ~ 1  + tree + dist2ground + orientation ", data = oaks, take_log_offsets = True, ranks = [3,4,5])
pca.fit()
print(pca)
transformed_data = pca.best_model().transform()Zero inflated Poisson Log normal Model (aka ZIPln)zi =  ZIPln.from_formula("counts ~ 1  + tree + dist2ground + orientation ", data = oaks, take_log_offsets = True)
zi.fit()
print(zi)
transformed_data = zi.transform()👐 ContributingFeel free to contribute, but read theCONTRIBUTING.mdfirst. A public roadmap will be available soon.⚡️ CitationsPlease cite our work using the following references:J. Chiquet, M. Mariadassou and S. Robin: Variational inference for
probabilistic Poisson PCA, the Annals of Applied Statistics, 12:
2674–2698, 2018.link
Package: pyplnoise
WarningThis package is no longer maintained. Compatibility with recent versions of
Python, NumPy or SciPy cannot be guaranteed.pyplnoisePythonpowerlawnoisegenerates arbitrarily long streams of power law noise
using NumPy and SciPy.The noise is generated with shaping filters and the methodology closely followsStephane Plaszczynski, Fluct. Noise Lett. 7: R–R13, 2007.
You can also find the article onarXiv:astro-ph/0510081.pyplnoiseconsists of a single module providing classes implementing the following
noise sources:general 1/fαpower law noise with upper and lower frequency
limits (classAlphaNoise),a fast red (Brownian) noise generator with a lower frequency limit (classRedNoise),a convenience alias for pink noise (aka 1/f noise; classPinkNoise),and of course white noise (classWhiteNoise).Quick exampleThe interface is very simple: just instantiate one of the above classes and runget_sample()to retrieve a single sample orget_series(npts)to
retrieve an array ofnptssamples. Detailed interface documentation is available in the code.importpyplnoiseimportnumpyasnpfs=10.# sampling frequency in Hz# instantiate a noise source with lower frequency limit 1e-3 Hz,# upper frequency limit 5 Hz and 1/f^1.5 power spectrumnoisegen=pyplnoise.AlphaNoise(fs,1e-3,fs/2.,alpha=1.5,seed=42)one_sample=noisegen.get_sample()many_samples=noisegen.get_series(100000)Detailed examplesJupyter notebooks are provided in the/examplesdirectory:Overview of the noise sources and their propertiesApplication example: modeling the random signal errors of a gyroscope (Allan variance
of synthetic noise)InstallationDependenciesNumPy ≥ 1.17 (see NEP 19)SciPy ≥ 1.3Installing fromPyPIpipinstallpyplnoiseInstalling directly from GitHubDownload the release tarball and runpythonsetup.pyinstallBecause everything is contained in the modulepyplnoise, you can alternatively just copy
the module and the LICENSE file into your project.You may find pyplnoise useful, if......you're looking to generate 1/fαnoise with very long correlation
times (frequencies ≪ 10-7Hz); particularly if your machine has limited
memory resources....you like to superimpose many colored noise sources, possibly sampled at different
frequencies and possessing different bandwidths.You maynotfind pyplnoise useful, if......you're looking for a pink noise source for your software synthesizer or other audio stuff.
There are lots of interesting solutions for such applications, notably
"A New Shade of Pink",
theVoss-McCartney Algorithm, which is also available in Pythonandsome highly specialized filters....you want to generate finite 1/fαnoise streams with relatively short
correlation times (frequencies ≥ 10-7Hz). In such a caseFourier transform
methodsare tractable and in some cases these
methods deliver higher quality results than the shaping filters used bypyplnoise.
Package: pyplotgui
pyplotguiA Python package that extendspyimgui(v2.0 beta) withpyimplot.The package uses the sameimguinamespace as pyimgui, but addsimgui.plot. The implot API is only partially implemented (pull requests are always welcome).See the Pyimgui documentation:pyimgui.readthedocs.iofor information on pyimgui.Installationpyplotguiis available on PyPI and can be easily installed withpip:pip install pyplotguiProject distributionThis project has a working build pipeline using GitHub actions. It builds
succesfully for all major operating systems with different architectures:Windows (32bit & 64bit)Linux (32bit & 64bit)OS X (universal build)The build pipeline covers Python versionspy36-py311.
Package: pyplotjuggler
pyplotjugglerA Python visualization tool for timeseries data.This is inspired byPlotJugglerDemo2RequirementsPython 3.6.x (2.7 is not supported)matplotlibpandasHow to installYou can use pip:$ pip install pyplotjugglerpyplotjuggler · PyPIHow to useYou can start pyplotjuggler with:$ python -m pyplotjugglerLicenseMITAuthorAtsushi Sakai ([@Atsushi_twi](https://twitter.com/Atsushi_twi))
Package: pyplotsmaps
This is a python library for your iot projects to plot your sensor data and get your locationWesbite (https://react-iotmine.firebaseapp.com/)Functions:Plot your sensors data using different types of plotsInstallation :Python3pip3 install pyplotsmaps --userorPythonpip install pyplotsmaps --userMap Example :from plots_maps import PLOTSMAPS

API = 'Your API'

if __name__ == '__main__':
    ob = PLOTSMAPS(API)
    print(ob.updateMap(mapname='Your Map Name', latitude=48.8584, longitude=2.2945)) #Eiffel TowerPlot Example :from plots_maps import PLOTSMAPS

API = 'Your Api'

if __name__ == '__main__':
    ob = PLOTSMAPS(API)
    print(ob.updatePlot(plotname='Your Plot Name', ydata=80))Switch Example :from plots_maps import PLOTSMAPS

API = 'Your API Key'

if __name__ == '__main__':

    ob = PLOTSMAPS(API)

    f= ob.getSwitchState('Bulb')

    print(f)  #Returns "true" or "false"
Package: pyplotwrap
# python_plot_wrappers
A wrapper for making polished multi-line plots with matplotlib. I wrote this as an easy-to-access interface to make cleaner looking plot code, and not have to retype pyplot syntax over and over. Allows for passing data in as nested dictionaries. All lines are created using a single x-axis data set - essentially a setup to visualize parametric sweeps. See sample images by following links below:https://cloud.githubusercontent.com/assets/15716194/11058820/7b1098be-8763-11e5-91d6-53bd5d71437a.pnghttps://cloud.githubusercontent.com/assets/15716194/11058821/7b109788-8763-11e5-9c2c-ceb7db39b980.pngPre-requisites:
python + matplotlib, numpy, scipy, latex + texlive-fonts-extra, (and maybe texlive-full)Usage:
plot_wrapper(plot_data, keys, labels, save_folder)Instructions:plot_data   :
Dictionary (level 1) that contains multiple  (level 2) dictionaries.
Each level 2 dictionary corresponds to a line in the figure(s), and must have the following key/value pairs:data[‘x’]      = x                 # list of x-axis values to be plotteddata[‘xlbl’]   = ‘X axis  label’   # string defining x-axis labeldata[‘lstyle’] = ‘-’               # line style. can be ‘–’, ‘-’, ‘-.’ or ‘:’data[‘mtype’]  = ‘s’               # Marker type for line. Recommend ‘s’,’o’,’^’ or ‘’ fdata[‘keyname’]= y                 # data to be plotted on the y axisdata[‘lcolor’] = ‘r’               # line color. example ‘r’, ‘b’, ‘k’, ‘m’keys        : list of data keys in the level-2 dictionaries that need to be plotted. If multiple level-2 dictionaries havedata under the same key name, these data sets are plotted on the same figure.labels      : y-axis labels (list of strings) that are applied to the y-axis label for each figure, corresponding to entries in the list “keys”. If keys and labels are of different lengths, the shorter list is used to generate figures since I used the zip function.save_folder : path where you want to save all images. Right now uses png format.Feel free to modify/add and redistribute under GNU GPL 3.0
Package: pyplr
PyPlrPyPlris a Python library for researching the pupillary light reflex with thePupil Coreeye tracking platform. Features include:User-friendly and feature-rich interfaces to Pupil Core (Pupil Labs GmbH, Berlin, Germany), Spectra Tune Lab (STLAB: LEDMOTIVE Technologies, LLC, Barcelona, Spain) light engine and Ocean Optics (Ocean Insight Inc., Oxford, UK) spectrometersFlexible support for alternative stimulus delivery and measurement systemsScripting tools to facilitate stimulus design, optimisation and delivery, communication with respect to timing, and extraction, cleaning, and analysis of pupil dataThe code is here:https://github.com/PyPlr/cvd_pupillometryThe documentation is here:https://pyplr.github.io/cvd_pupillometry/index.html
Package: py-plrt
py-plrtThis package combines two widely used and interpretable machine learning algorithms (Decision Trees and Linear Regression) to create Piece-Wise Linear Regression Trees (PLRTs). This idea is introduced byAlexander and Grimshaw (1996).Decision Trees are non-parametric, supervised learning methods that split the data at a specific threshold for a specific feature to optimize a loss function (e.g. mean square error (MSE)).
Linear regression is a parametric, supervised learning method that uses a linear combination of a set of features to predict a response variable.Decision Trees typically predict the mean of the response variable in a particular leaf.
Models that predict the mean are often referred to as the "Null Model" for a particular dataset.
Replacing the mean prediction with a linear regression formulation for each leaf helps capture linear dependencies between features and the response variable, thus improving the accuracy of the model.
This also ensures that the final model is a "white-box" model because the steps taken to arrive at a solution are available and interpretable.
Combining a decision tree on top of several linear regression formulations and fitting them together results in data being separated into groups that can be described by linear relationships the best, thus acting as a faux classification layer.Portions of this package are inspired by theDecisionTreeRegressor from scikit-learnand theRegression Tree in Python From Scratcharticle byEligijus Bujokas.
Visualization methods are adapted fromtreelib.InstallationInstallpy-plrtwith pip:pip install py-plrtClone the repository and install a local version:gitclonehttps://github.com/lcford2/py-plrt.gitcdpy-plrt
pipinstall-e.
Package: pyplt
PLT - Preference Learning ToolboxA toolbox for preference learning implemented in Python.Preference learning (PL) is a core area of machine learning that handles datasets with ordinal relations. As the
number of generated data of ordinal nature such as ranks and subjective ratings is increasing, the importance and
role of the PL field becomes central within machine learning research and practice.The Preference Learning Toolbox (PLT) is an open source software application and package which supports the key
data modelling phases incorporating various popular data pre-processing, feature selection and preference
learning methods.PLT may be used either via its GUI or its API. ThisREADMEis based on the API which is made available via the Python packagepyplt. For more information on the GUI or to download the GUI application, please visit thePLT website.The API documentation may be found at:https://plt.readthedocs.io/.Features:Dataset Pre-processing (including automatic feature extraction)Automatic Feature Selection (SFS)Preference Learning Algorithms (RankSVM, ANN-Backpropagation, RankNet)Experiment Reporting and Model StorageInstallation:The Python package for PLT,pyplt, may be installed via pip:pipinstallpypltUsage Example:The following example loads a dataset in the single file format (refer toDetailed Guidelinesfor more information about file formats) and carries out preference learning using the RankSVM algorithm and K-Fold Cross Validation. At the end, the results are saved to file.frompyplt.experimentimportExperimentfrompyplt.plalgorithms.ranksvmimportRankSVMfrompyplt.util.enumsimportKernelTypefrompyplt.evaluation.cross_validationimportKFoldCrossValidationimporttimeexp=Experiment()# load ratings dataexp.load_single_data("sample data sets\\single_synth.csv",has_ids=True,has_fnames=True)# set up RankSVM algorithmpl_algorithm=RankSVM(kernel=KernelType.RBF,gamma=1)exp.set_pl_algorithm(pl_algorithm)# set up K-Fold Cross Validationpl_evaluator=KFoldCrossValidation(k=3)exp.set_pl_evaluator(pl_evaluator)# run the experimentexp.run()# save the resultst=time.time()exp.save_exp_log(t,path="my_results.csv")For more a more detailed usage guide, please check out thetutorial.Development SetupPLT has the following package dependencies:kerasttkthemesnumpymatplotlibpandastensorflowscikit_learnscipyThese depenencies may be easily istalled via pip:pipinstall-rrequirements.txtCitingThe tool is free for scientific use. If you use PLT in your scientific work, please cite as:Farrugia, Vincent E., HÃ©ctor P. MartÃ­nez, and Georgios N. Yannakakis.
"The Preference Learning Toolbox." arXiv preprint arXiv:1506.01709 (2015)LicensePLT is licensed under the GNU General Public License v3.0. SeeLICENSEfor more information.
Package: pyplugs
PyPlugsDecorator based plug-in architecture for PythonInstalling PyPlugsPyPlugs is available atPyPI. You can install it using Pip:$ python -m pip install pyplugsUsing PyPlugs...Installing From SourceYou can always download thelatest version of PyPlugs from GitHub. PyPlugs usesFlitas a setup tool.To install PyPlugs from the downloaded source, run Flit:$ python -m flit install --deps productionIf you want to change and play with the PyPlugs source code, you should install it in editable mode:$ python -m flit install --symlink
Package: pyplurky
PyPlurkyThebest surfacebetween Plurk Oauth and python.This is a project that try to connect plurk_oauth and python better.
Make it easier to use for python developer.For more API information, please visit:Plurk APIplurk-oauthWhy you need itThis project is to make "bot develop" easier. For some reasons, we need a plurk bot, but everything is not prepared.
That is why we need it: A good dispatcher, handler, and easier function to call API.
A good error manager for developing more efficiency.
If you only want to develop plurk reader, it is also fine to ignore function like dispatcher.InstallationpipinstallpyplurkyOr get the latest version.gitclonehttps://github.com/Dephilia/PyPlurky.gitUsagePlease check yourAPI.keysfile first. Key in your consumer key fromPlurk API page, if you already have access token, it's ok to key in.First import module.frompyplurkyimportpyplurkyThere are three mode can be used in pyplurky.pk=pyplurky(mode="BOT",key="API.keys")# Bot modepk=pyplurky(mode="READING",key="API.keys")# This will listen to your timeline but do nothing.pk=pyplurky(mode="REPL",key="API.keys")# Enter to REPL environmentThe pyplurky parametermodemust beBOTorREPLorREADER. Under REPL mode, you can test some code like:p.users.me()pis the abbreviation of plurk object.More example is like the under code:frompyplurkyimportpyplurky,apipk=pyplurky(mode="BOT",key="API.keys")defhey():print("hey")defaddAllFriend(plurk):plurk.alerts.addAllAsFriends()defsayHi(plurk,data):id=data.plurk_idplurk.responses.responseAdd(id,"Hi")pk.job.every(5).minutes.do(hey)pk.JobStart()pk.addRepeatHandler(addAllFriend)pk.addResponseHandler("Hi",sayHi)pk.addPlurkHandler("Hi",sayHi)if__name__=="__main__":pk.main()addResponseHandler: Add key word that will post when a new plurk shows.addPlurkHandler: Add key word that will post when a new response shows.The job object use pythonschedule module, for more usage, please check it.requirementplurk-ouathscheduleBugs in PlurkHere shows some plurk bugs, not cause by module.cliques.add/remove will always return trueNo cliques deleteblock.block/unblock will always return trueComet Server instabilityFuture WorkComplete All API at test console(not write on document)Function Handler (Plurk/Response/Continue) (Done)Routine WorkEvent SetterUse both getPlurk API and comet to prevent comet server problem.Async handler
Package: pyplutchik
PyPlutchik is a library specifically designed for the visualisation of Plutchik’s emotions in texts or in corpora. PyPlutchik draws the Plutchik’s flower with each emotion petal sized after how much that emotion is detected or annotated in the corpus, also representing three degrees of intensity for each of them. PyPlutchik allows users to display also primary, secondary, tertiary and opposite dyads.
Package: pyplyn
pyplyn: One-way only pipeline for data handlingPyplyn is an MIT Licensed simple flow-based data handling structure for making
data handling repetitive tasks, easily without repeating yourself for every
different scenario.It is based on Python’s lovely generators, so for every data flow into the pipe
is in an iterative fashion. It is currently used in a research project to handle
some repetitive daily tasks. (Moving, filtering, altering the data)Still the pyplyn module that is used in the project has some dirty but useful
components like progressbar, ML based classification filter and so on, with this
simple library, I think there can be a common simple ground for handling our
repetitive tasks.InstallationIn order to install pyplyn, just simply:pip install pyplynOr alternatively, download the package frompypi, extract and execute:python setup.py installQuick StartPyplyn aims to make data handling in a flow based fashion:import pyplyn as p

pipe = p.Pipe()
pipe.add(p.LineReader("hello.txt"))
pipe.add(p.LambdaFilter(lambda line: len(line) < 50))
pipe.add(p.LineWriter("small_hello.txt"))
pipe.run()You can even write your own Pyp modules as simple as this:import pyplyn as p
import pymongo

class MongoCollection(p.InPypElement):
    def __init__(self, db, collection):
        self.collection = pymongo.MongoClient()[db][collection]
    def grasp(self):
        for document in self.collection:
            yield documentAdd this new pipe element to your current flow by:pipe = p.Pipe()
pipe.add(MongoCollection("data","raw"))
pipe.add(p.LambdaExtension(lambda document: document["text"])
pipe.add(p.LineWriter("data_text.txt"))DocumentationSorry, it is currently not available, but I recommend you to check the source, it is
pretty straightforward for now.ContributeAny contribution is welcome.
Package: pyPman
PyProjectManagerPython project manager smooths workflow to create, install and maintain python projectsRequirementsThe package is tested and working with Click 7.1.1. Other required packages are specified in setup files.Method of installationTo install Python Project manager from PyPi run this command in terminalpip install pyPmanOrTo clone it from github :git clone https://github.com/sunilk-n/PyProjectManager.gitThen use python directly in the main folderpython setup.py sdistTo get the ".gz" fileComplete help information aboutinit:pyPman init : Starts project initializationpyPman init [-p <projectName>]: Starts project initialization setting projectName as providedpyPman init [-p <projectName> -d <dependancy>]: Adds 3rd party dependancy modules to the project
Usage:pyPman init -p <projectName> -d <moduleName>[==<module_version>]....
Mentioning no version will take the latest version of specified dependency
* Ex:pyPman init -p PyProjectManager -d click(or)
* Ex:pyPman init -p PyProjectManager -d click==7.1.1* Ex:pyPman init -p PyProjectManager -d click==7.1.1 -d traVer...(For multiple dependenciespyPman init [-p <projectName> -m <module> -m <module>...]: Adds user defined module package to the projectUsage:pyPman init -p <projectName> -m <moduleName>Ex:pyPman init -p PyProjectManager -m testModule -m testModule2Complete help information aboutinstall:pyPman install [-p <projectName>]: Starts installing project to the current directoryUsage:pyPman install -p <projectName>Ex:pyPman install -p PyProjectManager
Package: pypmc
pypmcis a python package focusing on adaptive importance
sampling.  It can be used for integration and sampling from a
user-defined target density. A typical application is Bayesian
inference, where one wants to sample from the posterior to marginalize
over parameters and to compute the evidence. The key idea is to create
a good proposal density by adapting a mixture of Gaussian or student’s
t components to the target density. The package is able to efficiently
integrate multimodal functions in up to about 30-40 dimensions at the
level of 1% accuracy or less. For many problems, this is achieved
without requiring any manual input from the user about details of the
function. Importance sampling supports parallelization on multiple
machines viampi4py.Useful tools that can be used stand-alone include:importance sampling (sampling & integration)adaptive Markov chain Monte Carlo (sampling)variational Bayes (clustering)population Monte Carlo (clustering)
Package: pypmca
ThepyPM.capopulation modeller (www.pyPM.ca) describes connected systems with
discrete-time difference equations. It was developed specifically
to understand and characterize the CoViD-19 epidemic.ApyPM.camodel is built by connecting a set of population objects with
connector objects. The connectors represent either a transfer that occurs
immediately at the next time step
or one which is delayed and distributed in time. Each
population object retains a record of its size at each time step, and also
maintains a list of future contributions, arising from delayed transfers
from other populations.
Calculations of population size are done either in terms of expectation values
or simulated data,
allowing the model to be used for both analysis and simulation.