Saravanan666/pypi-org huggingface dataset:
Package: windsor
WindsorToolkit to speed up AWS CDK applications development.windsoris a CLI tool built byWestpointto increase the development speed of applications built using AWS CDK by injecting pre-made code into the project as well as managing dependencie versions and project configurations.System requirementsTo usewindsorand all of its features make sure you have the following dependencies installed.Python >= 3.6npmAWS CLIAWS CDKInstallationInstallwindsorusing PyPIpip install windsorGetting startedCreate a CDK application using windsorEach CDK app have its own dependencies and must be in its own folder. Start by creating an empty folder in your terminal.$ mkdir my-app
$ cd my-appStart a CDK application runningwindsor init.Theinitcommand doesn't need to be ran in an empty folder. If you want to usewindsorin a project already started, the commandinitwill identify your project and create the a configuration file for it.Control your dependenciesWindsor can help you manage your CDK dependencies by locking the version of@aws-cdk/coreand providing commands to install and update these dependencies. The following example shows how to install the package@aws-cdk/aws-lambda.windsor install aws-lambdaNotice that you also don't need to specify the namespace@aws-cdk, windsor will prefix that in all packages listed to install.If you have packages with different versions, windsor provides a command to update all of them to the version specified in theCDKVersionattribute ofwindsor.jsonfile. To update all your packages run.windsor lockGenerating resourceswindsoris able to generate resources with the commandgenerate. Each resource generate will be in the form a CDK Construct, meaning that you can extend them and customize as you wish.Obs:windsordoesn't inject code in files that already exists in your project, that means that for every generated resource, you will need to instanciate the construct into your stack.windsor generate lambda-function --function-name HelloWorldThe example above shows how to generate a lambda function. The only required parameter to generate lambda functions isfunction-name, since windsor will store a default runtime for them in its configuration. To change the default runtime change the attributeDefaultRuntimein windsor configuration file.Resources availablelambda-functionParameters:function-nameruntimeExampleimport*ascdkfrom'@aws-cdk/core';importHelloWorldFunctionfrom'./constructs/helloworld';exportclassWindsortestStackextendscdk.Stack{constructor(scope:cdk.Construct,id:string,props?:cdk.StackProps){super(scope,id,props);newHelloWorldFunction(this,'HelloWorldFunction');}}codepipeline-reactA Pipeline that builds a React Application and sends to a S3 Bucket. The source stage pull code from Github and is triggered every time the branch (specified with the parameterbranch) is updated.Parameters:pipeline-nameExample:import*ascdkfrom'@aws-cdk/core';importReactPipelinefrom'./constructs/react-pipeline';exportclassWindsortestStackextendscdk.Stack{constructor(scope:cdk.Construct,id:string,props?:cdk.StackProps){super(scope,id,props);newReactPipeline(this,'ReactPipeline',{owner:'REPOOWNER',repo:'REPONAME',oauthToken:'YOURTOKEN'});}}
Package: windspharm
windspharm - spherical harmonic vector wind analysis in PythonOverviewwindspharmis a Python package for computing quantities derived from global wind
fields using spherical harmonics, licensed under the MIT license.
windspharm provides a user-friendly interface for vector wind computations on the
sphere (e.g., divergence, streamfunction etc.). It is based on thepyspharmmodule.
windspharm provides a replacement for the windfield package from CDAT.Requirementswindspharmonly requiresnumpyandpyspharm(version 1.0.8 or higher), but for full functionality (meta-data interfaces) one or more ofiris,xarrayor thecdms2module (fromUV-CDATis required.
The setuptools package is required for installation.
windspharm runs on Python 2 and 3.DocumentationDocumentation is availableonline.
The package docstrings are also very complete and can be used as a source of reference when working interactively.CitationIf you use windspharm in published research, please cite it by referencing thepeer-reviewed paper.
You can additionally cite theZenodo DOIif you need to cite a particular version (but please also cite the paper, it helps me justify my time working on this and similar projects).Frequently asked questionsDo I need UV-CDAT/iris/xarray to use windspharm?No. All the computation code uses numpy only. The iris, xarray and  cdms2 modules are only required for the meta-data preserving interfaces.Is windspharm a drop in replacement for windfield?No. Because windspharm was written from scratch the naming conventions for methods
are different. Some new methods have been added compared to windfield, and some
methods from windfield do not exist in windspharm.InstallationThe easiest way to install is viaconda:conda install -c conda-forge windspharmYou can also install from the source distribution.
Download the archive, unpack it, then enter the source directory and use:python setup.py install
Package: windspharm-syl
windspharm - spherical harmonic vector wind analysis in PythonOverviewwindspharmis a Python package for computing quantities derived from global wind
fields using spherical harmonics, licensed under the MIT license.
windspharm provides a user-friendly interface for vector wind computations on the
sphere (e.g., divergence, streamfunction etc.). It is based on thepyspharmmodule.
windspharm provides a replacement for the windfield package from CDAT.Requirementswindspharmonly requiresnumpyandpyspharm(version 1.0.8 or higher), but for full functionality (meta-data interfaces) one or more ofiris,xarrayor thecdms2module (fromUV-CDATis required.
The setuptools package is required for installation.
windspharm runs on Python 2 and 3.DocumentationDocumentation is availableonline.
The package docstrings are also very complete and can be used as a source of reference when working interactively.CitationIf you use windspharm in published research, please cite it by referencing thepeer-reviewed paper.
You can additionally cite theZenodo DOIif you need to cite a particular version (but please also cite the paper, it helps me justify my time working on this and similar projects).Frequently asked questionsDo I need UV-CDAT/iris/xarray to use windspharm?No. All the computation code uses numpy only. The iris, xarray and  cdms2 modules are only required for the meta-data preserving interfaces.Is windspharm a drop in replacement for windfield?No. Because windspharm was written from scratch the naming conventions for methods
are different. Some new methods have been added compared to windfield, and some
methods from windfield do not exist in windspharm.InstallationThe easiest way to install is viaconda:conda install -c conda-forge windspharmYou can also install from the source distribution.
Download the archive, unpack it, then enter the source directory and use:python setup.py install
Package: wind-stats
Wind statsWind-stats is a package to easily compute power statistics for your wind energy projects.FeaturesRead generalized wind climate (GWC) file fromGlobal Wind Atlas.Shelter model for wind speed reduction from obstacles.Compute global Weibull parameters based on site location.Get general statistics to compare different sites implementation (mean wind speed, mean power density).Compute annual energy production based on wind turbine power curve & site's wind distribution.Installationpip install wind-statsExamplesSee our examples on how to useRessourcesTroen, I., & Lundtang Petersen, E. (1989). European Wind Atlas. Risø National Laboratory.Peña, A., Bechmann, A., Conti, D., Angelou, N., & Troen, I. (2015). Shelter models and observations. DTU Wind
Energy. DTU Wind Energy E, No. 00923Marc Rapin , Philippe Leconte (2017). Évolution, principes de base et potentiel de conversion. Techniques de l'ingénieur
Package: windtalker
Welcome towindtalkerDocumentationIn World War II, US Marine specially recruited a lots of bilingual Navajo speakers to serve in their standard communications units in the Pacific Theater. These Navajo transmitted tactical messages over military telephone or radio communications nets using formal or informally developed codes built upon their native languages. These people, we call them —Wind Talkerwindtalkeris a utility tools built on top ofcryptographyandrsa. With this,you can encrypt/decrypt binary data, text, files or even a entire directory in single line of code! It support both symmetry and asymmetry encryption algorithm. For usage, you should start fromHEREExample (SymmtricCipher):>>>fromwindtalkerimportSymmetricCipher>>>c=SymmetricCipher(password="password")# Fernet encrypter>>>c.encrypt_text("Hello")Z0FBQUFBQlo0VHpVVjdWR0xCb0VEc0dMVUxib25jZEwzTWZ1UC1raFVmWndwNERrTmZVR1hNdzE3ZS05RWkwWXBrTi1adUhRWTNWYkxUT1Vkekh3MlVVcHZXLWxaMWMyOEE9PQ==>>>c.encrypt_file(r"C:\test.py")# c.decrypt_file(xxx) for decryptionC:\test-encrypted.py>>>c.encrypt_dir(r"C:\User\Admin\Document")# c.decrypt_dir(xxx) for decryptionC:\User\Admin\Document-encrypted.pyHARDCODE YOUR PASSWORD IN YOUR CODE IS DANGEROUS!:You can create a.windtalkertext file in your ${HOME} directory. and put your secret password in it.windtalker.SymmetricCiphercan automatically read password from it.${HOME} directory:Windows:C:\Users\<username>MacOS:/Users/<username>Linux:/home/<username>For more features and how to use RSA to encrypt your file or directory, please readTHISInstallwindtalkeris released on PyPI, so all you need is to:$pipinstallwindtalkerTo upgrade to latest version:$pipinstall--upgradewindtalker
Package: wind-validation
Wind ValidationWind validation is a python package that makes it easy to validate
wind measurements for wind resource applications. The data structures
are time series, histograms and Weibull distributions and adopted from
and defined inwindkit.The available validation options are shown in the figure above. There is an information reduction by going through the diagram from left to right. A time series is the most complete data structure to represent a wind climate and contains data series of wind speed and wind direction at one or many points. A histogram does not have a time dimension but instead represent the wind climate by describing frequency distributions for bins along the dimensions wind speed (wsbin) and wind direction (sector).When measuring over a long period the frequency of occurrence usually follows aWeibull distribution,
particularly when looking at a single sector. It is therefore common
practice in the wind energy industry to use the WeibullAandkparameters to denote the wind resource at a certain location. For computational efficiency wind resource assessment often operate on histograms or Weibull distributions.
There is a filtering step, which is generally needed to make the two time series
similar in space and time. Some examples of spatially aligning data
are given in theexamplesInstallationThe package is installable by conda or pip. For more information, read the completeinstallation instructionsPlease note that we only support Python >= 3.8!DocumentationYou can find the full documentationhttps://docs-wasp.ramtt.xyz/wind_validation/. There is also aWAsP Python toolsforum, where you can ask questions or help other users.
Package: windy
# windy## Short descriptionWindows GUI application for managing user/system environment variables.## FeaturesAdd/update/remove of the environment variablesBatch import of the environment variables from a file or a clipboardResizable GUI with the examined viewsAbsolutely free and open source## How to insttall the windy application
You can use a Python package managerpip install windyto intall it, or download thewindy-0.9.8.2.exefrom the [GitHub] (https://github.com/zeljko-m-gavrilovic/windy/raw/master/dist/windy-0.9.8.2.exe) repository.## Homepagecode repository: [GitHub](https://github.com/zeljko-m-gavrilovic/windy),
Python package [PyPI](https://pypi.python.org/pypi/windy).## NotesTested on Windows 7 and Windows 8## License
MIT## CreditsIcon Author Website [link](http://www.iconsmind.com)
Package: winerp
winerpAn IPC based on Websockets. Fast, Stable, and easy-to-use, for inter-communication between your processes or discord.py bots.Key FeaturesFastwith minimum recorded response time being< 2msLightweight, Stable and Easy to integrate.No limitation on number of connected clients.InstallationStable:pipinstall-UwinerpMain branch (can be unstable/buggy):pipinstallgit+https://www.github.com/BlackThunder01001/winerpWorking:This library uses a central server for communication between multiple clients. You can connect a large number of clients for sharing data, and data can be shared between any connected client.Import the library:importwinerpInitialize winerp client:ipc_client=winerp.Client(local_name="my-cool-app",port=8080)Start the client:awaitipc_client.start()# orasyncio.create_task(ipc_client.start())Registering routes:@ipc_client.routeasyncdefroute_name(source,user_name):returnf"Hello{user_name}"Requesting data from another client:user_name=awaitipc_client.request(route="fetch_user_name",source="another-cool-bot",user_id=123)Sendinginformationtype data to other clients:data=[1,2,3,4]awaitipc_client.inform(data,destinations=["another-cool-bot"])Example Usage:Start the server on terminal using$ winerp --port 8080. You can also start the server usingwinerp.ServerClient 1 (some-random-bot):importwinerpimportdiscordfromdiscord.ext.commandsimportBotbot=Bot(command_prefix="!",intents=discord.Intents.all())bot.ipc=winerp.Client(local_name="some-random-bot",port=8080)@bot.command()asyncdefrequest(ctx):# Fetching data from a client named "another-bot" using route "get_some_data"data=awaitbot.ipc.request("get_some_data",source="another-bot")awaitctx.send(data)@bot.ipc.route()asyncdefget_formatted_data(source,user_id=None):returnf"<@{user_id}>"@bot.ipc.eventasyncdefon_winerp_ready():print("Winerp Client is ready for connections")bot.loop.create_task(bot.ipc.start())bot.run("TOKEN")Client 2 (another-bot)importwinerpimportdiscordfromdiscord.ext.commandsimportBotbot=Bot(command_prefix="?",intents=discord.Intents.all())bot.ipc=winerp.Client(local_name="another-bot",port=8080)@bot.command()asyncdefformat(ctx):# Fetching data from a client named "some-random-bot" using route "get_formatted_data"data=awaitbot.ipc.request("get_formatted_data",source="some-random-bot",user_id=ctx.author.id)awaitctx.send(data)@bot.ipc.route()asyncdefget_some_data(source):return"You are very cool"bot.loop.create_task(bot.ipc.start())bot.run("TOKEN")
Package: wine-wrap
A versioned wine-prefix management tool with memory-shared prefixes.This tool simplifies the maintenance of individual wine-prefixes per
executable. Each prefix is version-controlled using git, allowing for
reproducible setups. Furthermore (if supported by host system), the
prefixes are stored as subvolumes on a BTRFS image. This makes storing
them more memory efficient by only saving differences between each
installation.Installationwine_wrapcan be installed usingpip:$pipinstallwine_wrapUsage$wine_wrap--helpUsage:wine_wrap[OPTIONS]COMMAND[ARGS]...Options:--helpShowthismessageandexit.Commands:clearClearallassociations.configureAssociatescriptwithgivenwine-prefix.runExecutegivenscriptinwine-prefix.scanScanforexecutablesingivenprefix.setAssociatescriptwithgivenwine-prefix.showShowcurrentsetup.Getting startedA typical use-case would be to first run an installer, and then the
created executable in the same wine-prefix. To do so, first run the
installer (as well as winecfg beforehand) and name the used prefix:$wine_wraprun--configure--nameMyOwnPrefixinstaller.exe[..]Afterwards, find the newly installed executable within this prefix and
associate it correctly:$wine_wrapscanMyOwnPrefix[..]>"/path/to/executable.exe"[..]$wine_wrapset"/path/to/executable.exe"MyOwnPrefixWe can then make sure that the correct script-prefix associations are
set:$wine_wrapshow---MyOwnPrefix--->installer.exe>executable.exeIt is then possible to simply run the executable in the correct
wine-prefix:$wine_wraprun/path/to/executable.exe[..]If we don’t need the scripts anymore, we can delete them in the end:$wine_wrapclear--delete-prefixes--prefixMyOwnPrefix[..]
Package: winfiletime
filetime.pyA Python module to convert datetime to/from aWin32 FILETIME structure.Reference algorithmUsageInstall from PyPI:pip install winfiletimeExample usage:importdatetimeimportwinfiletime# Convert a datetime to a filetimewinfiletime.from_datetime(datetime.datetime(2009,7,25,23,0))# 128930364000000000# Convert a filetime to a datetimewinfiletime.to_datetime(128930364000000000)# datetime.datetime(2009, 7, 25, 23, 0)LicenseThis project is hereby released in the Public Domain.
See theLICENSEfile for the full CC0 license text.
Package: winfspy
Bindings forWinFSPversion 1.4 and onward.Winfspy consists of three important modules:winfspy: expose the WinFSP APIwinfspy.memfs: a memory file system based on winfspywinfspy.tests.winfsp_tests: a test suite for black box testingwinfspy.tests.winfstest: a lighter test suite for black box testingRequirements and installationWinFSPversion 1.4 or higher has to be installed separately.Then install winfspy using pip:$ pip install winfspyWinFSP python APIUsage:from winfspy import (
    FileSystem,
    BaseFileSystemOperations,
    enable_debug_log,
    FILE_ATTRIBUTE,
    CREATE_FILE_CREATE_OPTIONS,
    NTStatusObjectNameNotFound,
    NTStatusDirectoryNotEmpty,
    NTStatusNotADirectory,
    NTStatusObjectNameCollision,
    NTStatusAccessDenied,
    NTStatusEndOfFile,
)Winfspy memory file systemUsage:# Run the memory fs as X: drive in verbose mode
$ python -m winfspy.memfs X: -v

# More information
$ python -m winfspy.memfsWinfsp-tests test suiteThis test suite integrates the external test suite ofwinfsp-tests.Usage:# Install winfspy with the test dependencies
$ pip install winfspy[test]

# Run the winfstest test suite on an existing X: drive
$ python winfspy.tests.winfsp_tests --file-system-path X:

# More information about pytest
$ python winfspy.tests.winfsp_tests -hWinfstest test suiteThis test suite is taken fromsecfs.test.winfstest.
It is basic yet useful to test common use cases.Usage:# Install winfspy with the test dependencies
$ pip install winfspy[test]

# Run the winfstest test suite on an existing X: drive
$ python winfspy.tests.winfstest --file-system-path X:

# More information about pytest
$ python winfspy.tests.winfstest -hLicenseFree software: BSD
Package: wing-carrier
wing-carrierUsed to send commands between dcc applications with build-in support for the wing-ide.This will soon be intergrated in my wing-ide-maya project.  If you're looking to get up and running with Maya, please check:https://github.com/Nathanieljla/wing-ide-mayaIf you implement your own DCC Pigeon I'd love collab, to grow this repository.
Package: winged-python
Winged-Python=============Winged-Python is an innovative Domain-Specific Language (DSL) library for efficient HTML writing in Python. Mirroring its Swift counterpart, Winged-Python is based on the DSL concept, focusing on simplification and specificity in HTML generation. Using the Composite design pattern, the library enables developers to construct HTML structures in a logical, organized, and reusable manner.This library is created to be fully independent, not requiring integration with specific server frameworks or front-end libraries. This offers developers the freedom to use Winged-Python across a variety of projects, from simple static pages to complex web applications, keeping the code clean, readable, and efficient.Usage Examplefromwinged.HTML.divimportDivfromwinged.HTML.himportHfromwinged.HTML.tableimportTablefromwinged.HTML.stringimportStringdivC=Div(("class","container"))h=H("1")h.add(String("Hello World"))divC.add(h)table=Table()table.add_table_headers(["Name","Age","Height","Location"])# Define headerstable.add_row()table.add_in_row(String("John"))table.add_in_row(String("25"))table.add_in_row(String("1.80"))table.add_in_row(String("New York"))table.add_row()table.add_in_row(String("Maria"))table.add_in_row(String("23"))table.add_in_row(String("1.50"))table.add_in_row(String("New Jersey"))divC.add(table)print(divC.generate())Output<divclass="container"><h1>Hello World</h1><table><thead><th>Name</th><th>Age</th><th>Height</th><th>Location</th></thead><tbody><tr><td>John</td><td>25</td><td>1.80</td><td>New York</td></tr><tr><td>Maria</td><td>23</td><td>1.50</td><td>New Jersey</td></tr></tbody></table></div>ContributingTo contribute, it's simple, follow the guidelines below to prepare your development environmentCreate environmentUser OS terminal or IDE terminalLinux or macOSpython3-mvenvvenvsourcevenv/bin/activateWindows.\venv\Scripts\activate.bat.\venv\Scripts\activate.ps1`Install dependenciespython3-mpipinstall-rrequirements.txtRun testspytestTODOMake documentation with Sphinx
Package: wingmonkey
[![Coverage Status](https://coveralls.io/repos/github/vikingco/wingmonkey/badge.svg?branch=master)](https://coveralls.io/github/vikingco/wingmonkey?branch=master)[![CI Status](https://travis-ci.org/vikingco/wingmonkey.svg?branch=master)](https://travis-ci.org/vikingco/wingmonkey)# wingmonkeymailchimp api v3 clientmailchimp v3 api reference documentation: http://developer.mailchimp.com/documentation/mailchimp/reference/overview/### SettingsTo be able to make calls to mailchimp without having to initialize a custom MailChimpSession yourself make sure that at least following environment variable is set (or added to a .env file):```pythonDEFAULT_MAILCHIMP_API_KEY=<YOUR MAILCHIMP API KEY>```For more advanced usage you can pass a custom MailChimpSession to the serializers and functions:```from wingmonkey.mailchimp_session import MailChimpSessionfrom wingmonkey.lists import ListSerializersession = MailChimpSession(api_endpoint=<YOUR MAILCHIMP BASE URL>, api_key=<YOUR MAILCHIMP API KEY>)list_serializer = ListSerializer(session=session)```### Some more usage examples:#### getting list info```pythonfrom wingmonkey.lists import ListSerializerlist_serializer = ListSerializer()list_id = 'A_VALID_LIST_ID'my_list = list_serializer.read(list_id=list_id)name = my_list.nametotal_subscribers = my_list.stats['member_count']unsubscribe_count = my_list.stats['unsubscribe_count']```#### creating new member```pythonfrom wingmonkey.members import Member, MemberSerializeremail_address = 'monkeysee@monkey.do'merge_fields = {FNAME: 'Ceasar', LNAME: 'Chimp'}language = 'en'list_id = 'A_VALID_LIST_ID'member_to_add = Member(email_address=email_address,merge_fields=merge_fields,language=language,list_id=list_id)member_serializer = MemberSerializer()newly_added_member = member_serializer.create(list_id=list_id, instance=member_to_add)```#### get all members of a list```pythonfrom wingmonkey.async_operations import get_all_members_asyncfrom datetime import datetime, timedeltalist_id = 'A_VALID_LIST_ID'```* all members```pythonall_list_members = get_all_members_async(list_id=list_id)```* all members updated since specific date (take care to use the correct string format for datetime)```pythondate_since = datetime.strftime(datetime.now() - timedelta(days=1), '%Y-%m-%dT%H:%M:%S')extra_params = {'since_last_changed': date_since }all_updated_members_since_yesterday = get_all_members_async(list_id=list_id, extra_params=extra_params)```#### batch update of a large list of members* This will return a list of corresponding batch operation resources (1 for every 500 members)http://developer.mailchimp.com/documentation/mailchimp/reference/batches/#create-post_batcheshttp://developer.mailchimp.com/documentation/mailchimp/reference/lists/#create-post_lists_list_id```pythonfrom wingmonkey.async_operations import batch_update_members_asynclist_id = 'A_VALID_LIST_ID'member_list = [A_LIST_OF_MEMBER_INSTANCES]batch_operation_resource_list = batch_update_members_async(list_id=list_id, member_list=member_list)```