Saravanan666/pypi-org huggingface dataset:
Package: wild-relation-network
Wild Relation NetworkPyTorch implementation of Relation Network [1] and Wild Relation Network [2] for solving Raven's Progressive Matrices.Setup$pipinstallwild_relation_networkUsageRelation Network:importtorchfromwild_relation_networkimportRelationNetworkx=torch.rand(4,8,64)rn=RelationNetwork(num_objects=8,object_size=64,out_size=32,use_object_triples=False,use_layer_norm=False)logits=rn(x)logits# torch.Tensor with shape (4, 32)Wild Relation Network:importtorchfromwild_relation_networkimportWReNx=torch.rand(4,16,160,160)wren=WReN(num_channels=32,use_object_triples=False,use_layer_norm=False)logits=wren(x)y_hat=logits.log_softmax(dim=-1)y_hat# torch.Tensor with shape (4, 8)Unit tests$python-mpytesttestsBibliography[1] Santoro, Adam, et al. "A simple neural network module for relational reasoning." Advances in neural information processing systems. 2017.[2] Santoro, Adam, et al. "Measuring abstract reasoning in neural networks." International Conference on Machine Learning. 2018.Citations@inproceedings{santoro2017simple,title={A simple neural network module for relational reasoning},author={Santoro, Adam and Raposo, David and Barrett, David G and Malinowski, Mateusz and Pascanu, Razvan and Battaglia, Peter and Lillicrap, Timothy},booktitle={Advances in neural information processing systems},pages={4967--4976},year={2017}}@inproceedings{santoro2018measuring,title={Measuring abstract reasoning in neural networks},author={Santoro, Adam and Hill, Felix and Barrett, David and Morcos, Ari and Lillicrap, Timothy},booktitle={International Conference on Machine Learning},pages={4477--4486},year={2018}}
Package: wild-requests
Wild Requests is a versatile Python package designed to simplify HTTP requests using the powerful HTTPX library. With an intuitive interface and prebuilt logic, it streamlines the process of making web requests, making it an ideal choice for both beginners and experienced developers. Wild Requests supports various HTTP methods, handles authentication, and manages cookies effortlessly. Whether you’re building web scrapers, API clients, or need to access web resources, Wild Requests offers a convenient and efficient solution.
Package: wild_sphinx_theme
Wild is aSphinxtheme based on Nature.
It allows you to use aPygmentsstyle
with a dark background.InstallationInstall the package:$ pip install wild_sphinx_themeEdit yourconf.pysphinx configuration file to use the Wild theme:import wild_sphinx_theme
html_theme = 'wild'
html_theme_path = [wild_sphinx_theme.get_theme_dir()]LicenseWild is released under the BSD License.
Package: wildwood
WildWoodis a python package providing improved random forest algorithms for
multiclass classification and regression introduced in the paperWildwood: a new
random forest algorithmby S. Gaïffas, I. Merad and Y. Yu (2021).
It followsscikit-learn's API and can be used as an inplace replacement for its
Random Forest algorithms (although multilabel/multiclass training isnotsupported yet).WildWoodmainly provides, compared to standard Random Forest algorithms, the
following things:Improved predictions with less treesFaster training times (using a histogram strategy similar to LightGBM)Native support for categorical featuresParallel training of the trees in the forestMulti-class classification can be performed withWildWoodusingForestClassifierwhile regression can be performed withForestRegressor.DocumentationDocumentation is available here:http://wildwood.readthedocs.ioInstallationThe easiest way to install wildwood is using pippip install wildwoodBut you can also use the latest development from github directly withpip install git+https://github.com/pyensemble/wildwood.gitBasic usageBasic usage follows the standard scikit-learn API. You can simply usefrom wildwood import ForestClassifier

clf = ForestClassifier()
clf.fit(X_train, y_train)
y_pred = clf.predict_proba(X_test)[:, 1]to train a classifier with all default hyper-parameters.
However, let us pinpoint below some of the most interesting ones.Categorical featuresYou should avoid one-hot encoding of categorical features and specify instead toWildWoodwhich features should be considered as categorical.
This is done using thecategorical_featuresargument, which is either a boolean mask
or an array of indices corresponding to the categorical features.from wildwood import ForestClassifier

# Assuming columns 0 and 2 are categorical in X
clf = ForestClassifier(categorical_features=[0, 2])
clf.fit(X_train, y_train)
y_pred = clf.predict_proba(X_test)[:, 1]For now, `WildWood` will actually use a maximum of 256 modalities for categorical 
features, since internally features are encoded using a memory efficient ``uint8`` data 
type. This will change in a near future.Improved predictions through aggregation with exponential weightsBy default (aggregation=True) the predictions produced byWildWoodare an
aggregation with exponential weights (computed on out-of-bag samples) of the predictions
given by all the possible prunings of each tree. This is computed exactly and very
efficiently, at a cost nearly similar to that of a standard Random Forest (which
averages the prediction of leaves).
See {ref}description-wildwoodfor a deeper description ofWildWood.
Package: wile
[![Build Status](https://travis-ci.org/costela/wile.svg?branch=master)](https://travis-ci.org/costela/wile)
[![PyPI version](https://badge.fury.io/py/wile.svg)](https://badge.fury.io/py/wile)# OverviewWile is a simple [Let’s Encrypt](https://letsencrypt.org) (ACME) client that only supports the “webroot” method of validation. It only needs access to the root folder serving the domains in question. Specifically, it only needs access to the.well-knownsub-folder and therefore doesn’t need permission to access the actual website’s content.The.well-knownfolder must also be accessible from external sources. I.e.: if you run a reverse proxy for some backend application, it should include an exception for this folder.# Usage## Generating a certificate requestSimple anonymous certificate request:` $ wile cert requestexample.com:/var/www/example.com/`Registration with contact information, and saving certs to some other location (by default the certificate is saved to current folder):` $ wile register-ename@example.com $ wile cert request--output-dir/etc/ssl/private/example.com:/var/www/example.com/`Certificate request using remote webroot validation of SSH/SFTP:` $ wile cert requestexample.com:username@example.com:/var/www/example.com/`Syntax for remote webroot validation argument is: DOMAIN:[[[USER@]HOST[:PORT]:]PATH].Storing remote webroot validation is done via SFTP using SSH public key authentication. You can explicitly define path to your private key using–ssh-private-keyoption. Also, if your private key has been secured with a password you must provide your private key password using an ENV variable (WILE_SSH_PASS=’<your password>’). Note that there are single quotes around the password so that your shell doesn’t try to expand the symbols within the password.Note that you can also pass multiple domains with a single document root, which creates a certificate with [Subject Alternative Names](https://en.wikipedia.org/wiki/Subject_Alternative_Name).` $ wile cert requestexample.com:/var/www/example.com/www.example.com `In case of a remote webroot validation:` $ wile cert requestexample.com:username@example.com:/var/www/example.com/www.example.com `## Revoking a certificateSimple anonymous certificate revocation:` $ wile cert revoke /etc/ssl/private/example.com.crt `## Certificate renewalBy default, no new request will be made ifwiledetects an existing certificate for the same requested domains with a validity of at least 1 week. This can be changed with the–min-valid-timeand–forceoptions.This way a simple daily cronjob is enough to ensure certificate freshness and should make renewals resiliant against moderate letsencrypt API downtime.
Package: wilfred
WilfredWilfred is a command-line interface for running and managing game servers locally. It uses Docker to run game servers in containers, which means they are completely separated. Wilfred can run any game that can run in Docker.⚠️ Wilfred is currently under development and should not be considered stable. Features may break or may not be implemented yet. Use with caution.DocumentationThe official documentation is availablehere. For support, use ourDiscord Chat. For bugs, you can open an issuehere.Supported gamesAs long as your server can run in Docker, it can probably run using Wilfred (after some tinkering). These are the games supported by default. You can submit new games towilfred-dev/images.MinecraftVanilla MinecraftBungeeCordPaperSpigotSpongeVanillaWaterfallBedrockMulti Theft AutoVoice ServersMumbleInstallationPlease refer to theofficial documentationfor further installation instructions and documentation.QuickstartMake sure you have Docker installed (see the official documentation for more info). The recommended way of installing Wilfred is viaHomebrew. Once brew is installed, Wilfred can easily be installed from the official tap.brewtapwilfred-dev/wilfred
brewinstallwilfredWant the bleeding edge? You can install the latest commit using--HEAD(bugs are to be expected, don't use in production environments!).brewtapwilfred-dev/wilfred
brewinstall--HEADwilfredWilfred can also be installed usingpip. You need to usePython 3.7or newer to run Wilfred.pipinstallwilfred--upgradeOnce you got Wilfred installed, runwilfred setupto set a path for Wilfred to use to store server files.To create your first server, usewilfred create. Most values have a default value, where you can just press return to use them.Wilfred will ask you which "image" to use. An image is a set of configuration files that defines a specific game within Wilfred. These images are not to be confused with Docker images, Wilfred images sort of wrap around the Docker images. A couple of games are already built into Wilfred, but you can also create your own.Then, Wilfred will ask you to set any environment variables (if available for that image). The environment variables differ from game to game and most of them have a default value.Once the server is created, you can usewilfred serversto list available servers. To start it, usewilfred start <name>. To attach to the server console, you can usewilfred console <name>. If you want to start the server and attach to the server console in a single command, you can usewilfred start <name> --console(it will start the server and then immediately attach to the server console).HelpingThe best places to contribute are through the issue tracker and the official Discord server. For code contributions, pull requests and patches are always welcome!Contributors ✨Created, written, and maintained byVilhelm Prytz.Copyright (C) 2020-2022, Vilhelm Prytz,vilhelm@prytznet.se
Package: wiliot-tools
PyWiliot: wiliot-toolswiliot-tools is a python library for accessing Wiliot's ToolsPublic LibraryMAC InstallationGetting around SSL issue on Mac with Python 3.7 and later versionsPython version 3.7 on Mac OS has stopped using the OS's version of SSL and started using Python's implementation instead. As a result, the CA
certificates included in the OS are no longer usable. To avoid getting SSL related errors from the code when running under this setup you need
to execute Install Certificates.command Python script. Typically you will find it under/Applications/Python\ 3.7/Install\ Certificates.commandPython 3 on MacThe default Python version on mac is 2.x. Since Wiliot package requires Python 3.x you should download Python3
(e.g.  Python3.7) and make python 3 your default.
There are many ways how to do it such as add python3 to your PATH (one possible solutionhttps://www.educative.io/edpresso/how-to-add-python-to-the-path-variable-in-mac)Git is not working after Mac updateplease check the following solution:https://stackoverflow.com/questions/52522565/git-is-not-working-after-macos-update-xcrun-error-invalid-active-developer-paInstalling pyWiliotpip install wiliot-toolsUsing pyWiliotWiliot package location can be found, by typing in the command line:pip show wiliot-toolsplease check out our tools, including:Local Gateway GUIFor more documentation and instructions, please contact us:support@wiliot.comRelease Notes:Version 4.4.4:Added association tool to associate between tags and id for GCP and AWS platformslocal gw gui:add start/stop gw app instead of only reset optionVersion 4.2.2:Gateway GUIadd logger and improving data loggingimprove UID only modeadded macro for Gateway firmware updateOwner change GUI - new tool for changing owner to pixelsVersion 4.1.0:Gateway GUIadd the option to wrap it up as applicationhandle better packet parsing exceptionsVersion 4.0.5:Gateway GUI - Live Plots:improve visualization - add sample points, clear after changing featureadd empty featureadd option to save the last configurationGateway GUI - General:add sample pointsfix libraries compatibilityimprove logging from all data type and fix bugsenhance gw macrosVersion 4.0.4:Gateway GUIadd mode for printing full UID, advertising addressshow only Silicon Lab port as options for the gw GUIadd button to print the macro file to create new macros.update GUI visualizationVersion 4.0.2:First versionThe package previous content was published under the name 'wiliot' package.
for more information please read 'wiliot' package's release notes
Package: will
![Travis Badge](https://travis-ci.org/skoczen/will.svg?branch=master) ![Pypi Badge](https://badge.fury.io/py/will.png)<img  align="right" src="https://gk-will.s3.amazonaws.com/will-head.png?v2" alt="Will's smilling face" title="Will's smilling face"/>Meet Will.Will is the friendliest, easiest-to-teach bot you've ever used.  He works on Slack, Hipchat, Rocket.chat, and more - so you can build your bot without platform lock-in.He makes teaching your chat bot this simple:```python@respond_to("hi")def say_hello(self, message):self.say("oh, hello!")```The first version of Will was built by [Steven Skoczen](http://stevenskoczen.com) while in the Greenkahuna Skunkworks (now defunct), was extended by [Ink and Feet](https://inkandfeet.com) and has been [contributed to by lots of awesome people](http://skoczen.github.io/will/improve/#the-shoulders-of-giants).Will has docs, including a quickstart and lots of screenshots at:**[http://skoczen.github.io/will/](http://skoczen.github.io/will)**If you've been using Will 0.x or 1.x, and are wondering how to upgrade to 2.x, [here's our friendly guide](http://skoczen.github.io/will/upgrading_to_2/). :)Check them out!
Package: willing-zg
willing_zgWilling specific plugins for ZygoatHow does it work?willing-zgworks by adding additional components forzygoatto use when installing or upgrading a repository. These are components that the Willing team wants in every application, but might not be appropriate for everyzygoatapplication.How do I use it?Make surezygoatis installed. Then installwilling-zg:pipinstall--user--upgrade/path/to/willing-zgGo to your application directory and update thezygoat_settings.ymlfile to include the additional components.extras:
    - willing_zg:component_name
    - willing_zg:other_component_nameThen run a zygoat update to install the new components.zgupdate
Package: willisapi-client
WillisAPI ClientWillisAPI Client is the python interface for Brooklyn Health’s WillisAPI.Official documentation for WillisAPI Client can be found in theGithub Wiki.To learn more about Brooklyn Health or WillisAPI, visitbrooklyn.healthorgetintouch@brooklyn.health.Installationpip install willisapi_clientLoginBefore you log in, make sure you have an account with Brooklyn Health.import willisapi_client as willisapi
key, expiration = willisapi.login(username, password)Uploadsummary = willisapi.upload(key, 'data.csv')For more information on how to organize thedata.csv, visit theGithub Wiki.Downloadmeasures = willisapi.download(key, 'project_name')If you run into trouble while using the client, please raise it in theIssuestab.Brooklyn Health is a small team of clinicians, scientists, and engineers based in Brooklyn, NY.We develop and maintainOpenWillis, an open source python library for digital health measurement.
Package: will-markdownify
This is atemporaryfork of the [official markdownify](https://github.com/matthewwithanm/python-markdownify) repo to add Python 3 support, and allow pip to keep working with the behavior changes with the –process-dependency-links deprecation.Once [the python 3 pull request](https://github.com/matthewwithanm/python-markdownify/pull/1) is merged and a new version is released, this package will be deleted.Installationpip installwill-markdownifyUsageConvert some HTML to Markdown:frommarkdownifyimportmarkdownifyasmdmd('<b>Yay</b> <a href="http://github.com">GitHub</a>')# > '**Yay** [GitHub](http://github.com)'Specify tags to exclude (blacklist):frommarkdownifyimportmarkdownifyasmdmd('<b>Yay</b> <a href="http://github.com">GitHub</a>',strip=['a'])# > '**Yay** GitHub'...or specify the tags you want to include (whitelist):frommarkdownifyimportmarkdownifyasmdmd('<b>Yay</b> <a href="http://github.com">GitHub</a>',convert=['b'])# > '**Yay** GitHub'OptionsMarkdownify supports the following options:stripA list of tags to strip (blacklist). This option can’t be used with theconvertoption.convertA list of tags to convert (whitelist). This option can’t be used with thestripoption.autolinksA boolean indicating whether the “automatic link” style should be used when
aatag’s contents match its href. Defaults toTrueheading_styleDefines how headings should be converted. Accepted values areATX,ATX_CLOSED,SETEXT, andUNDERLINED(which is an alias forSETEXT). Defaults toUNDERLINED.bulletsAn iterable (string, list, or tuple) of bullet styles to be used. If the
iterable only contains one item, it will be used regardless of how deeply
lists are nested. Otherwise, the bullet will alternate based on nesting
level. Defaults to'*+-'.Options may be specified as kwargs to themarkdownifyfunction, or as a
nestedOptionsclass inMarkdownConvertersubclasses.DevelopmentTo run tests:python setup.py testTo lint:python setup.py lint
Package: will-natural
This is atemporaryfork of theofficial natural <https://github.com/tehmaze/natural>repo to add Python 3 support, and allow pip to keep working with the behavior changes with the –process-dependency-links deprecation.Oncethe python 3 pull request <https://github.com/tehmaze/natural/pull/13>is merged and a new version is released, this package will be deleted.Example UsageBasic usage:>>> from natural.file import accessed
>>> print accessed(__file__)
just nowWe speak your language (withyour support):>>> import locale
>>> locale.setlocale(locale.LC_MESSAGES, 'nl_NL')
>>> print accessed(__file__)
zojuistBugs/FeaturesYou can issue a ticket in GitHub:https://github.com/tehmaze/natural/issuesDocumentationThe project documentation can be found athttp://natural.rtfd.org/
Package: will-not-work-on-windows-try-from-wsl-instead
will-not-work-on-windows-try-from-wsl-insteadThis is a placeholder package used for preventing installation on Windows for
packages that are known to not work on Windows.If you have a Python package that only supports Unix-like systems, like Linux
or MacOS, you can add this package as a dependency to prevent installation on
pure-Windows.# setup.cfg[options]install_requires=# Special order section for helping pip:will-not-work-on-windows-try-from-wsl-instead; platform_system=="Windows"...
Package: willofsteel
A modern, easy to use, Pythonic API wrapper for the Will of Steel API in
Python.InstallingPython 3.8 or higher is requiredOn windows, the library can be installed using the following command:py-3-minstallwillofsteelOn macOS/linux, use the following command:python3 pip install willofsteelIf desired, you can also clone the repository directly:git clone https://github.com/WillofSteel-Devs/api-wrapperUsing the libraryCreating a ClientTo create a client to interact with the API with, you can use the
followning code:importwillofsteelAPI_KEY='Place your api key here'client=willofsteel.Wrapper(API_KEY)ExampleA quick example of using this library is to look up your profile every
hour and send the results to a text file, this can be accomplished with
the following:importwillofsteelimporttimeAPI_KEY='Place your api key here'client=willofsteel.Wrapper(API_KEY)defscheduled_query():# Querying the api for the api key holder's profileplayer=client.get_player()# Creating a file name to log the results withtimestamp=time.asctime().replace(':','_')# Logging resultswithopen(f'{timestamp}.txt','x',encoding='utf-8')asf:f.write(player)print(f"Query made at{timestamp}")whileTrue:scheduled_query()time.sleep(3600)
Package: willowlabs
Willow Labs Python APIWillow labs APIs offers services to get information regarding companies and related entities. The main companents are:Information about the owners of a company. This service provides owners at all levels, meaning it recursively goes through the ownership structure until a private owner is established.Basic company information as address, industry, number of employees and more.Signature rights and prokura holders for a company.Roles connected to the company, for example CEO, board members, accountant.Ultimate Beneficial Owners of a company.Function summaryService nameDescriptionLanguageEnglish versionget_basic_company_informationBasic information.Englishget_company_ownershipGet the full ownership structure.Englishget_company_power_of_attorneyGet everyone with power of attorney.English*get_company_prokuraGet everyone with prokura rights (power of attorney).Norwegianget_company_power_of_attorneyget_company_full_signatory_authorityAll signature holders.English*get_company_signaturGet all signatur (signature) holders.Norwegianget_company_signatory_informationget_company_signatory_informationGet the authority holder.Englishget_company_rolesGet all roles connect to a company.Englishget_ultimate_beneficial_ownersGet all ultimate beneficial ownersEnglish* The function is a Norwegian version of an english function - see english version column for information.Installationpipinstall-UwillowlabsExample usagefromwillowlabs.company_information.clientimportCompanyInformationClientclient=CompanyInformationClient("client_config.yaml")company_basic_results=client.get_basic_company_information(organisation_number)company_ownership_results=client.get_company_ownership(organisation_number,record_year)DocumentationRead the DocsVersionsUsingSemantic Versioning 2.0.0.[0.8.0] - 30.09.2020Added Ultimate Beneficial Ownership search.[0.5.4] - 16.04.2020Bug fixsmall bug fixes[0.5.4] - 16.04.2020Bug fixgcloud not authorized[0.5.1] - 16.04.2020Bug fixReadme file rendering error[0.5.0] - 16.04.2020AddedReadme file documentation.[0.4.0] - 16.04.2020AddedChange in import structure.[0.3.0] - 15.04.2020AddedNew function to get rollerBug fixRemoved __init__ import[0.2.0] - 04.04.2020First beta version: Basic functionality.LicenseMIT© 2020 Willow LabsWillow Labs AS
Package: willpyre
WillpyreWillpyre is a micro ASGI framework.
Willpyre gives flexibility and control, but abstracts ASGI to some extent and adds reusability to your code.QuickstartIt is quite simple to use Willpyre.fromwillpyreimportApp,Routerrouter=Router()@router.get('/')asyncdefindex(req,res):res.body="<h1>Please fasten your seatbelts!!</h1>"returnresapp=App(router)It should run with any ASGI server likeUvicorn,Daphne,Hypercorn.To run with Uvicorn, install Uvicorn usingpipinstalluvicornand thenuvicorn<file>:appThe framework is written in pure-python and can run in PyPy or CPython.
Tested on version 3.6 and above.FeaturesPredefined response objects for fast development.Optional base response object passed to handlers.Async.Light and tiny.And lots more..ContributionsIt is open to contributors willing to commit.
Please open issues if you find something wierd.
Fork this if you want to propose changes.