Saravanan666/pypi-org huggingface dataset:
Package: wheel-filename
GitHub|PyPI|Issues|Changelogwheel-filenamelets you verifywheelfilenames and parse them into
their component fields.This package adheres strictly to the relevant PEPs, with the following
exceptions:Unlike other filename components, version components may contain the
characters!and+for full PEP 440 support.Version components may be any sequence of the relevant set of characters;
they are not verified for PEP 440 compliance.The.whlfile extension is matched case-insensitively.Installationwheel-filenamerequires Python 3.6 or higher.  Just usepipfor Python 3 (You have pip, right?) to installwheel-filename:python3 -m pip install wheel-filenameExample>>> from wheel_filename import parse_wheel_filename
>>> pwf = parse_wheel_filename('pip-18.0-py2.py3-none-any.whl')
>>> str(pwf)
'pip-18.0-py2.py3-none-any.whl'
>>> pwf.project
'pip'
>>> pwf.version
'18.0'
>>> pwf.build is None
True
>>> pwf.python_tags
['py2', 'py3']
>>> pwf.abi_tags
['none']
>>> pwf.platform_tags
['any']
>>> list(pwf.tag_triples())
['py2-none-any', 'py3-none-any']APIparse_wheel_filename(filename)Parses a wheel filename (astr,bytes, oros.PathLike) and
returns aParsedWheelFilenameinstance.  Any leading directory
components are stripped from the argument before processing.  If the
filename is not a valid wheel filename, raises anInvalidFilenameError.ParsedWheelFilenameA namedtuple representing the components of a wheel filename.  It has the
following attributes and methods:project: strThe name of the project distributed by the wheelversion: strThe version of the project distributed by the wheelbuild: Optional[str]The wheel’s build tag (Noneif not defined)python_tags: List[str]A list of Python tags for the wheelabi_tags: List[str]A list of ABI tags for the wheelplatform_tags: List[str]A list of platform tags for the wheelstr(pwf)Stringifying aParsedWheelFilenamereturns the original filenametag_triples()->Iterator[str]Returns an iterator of all simple tag triples formed from the
compatibility tags in the filenameInvalidFilenameErrorA subclass ofValueErrorraised when an invalid wheel filename is passed
toparse_wheel_filename().  It has afilenameattribute containing
the basename of the invalid filename.CommandNew in version 1.4.0wheel-filenamealso provides a command of the same name that takes a wheel
filename (The actual wheel does not have to exist) and outputs the filename
components as JSON.Example:$ wheel-filename pip-18.0-py2.py3-none-any.whl
{
    "project": "pip",
    "version": "18.0",
    "build": null,
    "python_tags": [
        "py2",
        "py3"
    ],
    "abi_tags": [
        "none"
    ],
    "platform_tags": [
        "any"
    ]
}
Package: wheeljack-repoman
[![Build Status](https://travis-ci.org/pinterest/wheeljack.png?branch=master)](https://travis-ci.org/pinterest/wheeljack)# WheeljackWheeljack helps manage dependent python projects.  All related projects willlive in `$WHEELJACK_REPO` and will interact with one another in the activevirtual environment.E.g. you may have a directory structure:```$WHEELJACK_REPO/foo/bar/```Where `foo` and `bar` are both python packages.  In this environment you shouldbe able to freely edit `foo` or `bar` and access one another by doing `importfoo` or `import bar`.  If you also do:```pip install bar```Your environment should favor the `git` working copy of `bar` over the `pipinstall`ed package.  This will allow you to work on packages and theirdependencies fairly seemlessly.Wheeljack expects you to use a `virtualenv`.## repos.confThis is a `yaml` file which lists repositories in Github or Github Enterprise.There are two main parts of the config.  `global` which applies to all `repos`and `repos` which define individual repositories.See `example.conf`.## install-repo`install-repo` will install a repo from a repos.conf file to `$WHEELJACK_CODE`.We'll instruct the user to use the `hub` command to fork this repo.## TODO* `update-libs` will update the current virtualenv:* It will `git fetch origin/master` on any repos in `$WHEELJACK_CODE`* It will `pip install -r $WHEELJACK_CODE/**/requirements.txt` for everyinstalled requirement.* Work with multiple python `virutalenv`s.
Package: wheels2dmg
wheels2dmgA Python utility to build an OSX disk image and.pkginstaller to install
a given set of wheels.The idea is that any package that can be installed via pip can also have a
safe dmg installer, because we use pip to install the wheels, and pip will
manage the dependencies.The installer only installs into Python.org Python, but includes instructions
on how to install manually into macports and homebrew.Here’s how to make an installer for matplotlib 1.4.0:wheels2dmg matplotlib 1.4.0 matplotlib --python-version 3.4.1Or for more than one package:wheels2dmg scipy-stack 1.0 scipy matplotlib ipython[notebook] \
    pandas numexpr sympy --python-version 2.7.8WarningPlease be careful - this software is alpha quality and has not been much
tested in the wild.  I’d love to get feedback if you have problems, and
I’d be very happy to have pull requests to this repo too.CodeSeehttps://github.com/matthew-brett/wheels2dmgReleased under the BSD two-clause license - see the fileLICENSEin the
source distribution.travis-cikindly tests the
code automatically under Python 2.7, 3.3 and 3.4.The latest released version is athttps://pypi.python.org/pypi/wheels2dmgSupportPlease put up issues on thewheels2dmg issue tracker.
Package: wheeltennis
Essential data analysis scripts to analyse wheelchair tennis field data which means:Standardised field testingWheeling match performanceVisualisation of IMUsMore in future (?)PrerequisitesYou need a valid version of Python 3.7InstallingYou can install this package with pip:pip install wheeltennisExamplesJupyter notebook examples can be found in the ‘IMU Field Examples folder’Reporting errorsIf you find an error/mistake or want to contribute, please contact me or submit an issue through this page.CitingIf you want to refer to this package please let me know
Package: wheelwright
Wheelwright helps you build, repair, or maintain bicycle wheels by
easily visualizing the tension of each spoke in relation to the target
tension desired for the rim.FeaturesVisualizes spoke tension, quickly showing whether the wheel is within specConverts deflection readings from Park Tool’s TM-1 tension meter to kilograms-force (kgf)Outputs a report of the wheel (as a PDF file) that can be given to a customer or hung on the refrigerator
Package: wheezy.caching
wheezy.cachingwheezy.cachingis apythonpackage written in pure Python code. It
is a lightweight caching library that provides integration with:python-memcached-
Pure Pythonmemcachedclient.pylibmc- Quick and smallmemcachedclient for Python written in C.It introduces idea ofcache dependency(effectively invalidate
dependent cache items) and other cache related algorithms.It is optimized for performance, well tested and documented.Resources:source codeandissuestracker are available ongithubdocumentationInstallwheezy.cachingrequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypisite:pipinstall-Uwheezy.caching
pipinstall-Uwheezy.caching[pylibmc]pipinstall-Uwheezy.caching[python-memcached]If you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.captcha
wheezy.captchawheezy.captchais apythonpackage written in pure Python code. It
is a lightweight captcha library that provides integration with (one of
below must be installed):PIL- Python Imaging
Library 1.1.7.Pillow- Python Imaging
Library (fork).It is optimized for performance, well tested and documented.Resources:source code,examplesandissuestracker are available ongithubdocumentationInstallwheezy.captcharequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypisite (you need specify
extra requirements per imaging library of your choice):pipinstallwheezy.captcha
pipinstallwheezy.captcha[PIL]pipinstallwheezy.captcha[Pillow]If you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.core
wheezy.corewheezy.coreis apythonpackage written in pure Python code. It
provides core features.It is optimized for performance, well tested and documented.Resources:source code,examplesandissuestracker are available ongithubdocumentationInstallwheezy.corerequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypisite:pipinstall-Uwheezy.coreIf you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.html
wheezy.htmlwheezy.htmlis apythonpackage written in pure Python code. It
is a lightweight html widget library. Integrates with the following
template systems:Jinja2 TemplatesMako TemplatesTenjin TemplatesWheezy TemplatesIt is optimized for performance, well tested and documented.Resources:source codeandissuestracker are
available ongithubdocumentationInstallwheezy.htmlrequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypisite:pipinstall-Uwheezy.htmlIf you would like take a benefit of template preprocessing for Mako,
Jinja2, Tenjin or Wheezy.Template engines specify extra requirements:pipinstallwheezy.html[wheezy.template]If you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.http
wheezy.httpwheezy.httpis apythonpackage written in pure Python code. It
is a lightweight http library for things like request, response,
headers, cookies and many others. It a wrapper around theWSGIrequest environment.It is optimized for performance, well tested and documented.Resources:source code,examplesandissuestracker are available ongithubdocumentationInstallwheezy.httprequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypisite:pipinstall-Uwheezy.httpIf you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.routing
wheezy.routingwheezy.routingis apythonpackage written in pure Python code. It
is a simple mapping between URL patterns (as plain simple strings, curly
expressions or regular expressions) to a handler that can be anything
you like (there is no limitation or prescription what handler is or
could be).The mapping can include other mappings and constructed dynamically.It is optimized for performance, well tested and documented.Resources:source code,examplesandissuestracker are available ongithubdocumentationInstallwheezy.routingrequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypi:pipinstall-Uwheezy.routingIf you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.security
wheezy.securitywheezy.securityis apythonpackage written in pure Python code. It
is a lightweight security library that provides integration with:pycrypto- The Python
Cryptography Toolkit.pycryptodome- PyCryptodome
is a fork of PyCrypto. It brings several enhancements.pycryptodomex- PyCryptodomex
is a library independent of the PyCrypto.cryptography- cryptography
is a package which provides cryptographic recipes and primitives to
Python developers.It is optimized for performance, well tested and documented.Resources:source code,
andissuestracker are available ongithubdocumentationInstallwheezy.securityrequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypisite:pipinstall-Uwheezy.securityIf you would like take benefit of one of cryptography library that has
built-in support specify extra requirements:pipinstallwheezy.security[pycrypto]pipinstallwheezy.security[pycryptodome]pipinstallwheezy.security[pycryptodomex]pipinstallwheezy.security[cryptography]If you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.template
wheezy.templatewheezy.templateis apythonpackage written in pure Python code. It
is a lightweight template library. The design goals achived:Compact, Expressive, Clean:Minimizes the number of keystrokes
required to build a template. Enables fast and well read coding. You
do not need to explicitly denote statement blocks within HTML
(unlike other template systems), the parser is smart enough to
understand your code. This enables a compact and expressive syntax
which is really clean and just pleasure to type.Intuitive, No time to Learn:Basic Python programming skills
plus HTML markup. You are productive just from start. Use full power
of Python with minimal markup required to denote python statements.Do Not Repeat Yourself:Master layout templates for inheritance;
include and import directives for maximum reuse.Blazingly Fast:Maximum rendering performance: ultimate speed
and context preprocessor features.Simple template:@require(user, items)
Welcome, @user.name!
@if items:
    @for i in items:
        @i.name: @i.price!s.
    @end
@else:
    No items found.
@endIt is optimized for performance, well tested and documented.Resources:source code,examplesandissuestracker are available ongithubdocumentationInstallwheezy.templaterequirespythonversion 3.8+. It is independent of
operating system. You can install it frompypisite:pipinstall-Uwheezy.templateIf you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.validation
wheezy.validationwheezy.validationis apythonpackage written in pure Python code. It
provides python object validation.It is optimized for performance, well tested and documented.Resources:source codeandissuestracker are available ongithubdocumentationInstallwheezy.validationrequirespythonversion 3.8+. It is independent of
operating system. You can install it frompypi:pipinstall-Uwheezy.validationIf you run into any issue or have comments, go ahead and add ongithub.
Package: wheezy.web
wheezy.webwheezy.webis a lightweight,high performance,
high concurrencyWSGIweb
framework with the key features tobuild modern, efficient web:Requires Python 3.6+.MVC architectural pattern
(push-based).Functionality includesrouting,model update/validation,authentication/authorization,contentcachingwithdependency,
xsrf/resubmission protection, AJAX+JSON, i18n (gettext),
middlewares, and more.Template engine agnostic (integration withjinja2,mako,tenjinandwheezy.template) plushtml widgets.It is optimized for performance, well tested and documented.Resources:source code,examples(live) andissuestracker are available ongithubdocumentationInstallwheezy.webrequirespythonversion 3.8+. It is independent of operating
system. You can install it frompypisite:pipinstall-Uwheezy.webIf you run into any issue or have comments, go ahead and add ongithub.
Package: when
InstallationInstall from PyPI:$ pip install whenor usingpipx:$ pipx install whenor:$ pipx install git+https://github.com/dakrauth/when.gitUsageTo access city names, you must install the cities database:when --dbYou can specify minimum city size by adding--sizeSIZE, whereSIZEcan be one of:15000- cities with population > 15000 or capitals5000- cities with population > 5000 or seat of first-order admin division, i.e. US state1000- cities with population > 1000 or seat of third order admin division500- cities with population > 500 or seat of fourth-order admin divisionAdditionally, you can filter non-admin division seats using--popPOP.The appropriate GeoNames Gazetteer is downloaded and a Sqlite database generated. Once
installed, you can search the database:$ when --db --search New York
5106292, West New York, West New York, US, New Jersey, America/New_York
5128581, New York City, New York City, US, New York, America/New_YorkAdditionally, you can add aliases. In the example directly above, we see that New York City has
a GeoNames ID of 5128581. Pass that to the--aliasoption along with another name that
you would like to use:$ when --db --alias 5128581 NYC
$ when --source NYC
2023-07-06 07:58:33-0400 (EDT, America/New_York) 187d27w (New York City, New York, US)[🌕 Full Moon]Example$when2023-07-0620:58:02+0900(KST,Asia/Seoul)187d27w[🌕FullMoon]$when--sourceCST2023-07-0606:58:54-0500(CDT,CentralStandardTime)187d27w[🌕FullMoon]2023-07-0615:58:54+0400(+04,CaucasusStandardTime)187d27w[🌕FullMoon]2023-07-0619:58:54+0800(CST,ChinaStandardTime)187d27w[🌕FullMoon]2023-07-0607:58:54-0400(CDT,CubaStandardTime)187d27w[🌕FullMoon]$when--sourceParis2023-07-0613:59:25+0200(CEST,Europe/Paris)187d27w(Villeparisis,Île-de-France,FR)[🌕FullMoon]2023-07-0613:59:25+0200(CEST,Europe/Paris)187d27w(Paris,Île-de-France,FR)[🌕FullMoon]2023-07-0613:59:25+0200(CEST,Europe/Paris)187d27w(Cormeilles-en-Parisis,Île-de-France,FR)[🌕FullMoon]2023-07-0607:59:25-0400(EDT,America/Port-au-Prince)187d27w(FondParisien,Ouest,HT)[🌕FullMoon]2023-07-0606:59:25-0500(CDT,America/Chicago)187d27w(Paris,Texas,US)[🌕FullMoon]$when--source"San Francisco,US"--targetAmerica/New_YorkMar719457:00pm1945-03-0722:00:00-0400(EWT,America/New_York)066d10w[🌘WaningCrescent]1945-03-0722:00:00-0400(EWT,America/New_York)066d10w[🌘WaningCrescent]DevelopRequirements Python 3.8+$gitclonegit@github.com:dakrauth/when.git$cdwhen$python-mvenvvenv$.venv/bin/activate$pipinstall.$when--help$when--db$pipinstalltox$tox
Package: whenact
WhenActWhenAct is a module that defines a decision flow. A中文文档is available to.The executing flow looks like:decision1: [when0] > [action0]
decision2: [when1] > [action10 > action11]
decision3: [when20 > when21] > [action2]
decision4: [when31 > when32] > [action3]When allwhenin one decision is satisfied, than it runs to it's followingaction.This decision process has two modes,auto_break=True, when runs into the firstwhen=True, this flow will finish after it's followingact.auto_break=False, the flow will continue flow even whenwhen=False.For example:# auto_break = True
decision1: [when0=True] > [action0]
decision2: X
decision3: X
decision4: X# auto_break = False
decision1: [when0=True] > [action0]
decision2: [when1=False] > X
decision3: [when20=True > when21=True] > [action2]
decision4: [when31=False > X] > XInstallpipinstallwhenactCreate WhenAct decision flowSimpling usewhenact.add()to add new decision to the flow process.importwhenactdefw1(ctx):returnTruedefa1(ctx):return"done"whenact.add(when=w1,act=a1)whenact.print_flow()# p0: [w1] > [a1]hist=whenact.run()asserthist.last_output=="done"asserthist.outputs==["done"]More complex pipeline can include more than one decision. Usingwhenact.add()to accumulate decisions.importwhenactdefw_false(ctx):returnFalsedefw_true(ctx):returnTruedefa1(ctx):return1defa2(ctx):return2defa3(ctx):return3whenact.add(when=w_false,act=a1)whenact.add(when=w_true,act=[a2,a3])whenact.print_flow()# p0: [w1] > [a1]# p1: [w2] > [a2 > a3]hist=whenact.run()print(hist.summary)# [p1: w1, p2: w2 > a2 > a3]asserthist.first_output==2asserthist.last_output==3asserthist.outputs==[2,3]The context(ctx) in eachwhenandactfunction passes context information from outside. You can store external
information in context, then pass it to the flow. Moreover, values can be set to the context when inside those
functions, then be carried out once the flow is finished.importwhenactdefw_false(ctx):returnFalsedefw_true(ctx):returnTruedefa1(ctx):ctx["action"]="a1 action"defa2(ctx):ctx["action"]="a2 action"defa3(ctx):ctx["action"]+=" with a3"whenact.add(when=w_false,act=a1)whenact.add(when=w_true,act=[a2,a3])whenact.print_flow()# p0: [w1] > [a1]# p1: [w2] > [a2 > a3]classTestContext(whenact.BaseContext):passctx=TestContext()hist=whenact.run(ctx)print(hist.summary)# [p1: w1, p2: w2 > a2 > a3]asserthist.last_outputisNoneasserthist.outputs==[None,None]assertctx["action"]=="a2 action with a3"There is another way to set a decision flow.importwhenactdefw_false(ctx):returnFalsedefw_true(ctx):returnTruedefa1(ctx):return1defa2(ctx):return2flow=whenact.DecisionFlow([whenact.Decision(when=[w_false],act=[a1],name="D1"),whenact.Decision(when=[w_true],act=[a2],name="D2"),])print(flow)# D1: [w_false] > [a1]# D2: [w_true] > [a2]hist=flow.run()asserthist.first_output==2More examplesMore examples can be found intests
Package: whenareyou
Gets the timezone of any location in the world.This uses google and caches the results so that you can hopefully stay outside
the free rate limit (which I have no idea how high it is).This is how you use it:$ pip install whenareyou
$ ipython

In [1]: from whenareyou import whenareyou

In [2]: tz = whenareyou('Hamburg')

In [3]: tz
Out[3]: <DstTzInfo 'Europe/Berlin' LMT+0:53:00 STD>

In [4]: from datetime import datetime

In [5]: tz.localize(datetime(2002, 10, 27, 6, 0, 0))
Out[5]: datetime.datetime(2002, 10, 27, 6, 0, tzinfo=<DstTzInfo 'Europe/Berlin' CET+1:00:00 STD>)

In [6]: tz.localize(datetime(2002, 10, 27, 6, 0, 0)).isoformat()
Out[6]: '2002-10-27T06:00:00+01:00'
Package: when-changed
when-changedRun a command when a file is changed~ What is it?Tired of switching to the shell to test the changes you just made to
your code? Starting to feel like a mindless drone, manually running
pdflatex for the 30th time to see how your resume now looks?Worry not, when-changed is here to help! Whenever it sees that you have
changed the file, when-changed runs any command you specify.So to generate your latex resume automatically, you can do this:$ when-changed CV.tex pdflatex CV.texSweetness!~ What do I need?Python 2.6+
watchdog~ Installationpip installhttps://github.com/joh/when-changed/archive/master.zip~ Usagewhen-changed FILE COMMAND…
when-changed FILE [FILE …] -c COMMAND
Package: when-cli
When CLIwhen-cliis a timezone conversion tool. It takes as input a natural time string, can also be a time range, and converts it into different timezone(s) at specific location(s).Local:Everything runs on your local machine, no internet connection neededFast:it's fast! 🚀Easy:quick to install – start using it in minutes.Customizable:configure every aspect to your needs.Colorful:beautiful colors and Emoji 😎 support.InstallationYou can installwhen-clifromPyPIwithpipx):$pipxinstallwhen-clior install it withpip:$python3-mpipinstallwhen-cliYou can also download and use the pre-build binary from the latestRelease.Usage$when-cli"7. May 06:00 to May 7th 12:00 in PMI"-lAmerica/Los_Angeles-lklu-lPMISeeUsagefor more details.ContributingPull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.Please make sure to update tests as appropriate.LicenseMITLogovecteezy.com
Package: whendo
whendo (When? Do!)whendo a single process/local file system-based action scheduling API server. No SQL and no No SQL. An action can be something as simple as turning on a raspberry pi pin or blowing a fog horn or capturing scheduled data feeds from a public api.whendo let's you define actions, test them individually, and schedule them to be performed at specified times and intervals during the day (with schedulers). You can create actions and run schedulers from a python script, within a Python CLI interpreter, within a Jupyter notebook -- basically anywhere you can run Python.Dependenciesinstall_requires =
uvicorn >= 0.13.3
fastapi >= 0.63.0
pydantic >= 1.7.3
schedule >= 1.0.0
requests >= 2.25.1Computers tested (so far):32-bit Raspbian Pi OS [pi 3B+, pi 4B]64-bit Intel-based Mac OS
Package: whendo-gpio
whendo_gpiowhendo_gpio adds Raspberry Pi GPIO Actions to a whendo installation. See whendo_gpio/action.py for GPIO Actions.If running on a Raspberry Pi, be sure to install RPi.GPIO. Also install psutil if you want additional system information to be available through
the SysInfo Action.The Mock.GPIO library is useful for running Jupyter notebooks and other runtimes (on non-Raspberry Pi computers) that create and manage Actions, Schedulers, and Programs destined for Raspberry Pi deployments.Dependenciesinstall_requires =
whendo >= 0.0.2a27
Mock.GPIO >= 0.1.8Computers tested (so far):32-bit Raspberry Pi OS [pi 3B+, pi 4B]64-bit Intel MacOS