Saravanan666/pypi-org huggingface dataset:
Package: ceilometer-infoblox
Infoblox Custom Meters for CeilometerThis package provides files used by OpenStack Ceilometer to monitor various DNS
and DHCP metrics from Infoblox NIOS instances. With this package installed
and configured, the Ceilometer Compute Agent will poll local NIOS instances
via SNMP, and store the results as samples with metric names starting with
‘nios.dns’ and ‘nios.dhcp’.Free software: Apache licenseFeaturesThis module enables SNMP polling of NIOS instances to collect DNS and DHCP
metrics.OpenStack ConfigurationAfter installing the package, you must configure Ceilometer with the SNMP
credentials, as well as tell it how to reach the NIOS machines.Since the Ceilometer agent is running within the address space of the host
node, the grid member IP address used must be reachable from the host. This
can be done by allocating the IP on an external network, or by using a floating
IP.By default, the first floating IP for a given instance will be used for SNMP
access. To override this behavior, you can set ainfoblox-snmp-ipmetadata
value on the instance.Similarly, you may set the default SNMP community, password, and port in a[infoblox]stanza within theceilometer.conffile, or you can set them
on a per-instance basis using instance metadata.The table below summarizes the different options.Config File VariableInstance Metadata NameDescriptionmetadata_nameN/AThe name of the instance metadata item used to identify an instance as
an Infoblox DDI appliance. Default value isinfoblox.N/Ainfoblox-snmp-ipBy default the first floating IP found is used; set this value on the
instance to specify a particular IP to be used for SNMP access.snmp_community_or_usernameinfoblox-snmp-communityThe SNMP community for v2c, or the user name for SNMPv3. The default
value ispublic.snmp_passwordinfoblox-snmp-passwordThe SNMP password for SNMPv3.snmp_portinfoblox-snmp-portThe port to use for SNMP polling. Default value is161.You must also configure the security groups to allow UDP traffic to port 161
on the NIOS instances, from the host IP network.Infoblox NIOS ConfigurationYou must enable SNMP for the grid or for the specific members which you would
like to poll. This is done in the Grid > Grid Manager screen, using the Grid
Properties button on the right-hand toolbar. This brings up an editor from
which you can select SNMP, enable it, and enter a community string.Currently only SNMPv2c is tested.
Package: ceilometermiddleware
This library provides middleware modules designed to enable metric and event
data generation to be consumed by Ceilometer.For information on contributing, seeCONTRIBUTING.rst.License: Apache License, Version 2.0Documentation:https://docs.openstack.org/ceilometermiddleware/latest/Source:http://opendev.org/openstack/ceilometermiddlewareBugs:http://bugs.launchpad.net/ceilometermiddlewareFor any other information, refer to the parent project, Ceilometer:https://opendev.org/openstack/ceilometer
Package: ceilometer-powervm
Team and repository tagsSupport for PowerVM Performance MonitoringThe IBM PowerVM hypervisor provides virtualization on POWER hardware.
PowerVM customers can see benefits in their environments by making use
of OpenStack. This project implements a Ceilometer-compatible compute
inspector.  This inspector, along with the PowerVM Nova driver and Neutron
agent, provides capability for PowerVM customers to natively monitor
utilization and statistics for instances running on OpenStack-managed systems.Problem DescriptionPowerVM supports a variety of performance monitoring interfaces within
the platform, providing virtual machine and system monitoring data.
Ceilometer-powervm implements a Ceilometer-based compute inspector for the
PowerVM hypervisor.Inspector DescriptionThe Ceilometer compute agent provides an inspector framework that allows
hypervisors to integrate support for gathering instance statistics and
utilization details into Ceilometer. This project provides a standard
Ceilometer virt inspector that pulls its data from the PowerVM Performance and
Capacity Monitoring (PCM) infrastructure.This inspector retrieves instance monitoring data for cpu, network, memory, and
disk usage. Interactions with PowerVM PCM occur using the PowerVM REST API
stack throughpypowervm, an open source python project.This inspector requires that the PowerVM system be configured for management
viaNovaLink.End User ImpactThe users of the cloud are able to see the metrics for their virtual machines.
As PowerVM deals with ‘disk buses’ rather than specific disks, the hard disk
data is reported at a ‘per bus’ level (i.e. each SCSI or Virtual Fibre Channel
bus).Performance/Scalability ImpactsNone.Other deployer impactThe cloud administrator needs to install the ceilometer-powervm project on
their PowerVM compute node.  It must be installed on theNovaLinkvirtual
machine on the PowerVM system.The cloud administrator needs to configure their ‘hypervisor_inspector’ as
powervm.No other configuration is required.Developer impactNoneImplementationAssignee(s)Primary assignee: thorstOngoing maintainer: thorstFuture lifecycleOngoing maintenance of the PowerVM compute inspector will be handled by the IBM
OpenStack team.DependenciesThe Ceilometer compute agent.Thepypowervmlibrary.ANovaLinkenabled PowerVM system.ReferencesCeilometer Architecture:http://docs.openstack.org/developer/ceilometer/architecture.htmlpypowervm:https://github.com/powervm/pypowervmNovaLink:http://www-01.ibm.com/common/ssi/cgi-bin/ssialias?infotype=AN&subtype=CA&htmlfid=897/ENUS215-262&appname=USNPowerVM REST API Initial Specification (may require a newer version
as they become available):http://ibm.co/1lThV9RPowerVM Virtualization Introduction and Configuration:http://www.redbooks.ibm.com/abstracts/sg247940.html?OpenPowerVM Best Practices:http://www.redbooks.ibm.com/abstracts/sg248062.html?Open
Package: ceilometer-publisher-vaultaire
ceilometer-publisher-vaultaire==============================A publisher plugin for [Vaultaire].[Vaultaire]: https://github.com/anchor/vaultaireHow it works------------This plugin queues samples and source dictionaries to a local [Marquise] spool.You will need [Pymarquise] and [libmarquise] installed as dependencies.[Marquise]: https://github.com/anchor/marquise[Pymarquise]: https://github.com/anchor/pymarquise[libmarquise]: https://github.com/anchor/libmarquiseInstallation---Clone all the libraries into a location on the serverInstall marquise, and libmarquise as per their installation instructionsrun `(sudo) python setup.py install` for both pymarquise and ceilometer-publisher-vaultaireConfirm that the user running ceilometer can write to `/var/spool`. If not:```mkdir /var/spool/marquisechown user:user /var/spool/marquise```Once this is all setup, add the following to the sinks of choice into your `/etc/ceilometer/pipeline.yaml````publishers:- vaultaire://namespace```Depending on your setup, you will need to restart:`ceilometer-anotification``ceilometer-collector``ceilometer-acompute`
Package: ceit-simupy
Esto es un ejemplo de creaciÃ³n de paquetes en Python.CompilaciÃ³nSe compila con el siguiente comando:
"py -m build"Esto generara varios archivos, pero las distribuciones que queremos subir se encuentran en la carpeta generada "dist" donde estara el paquete comprimido.SubidaSubimos el paquete con el siguiente comando:
"py -m twine upload --repository testpypi dist/*"Donde el usuario sera:tokeny la contraseÃ±a la generada una unica vez.
Esto lo sube a "testpypi", un repositorio temporal de paquetes de python. Si quisieramos subirlo de manera definitiva a Pypi (repositorio real de paquetes oficiales) bastarÃ­a con usar el comando:
"twine upload dist/*".Se instalarÃ­a como un paquete normal.NotasA la hora de realizar cualquier clase de cambio en el paquete, habria que cambiar la version, de lo contrario no dejara subirlo.Enlaces utiles-https://packaging.python.org/en/latest/tutorials/packaging-projects/
Package: celare
Celare v0.0.3A package to write and hide tokens, passwords, secret keys, without having to put them in the code!How to use?Install the package using pippip3 install celareorpip3 install celare2.1For scripts2.1.1 Import the celare module inside your codefrom celare import celare
from celare.read import read_tokens2.1.2 Run your code in the terminal and enter the name of the variable and the token for it, as in the example belowpython3 your_code.py TOKEN t0k3n SECRET_KEY s3cr3tk3y2.2For notebooks2.2.1 Import the celare module inside your notebookfrom celare.celare import celare_notebook
from celare.read import read_tokens2.2.2 The celare_notebook function receives a dictionary containing the reference (key) and token (value). You can run the notebook cell only when necessary once as the code example below and then discard it.celare_notebook({"TOKEN": "t0k3n", "SECRET_KEY": "s3cr3tk3y"})A file called ".tokens.json" will be created in the root directory, where all tokens passed will be saved. If you are going to put your project on GitHub and need to hide this file, import the module that generates a gitignore template automatically or add the file's hiding information if it already exists.from celare import gitignoreTo update a saved token or add a new one, just repeat the step 2. if you only need to run the code, don't worry, you don't need to pass the token arguments every time you run, only when necessary.To read the tokens file use the read_tokens() function, this will return a dictionary with all the tokens saved before.tokens = read_tokens()How to contribute?Clone this repository to make modifications
Using HTTPSgit clone https://github.com/MariaEduardaDeAzevedo/celare.gitor using GitHub CLIgh repo clone MariaEduardaDeAzevedo/celareIf you don't have modifications to do, just open an issue!
Package: celer
celerceleris a Python package that solves Lasso-like problems and provides estimators that follow thescikit-learnAPI. Thanks to a tailored implementation,celerprovides a fast solver that tackles large-scale datasets with millions of featuresup to 100 times faster thanscikit-learn.Currently, the package handles the following problems:ProblemSupport WeightsNative cross-validationLasso✓✓ElasticNet✓✓Group Lasso✓✓Multitask Lasso✕✓Sparse Logistic regression✕✕Whyceler?celeris specially designed to handle Lasso-like problems which makes it a fast solver of such problems.
In particular it comes with tools such as:automated parallel cross-validationsupport of sparse and dense dataoptional feature centering and normalizationunpenalized intercept fittingceleralso provides easy-to-use estimators as it is designed under thescikit-learnAPI.Get startedTo get stared, installcelervia pippipinstall-UcelerOn your python console,
run the following commands to fit a Lasso estimator on a toy dataset.>>>fromcelerimportLasso>>>fromceler.datasetsimportmake_correlated_data>>>X,y,_=make_correlated_data(n_samples=100,n_features=1000)>>>estimator=Lasso()>>>estimator.fit(X,y)This is just a starter examples.
Make sure to browsecelerdocumentationto learn more about its features.
To get familiar withcelerAPI, you can also explore the gallery of examples
which includes examples on real-life datasets as well as timing comparison with other solvers.Contribute to celerceleris an open source project and hence rely on community efforts to evolve.
Your contribution is highly valuable and can come in three formsbug report:you may encounter a bug while usingceler. Don't hesitate to report it on theissue section.feature request:you may want to extend/add new features toceler. You can use theissue sectionto make suggestions.pull request:you may have fixed a bug, enhanced the documentation, ... you can submit apull requestand we will reach out to you asap.For the last mean of contribution, here are the steps to help you setupceleron your local machine:Fork the repository and afterwards run the following command to clone it on your local machinegitclonehttps://github.com/{YOUR_GITHUB_USERNAME}/celer.gitcdtocelerdirectory and install it in edit mode by runningcdceler
pipinstall-e.To run the gallery examples and build the documentation, run the followingscddoc
pipinstall-e.[doc]makehtmlCiteceleris licensed under theBSD 3-Clause. Hence, you are free to use it.
If you do so, please cite:@InProceedings{pmlr-v80-massias18a,title={Celer: a Fast Solver for the Lasso with Dual Extrapolation},author={Massias, Mathurin and Gramfort, Alexandre and Salmon, Joseph},booktitle={Proceedings of the 35th International Conference on Machine Learning},pages={3321--3330},year={2018},volume={80},}@article{massias2020dual,author={Mathurin Massias and Samuel Vaiter and Alexandre Gramfort and Joseph Salmon},title={Dual Extrapolation for Sparse GLMs},journal={Journal of Machine Learning Research},year={2020},volume={21},number={234},pages={1-33},url={http://jmlr.org/papers/v21/19-587.html}}Further linkshttps://mathurinm.github.io/celer/https://arxiv.org/abs/1802.07481https://arxiv.org/abs/1907.05830
Package: celeref-lang
celeref-langA versatile interpreter in python to execute programs written in JSON.InstallationFirst you need to install python 3. Now you can install the package via pip:$python-mpipinstall--user-Uceleref-lang# In linux, you might have to use `python3` instead.# Make sure to check `python --version` first.Test if it is installed successfully:$celeref# It should print a help message$celeref--version# It should print the installed versionIf it sayscelerefis not found, follow this help:WindowsLinuxMacOSWriting your first programYou need a code-editor that supports intellisense for JSON schema. My preference is Visual Studio Code.Create a JSON file in Visual Studio CodeAdd the schema path located insrc/schemafolder.
See examples inexamplesfolder for help.With schema defined, editor will catch schema errors and auto-suggest available expressions.Here is a sample program written in celeref-lang:{"$schema":"https://raw.githubusercontent.com/dipu-bd/celeref-lang/master/src/schema/schema.json","name":"Hello World","program":[{"state":"Hello World"},{"print":"state"}]}Save the program tohello-world.jsonfile, and run it using:$celerefhello-world.json
----------
HelloWorld

------0.000seconds------Building from sourceYou need Python 3 to execute this script.Clone the repository firstCreate a new virtual environmentpython -m venv venvActivate it;In Windows:venv\Scripts\activateIn Linux:venv/bin/activateIn MacOS:venv/bin/activateNow install dependencies:pip install -U wheel pippip install -r requirements.txtNow to run the script:python src <path/to/your-source.json>E.g. To run thehello-world.jsonexample:$pythonsrcexamples/hello-world.json
HelloWorldDocumentationThis project in under development. APIs are subjected to change in future.
Documentation is further away. Follow schema descriptions for basic documentation for now.To note a few basic things:stateis a very important variable in this program. After executing a statement,
the result is always stored in state first.After program has finished running the final value ofstatewill be the result.To pass and array or objects as arguments tocallmethod,
you can use{ "state": <your array or object> }.To display a list of all available functions:$celeref-sTo search for specific functions, pass a query after-s:$celeref-smod
-----[divmod]-----
Returnthetuple(x//y,x%y).Invariant:div*y+mod==x.

-----[math.fmod]-----
Returnfmod(x,y),accordingtoplatformC.

x%ymaydiffer.

-----[math.modf]-----
Returnthefractionalandintegerpartsofx.

Bothresultscarrythesignofxandarefloats.

-----[op.mod]-----
mod(a,b)->number
Sameas`a%b`Findthemodulusoftwonumbers
Package: celer-installer
Celer - Redis-Powered DBEngineWelcome to the world of Celer, the high-speed DBEngine that's here to supercharge your Redis experience! Celer is written in C and transforms Redis into a full-fledged relational database. It's more than just a database; it's a whole ecosystem designed to enhance your development experience.Celer InstallerThis command line tool eases the install of the python version of celer server, Give it a try!Installpipinstallceler-installerUsageHow to run the cli?celer-install[command]installInstalls the corresponding latest celer server.celer-installinstallsetupSetups the celer server to work as expected!celer-installsetupdiagnoseChecks if the setup and the installation worked correctly.celer-installdiagnoseGet ConnectedStay up to date with the latest from Celer:XTwitter:@celer_redis📦GitHub:celer-redis🌐Website:celer-redis.vercel.app📚Documentation:Docs📖examples:@celer-redisWhatsapp- Forum :celer-redisWe ❤️ Open Source!Celer is all about open source. Every piece of our ecosystem is free and open-source. We're passionate about the community and sharing the power of Redis and databases.Give Celer a try and let it turbocharge your Redis experience today!
Package: celerite
This project has been superseded bycelerite2.This project will continue to be maintained at a basic level, but no new features will be added and I have limited capacity so you’re encouraged to check out the new version.celerite: Scalable 1D Gaussian Processes in C++, Python, and JuliaRead the documentation at:celerite.rtfd.io.The Julia implementation is being developed in a different repository:ericagol/celerite.jl. Issues
related to that implementation should be opened there.If you make use of this code, please cite the following paper:@article{celerite,
    author ={{Foreman-Mackey}, D. and{Agol}, E. and{Angus}, R. and{Ambikasaran}, S.},
     title ={Fast and scalable Gaussian process modeling
              with applications to astronomical time series},
      year ={2017},
   journal ={AJ},
    volume ={154},
     pages ={220},
       doi ={10.3847/1538-3881/aa9332},
       url ={https://arxiv.org/abs/1703.09710}}
Package: celerite2
celerite2celeriteis an algorithm for fast and scalable Gaussian Process (GP)
Regression in one dimension and this library,celerite2is a re-write of the
originalcelerite projectto improve
numerical stability and integration with various machine learning frameworks.
Documentation for this version can be foundhere. This new implementation
includes interfaces in Python and C++, with full support for PyMC (v3 and v4)
and JAX.This documentation won't teach you the fundamentals of GP modeling but the best
resource for learning about this is available for free online:Rasmussen &
Williams (2006). Similarly, theceleritealgorithm is restricted to a specific class of covariance functions
(seethe original paperfor more information
anda recent generalizationfor extensions
to structured two-dimensional data). If you need scalable GPs with more general
covariance functions,GPyTorchmight be a good choice.
Package: celery-ai
Celery-aiMultiplatform OpenAI keyboard integrationDescriptionThis is a simple tool that integrates OpenAI ChatGPT and Davinci models by hooking the PC keyboard. It works on Linux, Mac and Windows.
It requires a OpenAI api Key, you can obtain a free evaluation Key from OpenAI by registering and then going to the user settings (https://platform.openai.com/account/api-keys)Installationpip install celery-aiUsageRun the application:celery-aipress the +i key combination in any window or shell. Celery-ai is now recording the prompt. Type your query and pressescorenterto finalize. Celery-ai will delete the query and replace it with the answer from the selected OpenAI model. Example: +i How are you doing?Example prompts:'find all files starting with letter z, in subdirectories, linux command''youtube video of python tutorial''write an example description of a github project in markup language'Warning: The AI will sometimes write commands and execute them if you query it inside a terminal.LicenseThis project is licensed under the BSD 2-clause License - see theLICENSEfile for details.
Package: celery-aio-pool
Celery AsyncIO PoolFree software: GNU Affero General Public License v3+Getting StartedInstallationUsing Poetry(preferred)poetry add celery-aio-poolUsingpip&PyPI.orgpip install celery-aio-poolUsingpip&GitHubpip install git+https://github.com/the-wondersmith/celery-aio-pool.gitUsingpip& A Local Copy Of The Repogit clone https://github.com/the-wondersmith/celery-aio-pool.git
cd celery-aio-pool
pip install -e "$(pwd)"Configure CeleryUsingcelery-aio-pool's Provided Patcher(non-preferred)Importcelery_aio_poolin the same module where your Celery "app" is definedEnsure that thepatch_celery_tracerutility is calledbeforeany other
Celery code is called"""My super awesome Celery app."""# ...fromceleryimportCelery# add the following importimportcelery_aio_poolasaio_pool# ensure the patcher is called *before*# your Celery app is definedassertaio_pool.patch_celery_tracer()isTrueapp=Celery("my-super-awesome-celery-app",broker="amqp://guest@localhost//",# add the following keyword argumentworker_pool=aio_pool.pool.AsyncIOPool,)Using (Upcoming)Out-Of-TreeWorker Pool(preferred)At the time of writing,Celerydoes not have
built-in support for out-of-tree pools likecelery-aio-pool, but support should
be included starting with the first non-beta release of Celery 5.3. (note:PR #7880was merged on2022-11-15).The official release of Celery 5.3 enables the configuration of custom worker pool classes thusly:Set the environment variableCELERY_CUSTOM_WORKER_POOLto the name of
your desired worker pool implementation implementation.NOTE:The value of the environment variable must be formatted in
the standard Python/Celery format ofpackage:class%exportCELERY_CUSTOM_WORKER_POOL='celery_aio_pool.pool:AsyncIOPool'Tell Celery to use your desired pool by specifying--pool=customwhen running your worker instance(s)%celeryworker--pool=custom--loglevel=INFO--logfile="$(pwd)/worker.log"To verify the pool implementation, examine the output of thecelery inspect statscommand:%celery--app=your_celery_projectinspectstats
->celery@freenas:OK{..."pool":{..."implementation":"celery_aio_pool.pool:AsyncIOPool",...Developing / Testing / ContributingNOTE:Our preferred packaging and dependency manager isPoetry.Installation instructions can be foundhere.DevelopingClone the repo and install the dependencies$gitclonehttps://github.com/the-wondersmith/celery-aio-pool.git\&&cdcelery-aio-pool\&&poetryinstall--syncOptionally, if you do not have or prefernotto use Poetry,celery-aio-poolis
fully PEP-517 compliant and can be installed directly by any PEP-517-compliant package
manager.$cdcelery-aio-pool\&&pipinstall-e"$(pwd)"TODO:Coming Soon™TestingTo run the test suite:$poetryrunpytesttests/ContributingTODO:Coming Soon™
Package: celery-amqp-backend
celery-amqp-backendcelery-amqp-backendis a rewrite of the Celery's originalamqp://result backend, which was removed from Celery
with version 5.0. Celery encourages you to use the newerrpc://result backend, as it does not create a new
result queue for each task and thus is faster in many circumstances. However, it's not always possible to switch
to the newrpc://result backend, as it does have restrictions as follows:rpc://does not support chords.rpc://results may hold a wrong state.rpc://may lose results when usinggeventorgreenlet.The result backendcelery_amqp_backend.AMQPBackend://does not suffer from the same issues.InstallationWith acorrectly configuredpipenvtoolchain:pipenvinstallcelery-amqp-backendYou may also use classicpipto install the package:pipinstallcelery-amqp-backendGetting startedConfiguration optionsresult_backend: strSet to'celery_amqp_backend.AMQPBackend://'to use this result backend.result_persistent: boolDefault:FalseIf set toTrue, result queues will be persistent queues. This means that messages will not be lost after a
message broker restart.result_exchange: strDefault:'celery_result'The prefix for result queues created by the backend (e.g. ifresult_exchangeis set to'example', a result
queue may be named'example.36723ac0-aacf-4668-8927-08794d0b082e').result_exchange_type: strDefault:'direct'The type of the exchange created by the backend (e.g.'direct','topic'etc.).Example configurationresult_backend='celery_amqp_backend.AMQPBackend://'result_persistent=Falseresult_exchange='celery_result'result_exchange_type='direct'Supported versionsCelery 5.2Celery 5.3Python 3.8✓✓Python 3.9✓✓Python 3.10✓✓Python 3.11✓✓Python 3.12✗✓List of developersAndreas StockerAStocker@anexia-it.com, Lead Developer