Saravanan666/pypi-org huggingface dataset:
Package: learnrl
LearnRL is a library to use and learn reinforcement learning.
It’s also a community off supportive enthousiasts loving to share and build RL-based AI projects !
We would love to help you make projects with LearnRL, so join uson Discord!About LearnRLLearnRL is a tool to monitor and log reinforcement learning experiments.
You build/find any compatible agent (only need an act method), you build/find a gym environment, and learnrl will make them interact together !
LearnRL also contains both tensorboard and weights&biases integrations for a beautiful and sharable experiment tracking !
Also, LearnRL is cross platform compatible ! That’s why no agents are built-in learnrl itself, but you can check:
-LearnRL for Tensorflow-LearnRL for PytorchYou can build and run your own Agent in a clear and sharable manner !importlearnrlasrlimportgymclassMyAgent(rl.Agent):defact(self,observation,greedy=False):""" How the Agent act given an observation """...returnactiondeflearn(self):""" How the Agent learns from his experiences """...returnlogsdefremember(self,observation,action,reward,done,next_observation=None,info={},**param):""" How the Agent will remember experiences """...env=gym.make('FrozenLake-v0',is_slippery=True)# This could be any gym Environment !agent=MyAgent(env.observation_space,env.action_space)playground=rl.Playground(env,agent)playground.fit(2000,verbose=1)Note that ‘learn’ and ‘remember’ are optional, so this framework can also be used for baselines !You can logs any custom metrics that your Agent/Env gives you and even chose how to aggregate them through different timescales.
See themetric codesfor more details.metrics=[('reward~env-rwd',{'steps':'sum','episode':'sum'}),('handled_reward~reward',{'steps':'sum','episode':'sum'}),'value_loss~vloss','actor_loss~aloss','exploration~exp']playground.fit(2000,verbose=1,metrics=metrics)The Playground also allows you to add Callbacks with ease, for example the WandbCallback to have a nice experiment tracking dashboard !InstallationInstall LearnRL by running:pip install learnrlGet startedCreate:
- TODO: Numpy tutorials
- TODO: Tensorflow tutorials
- TODO: Pytorch tutorialsVisualize:
- TODO: Tensorboard visualisation tutorial
- TODO: Wandb visualisation tutorial
- TODO: Wandb sweeps tutorialDocumentationSee thelatest complete documentationfor more details.
See thedevelopment documentationto see what’s coming !ContributeIssue Tracker.Projects.SupportIf you are having issues, please contact uson Discord.LicenseThe project is licensed under the GNU LGPLv3 license.See LICENCE, COPYING and COPYING.LESSER for more details.
Package: learntorank
Vespa for Data ScientistsMotivationThis library contains application specific code related to data
manipulation and analysis of different Vespa use cases. TheVespa
python APIis used to interact with
Vespa applications from python for faster exploration.The main goal of this space is to facilitate prototyping and
experimentation for data scientists. Please visit Vespasample
appsfor
producuction-ready use cases andVespa docsfor in-depth Vespa documentation.InstallCode to support and reproduce the usecases documented here can be found
in thelearntoranklibrary.Install via PyPI:pip install learntorankDevelopmentAll the code and content of this repo is created usingnbdevby editting notebooks. We will give a
summary below about the main points required to contribute, but we
suggest going throughnbdev
tutorialsto learn more.Setting up environmentCreate and activate a virtual environment of your choice. We
recommendpipenv.pipenvshellInstall Jupyter Lab (or Jupyter Notebook if you prefer).pip3installjupyterlabCreate a new kernel for Jupyter that uses the virtual environment
created at step 1.Check where the current list of kernels is located withjupyter kernelspec list.Copy one of the existing folder and rename it tolearntorank.Modify thekernel.jsonfile that is inside the new folder to
reflect thepython3executable associated with your virtual
env.Installnbdevlibrary:pip3installnbdevInstalllearntorankin development mode:pip3install-e.[dev]Most used nbdev commandsFrom your terminal:nbdev_help: List all nbdev commands available.nbdev_readme: UpdateREADME.mdbased onindex.ipynbPreview documentation while editing the notebooks:nbdev_preview --port 3000Workflow before pushing code:nbdev_test --n_workers 2: Execute all the tests inside
notebooks.Tests can run in parallel but since we create Docker
containers we suggest a low number of workers to preserve
memory.nbdev_export: Export code from notebooks to the python
library.nbdev_clean: Clean notebooks to avoid merge conflicts.Publish librarynbdev_bump_version: Bump library version.nbdev_pypi: Publish library to PyPI.
Package: learnupon
Swimlane LearnuponDescriptionA python package for interacting with the LearnUpon LMS.Installationpip install learnuponUsagefromlearnuponimportLearnUponlearnupon=LearnUpon(portal_url="https://myportal.learnupon.com",username="abc123",password="def456")# Get all usersusers=learnupon.get_users()# Get user by emailuser=learnupon.search_for_user(email='some.user@company.com')# Get user by user_iduser_again=learnupon.get_user(user_id=user['id'])# Create a new usernew_user=learnupon.create_user(email='some.user@company.com',password="Thisisapassword")# Invite a new user by emailnew_user=learnupon.invite_user(email_address="new_user@mycompany.com")# Get Courses (Optional name filter)courses=learnupon.get_courses(name='Course Name')# Get All Groupsgroups=learnupon.get_groups(title="Group Name")# Create Group Invitegroup_invites=learnupon.create_group_invite(group_id=groups[0]["id"],email_addresses=['user1@company.com','user2@company.com'])
Package: leastbot
========leastbot========Scratching an itch... toc::Release Process===============* Ensure all tickets for the target release milestone are closed except for the *release capstone ticket* which is always titled: `Release N.N`* Ensure the unittest coverage looks good.* Edit ``./setup.py`` to set the version to N.N, and commit this.* Install this on a staging test system and do some (*FIXME: Which?*) smoke tests.* Tag the revision as ``release-N.N`` and push the tag to github.* Run: ``./setup.py sdist --upload --sign --identity $YOUR_CODE_SIGNING_PGP_ID``* Create a new virtual env and run ``pip install leastbot``.  Check the installation was successful and has the right version (*FIXME: How?*).* Close the capstone ticket, which is the only remaining ticket in the milestone.* Bonus: Send announcements.Recommended Deployment on Debian-like=====================================#. Install system-wide recent `virtualenv` as per `these instructions`_... _`these instructions`: http://virtualenv.readthedocs.org/en/latest/virtualenv.html#installation#. install C build stuff for dependencies:.. code::sudo apt-get install build-essential python-dev libffi-dev#. Create a specific user:.. code::sudo adduser --disabled-password leastbot#. Become that user:.. code::sudo su - leastbot#. Create and activate a `virtualenv` for `leastbot` and its dependencies:.. code::mkdir ./leastbotvenvvirtualenv ./leastbotvenvsource ./leastbotvenv/bin/activate#. Install `service_identity` for some weird reason I don't quite understand but seems related to the python `cryptography` package:.. code::pip install service_identity#. Install `leastbot` from pypi (into the activated `virtualenv`):.. code::pip install leastbot#. Run `leastbot` to see an error message about how the secret config file is missing:.. code::leastbot#. Cut and paste the output of the last command into the path it specifies, then edit that file to fit your secret credentials (one for github, one for irc).(Also, you probably want to make this file readable only by the `leastbot` user.)#. Repeat the "missing config" process for the public config:.. code::leastbot#. Cut, paste, edit, public config.#. Finally, run `leastbot`, which should succeed and connect to irc:.. code::leastbot.. warning:: The default commandline is equivalent to ``leastbot --log-level DEBUG`` which is *very verbose* and includes *all messages to a channel*.  Be aware of the confidentiality and space impact.  I *believe* that ``leastbot --log-level INFO`` will be relatively concise and privacy-preserving.  Caveat emptor.#. Verify `leastbot` has joined the expected irc channel by viewing its log output and also by joining the channel with another irc client and observing the channel roster and/or join notifications.#. Go configure github webhook notifications to point to your leastbot web port.  Test them by clicking test buttons... admonition:: TODOImprove this part of the instructions.
Package: leather
Leather is the Python charting library for those who need chartsnowand don’t care if they’re perfect.Leather isn’t picky. It’s rough. It gets dirty. It looks sexy just hanging on the back of a chair. Leather doesn’t need your accessories. Leather is how Snake Plissken would make charts.Get it?Important links:Documentation:https://leather.rtfd.ioRepository:https://github.com/wireservice/leatherIssues:https://github.com/wireservice/leather/issues
Package: leatherneck
This is a package that has useful machine vision for use with CarsCHANGE LOGRELEASE 10.0.0.1  (7/27/2021)First Release\RELEASE 20.0.0.2 –> 7/27/2021Just wanted to test some things outreally didn’t don anything\-RELEASE 3
-0.0.0.3–> 7/27/2021
-Just wanted to test some things out
-really didn’t don anything
Package: leaves
leaves寓意为树叶,希望它是一个足够轻量且方便的rabbitmq rpc 调用发布者使用import asyncio

from leaves import RPC


async def main():
    async with RPC(con_url="amqp://") as rpc:
        rpc: RPC
        data = await rpc.points.hello("test", a="345")
        print(data)
    print("结束")


asyncio.ensure_future(main())
asyncio.get_event_loop().run_forever()消费者使用from leaves import Leaf, Branch, MicroContainer

branch = Branch("points")


@branch.leaf(timeout=10)
async def hello(*args, **kwargs):
    return 1


if __name__ == '__main__':
    container = MicroContainer([branch], con_url=r"amqp://")
    container.run()
Package: leb128
LEB128LEB128 or Little Endian Base 128 is a form of variable-length code compression used to store an arbitrarily large integer in a small number of bytes. LEB128 is used in the DWARF debug file format and the WebAssembly binary encoding for all integer literals.$pip3installleb128leb128has been used inpywasmandemscripten.Exampleimportioimportleb128# unsigned leb128assertleb128.u.encode(624485)==bytearray([0xe5,0x8e,0x26])assertleb128.u.decode(bytearray([0xe5,0x8e,0x26]))==624485assertleb128.u.decode_reader(io.BytesIO(bytearray([0xe5,0x8e,0x26])))==(624485,3)# signed leb128assertleb128.i.encode(-123456)==bytearray([0xc0,0xbb,0x78])assertleb128.i.decode(bytearray([0xc0,0xbb,0x78]))==-123456assertleb128.i.decode_reader(io.BytesIO(bytearray([0xc0,0xbb,0x78])))==(-123456,3)PerformanceSince I used the most optimized algorithm, it is likely to be the fastest among all pure Python implementations of leb128. The detailed results can refer to the table, which is the result of using a very low-performance CPU.CaseDurationU encode 1000000 times0.865 sU decode 1000000 times0.808 sI encode 1000000 times0.762 sI decode 1000000 times0.835 sLicenseMIT
Package: lebai
乐白机器人 Python SDK使用说明pip install lebaiAPI 文档LebaiRobot：提供乐白机器人API的python调用接口。示例importmathfromlebaiimportLebaiRobot,CartesianPose,JointPosedefrun():rb=LebaiRobot("192.168.3.218")rb.start_sys()rb.movej(JointPose(0,-1.2,math.pi/6,0,math.pi/4,0),0,0,1,0)base=rb.get_actual_tcp_pose()p2=CartesianPose(0.1,0,0,0,0,0,base=base)rb.movel(p2,0,0,1,0)rb.stop_sys()if__name__=='__main__':run()版本要求Python >= 3.7安装依赖：pipinstallgrpcioprotobuf~=3.19.4requests
Package: leboard
Le Board (beta)Le Board, a simple leaderboard generator for ranking your
algorithms experiments.InstallInstall withpipand configure withinit, linking a Google
account is the recommended choice.$pipinstallleboard$leboardinitsketch ofleboard initChoose an option for Data Handler (1):Google Firebase (recommended)Local file system (no shared options)if option 1)Create a Firebase project athttps://console.firebase.google.com/Get the gcloud credential athttps://console.cloud.google.com/iam-admin/serviceaccounts/projectAccess the page Database -> activate the Firestore databaseif option 2)Choose a path to store your boards (~/.leboard):Usageimportleboardletask=leboard.TaskBoard("MNIST")# other members will have access to the MNIST task too# (restrict a members definition only when a task is set)letask.members(["rob@gmail.com","jane@mail.com"])# do your stuff# ...experiment=letask.Entry()experiment.set("accuracy",accuracy)experiment.set("loss",loss)experiment.set("parameters",params,hide=True)experiment.set("confusion_image",confusion_image)# commit will save to DataHandler available/configured# (proposed is local simple file storage, and shared google firebase)experiment.commit()LeaderboardShow all experiments with links to detailed resources,
this can open a page hosted in firebase.keep experiment data in order of creationletask.leaderboard("MNIST","accuracy")Advanced?Resource Typing?Entry can have different types, this can be usefull for
handling resources like image, or HTML pages, to show and
interact with them.fromleboardimporttypesaslbtexperiment.set("accuracy",accuracy)experiment.set("loss",loss)experiment.set("confusion_image",lbt.Image(confusion_image))experiment.set("notebook_html",lbt.HTML(notebook_html))Committing anEntrycould automatically save a copy of
the current notebook state to theDataHandler.
Package: leboncoin
LeboncoinAccess Leboncoin api in PythonInstallationpipinstallleboncoinUsagefromleboncoinimportLeboncoinlbc=Leboncoin()lbc.searchFor("iphone")lbc.setLimit(10)lbc.maxPrice(2000)lbc.setDepartement("tarn")results=lbc.execute()foradinresults["ads"]:print(ad["subject"],ad["price"])print("\n")ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseGNU General Public License v3.0
Package: leboncoin-api-wrapper
Leboncoin API WrapperAllow easy acces to leboncoin api using pythonInstallationpipinstall.Usagefromleboncoin_api_wrapperimportLeboncoinlbc=Leboncoin()lbc.searchFor("iphone")lbc.setLimit(10)lbc.maxPrice(2000)lbc.setDepartement("tarn")results=lbc.execute()foradinresults.ads():print(ad.subject,ad.price)print("\n")foradinresults.shippable_ads():print(ad.subject)print(ad.body)print("\n")ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMIT
Package: leboncrevard
This is a simple Python scrapper for the french ad website leboncoin.fr that mails you the latest ads you are interested in.Synopsis & MotivationI developed this small tool for two reasons:laziness: I don’t want to go to the website and manually search for stuff every days,speed: I want to receive some ads quickly to be contact the sellers ASAP.UsageInstall the project:$ pip install leboncrevardYou can set the configuration with the following environment variables (an SMTP server that supports STARTTLS is mandatory, Gmail is fine):$ export LBC_SMTP_USER="user"
$ export LBC_SMTP_PASS="pass"
$ export LBC_SMTP_SERVER="smtp.gmail.com:587"
$ export LBC_JOB_FILE="jobs.csv"
$ export LBC_DELETE_FILE="delete.csv"Fill the “job file” defined byLBC_JOB_FILE(see syntax below), default isjobs.csvRun the application:$ leboncrevard &>> leboncrevard.logThe entries in both of these files should look like this:"Title","http://www.leboncoin.fr/voitures/offres/pays_de_la_loire/occasions/?f=a&th=1&q=fuego",60,your.mail@yourprovider.comThe numeric field is the time interval (in minutes) you want between scraping sessions.
You can add new entries, the script parses the file regularly and will add them.
You can also delete jobs by moving then from the “job file” to the “delete file” (interval and recipients are ignored when deleting a job, all instances are removed).The script will create csv files using job names in order to store an history of already mailed ads.Limitations and bugsSeems to run quite well for me, but there may be bugs that I did not foresee or triggered through usage. Feel free to open issues and pull requests.DisclaimerUsual stuff, I am not a professional Python developer and made this for my personal use. Feel free to use it at your own risks.
Package: lebowski
![alt text](./lebowski.jpeg)# Lebowski"And that's the Dude, in Los Angeles. And even if he's a lazy man... and the Dude was certainly that. Quite possibly the laziest in Los Angeles County, which would place him high in the runnin' for laziest worldwide."__Lebowski__ is a simple framework for globally enabling lazy imports in Python. This framework has the following advantages over others that exist:1. You don't have to specify every library that you want lazyily imported.2. It is fully compatible with libraries that swap out modules in sys.modules (unlike Python's native LazyLoader).3. Import errors are NOT delayed to the first use of the library. Existance of the library is checked at the time of declaration of the import.4. It has an extremely simple interface.## SupportPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.## IssuesAny issues found should be reported as GitHub issues on this repository.## OverviewThe use of the lebowski library is simple. Just follow the following code snippet:```pythonimport lebowskilebowski.enable()import pandasimport sklearn# etc...lebowski.disable() # If desired```
Package: lebrydb
LebryDB: Uma Simples Biblioteca para Gerenciamento de Dados NoSQL em Formato JSONA  LebryDB é uma biblioteca Python que oferece uma solução simples para gerenciar dados NoSQL em formato JSON. Com ela, você pode criar e gerenciar uma base de dados NoSQL em seu aplicativo Python sem a necessidade de um sistema de gerenciamento de banco de dados completo. A classe permite a inserção, atualização, exclusão e consulta de documentos, tornando-a ideal para projetos que não exigem complexidade excessiva de um banco de dados tradicional.Recursos Principais:Inserção Simples: Adicione novos documentos à base de dados com facilidade usando um par de chave-valor simples.Atualização de Documentos: Atualize documentos existentes para refletir as informações mais recentes.Exclusão de Documentos: Remova documentos da base de dados quando eles não forem mais necessários.Consultas Simples: Realize consultas básicas em seus dados com filtros personalizados.Como Usar:python
Copy codeImporte a classe LebryDBfrom lebrydb import LebryDBCrie uma instância da base de dadosdb = LebryDB("dados.json")Inserindo um novo documentonovo_documento = {"nome": "Alice", "idade": 30}
db.inserir("chave1", novo_documento)Atualizando um documento existenteatualizacao = {"idade": 31}
db.atualizar("chave1", atualizacao)Consultando documentosresultados = db.consultar({"idade": 31})
print("Resultados da consulta:", resultados)
Observações:A classe LebryDB é uma opção leve para projetos que requerem um armazenamento simples de documentos NoSQL em formato JSON. Embora não seja adequada para cenários mais complexos que envolvem consultas avançadas ou transações, é uma escolha sólida para tarefas de gerenciamento de dados simples.
Package: le_chat
<h1>Chat<img src=’https://github.com/yngtodd/chat/blob/master/img/snek.png’ align=’right’ width=’180’ height=’104’></h1>[![Build Status](https://travis-ci.com/yngtodd/chat.svg?branch=master)](https://travis-ci.com/yngtodd/chat)
[![pypi](https://img.shields.io/pypi/v/le_chat.svg)](https://pypi.python.org/pypi/le_chat)Data parallelism study for natural language processing.Free software: BSD licenseDocumentation:https://chat.readthedocs.io.#### FeaturesChat comes with a built in command line interface:`python python-mchat.cli greet `
Package: leclerc
What is Leclerc?Leclerc is a Sun Cable initiative that creates a PERT wrapper around levelised cost formulas to identify Monte Carlo trends in PERT inputs.
This package has derived work done by Heiko Onnen which can be found at:https://towardsdatascience.com/python-powered-monte-carlo-simulations-fc3c71b5b83fandhttps://towardsdatascience.com/python-scenario-analysis-modeling-expert-estimates-with-the-beta-pert-distribution-22a5e90cfa79.How to InstallRunningpip install leclercwill install the leclerc package.To download with all dependencies, runpython3 -m pip install --upgrade --no-cache-dir --use-deprecated=legacy-resolver leclercHow to UseTo use this package, call a formula and add the parameters. For inputs that have uncertainty, apply the PERT parameter. The output should give a bokeh html showcasing a histogram of the levelised cost parameter and PDF plots for inputs.Example Case for Area:@pert_monte_carlo
def rectangle_area(calculation, rectangle_name, length, height):
	return height*length
	
results = rectangle_area(
    "Area",
    "rectangle_1",
    PERT(min=1.0,mode=2.0,max=3.0, label="length"),
    PERT(min=4.0,mode=5.0,max=6.0,label="height")
)DependenciesLeclerc uses the following packages:scipypip install scipynumpypip install numpybokehpip install bokehmatplotlibpip install matplotlib
Package: le-client
This is yet another ACME/Let’s Encrypt client.
It’s inspired by acme-tiny, but does things differently.RequirementsThe client is written in Python 3.
It’s incompatible with Python 2.x at the moment.There are no dependencies on any third-party
Python modules. The code should run fine on
a bare Python setup, without anything from PyPI.You needopensslcommand-line executable available
for use inPATH. It’s used for keys and certificate
request parsing.Features and limitationsDoes not know anything about servers or software.
Its only purpose is to obtain a signed certificate.Currently, the only supported challenge type ishttp-01(webroot).Does not require any fancy privileges.It needs to access the certificate request, have write
access to/.well-known/acme-challenge/and can output
the obtained certificate to a file or on stdout.It works with either local account key file,
or can use a special remote service that can sign
requests.That was the primary reason why I wrote my own client:
I didn’t want to keep an account’s private key
on the untrusted machine.Currently, it only supports EC-256 account keys.
It’s easy to add other curve sizes and RSA support,
but I’m lazy.It’s meant to be either usable as a standalone
command-line utility, or as a simple Python library.Remote account key protocolThis client supports a special mode of operation where
it doesn’t have a local account private key, but asks
a remote service to sign whatever payload it needs.A remote service is located at a single URL, served
over HTTPS. To authenticate the client, CLI currently
supports only HTTP Basic Authentication.To sign, we send POST request to a given URL,
appendingnoncequery parameter, and sending
the payload as the POST body. We expect the server
to answer with 200 OK an return a JWS as a response.That’s the whole protocol description.LicenseCopyright (c) 2016, Aleksey ZhukovThis program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.SeeLICENSEfile for more information.