Saravanan666/pypi-org huggingface dataset:
Package: walkscore-api
(Unofficial) Python Bindings for the WalkScore APIBranchUnit Testslatestv.1.0developTheWalkScore Libraryis a Python library that provides Python bindings for theWalkScore API. It enables you to retrieve
WalkScores, TransitScores, and BikeScores from the API within your Python code
in Python versions 3.6 and higher.WarningTheWalkScore Libraryis completely unaffiliated withWalkScore. It is entirely unofficial and was
developed based on publicly available documentation of the WalkScore APIs
published to the WalkScore website. Use of WalkScore is subject to WalkScore’s
licenses and terms of service, and this library is not endorsed by WalkScore
or any affiliates thereof.COMPLETE DOCUMENTATION:http://walkscore-api.readthedocs.org/en/latest/index.htmlContentsInstallationDependenciesKey WalkScore FeaturesHello, World and Basic Usage1. Import the WalkScore API2. Initialize the API3. Retrieve a ScoreQuestions and IssuesContributingTestingLicenseInstallationTo install theWalkScore Library, just execute:$pipinstallwalkscore-apiDependenciesPython 3.x*Validator-Collection v1.3or higher*Backoff-Utils v.1.0or higherKey WalkScore FeaturesPython representation of WalkScores, TransitScores, and BikeScores.Easy serialization and deserialization of API responses to Python objects,dictobjects or JSONBuilt-in back-off/retry logic if the WalkScore API is unstable at any mometn in timeRobust error handling to surface meaningful information to help you debug your
code.Hello, World and Basic Usage1. Import the WalkScore APIfromwalkscoreimportWalkScoreAPI2. Initialize the APIYou can either use a single object to communicate with all of the available
WalkScore APIs, or initialize a single object for each API:api_key='YOUR API KEY GOES HERE'walkscore_api=WalkScoreAPI(api_key=api_key)3. Retrieve a Scoreaddress='123 Anyplace St Anywhere, AK 12345'result=walkscore_api.get_score(latitude=123.45,longitude=54.321,address=address)# the WalkScore for the locationresult.walk_score# the TransitScore for the locationresult.transit_score# the BikeScore for the locationresult.bike_scoreQuestions and IssuesYou can ask questions and report issues on the project’sGithub Issues PageContributingWe welcome contributions and pull requests! For more information, please see theContributor Guide.TestingWe useTravisCIfor our build automation andReadTheDocsfor our documentation.Detailed information about our test suite and how to run tests locally can be
found in ourTesting Reference.LicenseWalkScoreis made available under anMIT License.
Package: walk-sftp
WalkSFTPThis is project is a class that allows for a glob like sftp download to a temporary file and lets you process the downloaded data using processing_function. The log argument can be used to check if the get and process ran correctly so you can run and not pull files that have already been processed and keeps track of files based on their modified time. This uses threading to separate the glob sftp files and the process function.InstallationRun the following to install:pipinstallwalk_sftpUsagefrom walk_sftp import WalkSFTP

def process(f)

	try:
		# if successfull
		return True
	except:
		# if unsuccessfull
		return False

WalkSFTP(
    ftp_web_address,
    username,
    password,
    start_date='2020-12-25', # optional
	end_date='2020-12-28', # optional
    print_out=True, # optional
    processing_function=process, # optional
    log='/some_path_to_log.p', # optional
)Development walk_sftpTo install walk_sftp, along with the tools you need to develop and run tests, run the following in your virtualend:$pipinstall-e.[dev]
Package: walk-up
What is this?A simple function for walking up a file directory until a certain file is found.JavaScript version:const{walkUpUntil}=require("walk_up")letfilepath=walkUpUntil("package.json")Python version:fromwalk_upimportwalk_up_untilfilepath=walk_up_until("requirements.txt")Ruby version:require"walk_up"require_relativewalk_up_until("globals.rb")# <- will keep looking in parent directories for a "globals.rb" file
Package: walkway
Walkway - motion detectorCapture high frame rate videos of a custom-made, CatWalk like setup for mice using a FLIR's BlackFly camera.
A video is saved to disk whenever motion is detected and if locomotion satisfies the criteria defined in the configuration (e.g. ignoring brief periods of locomotion).InstallationInstallSpinView (Spinnaker Web Installer)InstallPython version 3.8OpencmdRunpip install walkwayorpython -m pip install walkway.Usage overviewPower on IR light source.Plug in camera to computer.Adjust camera settings using SpinView (optional)Adjust camera aperture and focus to view region of interest under the light conditions expected during the experiment.Adjust image format to limit the view to the apparatus' walkway. Note that some parameters can only be changed when acquisition is off.OpencmdRunpython -m walkway.captureto start auto-triggering.Pressqon the GUI orctrl+con the command window when done.Video files are saved to cmd's working directory (defaults toC:/Users/<your username>in Windows). You maycdto a different directory prior to start capturing to save videos elsewhere.You may use a configuration file in JSON format withpython -m walkway.capture --configuration configuration.json; this will override any parameters previously set to the camera.Runpython -m walkway.capture --helpfor more information.Runpython -m walkway.guito open GUI.Runpython -m walkway.experimentto open an experiment with two FLIR cameras and a Petteron microphone.Version History0.0.9: Fixed folder select and load profile in experiment.0.0.8: Added a GUI and an experiment.0.0.7: Changed defaults. Added image parameters.0.0.4: Add argument parser and configuration file.0.0.1: Initial release. Scripts are multithreaded so as to not lag during writing operations to disk.License© 2021Leonardo MolinaThis project is licensed under theGNU GPLv3 License.
Package: wallabag2readwise
wallabag2readwiseDescriptionExports / synchronizes annotations fromwallabagtoReadwisearticle highlights.This tool can be run as a cli tool or as a (docker) container.Rate limiting of the Readwise API is supported.InstallationCLIpipinstall-Uwallabag2readwiseor withpipxpipxinstallwallabag2readwiseDocker / Containerdockerpullghcr.io/rwxd/wallabag2readwise:latestdockerrunghcr.io/rwxd/wallabag2readwise:latest--wait-time60...Docker-Composeversion:"3.9"services:wallabag2readwise:image:ghcr.io/rwxd/wallabag2readwise:latestcontainer_name:wallabag2readwiserestart:unless-stoppedenvironment:READWISE_TOKEN:''WALLABAG_URL:''WALLABAG_USER:''WALLABAG_PASSWORD:''WALLABAG_CLIENT_ID:''WALLABAG_CLIENT_SECRET:''# env_file:#  - .envdocker-composeup-d&&docker-composelogs-fUsageCommandswallabag2readwisepushDaemonRun continuously and push new annotations to Readwise every 60 minutes.
(The container is automatically in daemon mode.)wallabag2readwisedaemon--wait-time60Import all Wallabag entries to Readwise Readerwallabag2readwisereaderImport all Readwise Reader Documents to Wallabagwallabag2readwisewallabagConfigurationGet a new Readwise API Token fromhttps://readwise.io/access_token.Create a new wallabag API client in your instancehttps://my-wallabag.com/developer/client/create.ENV VarsREADWISE_TOKEN=''WALLABAG_URL=''WALLABAG_USER=''WALLABAG_PASSWORD=''WALLABAG_CLIENT_ID=''WALLABAG_CLIENT_SECRET=''CLI OptionsSecrets can also be used with cli options.All cli options can be viewed withwallabag2readwise --help
Package: wallabagapi
Python API for Wallabag v2.4.2Requirements :httpxInstallation:to get the project, from your virtualenv, do :gitclonehttps://gitlab.com/foxmask/wallabagapi/orpipinstallwallabagapiCreating a post :request the token, if you don’t have it yetcreate the post#!/usr/bin/env pythonimporthttpxfromwallabagapi.wallabagimportWallabag# settingsmy_host='http://localhost:8080'asyncdefmain(loop):params={'username':'foxmask','password':'mypass','client_id':'myid','client_secret':'mysecret','extension':'pdf'}# get a new tokentoken=awaitWallabag.get_token(host=my_host,**params)wall=Wallabag(host=my_host,client_secret=params.get('client_secret'),client_id=params.get('client_id'),token=token,extension=params['extension'],aio_sess=session)# initializingasyncwithhttpx.AsyncClient()asclient:url='https://foxmask.trigger-happy.eu'title='foxmask\'s  blog'awaitclient.post_entries(url,title,'',0,0)url='https://trigger-happy.eu'title='Project TrigerHappy'awaitwall.post_entries(url,title,'',0,0)# get all the articlesmy_wallabag=awaitwall.get_entries()all_article=my_wallabag['_embedded']['items']forarticleinall_article:print(article['id'],article['title'])# get the version of wallabagversion=awaitwall.versionprint(f"version{version}")# export one article into PDFmy_wallabag=awaitwall.get_entry_export(entry=1)withopen("foobar.pdf","wb")asf:f.write(my_wallabag)if__name__=='__main__':loop=asyncio.get_event_loop()loop.run_until_complete(main(loop))this will give you something like this :Testing :Install Wallabag V2 on your own host like explain herehttp://doc.wallabag.org/en/v2/user/installation.htmlThen run the development version (with make run)Then create a client API like explain herehttp://doc.wallabag.org/en/v2/developer/api.htmlthis will give you something like thisThen replace the client_id / client_secret / login / pass to wallabag_test.py and runpythonwallabag_test.py
Package: wallabag-client
wallabag-clientWallabag-client is a command line client for the self hosted read-it-later appwallabag. Unlike to other services, wallabag is free and open source.Wallabag-client is refactored version of existed wallabag-cli tool.You can read additional infohereFeaturesList entries (filterable tabulated output with nerd icons);Show the content of an entry with custom width and alignment;Add new entries;Delete entries;Mark existing entries as read;Mark existing entries as starred;Change the title of existing entries;Tags support;Annotations support;Opening entries in browser;Showing entry information;Export entry to file.Installationsudo pip3 install wallabag-clientUsagewallabag --helpUsage: wallabag [OPTIONS] COMMAND [ARGS]...

Options:
  --config TEXT       Use custom configuration file
  --debug             Enable debug logging to stdout
  --debug-level TEXT  Debug level
  --version           Show the version and exit.
  -h, --help          Show this message and exit.

Commands:
  add             Add a new entry to wallabag.
  anno            Annotation commands.
  config          Start configuration.
  delete          Delete an entry from wallabag.
  delete-by-tags  Delete entries from wallabag by tags.
  export          Export entry to file.
  info            Get entry information.
  list            List the entries on the wallabag account.
  open            Open entry in browser.
  read            Toggle the read-status of an existing entry.
  repl            Start an interactive shell.
  show            Show the text of an entry.
  star            Toggle the starred-status of an existing entry.
  tags            Retrieve and print all tags.
  update          Toggle the read or starred status or change the title of...
  update-by-tags  Set the read or starred status of an existing entries...
Package: wallaby-backend-elasticsearch
wallaby-backend-elasticsearch=============================This package provides an asynchronous python interface to elasticsearch (using twisted).For more information on wallaby visit http://wlby.freshx.deInstallation============You can install the elasticsearch backend with pip```bashpip install wallaby-backend-elasticsearch```How to use==========The library is based on twisted's asynchronous pattern. To use the library in an asynchronous fassion youfirst need to create an reactor based application:```pythonfrom twisted.internet import defer@defer.inlineCallbacksdef run():# wait 1 secondd = defer.Deferred()reactor.callLater(1.0, d.callback)yield d# stop the reactor and quit the applicationreactor.stop()from twisted.internet import reactorreactor.callWhenRunning(run)reactor.run()```Now we can connect to an existing elasticsearch cluster:```python@defer.inlineCallbacksdef run():# Create elasticsearch client objectfrom wallaby.backends.elasticsearch import Connectiones = Connection(baseURL="http://localhost:9200",index="<name of index>",username="<username>",password="<password>",)# Send queryres = yield es.doQuery({"query": {"query_string": {"query": "*"}}})# stop the reactor and quit the applicationreactor.stop()```
Package: wallaby-data-access
WALLABY data accessPython module with tools for accessing internal release data from the WALLABY databaseConfigurationThere are two requirements for accessing data via the module. They are:Clone ofWALLABY_databaserepositoryEnvironment file with database credentials.The.envfile requires:DATABASE_HOST
DATABASE_NAME
DATABASE_USER
DATABASE_PASSOnce these files are in your working directory you can specify them in theconnect()functionimport wallaby_data_access as wallaby
wallaby.connect(db='<PATH_TO_WALLABY_database>', env='<PATH_TO_.env>')ReleaseOfficial PyPI packageWe can release to PyPI manually or automatically through ouraction. To release manually:export RELEASE_VERSION=<version>
python setup.py sdist
twine upload dist/*Coverage
Package: wallace-platform
Wallace is a platform for conducting research on experimental cultural
evolution. Its namesake is Alfred Russel Wallace, a British naturalist
and the oft-ignored codiscoverer of evolution by natural selection. You
can use Wallace to create new experiments or to reproduce existing
experiments.FeaturesRuns experiments on experimental cultural evolutionCoordinates participant recruitment using Mechanical TurkDemos of common experimental paradigmsInstallTo install Wallace, seeDeveloping Wallace (setup
guide).DocumentationDocumentation is available on thedocumentation
website.ContributeIssue Tracker:http://github.com/berkeley-cocosci/Wallace/issuesSource Code:http://github.com/berkeley-cocosci/WallaceSupportIf you are having issues, please let us know. We run a users group athttps://groups.google.com/d/forum/wallace-usersLicenseThe project is licensed under the MIT license.
Package: wal-lang
WAL the Waveform Analysis LanguageWelcome to the Waveform Analysis Language (WAL) repository. This domain-specific language aims at enabling automated and sophisticated analysis of hardware waveforms. In WAL, hardware-specific things such as signals and simulation time are treated as first-class citizens of the language.Installation from PyPiWAL is available fromPyPi!pip install wal-lang --userOn some systems, pip does not add WALs installation path to the PATH variable. If the "wal" command is not available after installation please add the installation path, e.g. ~/.local/bin on Ubuntu, to your PATH variable.To get the latest development version of WAL you can clone this repository.
After that, follow the instructions for your OS below inside the cloned directory.Installation from SourceFor Ubuntu (22.04 LTS):sudo apt install git cmake python3-cffi python3.10-venv python3-pip build-essential -y
git clone https://github.com/ics-jku/wal.git
cd wal
PYTHON=python3 make install
echo "export PATH=\$PATH:$HOME/.local/bin" >> ~/.bashrcFor Fedora (36):sudo dnf install git cmake g++ zlib-devel python3-devel -y
git clone https://github.com/ics-jku/wal.git
cd wal
make installFor OpenSuse Tumbleweed:sudo zypper install git cmake gcc-c++ zlib-devel python3-devel
git clone https://github.com/ics-jku/wal.git
cd wal
make installSupport for fst waveformsTo add support for the fst filetype to WAL, install thepylibfstpackage.pip install --user pylibfstPyPy and Pyston SupportWAL also supports the alternative Python implementations PyPy and Pyston.
Both alternative implementations can lead to substantial speedups in a lot of scenarios.
To install WAL with an alternative implementation change thePYTHONvariable in the Makefile or install withPYTHON=pypy3 make install.If you are using PyPy you must also have the python-dev package installed for PyPy3.
On Ubuntu this package can be installed with 'sudo apt install pypy3-dev'.DocumentationThe WAL Programmer Manual is available onwal-lang.org.ExamplesTo get an impression of WAL you can check outbasic examples.
Also, this ASCII castASCII Cast, shows how the WAL REPL is used to compare two RISCV cores.WAWKWAWKis a project building on top of the WAL language. It combines the waveform analysis of WAL with the programming Style of AWK.
Internally, WAWK is transpiled to WAL expressions, showcasing how new languages can be build on top of WAL.PublicationsThe initial paper on WAL was presented at ASPDAC'22 and can be downloaded here:https://www.ics.jku.at/files/2022ASPDAC_WAL.pdf.
The examples from the paper can be found in theexamplesfolder.If you like WAL or found it useful, you can cite our paper as follows:@InProceedings{KG:2022,
  author        = {Lucas Klemmer and Daniel Gro{\ss}e},
  title         = {{WAL:} A Novel Waveform Analysis Language for Advanced Design Understanding and Debugging},
  booktitle     = {ASP Design Automation Conf.},
  year          = 2022
}WAL was also used in other publications forprocessor analysis,Spade HDL integration,pipeline visualization, and for a noveldebug methodology.Emacs ModeA basic major mode for Emacs is availablehere.
Package: wallapopupdatewatcher
Wallapop update notifierThis package can be used to provide updates when new products appear on Wallapop. Install it just by using:pip install wallapopUpdateWatcherBasic usage examplefromwallapopUpdateWatcherimportupdateWatcher,Query,Productoimportasyncioasyncdefcallback(q:Query,l:list[Producto]):forprodinl:print(prod.msg())asyncdefmain():watcher=updateWatcher(callback)awaitwatcher.create("Iphone",strategy="price",min_max_sale_price=(15,30))# this creates a search for the product "Iphone"# between 15€ and 30€.whileTrue:awaitwatcher.checkOperation()awaitasyncio.sleep(5)asyncio.run(main())Strategies:Strategies are what decides if a product that has already appeared sometime is going to be notified. There are 3 strategies:Price:
This strategy only adds the product if its price has changed. It is thedefaultstrategy.New:
This strategy only notifies new products.Any:
This strategy notifies any product, even if it has already been notified.
Package: wallapopy
# wallapopyThis library provides a pure Python client for Wallapop. It works with Python versions from 2.6+ and Python 3.## APIAlready implemented:* User:* Profile.* Sold items.* Unsold published items.* Reviews sent to others.* Reviews received by others.* Items search.Other endpoints will be implemented as needed or requested.## InstallingYou can install wallapopy using:```$ pip install wallapopy```## UsingThe motivation for this project was to enable research about reputation in the Sharing Economy. Because I needed lots of data, it includes not only a _client_ but also a _request builder_ which can be used together with [Scrapy](https://github.com/scrapy/scrapy).### Client```python>>> from wallapopy import WallapopClient>>> client = WallapopClient()>>> client.user(40000000){u'gender': u'M', u'image': {u'averageHexColor': u'565b51', u'pictureId': 148033140...```### Request BuilderIt returns how to query the data: at the moment the url and HTTP method as nothing more is needed for the implemented endpoints.```python>>> from wallapopy import WallapopRequestBuilder>>> request_builder = WallapopRequestBuilder()>>> request_builder.user(40000000){'method': 'GET', 'url': 'http://pro2.wallapop.com/shnm-portlet/api/v1/user.json/40000000?'}```
Package: wallarm-fast-cli
DescriptionWallarm FAST CLI - A simple command line interface forWallarm FAST. For now, this tool can be used in CI system to create test runs and retrieve detected vulnerabilities.InstallationTo install the latest release from PyPI, you can run the following command:pip install wallarm-fast-cliAlso, you can use docker image:docker pull faloker/wallarm-fast-cliUsageUsage: fast-cli [OPTIONS] COMMAND [ARGS]...

  Wallarm FAST CLI - A simple command line interface for Wallarm FAST.

Options:
  --uuid TEXT    You personal UUID to authorize API calls. Defaults to the
                 value of the env variable WALLARM_UUID.
  --secret TEXT  You personal secret key to authorize API calls. Defaults to
                 the value of the env variable WALLARM_SECRET.
  --help         Show this message and exit.

Commands:
  check   Check that credentials (UUID and Secret key) are valid.
  create  Create a new test run with provided parameters.
  report  Get all findings from test run by id. Findings will be in JSON
          format.Main purpose of this tool is to create test runs from CI system (i.e. Jenkins), it can be done with create command:Usage: fast-cli create [OPTIONS]

Options:
  -n, --name TEXT             Test run name.  [required]
  -N, --node TEXT             Node name for test execution. No cloud, only
                              node.  [required]
  -D, --desc TEXT             Short description. Defaults to empty decription.
  -P, --policy TEXT           Policy name to apply.
  -T, --tags TEXT             Comma-separated tags to test run.
  -Rt, --rps-total INTEGER    The max number of concurrent requests.
  -Rb, --rps-per-url INTEGER  The max number of concurrent requests for one
                              baseline (unique url).
  --track / --no-track        If set, then test execution will be tracked and
                              all findings will be exported at the end.
  -o, --out-file TEXT         Save report to the file. Otherwise, the results will
                              be output to stdout.
  --help                      Show this message and exit.Example of command to create test run:fast-cli create -n awesome_run -N super_node -P my_policy -T fast,cli,test -Rt 200 -Rb 20
Package: wallarmrasp
Wallarm RASP clientIntroductionWallarm real time application security middleware (python module). Implement as WSGI applicationWorks on Python 2.7, 3.4, 3.5, 3.6, 3.7How to installpipinstallwallarmraspHow to useTheWallarmRASPMiddlewaresupports the following arguments:WallarmRASPMiddleware(self,application,mode='monitoring',**kwargs):"""Create and initialize Wallarm RASP WSGI middleware. Options host, portor sock are required.Args:application: WSGI applicationmode (str, optional): Wallarm mode. (default: 'monitoring')Keyword Args:host (str): Wallarm RASP server hostnameport (int): Wallarm RASP server portsock (str): Wallarm RASP server socket filenameblock_if_disconnected (bool, optional): Set to True if want to block page if connection to Wallarm RASP server is lost (default: False)sock_timeout_msec (int, optional): socket connection timeout with Wallarm RASP server (default: 10 seconds)request_max_body_size (int, optional): request max body size size that can be sent to Wallarm RASP server (default: 100MB)response_max_body_size (int, optional): response max body size size that can be sent to Wallarm RASP server (default: 100MB)block_headers (list of (header_name, header_value) tuples, optional): custom headers for block pageblock_body (list of str, optional): custom body for block pageReturns:WSGI application with Wallarm RASP middleware."""Connect to Wallarm RASP server via TCPfromwallarmrasp.wallarmraspimportWallarmRASPMiddleware# initialize default WSGI applicationwsgi_application=WallarmRASPMiddleware(wsgi_application,'block',host='WALLARM_RASP_SERVER_HOST',port='8989')## start WSGI applicationConnect to Wallarm RASP server via UDSfromwallarmrasp.wallarmraspimportWallarmRASPMiddleware# initialize default WSGI applicationwsgi_application=WallarmRASPMiddleware(wsgi_application,'block',sock='PATH_TO_WALLARM_RASP_SOCKET')## start WSGI application