Saravanan666/pypi-org huggingface dataset:
Package: wasabi-geom
wasabigeom - fast geometry types for Python gameswasabigeomis a 2D geometry library intended for game development. It started
life as a pure Python library but is now implemented in optimised Cython code.DocumentationView on ReadTheDocsInstallationTo install, just run:pip install wasabi-geomWhat's new in 2.0.0I took the existingwasabi.geomcode and Cythonised it.I've made some big, breaking changes to the interface; notably, I prefer
radians thes days and eschew namespace packages. To install the old,
pure-Python version, pin towasabi-geom<2.
Package: wasabis3
WasabiS3A suite of maintenance tools for Wasabi S3 bucketsFree software: GNU General Public License v3Documentation:https://wasabis3.readthedocs.io.FeaturesDelete only non-current objectsDelete both current and non-current objectsPurge delete markers from bucketDelete bucket (after running above commands to ensure it’s empty)History0.1.0 (2023-03-03)First release on PyPI.
Package: wasamole
WasamoleA tasty framework for WebAssembly Software AnalysisDescriptionWasamole is a framework for analysingWebAssemblyprograms. It is meant to provide:A WASM disassembler.A WASM assembler.A WASM VM implementation.A set of core modules to be used to build other WASM-based tools.DevelopmentWhen working on Wasamole please keep the following things in mind.FormattingAll code should be formatted withblack. There is amaketarget for it:make formatType CheckingAll code should be type checked withmypy.  There is amaketarget for it:make typecheckTestingRun unit tests with:make test
Package: wasc
Web Accessibility Simple CheckerTable of ContentsWeb Accessibility Simple CheckerInstallationUsageDocumentationLicenseDeveloppementDependenciesRunning wasc with hatchTesting wasc with hatchInstallationAttention, l'utilisation de python > 3.12 est nécessaire car il y a des soucis d'encodage pour les versions inférieures.pip install wascUsageUsage:wasc[OPTIONS]WEBSITESWebsitesAccessibilityCriteriaChecker,helpstoevaluateaccessibilityonalistofwebsitesWEBSITESisaCSVfilecontainingalistofwebsitesascouples"label";"URL"Options:-c,--checkersPATHPathtothelistofcheckers-f,--output_format[json|csv]Outputformat[default=json]-o,--outputFILENAMEOutputfile[default=stdout]--versionShowtheversionandexit.-h,--helpShowthismessageandexit.Example files are given indatadirectoryDocumentationDocumentation is availablehereLicensewascis distributed under the terms of theCECILL-2.1license by the following licensors :Juliette FrancisFrançois le BerreGuillaume Colletwascmain contact iscontact@latelierpartage.frFor details about the license, see fileLICENSE.txtDeveloppementFull source code is available on github :https://github.com/gcollet/wascThe project is developed under hatch project manager (hatch.pypa.io)Dependencieshatchproject manager is mandatory. The other dependencies are managed with hatch environment system.It isnot necessaryto install dependencies usingpip install -r requirements_dev.txtbut the file is present if needed.Running wasc with hatchInwascdirectory, use hatch to run wasc in the default environnement :hatch run wasc data/url_example.csvTesting wasc with hatchInwascdirectory, use hatch to test wasc files in the default environnement :hatch run test_all
Package: wAsciiArt
wAsciiArtSimple python module providing witrdotnet in ASCII art_ _           _       _              _   
 __      _(_) |_ _ __ __| | ___ | |_ _ __   ___| |_ 
 \ \ /\ / / | __| '__/ _` |/ _ \| __| '_ \ / _ \ __|
  \ V  V /| | |_| | | (_| | (_) | |_| | | |  __/ |_ 
   \_/\_/ |_|\__|_|  \__,_|\___/ \__|_| |_|\___|\__|Usagepip install wAsciiArtWith command linepython -m wAsciiArtWith interactive interpreter$ python
>>> from wAsciiArt import Waa
>>> w = Waa()
>>> print(w.getAsciiArt())In projectfrom wAsciiArt import Waa

waa = Waa()
print(waa.getAsciiArt())
Package: wasd
Yet another selenium wd wrapperRequirementspython >= 3.6pyenv is recommended (pyenv&pyenv virtualenv plugin)Docker & imageselenoid/vnc_chrome:##.#(https://hub.docker.com/r/selenoid/vnc_chrome)InstallBuild from source:$gitclonegit@github.com:Aurococcus/wasd.git
$cdwasd
$pipinstall.From pypi:$pipinstallwasdRun$mkdirhello_world
$cdhello_world# activate vevn e.g. $ pyenv local my_venv$pipinstallwasd
$wasdscaffold
$invokeselenoid.up
$pytesttestsThen go tolocalhost:8080CLI options$ pytest --env=<env>- run tests with settings<env>.ymlfrom_envdir$ pytest --listener- highlight found element during runtime$ pytest --save-screenshot- save screenshot on failure in_outputdir$ pytest --steps- enable verbose logApidef new_driver(self)
def get_driver(self)
def close_driver(self)
def open(self, path)
def open_url(self, url)
def refresh(self)
def grab_console_log(self)
def grab_page_html(self)
def grab_html_from(self, element)
def clear_field(self, input_element)
def fill_field(self, element, text)
def fill_field_with_delay(self, element, text, delay = 0.1)
def press_key(self, element, *chars)
def append_field(self, element, text)
def wait_for_element_visible(self, element, timeout = 5)
def wait_for_element_not_visible(self, element, timeout = 5)
def see_element(self, element, attributes = {})
def see_text(self, text, element = None)
def see_in_field(self, input_element, needle)
def see_number_of_elements(self, element, expected)
def click(self, element)
def grab_visible(self, element)
def grab_text_from(self, element)
def grab_attribute_from(self, element, attribute)
def grab_value_from(self, input_element)
def grab_multiple(self, elements)
def save_screenshot(self, name=None)
def get_screenshot_binary(self)
def move_mouse_over(self, element)
def switch_to_iframe(self, frame = None)
def save_session_snapshot(self, name)
def load_session_snapshot(self, name)
def set_cookie(self, name, value, params = {})
def scroll_to(self, element, offset_x = 0, offset_y = 0)
def scroll_into_view(self, element, offset_x = 0, offset_y = 0)
def delete_all_cookies(self)
def element_has_attribute(self, element, attr, expected_value = None)
def execute_js(self, script, *args)
def sleep(self, secs)
def wd_wait(self, timeout = 10, poll_frequency = 0.5)
def scroll_top(self)
def find(self, element)
def finds(self, element)
Package: wasd2play
Wasd2PlayOpen any stream in your favorite player!InstallFrom pippip install wasd2playManuallypython setup.py installRequirementspip install -r requirements.txtFeaturesOpen live wasd.tv streamsEx:wasd.tv/thedrzj -p vlcDesc: Open live stream THEDRZJ in vlc playerOpen  archived streamsEx:wasd2play wasd.tv/thedrzj --listEx:wasd2play wasd.tv/thedrzj --select 2or justwasd2play wasd.tv/thedrzj --lastDownload streamEx:wasd2play thedrzj -dDownload streamHelpusage: wasd2play [options] url

Open any stream in your favorite player!

positional arguments:
  url                   stream url

optional arguments:
  -h, --help            show this help message and exit
  -p YOUR_PLAYER, --player YOUR_PLAYER
                        Point your player
  -l, --last            Open last stream
  -s SELECTED, --select SELECTED
                        Select stream
  -ls [PAGE], --list [PAGE]
                        Show recent streams page by page
  -d, --download        Download stream with ffmpeg

Have a good time!
Package: wasd3r-sdk
Wasd3r Python SDKInstalling SDKUnix/macOSpython-mpipinstallwasd3r-sdkWindowspy-mpipinstallwasd3r-sdkUsing specific blockchain locally (optional)SupportingAPTOSTo use APTOS without a wasd3r server,aptos-sdkneeds to be installed optionally.Unix/macOSpython-mpipinstallwasd3r-sdk[APTOS]Windowspy-mpipinstallwasd3r-sdk[APTOS]Preparing DEV environmentUsingpyenvpyenvcould be installed viathis link.Initialize envpyenvinstall3.8.13
pyenvglobal3.8.13
gitclonegit@github.com:WASD3Rplay/wasd3r-sdk.gitcdwasd3r-sdkPATH=$(pyenvroot)/shims:$PATH;poetryenvusepython3.8;poetryinstallStart envcdwasd3r-sdk
poetryshell

python--version# Python 3.8.13whichpython|xargsls-al# /poetry/virtualenvs/wasd3r-sdk-xx-py3.8/bin/python -> /pyenv/versions/3.8.13/bin/python3.8UsingMinicondaMinicondacould be install viathis link.Initialize envcondacreate-nwasd3r-sdk-py3.8python=3.8
condaactivatewasd3r-sdk-py3.8
gitclonegit@github.com:WASD3Rplay/wasd3r-sdk.gitcdwasd3r-sdk
poetryenvusepython3.8;poetryinstallStart envcdwasd3r-sdk
poetryshell

python--version# Python 3.8.xwhichpython|xargsls-al# /poetry/virtualenvs/wasd3r-sdk-xx-py3.8/bin/python -> /miniconda/envs/wasd3r-sdk-py3.8/bin/python3.8
Package: waseda-ml-pipelines-sdk
ML Pipelines SDKTheml-pipelines-sdkpackage provides the pipeline-authoring SDK for theTFXmachine learning framework. This package is
a subset of thetfxpackage and is provided for TFX pipeline authors who wish
to minimize runtime dependencies.Releases are synchronized in lock-step with thetfxpackageand overall release notes
can be found athttps://github.com/tensorflow/tfx/releases.
Package: washer
Create fulltext indexes with your files and query them from the command line.InstallWith pip or (better)pipsi <https://github.com/mitsuhiko/pipsi>:pipsi install --python (which python3) washer
# or `sudo pip3 install washer`QuickstartOr seehttps://github.com/fiatjaf/washer/tree/master/example.UsageUsage: washer [OPTIONS] COMMAND [ARGS]...

Options:
  -d, --indexdir DIRECTORY  The directory in which the index files will be
                            kept. Defaults to a temporary directory.
  --help                    Show this message and exit.

Commands:
  index     Creates or overwrites and index at an...
  info      Display information about the index and...
  morelike  Lists files present at the index that share...
  search    Search the given index for a term or multiple...Usage: washer index [OPTIONS] [FILES_TO_INDEX]...

  Creates or overwrites and index at an specified location using the given
  files.

  FILES_TO_INDEX accepts multiple files and wildcards, as usual.

Options:
  -l, --lang [ar|da|nl|en|fi|fr|de|hu|it|no|pt|ro|ru|es|sv|tr]
                                  Comma-separated list of languages to use
                                  when indexing. Should be specified multiple
                                  times. Defaults to "-l pt -l en".
  --help                          Show this message and exit.Usage: washer search [OPTIONS] [QUERY]...

  Search the given index for a term or multiple terms.

  QUERY can be anything, typically it will be just one or a bunch of words,
  but it accepts special operators (NOT, AND, *, ? etc.) as specified in
  http://whoosh.readthedocs.io/en/latest/querylang.html

Options:
  --count             Force counting results. A mostly useless flag.
  --frag / --no-frag  Show text fragments of the files that matched.Enabled by
                      default.
  --help              Show this message and exit.LicenseThis tool is licensed in the same way as Whoosh, as long as it complies with requirements from the other two dependencies, click and blessings.
Package: washi
WashiWashi is a command line interface for organizing scientific research.  Yes, there are electronic lab notebooks out there.  However, most researchers still end up with a mess of unorganized data files on their computer.How it worksWashi organizes each experiment your run into the following folder structure:EXPINFO.md
setup/
data/
analysis/EXPINFO.md is like a readme.  It describes the experiment, maybe has pictures of your lab notebook, etc.The setup/ directory is for everything you do before the experiment (e.g., dilution calculations in excel, import literature references)The data/ directory is for RAW data.  That means the raw csv files coming of the your HPLC, spectrometer or whatever you use. This should not be processed.The analysis/ directory is for processed data and the scripts used to get that data.UsageTo create a washi folder structurewashi init
Package: wasimtest
SDK for Falcon AI.PurposeThefalconaiSDK is designed to provide developers with a streamlined way to interface with Falcon AI’s services. This SDK simplifies the process of making requests to various Falcon AI endpoints, enabling developers to focus on integrating AI capabilities without worrying about underlying API details.Package Installation and UsageThe SDK is available on PyPI:python -m pip install falconaiAfter installation, the SDK can be imported and utilized as follows:from falconai import falconai
result = falconai.chat(query="Hello Falcon AI!")
Package: waskr
Provides statistics for any WSGI application:Requests Per SecondTime to respondData can be accessed via a web interface and/or writing your own
plugins.
The plugins API is simple yet flexible enough to allow you to
get the specific stats you may need.Configuration is not needed and waskr provides a simple way
of configuring the middleware.
You can pass a dictionary with some values a path to an INI file
or work with paster/pylons/turbogears configuration objects.Full documentation can be found athttp://code.google.com/p/waskr
Package: wasm-cli-runner
WASM CLI RunnerRun WebAssembly Binary or Text files (.wator.wasm) directly from the command line.Imported functions to WebAssembly are at the moment:"print" ((import "" "print" (func $print (param i32))))To run a WebAssembly file, use:wasm_cli_runner test.watInstallationVia pippip install wasm_cli_runnerFrom sourceTo run this program from the code directly,pythonandpoetry(pip install poetry) are required. Clone or download the repository.To install all the dependencies, use your command line and navigate to the directory where thisREADMEfile is located in. Then runpoetryinstallExecutionTo execute the program usepoetryrunpython-mwasm_cli_runner
Package: wasmer-compiler-cranelift
Wasmer Python, the Cranelift compilerwasmeris a complete and mature WebAssembly runtime for
Python.wasmer_compiler_craneliftprovides the Cranelift compiler towasmer, so thatwasmeris able to compile WebAssembly module.Other compilers exist:wasmer_compiler_llvm,wasmer_compiler_singlepass.To get a more complete view, please see the documentation ofthewasmerpackage itself.InstallThis package must be used with thewasmerpackage, thus:$pipinstallwasmer
$pipinstallwasmer_compiler_craneliftUsageAny engines inwasmer.enginecan take thewasmer_compiler_cranelift.Compilerclass as argument:fromwasmerimportengine,Store,Module,Instancefromwasmer_compiler_craneliftimportCompiler# Let's use the Cranelift compiler with the JIT engine…store=Store(engine.JIT(Compiler))# … or with the native engine!store=Store(engine.Native(Compiler))# And now, compile the module.module=Module(store,open('my_program.wasm','rb').read())# Now it's compiled, let's instantiate it.instance=Instance(module)# And get fun, for example by calling the `sum` exported function!print(instance.exports.sum(1,2))DocumentationBrowse the documentation athttps://wasmerio.github.io/wasmer-python/api/wasmer_compiler_cranelift/.Alternatively, runjust build compiler-craneliftfollowed byjust docto generate the documentation insidedocs/api/wasmer_compiler_cranelift.html.
Package: wasmer-compiler-cranelift-py310
Wasmer Python, the Cranelift compilerwasmeris a complete and mature WebAssembly runtime for
Python.wasmer_compiler_craneliftprovides the Cranelift compiler towasmer, so thatwasmeris able to compile WebAssembly module.Other compilers exist:wasmer_compiler_llvm,wasmer_compiler_singlepass.To get a more complete view, please see the documentation ofthewasmerpackage itself.InstallThis package must be used with thewasmerpackage, thus:$pipinstallwasmer
$pipinstallwasmer_compiler_craneliftUsageAny engines inwasmer.enginecan take thewasmer_compiler_cranelift.Compilerclass as argument:fromwasmerimportengine,Store,Module,Instancefromwasmer_compiler_craneliftimportCompiler# Let's use the Cranelift compiler with the JIT engine…store=Store(engine.JIT(Compiler))# … or with the native engine!store=Store(engine.Native(Compiler))# And now, compile the module.module=Module(store,open('my_program.wasm','rb').read())# Now it's compiled, let's instantiate it.instance=Instance(module)# And get fun, for example by calling the `sum` exported function!print(instance.exports.sum(1,2))DocumentationBrowse the documentation athttps://wasmerio.github.io/wasmer-python/api/wasmer_compiler_cranelift/.Alternatively, runjust build compiler-craneliftfollowed byjust docto generate the documentation insidedocs/api/wasmer_compiler_cranelift.html.
Package: wasmer-compiler-llvm
Wasmer Python, the LLVM compilerwasmeris a complete and mature WebAssembly runtime for
Python.wasmer_compiler_llvmprovides the LLVM compiler towasmer,
so thatwasmeris able to compile WebAssembly module.Other compilers exist:wasmer_compiler_cranelift,wasmer_compiler_singlepass.To get a more complete view, please see the documentation ofthewasmerpackage itself.InstallThis package must be used with thewasmerpackage, thus:$pipinstallwasmer
$pipinstallwasmer_compiler_llvmUsageAny engines inwasmer.enginecan take thewasmer_compiler_llvm.Compilerclass as argument:fromwasmerimportengine,Store,Module,Instancefromwasmer_compiler_llvmimportCompiler# Let's use the LLVM compiler with the JIT engine…store=Store(engine.JIT(Compiler))# … or with the native engine!store=Store(engine.Native(Compiler))# And now, compile the module.module=Module(store,open('my_program.wasm','rb').read())# Now it's compiled, let's instantiate it.instance=Instance(module)# And get fun, for example by calling the `sum` exported function!print(instance.exports.sum(1,2))DocumentationBrowse the documentation athttps://wasmerio.github.io/wasmer-python/api/wasmer_compiler_llvm/.Alternatively, runjust build compiler-llvmfollowed byjust docto generate the documentation insidedocs/api/wasmer_compiler_llvm.html.
Package: wasmer-compiler-singlepass
Wasmer Python, the Singlepass compilerwasmeris a complete and mature WebAssembly runtime for
Python.wasmer_compiler_singlepassprovides the Singlepass compiler
towasmer, so thatwasmeris able to compile WebAssembly module.Other compilers exist:wasmer_compiler_cranelift,wasmer_compiler_llvm.To get a more complete view, please see the documentation ofthewasmerpackage itself.InstallThis package must be used with thewasmerpackage, thus:$pipinstallwasmer
$pipinstallwasmer_compiler_singlepassUsageAny engines inwasmer.enginecan take thewasmer_compiler_singlepass.Compilerclass as argument:fromwasmerimportengine,Store,Module,Instancefromwasmer_compiler_singlepassimportCompiler# Let's use the Singlepass compiler with the JIT engine…store=Store(engine.JIT(Compiler))# … or with the native engine!store=Store(engine.Native(Compiler))# And now, compile the module.module=Module(store,open('my_program.wasm','rb').read())# Now it's compiled, let's instantiate it.instance=Instance(module)# And get fun, for example by calling the `sum` exported function!print(instance.exports.sum(1,2))DocumentationBrowse the documentation athttps://wasmerio.github.io/wasmer-python/api/wasmer_compiler_singlepass/.Alternatively, runjust build compiler-singlepassfollowed byjust docto generate the documentation insidedocs/api/wasmer_compiler_singlepass.html.
Package: wasm-exec
wasm_execWasm-powered, sandboxed implementation ofexec()for safely running dynamic Python codeInstallpip install wasm_execUsagefrom wasm_exec import WasmExecutor

wasm = WasmExecutor()
code = "print('Hello World!')"
print(wasm.exec(code).text)

>> Hello World!How does this work?Arbitrary Python code is passed to thewasm_execfunctionA separate Wasm-based Python interpreter is setup via wasmtime in a chroot jailThe arbitrary code is executed safely inside your isolated interpreterWhy?There are number of use-cases emerging that require arbitrary code execution, often code that is generate by LLMs (Large Language Models) like ChatGPT. This can enable some really cool functionality - like generative BI or website generation - but also introduce a massive security flaw if implemented viaeval() or exec(). This is because arbitrary code can be executed using these methods. In a worst case scenario,exec'ing arbitrary code could enable some torm -rf /your entire server!This repo intends to provide a secure method of executing arbitrary Python code to empower LLM-based code generation. This was originally intended to be a direct PR toLangchainbut given that the problems withexec()extend to the entire Python ecosystem, it was decided that it would be better as a standalone package.Prove it.I understand any claims of being able to securely execute arbitrary code strings (rightfully) raises some eyebrows. Because of that, I've included a set of security-focused tests that attempt to use some common escape patterns to attempt to escape the jailed Wasm Python interpreter, including running therm -rf /test onmy own personal desktop.I strongly welcome any attempts to break the interpreter containment and/or security improvements to the code!Implementation NotesI do not claim the jailed Wasm Python interpreter as my original idea. This was inspired bySimon Willison's Blogon this topic and the linked code provided byTim BartThe Wasm Python runtime is redistributed from VMWare Wasm Labs' offering of aPython Wasm runtimeShout0out to Langchain as a source for Github workflowsBecause it is a separate interpreter, there are currently some limitations on imports. I am working to test and document these limitations.ContributingContributions VERY welcome! Seehere.
Package: wasm-import
printffunction for Python Web Assembly runtimeTHis project is intended as a small helper package for running Web Assembly files generated byc4wa compilerin Python.
However, it could be used with any Web Assembly project provided thatvariable arguments calling conventiondefined inc4waspec is followed.Consider the following WAT file, with comments (save it as fileadd.wat):(module;; function printf (imported): int, int -> void(import"c4wa""printf"(func$printf(parami32)(parami32)));; memory (exported)(memory(export"memory")1);; "%d + %d = %d\n" is written at address 1024(data(i32.const1024)"%d + %d = %d\0A\00");; function add (exported): int, int -> void(func$add(export"add")(param$ai32)(param$bi32);; memory[0-7] = $a(i64.store(i32.const0)(i64.extend_i32_s(get_local$a)));; memory[8-15] = $b(i64.store(i32.const8)(i64.extend_i32_s(get_local$b)));; memory[16-23] = $a + $b(i64.store(i32.const16)(i64.extend_i32_s(i32.add(get_local$a)(get_local$b))));; printf(1024, 0)(call$printf(i32.const1024)(i32.const0))))It exports functionadd, linear memory asmemoryand imports functionprintf, which expects twoi32arguments.To run it usingwasmer, we can use the following Python script
(save it as fileadd.py:importsysfromwasm_importimportsprintfdefmain(num1:int,num2:int):fromwasmerimportengine,Store,Module,Instance,Function,FunctionType,Type,ImportObjectfromwasmer_compiler_llvmimportCompilerstore=Store(engine.Native(Compiler))module=Module(store,open("add.wat",'r').read())import_object:ImportObject=ImportObject()defprintf(p_fmt,offset):mem=instance.exports.memory.uint8_view()res=sprintf(p_fmt,mem,offset)print(res,end='')import_object.register("c4wa",{"printf":Function(store,printf,FunctionType(params=[Type.I32,Type.I32],results=[]))})instance=Instance(module,import_object)instance.exports.add(num1,num2)if__name__=="__main__":iflen(sys.argv)!=3:print(f"USAGE:{sys.argv[0]}<num 1> <num 2>")exit(0)main(int(sys.argv[1]),int(sys.argv[2]))Then installwasmerpackages and execute:python3-mpipinstall--upgradewasmerwasmer_compiler_llvm
python3add.py1317# 13 + 17 = 30To usewasmtimeinstead, replacemainfunction above with this:defmain(num1:int,num2:int):fromwasmtimeimportStore,Module,Instance,Func,FuncType,ValTypestore=Store()module=Module.from_file(store.engine,"add.wat")defprintf(p_fmt,offset):mem=instance.exports(store)["memory"].data_ptr(store)res=sprintf(p_fmt,mem,offset)print(res,end='')instance=Instance(store,module,[Func(store,FuncType([ValType.i32(),ValType.i32()],[]),printf)])instance.exports(store)["add"](store,num1,num2)