Saravanan666/pypi-org huggingface dataset:
Package: webim
Webim-python============WebIM python client for nextalk.imUsage=====```pythonimport webimendpoint = {'id': 'uid1', 'nick': 'user1', 'presence': 'online', 'show': 'available'}c = webim.Client(endpoint, 'domain', 'apikey', host='nextalk.im', port = 8000)c.online(['uid1','uid2','uid3'], ['room1','room2','room3'])c.offline()```API===Online------```pythonbuddies = ['uid1', 'uid2', 'uid3']rooms = ['room1', 'room2', 'room3']c.online(buddies, rooms)```Offline-------```pythonc.offline()```Presence---------------```pythonshow = 'away'status = 'Away'status, resp = self.client.show(show, status)```Send Message-------------```pythonmessage = {'to': 'uid2','nick': 'user1','body': 'hahaha','timestamp': time.time()*1000,'type': 'chat','style': ''}status, resp = self.client.message(message)```Push Message-------------```pythonc = Client(self.endpoint, "localhost", "public")message = {'from': 'uid3','to': 'uid2','nick': 'user3','body': 'hahaha','timestamp': time.time()*1000,'type': 'chat','style': ''}status, resp = c.message(message)```Send Status-----------```pythonstatus = {'to': 'uid2','show': 'typeing','status': 'user1 is typing'}status, resp = c.status(status)```Retrieve Presences------------------```pythonuids = ['uid1', 'uid2']status, json = c.presences(uids)```Retrieve room members----------------------```pythonroom = 'room1'status, json = c.members(room)```Join Room----------```pythonroom = 'room1'c.join(room)```Leave Room-----------```pythonroom = 'room1'c.leave(room)```Author============http://nextalk.imhttp://github.com/webimContact============ery.lee at gmail.com
Package: web_imagery
Grab images from the web by their urlsCurrently supports:direct image links that have the following extensions (jpg, jpeg, gif, png)InstagramImgurFlickrPathSkitchMinusCloud AppRequirements>> pip install -r requirements.txtUsage>> from webimagery import *>> image = WebImagery()First set the url>> image.set_image(’http://www.flickr.com/photos/ednapiranha/4437021184/’)
>> TrueYou can get the source link>> image.get_image()
>> ‘http://farm3.static.flickr.com/2788/4437021184_848d7fa79d.jpg’Or you can get the image tag, setting your own alt text and dimensions>> image.get_image_as_html(‘cat sleeping’)
>> image.width = 350
>> ‘<img src=”http://farm3.static.flickr.com/2788/4437021184_848d7fa79d.jpg” alt=”cat sleeping” width=”350” height=”200” />’
Package: webinar
Webinar PackageA helper pip package for webinarAssumptions:Assuming python is installed on your system.Installation sets up commandSituation before installation::$ webinar
bash: webinar: command not foundInstallation right from the source tree (or via pip from PyPI)::$ python setup.py install

$ pip install webinarNow, thewebinarcommand is available::$ hello
Your name: Yusa
Hello Yusa!
Package: webinspectapi
WebInspect APIA Python module to assist with theWebInspectRESTFul API to administer scans.Quick StartSeveral quick start options are available:Install with pip:pip install webinspectapiBuild locally:python setup.py buildDownload the latest release.Example# import the package
from webinspectapi import webinspect

# setup webinspect connection information
host = 'http://localhost:8083/webinspect/'

# instantiate the webinspect api wrapper
wi = webinspect.WebInspectApi(host)

# List scans
scans = wi.list_scans()

for scan in scans.data:
        print(str(scan['Name']), str(scan['Status']), str(scan['ID']))Supporting information for each method available can be found in thedocumentation.Bugs and Feature RequestsFound something that doesn’t seem right or have a feature request?Please open a new issue.Copyright and License
Package: webint
webinthelps you build a web interface.Usagemkdir example.site && cd example.site
poetry init --name=example-site
poetry add webint
poetry run web scaffold
poetry version minor
poetry publish

web config --host digitalocean --token {YOUR_TOKEN}
web init example.site example-site example:appHackpoetry run web run example:app --port 9999Changes to your python code will auto-reload the local development server.Deploy an updatepoetry version (major|minor|patch)
poetry publishWait a couple minutes and update your site athttps://example.site/system/software
Package: webinteractions
This package aims towards providing API interfaces for various python libraries which results in reduction of
writing boilerplate code for each project using these libraries, instead users can use this package to complete
initial setup with as less as a single function call.For example, if a user wants to create a TCP server then instead of going through and setting up all the details,
the user can simple run a function that creates a TCP server running on socketserver library, the user only needs to
provide the hostname and port number for the server to start, like shown belowfromwebinteractions.server_client.tcp_socket_serverimportcreate_tcp_synchronous()create_tcp_synchronous(hostname="localhost",port=8000)Listeningonlocalhost:8000The package includes following functionalities:ip_functions.py module contains functions that provides you with a generator for ipv4 and ipv6 respectively.http_interactions.py contains two functions one for interacting with REST apis and another for getting file dataserver_client.tcp_socket_server contains functions that start a tcp server synchronous and threaded with a simple function callserver_client.udp_socket_server does the same as tcp_socket_server just with udp protocolserver_client.xmlrpc_wrapper.server provides a function using which a user can start a xmlrpc server and define server side functionsserver_client.xmlrpc_wrapper.client returns a server proxy using which a user can interact with xmlrpc server
Package: webio-jupyter-extension
webio_jupyter_extensionRequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstallwebio_jupyter_extensionUninstallTo remove the extension, execute:pipuninstallwebio_jupyter_extensionContributingHow installing the server/labextension components workstl;dr: We define somedata_filesin thesetup.pythat places the relavent server and labextension files in the right place. This means it's also automatically cleaned up when uninstalled.Differences from typical JupyterBecausereasons, we actually differ from the normal Jupyter labextension cookiecutter.
Namely, we actually have a pre-build process before we pass it off to the rest of the
Jupyterlab installation process. The reason we do this is that we need some special
webpack configuration to deal with SystemJS (which we use to load custom JS/CSS resources
at runtime) and that custom webpack configuration is hard to do within the Jupyter
labextension tooling.Development installNote: You will need NodeJS to build the extension package.# Clone the repo to your local environment# Change directory to the webio_jupyter_extension directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Server extension must be manually installed in develop modejupyterserverextensionenablewebio_jupyter_extension.serverextension# Rebuild extension Typescript source after making changesyarnbuildBy default, theyarn buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstalljupyterserverextensiondisablewebio_jupyter_extension.serverextension
pipuninstallwebio_jupyter_extensionIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedwebio-jupyter-labextensionwithin that folder.
Package: webio-jupyterlab-provider
webio_jupyterlab_providerRequirementsJupyterLab >= 3.0InstallTo install the extension, execute:pipinstallwebio_jupyterlab_providerUninstallTo remove the extension, execute:pipuninstallwebio_jupyterlab_providerContributingDifferences from typical JupyterBecausereasons, we actually differ from the normal Jupyter labextension cookiecutter.
Namely, we actually have a pre-build process before we pass it off to the rest of the
Jupyterlab installation process. The reason we do this is that we need some special
webpack configuration to deal with SystemJS (which we use to load custom JS/CSS resources
at runtime) and that custom webpack configuration is hard to do within the Jupyter
labextension tooling.Development installNote: You will need NodeJS to build the extension package.Thejlpmcommand is JupyterLab's pinned version ofyarnthat is installed with JupyterLab. You may useyarnornpmin lieu ofjlpmbelow.# Clone the repo to your local environment# Change directory to the webio_jupyterlab_provider directory# Install package in development modepipinstall-e.# Link your development version of the extension with JupyterLabjupyterlabextensiondevelop.--overwrite# Rebuild extension Typescript source after making changesjlpmrunbuildYou can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.# Watch the source directory in one terminal, automatically rebuilding when neededjlpmrunwatch# Run JupyterLab in another terminaljupyterlabWith the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).By default, thejlpm run buildcommand generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:jupyterlabbuild--minimize=FalseDevelopment uninstallpipuninstallwebio_jupyterlab_providerIn development mode, you will also need to remove the symlink created byjupyter labextension developcommand. To find its location, you can runjupyter labextension listto figure out where thelabextensionsfolder is located. Then you can remove the symlink namedwebio-jupyterlab-providerwithin that folder.Packaging the extensionSeeRELEASE
Package: webit
webitA web tools by Python.Installpip install webitUsecd to you working directory and run command:webit.batif can’t find webit command, try:python -m webitopen broswer with urlhttp://127.0.0.1:8000, add shell script and run it.Other tips1.set http port 80webit 802.authenticate with username and password (admin admin)webit -u admin -p admin3.set the working directory (/tmp)webit -d /tmp4.bind address with 127.0.0.1webit 127.0.0.1:80005.use as wsgi# set username and passwor
export WSGI_PARAMS="-u admin -p admin"
# run wsgi with gunicorn
gunicorn -b 0.0.0.0:8000 webit.wsgi:applicationCHANGES0.0.1init version.0.0.2fix command error.0.0.3fix static file error.
Package: webkit-server
# OverviewAuthor:Niklas BaumstarkA standalone version of the Webkit server included in [capybara-webkit][1].
It includes a slim Python wrapper and the following improvements over the
original version from thoughtbot:Waitcommand to wait for the current page to loadSetAttributecommand to [configure certainQWebkitsettings][2]SetHtmlcommand to [load custom HTML][3] into the browser (e.g. to
execute scripts on web pages scraped by a static scraper)SetViewportSizecommand to set the viewport size of the in-memory browserIf you are interested in web scraping using this server, have a look at [dryscrape][4].# Building and InstallingTo install the Python binding (this also builds the server and places it into
Python’ssite-packagedirectory):sudo python setup.py installIf you don’t need the Python bindings, you can also use the suppliedbuild.shshellscript to build the server only.# Contact, Bugs, ContributionsIf you have any problems with this software, don’t hesitate to open an
issue on [Github](https://github.com/niklasb/webkit-server) or open a pull
request or write a mail toniklas
baumstark at Gmail.# LicenseThis software is based on [capybara-webkit][1].
capybara-webkit is Copyright (c) 2011 thoughtbot, inc. It is free software, and
may be redistributed under the terms specified in the LICENSE file.[1]:https://github.com/thoughtbot/capybara-webkit[2]:https://github.com/thoughtbot/capybara-webkit/pull/171[3]:https://github.com/thoughtbot/capybara-webkit/pull/170[4]:https://github.com/niklasb/dryscrape
Package: webknossos
WEBKNOSSOS Python LibraryPython API for working withWEBKNOSSOSdatasets, annotations, and for WEBKNOSSOS server interaction.For the WEBKNOSSOS server, please refer tohttps://github.com/scalableminds/webknossos.Featureseasy-to-use dataset API for reading/writing/editing raw 2D/3D image data and volume annotations/segmentation in WEBKNOSSOS wrap (*.wkw) formatadd/remove layersupdate metadata (datasource-properties.json)up/downsample layerscompress layersadd/remove magnificationsexecute any of thewkCuberoperations from your codemanipulation of WEBKNOSSOS skeleton annotations (*.nml) as Python objectsaccess to nodes, comments, trees, bounding boxes, metadata, etc.create new skeleton annotation from Graph structures or Python objectsinteraction, connection & scripting with your WEBKNOSSOS instance over the REST APIup- & downloading annotations and datasetsPlease refer tothe documentation for further instructions.InstallationThewebknossospackage requires at least Python 3.8.You can install it frompypi, e.g. via pip:pipinstallwebknossosExamplesSee theexamples folderor thethe documentation.Contributions & DevelopmentPlease see therespective documentation page.LicenseAGPLv3Copyrightscalable mindsTest Data CreditsExcerpts for testing purposes have been sampled from:Dow Jacobo Hossain Siletti Hudspeth (2018).Connectomics of the zebrafish's lateral-line neuromast reveals wiring and miswiring in a simple microcircuit.eLife.DOI:10.7554/eLife.33988Zheng Lauritzen Perlman Robinson Nichols Milkie Torrens Price Fisher Sharifi Calle-Schuler Kmecova Ali Karsh Trautman Bogovic Hanslovsky Jefferis Kazhdan Khairy Saalfeld Fetter Bock (2018).A Complete Electron Microscopy Volume of the Brain of Adult Drosophila melanogaster.Cell.DOI:10.1016/j.cell.2018.06.019. License:CC BY-NC 4.0Bosch Ackels Pacureanu et al (2022).Functional and multiscale 3D structural investigation of brain tissue through correlative in vivo physiology, synchrotron microtomography and volume electron microscopy.Nature Communications.DOI:10.1038/s41467-022-30199-6
Package: weblablib
weblablibweblablibis a library for creatingWebLab-Deustoremote laboratories.A remote laboratory is a software and hardware system that enables students to access real laboratories through the Internet.
For example, a student can be learning how to program a robot by writing code in a computer at home and sending it to a remote laboratory, where the student can see how the program behaves in a real environment.Creating a remote laboratory may imply many layers, such as authentication, authorization, scheduling, etc., so Remote Laboratory Management Systems (RLMS) were created to make the common layers of remote laboatories.
WebLab-Deusto is an Open Source RLMS, and it has multiple ways (see the docs) to create a remote laboratory (in different programming languages, etc.).In the case of Python, with the popularFlaskmicroframework,weblablibis the wrapper used to createunmanaged labs.Unmanaged labsis a term used in WebLab-Deusto to refer laboratories where the authors develop the full stack (server, client, deployment), as opposed tomanaged labs.If you are familiar with Flask and with Web development, and want to be able to customize everything but not need to implement all the layers of authentication, administration, etc., this library would be very useful. Furthermore, this library allows you to develop remote laboratories for many environments (from regular computers with Linux to systems such as Raspberry Pi). And it integrates very well with other Flask components such asFlask-SocketIO,Flask-SQLAlchemyfor databases orFlask-Assets.DocumentationRead the documentation:https://developers.labsland.com/weblablib/InstallationSimply use pip:pip install weblablibSimple usagefromflaskimportFlask,url_forfromweblablibimportWebLab,weblab_user,requires_activeapp=Flask(__name__)app.config.update({'SECRET_KEY':'secret',# MUST CHANGE'WEBLAB_USERNAME':'weblabdeusto','WEBLAB_PASSWORD':'password',})weblab=WebLab(app)@weblab.on_startdefon_start(client_data,server_data):# ...print("Starting user")@weblab.on_disposedefon_dispose():# ...print("Ending user")@weblab.initial_urldefinitial_url():returnurl_for('index')@app.route('/')@requires_activedefindex():return"Hello,{}".format(weblab_user.username)if__name__=='__main__':app.run(debug=True)Advance examplesYou may findherethe following examples:simple: basic usage, all in one file.advanced: more advanced usage, with separation of files, tasks, more complex session managementcomplete: based on advanced, but using WebSockets with Flask-SocketIO, internationalization with Flask-Babel and minimified static files with Flask-Assets.There is another example calledquickstart, which is the one used in the documentation, which is something in betweensimpleandadvanced.
Package: weblate-language-data
Weblate is libre software web-based continuous localization system,
used by over 2500 libre projects and companies in more than 165 countries.Language definitions used byWeblateand free to use by others.UsageThe Python module can be installed from the PyPI:pipinstallweblate-language-dataIt contains several modules containing language definitions and Gettext
translations for them (in a way that they would be discovered by Django when
used as an Django application).CSV FilesThe repository also contains CSV files which are used to generate the Python
code and can be used independently.Semicolon delimited filesContains language code, name, number of plurals and plural equationlanguages.csvCombined from several sources, plurals should match CLDR when availableUsed byWeblatefor language definitionsManually editedaliases.csvLanguage aliases to map non standard or legacy locales to ones inlanguages.csvManually editeddefault_countries.csvList of default country specific localesUsed to map them to ones inlanguages.csvManually editedextraplurals.csvAdditional plural variants for some languagesUsually used in GettextManually editedcldr.csvBased purely on the CLDR dataGenerated using export-cldr fromhttps://github.com/mlocati/cldr-to-gettext-plural-rulesgettext.csvBased on Gettext defaultsGenerated using export-gettexttranslate.csvExtracted fromtranslate-toolkitGenerated using export-translatel10n-guide.csvExtracted from thel10n guideGenerated using export-l10n-guidelanguages-poDirectory containing PO files with langauge names translationsExtracted from CLDR dataContributingContributions are welcome! Seedocumentationfor more information.
Package: weblate-reposync
weblate_reposyncCreateWeblatetranslation components based on repository content. There is
aComponent discoveryaddon
in Weblate, which already does a similar thing, however weblate_reposync is a bit more configurable.Installation$ pip install weblate_reposyncUsage$ weblate_reposync -c path_to_conf.cfgConfigurationTODO: To be documented.
Package: weblate-schemas
Weblate is libre software web-based continuous localization system,
used by over 2500 libre projects and companies in more than 165 countries.This module contains schemas used in Weblate exports.InstallationInstall using pip:pip3installweblate_schemasSources are available at <https://github.com/WeblateOrg/weblate_schemas>.ContributingContributions are welcome! Seedocumentationfor more information.
Package: weblayer
weblayeris aPythonpackage, built onWebOb, that provides a set of
components that can be used to handle requests within aWSGIapplication.It is not a framework.  In contrast,weblayertries to prescribe as little
as possible, allowing you to swap out components and work with your weapons
of choice.It’s fast, tested anddocumented.  Thesource codeispublic domain.InstallweblayerrequiresPythonversion 2.5 to 2.7.  It’s operating system
independent, so runs on Unix (including Mac OSX) and on Windows.  Install it
via thePython Package IndexusingSetuptools:easy_install weblayerDevelopTo develop (or play around with) it, get thesource codeusingGit:git clone git://github.com/thruflo/weblayer.git
cd weblayerDevelop the egg:python setup.py developInstall the additional dependencies:easy_install weblayer[dev]Run the tests:nosetests -c etc/nose.cfgGenerate the docs:sphinx-build -a -b html doc doc/_buildIf you have any problems or suggestions,Github Issuesis the place to raise
a ticket.UsageSee theUser Guideandexamplesfor more information.
Package: weblaze
weblazeUsage:$weblaze[OPTIONS]COMMAND[ARGS]...Options:--install-completion: Install completion for the current shell.--show-completion: Show completion for the current shell, to copy it or customize the installation.--help: Show this message and exit.Commands:edit: Edit the configuration file in the...init: Initialize and generate a configuration...run: main functionConfigurationbackblaze:application_key_id:***application_key:***bucket_name:***local:compressor:***\cwebp.exeCommandseditEdit the configuration file in the system's default editor.Usage:$edit[OPTIONS]Options:--help: Show this message and exit.initInitialize and generate a configuration file in the user's .config directory.Usage:$init[OPTIONS]Options:--help: Show this message and exit.runmain functionUsage:$run[OPTIONS]Options:-i, --local-directory TEXT: Path to the local directory where images are stored [default: ./]--compress-max INTEGER: max workers to compress [default: 3]--upload-max INTEGER: max workers to upload [default: 3]--help: Show this message and exit.flowchart TD
    w(weblaze) --> 1.jpg --> cwebp1(cwebp 1)
    w --> 2.jpg --> cwebp2(cwebp 2)
    w --> 3.jpg --> cwebp3(cwebp 3)
    cwebp1 --> |compress| 1.webp
    cwebp2 --> |compress| 2.webp
    cwebp3 --> |compress| 3.webp
    1.webp --> |upload| b1[B2_uploader_1] --> B2(Backblaze)
    2.webp --> |upload| b2[B2_uploader_2] --> B2
    3.webp --> |upload| b3[B2_uploader_3] --> B2
Package: weblib
WeblibWeblib provides tools to solve typical tasks in web scraping:processing HTMLhandling text encodingscontroling repeating and parallel tasksparsing RSS/ATOM feedspreparing data for HTTP requestsworking with DOM treeworking with text and numeral datalist of common user agentscross-platform file lockingoperations with files and directoriesInstallationRun:pipinstall-UweblibDocumentationDocs are incomplete. Most docs are auto-generated from modules/methods docstrings.
Check out docs herehttp://weblib.readthedocs.org/en/latest/
Package: weblibrary
IntroductionWebLibrary is a web testing library forRobot Frameworkthat leverages theSelenium 2 (WebDriver)libraries from theSeleniumproject.
We wrap the KWs(Web_xxxx) on it according to our project requirements.It support Python 2.x only.InstallationUsingpipThe recommended installation method is usingpip:pip install weblibraryThe main benefit of usingpipis that it automatically installs all
dependencies needed by the library. Other nice features are easy upgrading
and support for un-installation:pip install --upgrade weblibrary
pip uninstall weblibraryProject ContributorsDong HaoWang YangdanXia Daqiang
Package: webling-calendar
webling_calendarThis is a simple command line interface to interact with the webling calendar API.Install it from PyPIpipinstallwebling_calendarUsagefromwebling_calendarimportBaseClassfromwebling_calendarimportbase_functionBaseClass().base_method()base_function()$python-mwebling_calendar#or$webling_calendarDevelopmentRead theCONTRIBUTING.mdfile.