Saravanan666/pypi-org huggingface dataset:
Package: whitespace
An interpreter written inPythonfor the imperative, stack-based language calledWhitespace.InstallationTo install, simply use pip (orpipenv):$pipinstallwhitespaceUsageLetprogram.wsbe anyWhitespaceprogram. To execute it, type:$whitespaceprogram.wsYou can find exampleWhitespaceprograms attests/fixtures.For example, here’s thefactorial program:$whitespacefact.wsEnteranumber:4040!=815915283247897734345611269596115894272000000000DevelopmentRecommended tools:pyenvpipenvClone the repository and install the dependencies:$gitclonegit@github.com:dwayne/whitespace-python.git$cdwhitespace-python$pipenvshell$pipenvinstall--devYou’re now all set to begin development.TestingTests are written using the built-in unit testing framework,unittest.Run all tests.$python-munittestRun a specific test module.$python-munittesttests.test_parserRun a specific test case.$python-munittesttests.test_parser.ParserTestCase.test_it_parses_pushReferencesWhitespace tutorialCreditsThanks toEdwin Bradyand Chris Morris for designing/developing this programming language; they are also developers of theIdrisprogramming language.
Package: whitespacelint
Simple Linting tool for whitespace written in Python based on [bashlint](https://github.com/skudriashev/bashlint)Installationwhitespacelintcan be installed via the Python Package Index or from source.Usingpipto installwhitespacelint:$ pip install whitespacelintYou can download the source tarball and installwhitespacelintas follows:$ python setup.py installor in development mode:$ python setup.py developRules listW201 Trailing whitespace: Trailing whitespaces are superfluous:Okay: echo Test#
W201: echo Test #W202 Blank line contains whitespace: Trailing whitespaces on blank lines
are superfluous:Okay: #
W202:  #W203 Trailing semicolon: Trailing semicolons are superfluous:Okay: echo Test#
W203: echo Test;#
Package: whitesymex
WhitesymexWhitesymex is a symbolic execution engine forWhitespace. It uses dynamic symbolic analysis to find execution paths of a Whitespace program. It is inspired byangr.InstallationIt is available on pypi. It requires python 3.7.0+ to run.$pipinstallwhitesymexUsageCommand-line Interface$whitesymex-h# usage: whitesymex [-h] [--version] [--find FIND] [--avoid AVOID] [--strategy {bfs,dfs,random}]#                   [--loop-limit LIMIT]#                   file## Symbolic execution engine for Whitespace.## positional arguments:#   file                  program to execute## optional arguments:#   -h, --help            show this help message and exit#   --version             show program's version number and exit#   --find FIND           string to find#   --avoid AVOID         string to avoid#   --strategy {bfs,dfs,random}#                         path exploration strategy (default: bfs)#   --loop-limit LIMIT    maximum number of iterations for symbolic loopsSimple example:$whitesymexpassword_checker.ws--find'Correct!'--avoid'Nope.'# p4ssw0rdPython APISimple example:fromwhitesymeximportparserfromwhitesymex.stateimportStatefromwhitesymex.path_groupimportPathGroupinstructions=parser.parse_file("password_checker.ws")state=State.create_entry_state(instructions)path_group=PathGroup(state)path_group.explore(find=b"Correct!",avoid=b"Nope.")password=path_group.found[0].concretize()print(password.encode())# p4ssw0rdMore complex example from XCTF Finals 2020:importz3fromwhitesymeximportparser,strategiesfromwhitesymex.path_groupimportPathGroupfromwhitesymex.stateimportStateinstructions=parser.parse_file("xctf-finals-2020-spaceship.ws")flag_length=18flag=[z3.BitVec(f"flag_{i}",24)foriinrange(flag_length)]+list(b"\n")state=State.create_entry_state(instructions,stdin=flag)# The flag is printable.foriinrange(flag_length):state.solver.add(z3.And(0x20<=flag[i],flag[i]<=0x7f))path_group=PathGroup(state)path_group.explore(avoid=b"Imposter!",strategy=strategies.DFS)flag=path_group.deadended[0].concretize()print(flag.decode())# xctf{Wh1t3sym3x!?}You can also concretize your symbolic variables instead of stdin:importz3fromwhitesymeximportparserfromwhitesymex.path_groupimportPathGroupfromwhitesymex.stateimportStateinstructions=parser.parse_file("tests/data/xctf-finals-2020-spaceship.ws")symflag=[z3.BitVec(f"flag_{i}",24)foriinrange(12)]stdin=list(b"xctf{")+symflag+list(b"}\n")state=State.create_entry_state(instructions,stdin=stdin)forcinsymflag:state.solver.add(z3.And(0x20<=c,c<=0x7f))path_group=PathGroup(state)path_group.explore(find=b"crewmember",avoid=b"Imposter!")flag=path_group.found[0].concretize(symflag)print("xctf{%s}"%flag)# xctf{Wh1t3sym3x!?}
Package: whitewater
A command line utility that converts short videos a format that can be played on mobile websites with the Whitewater Player Javascript library.→Full Documentation→Whitewater Player(needed to play videos)→Example SiteInstallation$pipinstallwhitewaterUsage$whitewater<file>[options]$whitewater(-h|--help|--version)Example:$whitewaterpath/to/video.mp4Options--blocksize <size>   The width/height of a single grid cell when
                     checking one frame against the previous one.
--grid <size>        The size of the diffmap images in rows and
                     columns, not absolute pixels.
--quality <percent>  JPEG quality setting.
--threshold <rms>    RMS threshold for determining whether a
                     single cell of a frame is different from
                     the previous one.
--format <filetype>  File format to save diffmap images as.For a full explanation of what these do and when you might want to use
them, checkthe
documentation.Python ModuleWhitewater can also be used as a module in your own Python scripts. TheWhitewater()class and its options are described in detail in thefull
documentation.fromwhitewaterimportWhitewatervideo=Whitewater('path/to/video.mp4')video.encode()
Package: whitex
whitexClean up LaTeX filesFree software: GNU General Public License v3Documentation:https://whitex.readthedocs.io.FeaturesTODOCreditsThis project is a fork ofblacktex.
The present project aims at OOP development.This package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.0.1 (2020-08-17)First release on PyPI.0.0.2 (2020-08-17)Restricted to tex extension only.0.0.3 (2020-08-18)Added flag –keep-comments.Improved comments handling.Modified behavior for removal whitespace around brackets.0.0.4 (2020-08-18)Internal changes0.0.5 (2020-08-18)Overwrite tex files and optionally keep backup.
Package: whitey
yt: a command-line YouTube clientytis a command-line front-end to YouTube which allows you to browse YouTube
videos and play them directly from the command-line. It usesyoutube-dlandmplayeroromxplayerto actuallyplaythe videos.The combination of a text based interface andomxplayermakesyta great
YouTube client for the Raspberry Pi.UsageLaunch usingmplayerwith:ytor, if you’re using a Raspberry Pi, usingomxplayer:pi-ytInstallationFrom PyPi (easier!)# Install dependancies
sudo apt-get install youtube-dl
# Ensure using latest version of youtube-dl to keep up with YouTube API changes
sudo youtube-dl -U

# Install from PyPi
sudo apt-get install python-setuptools
sudo easy_install whiteyFrom GitHub# Install dependancies
sudo apt-get install youtube-dl
# Ensure using latest version of youtube-dl to keep up with YouTube API changes
sudo youtube-dl -U

# Install from GitHub
sudo apt-get install python-setuptools
git checkout git@github.com:rjw57/yt.git
cd yt
sudo python setup.py installOne line install for the Raspberry Picurl -L https://github.com/rjw57/yt/raw/master/tools/install-pi.sh | shDependanciesyoutube-dlmplayer or omxplayerCommon problemsVideos don’t play when selected in interfaceMake sure you have the latest version of youtube-dl. youtube-dl has a self update
mechanism:sudo youtube-dl -UOmxplayer starts and terminates without playing videoFor high quality videos the default memory allocation on the Raspberry Pi doesn’t
provide enough memory to the GPU.The default 192M ARM, 64M GPU split can be changed to a 128M ARM, 128M GPU split
using raspi-config.sudo raspi-config
# Select memory-split
# Allocate 128M to the GPUSeehttp://elinux.org/RPi_Advanced_Setupfor more information.Getting more helpSeehttps://github.com/rg3/youtube-dlandhttps://github.com/huceke/omxplayerfor
more detailed help.ContributorsRich WarehamCreatedyt.Calum J. EadieAdded OMXPlayer support and pi-yt entry point.CreditsDistributeBuildoutmodern-package-templateyoutube-dlmplayerOmxplayerMark Baldridges’s“HOWTO: YouTube on the Raspberry Pi - sans X)”News0.4 - 27/00/2013Clarify licensing.Add Trove classifiers in setup.py.0.3 - 21/02/2013Added pi-yt entry point (Calum Eadie)0.2 - 29/10/2012Added command-line configuration of media player and OMXPlayer support (Calum Eadie)0.1 - 29/02/2012Initial version
Package: whit-phys-util
Tools for Colab in the Physics LabTools to support the use of Google Colab + GitHub for teaching undergraduate physics labs. Support for private repositories enables the use of GitHub Classroom.InstallationThis package is primarily intended for use within Google Colab. To install in a Colab notebook:!pip install whit-phys-utilImportingTo import the package after installation:importwhit_phys_utilCreating a GitHub credentials fileIf you will be regularly connecting GitHub private repositories to Colab sessions, the recommendation is to create a file containing your GitHub info and store it in your Google Drive.Create a file with the name.envordotenvusing the plain text editor of your choice.This file should have the following format:# for git
user_email = "yourname@host"
user_name = "your_GitHub_user_name"
gh_token = "GitHub_personal_access_token"In my case"yourname@host"was"jlarkin@whitworth.edu"and"your_GitHub_user_name"was"JohnMLarkin".Next, login to GitHub and selectSettingsfrom the menu hiding under your profile picture.SelectDeveloper settingsfrom the sidebar and thenPersonal access tokens.Click on theGenerate new tokenbutton.Noteis your name for this token so you can remember what it does and where it is used. Picking something likeColab repo linkmakes that clear.Check therepobox and then theGenerate tokenbutton.Copy this token and paste it into your.env/dotenvfile in place ofGitHub_personal_access_token.Move this file to the top-level folder of your Google Drive.Working with a GitHub repositoryClone a repository to Colab session storageReplaceREPO_URLwith the URL to your private GitHub repository:repo=whit_phys_util.local_repository("REPO_URL")If your Google Drive is not already mounted to this Colab session, you will be prompted to do so. If you created the GitHub credentials file as described above, this will then create a clone of the repository located in/content/REPO_NAME. Your current working directory will also be changed to this folder.
Package: whitson-sdk-python
Whitson Python SDKThis is the Whitson Python SDK for developers, data scientists, and engineers working withWhitson+.The API documentation is accessible with the client name:https://<CLIENT_NAME>.whitson.com/api-external/swagger/The source code is located in thewhitson/clientdirectory.Example usageStore your secrets in a.envfile:WHITSON_CLIENT_NAME=<client-name>WHITSON_CLIENT_ID=<client-id>WHITSON_CLIENT_SECRET=<client-secret>PATH_TO_TOKEN=token.jsonIf you have it, store your token in a JSON file. If not, it will be automatically generated and saved in the
directory specified byPATH_TO_TOKEN:{'access_token':'<access-token-value>','scope':'get:apipost:apidelete:api','expires_in':86400,'token_type':'Bearer','issued_at':1692136969.7024412}In a Python file:fromdecoupleimportconfigfromwhitson.clientimportWhitsonClientfromwhitson.client.configimportClientConfig# Get environment variablesclient_name=config("WHITSON_CLIENT_NAME")client_id=config("WHITSON_CLIENT_ID")client_secret=config("WHITSON_CLIENT_SECRET")path_to_token=config("WHITSON_TOKEN_PATH")# CONNECT TO WHITSON# If no token_path is specified, the default location ("token.json") will be used.# If certain certificates are required for data to be requested, this can be specified in a PEM fileconfig=ClientConfig(client_name=client_name,client_id=client_id,client_secret=client_secret,pem_path="src/custom_cacerts.pem",# optional, may be required to traverse firewalltoken_path=path_to_token# where the token will be saved)# Instantiate client and retrieve dataclient=WhitsonClient(config)# ConstantsFIELD_ID=1PROJECT_ID=159# Get fieldfield=client.fields.retrieve(field_id=FIELD_ID)print(f"{field.name}field retrieved.")# Get project associated with fieldproject=client.projects.retrieve(field_id=field.id,project_id=PROJECT_ID)print(f"{project.name}project retrieved.")# Get wells associated to the projectwells=client.wells.list(project_id=project.id)well=wells[0]print(f"{well.name}retrieved.")# Run BHP calculations for a wellclient.wells.run_bhp_calc(well_id=well.id)print("BHP calculations complete.")# Retrieve BHP calculations for a wellbhp_corr_well=client.wells.retrieve_bhp_calcs(well_id=well.id)print(f"BHP calculations retrieved for{well.name}({well.id}).")# Retrieve all BHP calculations in a projectbhp_corr=client.wells.retrieve_bhp_calcs(project_id=project.id)print("BHP calculations retrieved for all wells.")ImprovementsThelist()andretrieve()functions in theapi/classes are very similiar. Need to find a way to
simplify this.Tests need to be written to show expected result when retrieving dataAcknowledgementsI learned a great deal from the amazing and talented people atCogniteand this
repository isheavilybased off of the structure of the publicly availableCognite Python SDK.
Thank you for the incredible experience and the continued learning your resources have provided me.
Package: whizbang-deployer
WhizbangThe Whizbang deployer is a tool designed to simplify deployments of Azure solutions.  The solutions contains utilities and functions that implmenting projects use to deploy specific azure solutions for customers.InstallationIt it important to note that this package is installed and distributed in two different modes:Local Binary Installation-> This requires the needed packages to be install globally.  This is how development with dependent projects (i.e. empower) is typically done.Containerized-> The containerized method includes binary dependencies which are used for CI/CD and is how the artifact is actually deployed and used in production.Mac Prequisitesbrew install docker docker-composeWindows PrequisitesTODOLocal Binary Buildpoetry installpoetry buildpip3 uninstall whizbang-deployer -ypip3 install ./dist/whizbang*.whlThen run any solution file directly:python solution.pyTo run tests:python3 -m pytestContainerized BuildThese may no longer work.To run pytests:docker-compose -f docker_builds/docker-compose.yml up --build pyenvTo run pytests with watch:docker-compose -f docker_builds/docker-compose.yml up --build pyenv-watch
Package: whizzml-kernel
whizzml_kernelwhizzml_kernelis a simple Jupyter kernel that allows you to run WhizzML
code in a Jupyter Notebook.InstallationNode.js and npm are needed for the kernel to work
properly. If you need information to install those, please refer tohttps://docs.npmjs.com/downloading-and-installing-node-js-and-npm. The rest of dependencies
will automatically be installed when installingwhizzml_kernelfrom PyPI::pipinstallwhizzml_kernelnpminstallxmlhttprequestpython-mwhizzml_kernel.installWhizzML credentialsIn order to access BigML using WhizzML, you'll need to provide your
credentials. Currently, the credentials are extracted from the existing
environment variables: BIGML_USERNAME, BIGML_API_KEY, BIGML_DOMAIN,
BIGML_API_VERSION, BIGML_PROJECT and BIGML_ORGANIZATION. The first two are
mandatory, while the rest can be missing. If so, BIGML_DOMAIN will be
set tohttps://bigml.io, the BIGML_API_VERSION will be set to the latest
version and no project or organization will be used. In order to set or
change those, you'll need to use the%envmagic command, as you would
using the Python kernel.Using the WhizzML kernelNotebook: TheNewmenu in the notebook should show an option for a WhizzML notebook.Console frontends: To use it with the console frontends, add--kernel whizzmlto
their command line arguments.The goal of this kernel is providing a REPL to useWhizzML.
As an example, you can try basic WhizzML operations, like defining a variable:defining a function:calling the function on two numbers:creating a source in BigML from some data:Summarizing and storing your WhizzMLSome magics have been added to the currently availablePythonmagics as
utilities that can help you store your WhizzML code and create a script from
it. The steps to do so are:Saving the notebook, so that the corresponding.ipynbfile contains
the current version of the code.Using the%wstoremagic command in a separated input cell. The command
will callnbconvertto extract from the stored notebook the WhizzML code
and will create a.whizzmlfile with it. After that, a new cell will be
added to your notebook containing the%%wscriptmagic command and the
JSON needed to define the name, description, inputs and outputs of the
script. Inputs and outputs will be pre-populated by analizing the WhizzML
variables, but their type and defaults should be modified at will.Running the%%wscriptcommand with the correctly formatted JSON will
create a script from the code and the metadata.If you want to see the WhizzML code retrieved from your input cells, you can
use the magic command%wsource, that will output that for you.Also, if you want your environment (credentials, stored WhizzML code, etc.) to
be removed, you can use%wresetthat will clear all the stored information
without affecting the code in the input cells of your notebook.
Package: whl
Quickly makes Pythonwheelsfrom a bunch of .py files without needing asetup.pyat all.You probably don’t want to use this. It’s intentionally minimal for my own use-cases, and doesn’t have many features yet (no support for entrypoints, dependencies, extras). If all you’re looking for is a fast build, then consider usingflit build--formatwheelwith apyproject.toml, this should be nearly as fast.UsageFor a single file distribution:pythonwhl.pypath/to/myfile.pyFor a package (directory with an__init__.pyfile in it):pythonwhl.pypath/to/dirwhl.pywill look in some sensible places to autodetect the package name/version.RationaleIf all you want to do is package some.pyfile(s) into a.whl, that’s essentially just making a zipfile. Executing asetuptools/distutilsstyle installer script or aPEP517/PEP518style build system is bloated with features which you don’t need, and it can be done much cheaper/faster:$timepythonwhl.pymypkg./mypkg-0.1-py2.py3-none-any.whlpythonwhl.pymypkg0.06suser0.02ssystem86%cpu0.091totalCompared with doing things thecorrectway:$timepython-mbuild--wheel.*Creatingvenvisolatedenvironment......<blahblah>...Successfullybuiltmypkg-0.1-py2.py3-none-any.whlpython-mbuild--wheel.5.05suser0.53ssystem96%cpu5.776total
Package: whl2conda
whl2condaGenerate conda packages directly from pure python wheelswhl2condais a command line utility to build and test conda packages
generated directly from pure python wheels.Performance: because it does not need to create conda environments
in order to build, this ismuchfaster than solutions involvingconda-build.Dependency renaming: renames pypi package dependencies to their
corresponding conda name. Automatically renames packages from known
list collected from conda-forge and supports user-specified rename
patterns as well.Multiple package formats: can generate both V1 ('.tar.bz2') and V2 ('.conda')
conda package formats. Can also generate a unpacked directory tree for debugging
or additional user customization.Project configuration:whl2condaproject-specific options can be read from
project'spyproject.tomlfile.Test install support: supports installing conda package into a conda
environment for testing prior to deployment.Hides pypi dependencies: rewrites the original pip/pypi dependencies in the
installed dist-info to avoidcompatibility issues.InstallationWith pip:pipinstallwhl2condaWith conda (upcoming):condainstall-cconda-forgewhl2condaQuick usageGenerate a conda package in same directory as wheel file:whl2condabuilddist/mypackage-1.2.3-py3-none-any.whlAdd default tool options topyproject.tomlwhl2condaconfig--generate-pyprojectpyproject.tomlBuild both wheel and conda package for project:whl2condabuild--build-wheelmy-project-rootCreate python 3.10 test environment for generated conda package:whl2condainstalldist/mypackage-1.2.3.-py_0.conda--create-ntestenv\--extrapytestpython=3.10
Package: whlctl
Warthog Lights ControlThis Python module and command line tool control the lights on Thrustmaster's Warthog HOTAS throttle box.Largely based on thereverse-engineeringwork done by mfranzHow to useOnce installed, this tool provides a Python module and a command-line tool, both namedwhlctl.Command line toolwhlctl0# Turn off backlightwhlctl5# Turn backlight up to max brightnesswhlctl3-l1,5# Turn lights 1 and 5 up to brightness 3/5whlctl1-l0,5# Turn backlight and light 5 up to brightness 1/5Omitting the-lflag will default to adjusting the backlight, and turn off all other lights.Python APIimportwhlctlwhlctl.find_throttle()# -> "/dev/hidrawN" or FileNotFoundErrorwhlctl.write_leds(backlight=True,leds=[True,True,True,True,True],brightness=5)# -> None or FileNotFoundError (see find_throttle)find_throttle()Takes no argument and returns the HID node for the Thrustmaster Warthog throttle (044f:0404), or raises aFileNotFoundErrorif the device isn't found.This function is cached.write_leds(backlight: bool, leds: list[bool], brightness: int)Theledslist must contain 5 booleans which designate, in order, the five circular lights from top to bottom.Truemeans the light is to be powered on at the given brightness,Falsemeans it should be powered off.brightnessis expressed between 0 and 5.Returns nothing, implicitly callsfind_throttle()and thus can fail withFileNotFoundErroras above. It can also hit a permission error if the current user has no write permission to the device node.
Package: wh-lookml-gen
wh_lookml_gengenerates lookml from a warehouseFree software: MIT licenseDocumentation:https://wh-lookml-gen.readthedocs.io.Features### bq_lookml_generator v.0.1.1This automatic generator is buit over Josh Temples looker parser [https://github.com/joshtemple/lkml]. Building out lkml, it allows you to generate lookml from BigQuery metadata.## getting startedmake sure you are working in a venv.pip install lookml_genconfig paramsrun lookml_gen_inithead to .lookml_gen and input your wh credentialswarehouse configseither input big_query or red_shift (current support warehouses) under warehouse_nameinput schema nameinput project namesecuritybig_queryinput your keyfile pathred_shiftinput you credentialsinput your warehouse schema target in here lookml/bq_lookml_gen/warehouse_target.pytype lookml_gen into terminal and watch the base explore generate…## troubleshootingrun pip install -r requirements.txt if you are running into dependency issuesyou can run bq_lookml_gen.py from terminal if needed## to updatetwine upload –skip-existing dist/*## to developadd new features to setup tools using: python setup.py developrebuild the wheelpython setup.py sdist bdist_wheelpip freeze > requirements.txtcat requirements.txtCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.7 (2021-05-28)First release on PyPI.
Package: whl.setup
an experiment to replace ez_setup and setup_requires with something that works
the provided mechanism adds a python path where very recent seupptools and setuptools extensions can be installedinstallation:pip install -U whl_setup
whl_setup_script_installusage:# setup.py

from whl_setup import setup, Lazy

@Lazy
def extensions():
    from setuptools import Extension
    return [...]

if __name__ = '__main__':
    setup(
        ...
        use_scm_version=True,
        setup_requires=[
            'setuptools',
            'setuptools_scm'
        ]
        extensions=extensions,
        ...
    )