Saravanan666/pypi-org huggingface dataset:
Package: winkeyerserial
winkeyerserialTalk to the K1EL WinKeyerSerial, WinKeyerUSB and WKMini.It provides an API to control the WinKeyer. It listens for XMLRPC requests on port 8000.The XMLRPC server exposes the following methods:k1elsendstringsetspeedsendblendedtuneontuneoffHave the Winkeyer device plugged in before starting this program.On first run the program writes a file.pywinkeyer.jsonto the root of your home directory.
This file contains the default serial device along with any saved messages. If your winkeyer doesn't happen to be /dev/ttyUSB0 choose the correct device in the upper left.Any time you edit a message field, it is automatically resaved to the json file.The default speed is set to by polling the speedpots current state. The program watches for speedpot changes and sets the speed accordingly. I do realize some of you (WKMini) may not have a speedpot. You can change the speed via the onscreen widget.Installing, updating, running and removal# installpipinstallwinkeyerserial# updatepipinstall-Uwinkeyerserial# runwinkeyerserial# removepipuninstallwinkeyerserialWhat's new[24-1-23] Removed trailing space in k1elsend()[23-5-11] Added xmlrpc function to set speed.[23-2-17] Added serial device descriptions (hover tooltip) to the detected serial devices in the dropdown.Added an XMLRPC server. So now myWinter Field Day,Field DayandK1USNSSTLoggers will be able to send CW macros to this. The interface for the client is dead simple:xmlrpc.client.ServerProxy("http://localhost:8000").k1elsendstring("Hello World")That's it...
Package: winlin
winlinwinlin is a portmanteau of the words windows and linux. The goal of this project
is to provide a small set of features for manipulating windows on linux platforms.
Eventually X11 and wayland will both be equally well supported.functionalitycurrently there are only two commands that are supportedresizeandmoveeach takes a window id in hexadecimal form as well as h, w and x, y respectively
they're both direct wrappers of the xdotool commands windowsize and windowmoveinstallingpip install winlin
Package: win-maximize
Win Maximize (Windows only)Finds Windows window by name (or part of it, or regex) and moves to monitor specified by monitor number or to monitor where mouse cursor is placed. Window is also maximized and placed on top.Automatically detects if found window is part of current process tree (as command line will have same text).I'm using it when I work on multiple Sublime Text 3 projects and I want to switch between them easily without alt-tabbing. I've done that by monkey-patching GotoWindow plugin.I've written is as replacement forhttps://github.com/ritchielawrence/cmdowwhich is excellent but antyvirus programs detects it as malware (which it is not but ...). If you do not have agressive corporate AV installed then I suggest just using it.InstallationInstall via pip:pip install win-maximizeUsageusage: win-mazimize [-h] [-m MONITOR] [-c] [window_title [window_title ...]]

positional arguments:
  window_title

optional arguments:
  -h, --help            show this help message and exit
  -m MONITOR, --monitor MONITOR
                        Monitor number to maximize to (if you have only 1
                        monitor - pass 0)
  -c, --cursor-track    Move window to monitor where cursor is located
Package: winmltools
WinMLTools provide following tools for Windows ML:Model ConversionWinMLTools enables you to convert models from different machine
learning toolkits intoONNXfor use with Windows ML.
Currently the following toolkits are supported:apple CoreMLkerasscikit-learnlightgbmxgboostlibSVMtensorflow (experimental)Here is a simple example to convert a Core ML model:from coremltools.models.utils import load_spec
from winmltools import convert_coreml
model_coreml = load_spec('example.mlmodel')
model_onnx = convert_coreml(model_coreml, 10, name='ExampleModel')Post Training Weight QuantizationWinMLTools provides quantization tool to reduce the memory footprint of the model.Here is an example to convert an ONNX model to a quantized ONNX model:import winmltools

model = winmltools.load_model('model.onnx')
quantized_model = winmltools.quantize(model, per_channel=True, nbits=8, use_dequantize_linear=True)
winmltools.save_model(quantized_model, 'quantized.onnx')DependenciesIn order to convert from different toolkits, you may have to install the following packages for different converters:ToolkitSourcekerashttps://pypi.org/project/Kerastensorflowhttps://pypi.org/project/tensorflowscikit-learnhttps://pypi.org/project/scikit-learnlightgbmhttps://pypi.org/project/lightgbmxgboosthttps://pypi.org/project/xgboostlibsvmYou can download libsvm wheel from various web sources. One example can be found here:https://www.lfd.uci.edu/~gohlke/pythonlibs/#libsvmcoremltoolsCurrenlty coreml does not distribute coreml packaging on windows. You can install from source: pip install git+https://github.com/apple/coremltoolsFor more information on WinMLTools, you can go toConvert ML models to ONNX with WinMLToolsLicenseMIT License
Package: winney
winneyInstallpip install winneyTutorialfromwinney.winneyimportAddressfromwinneyimportWinney,retryfromwinney.mockimportMockclassUserMock(Mock):data={"name":"olivetree"}classUserCenter(object):def__init__(self):self.winney=Winney(host="localhost",port=5000)self.init_functions()definit_functions(self):self.winney.register(method="post",name="login",uri="/api/login",mock=False,mock_data=None)self.winney.register(method="get",name="get_user",uri="/api/user",mock=True,mock_data=UserMock())deflogin(self,account,password):r=self.winney.login(json={"account":account,"password":password})returnr.json()defget_user(self,user_id):r=self.winney.get_user(data={"user_id":user_id})returnr.json()if__name__=="__main__":uc=UserCenter()uc.login("hello","123456")
Package: winney-redis
Winney 面向对象的 HTTP 请求Tutorialwy=Winney(host="www.baidu.com")wy.add_url(method="get",uri="/",function_name="download")wy.download()t=wy.get_bytes()print(t)The Best PracticefromwinneyimportWinneyfromconfigimportZEUS_HOST,ZEUS_PORT,APP_TYPE,ZEUS_TOKEN_HEADER,ZEUS_TOKEN_VALUEclassZeus(object):def__init__(self,host,port):self.winney=Winney(host=host,port=port,headers={ZEUS_TOKEN_HEADER:ZEUS_TOKEN_VALUE})self.init_functions()definit_functions(self):self.winney.add_url(method="get",uri="/zeus/app_types/",function_name="get_types")self.winney.add_url(method="get",uri="/zeus/app_types/{type_id}",function_name="get_type")self.winney.add_url(method="get",uri="/zeus/accounts/{user_id}",function_name="get_user_info")self.winney.add_url(method="get",uri="/zeus/application/{app_id}",function_name="get_app_info")self.winney.add_url(method="get",uri="/zeus/applications/",function_name="get_apps")defget_data(self,r):ifnotr.ok():returnNonedata=r.get_json()ifdata["code"]!=0:print("Failed to get zeus data, response = ",data)returnNonereturndata["data"]defget_apps(self,user_id):r=self.winney.get_apps(headers={"Authorization":"Token{}".format(user_id)},user_id=user_id)returnself.get_data(r)defget_types(self):r=self.winney.get_types()returnself.get_data(r)defget_type_by_id(self,type_id):r=self.winney.get_type(type_id=type_id)returnself.get_data(r)defget_user_info(self,user_id):r=self.winney.get_user_info(user_id=user_id)returnself.get_data(r)defget_app_info(self,app_id):r=self.winney.get_app_info(app_id=app_id)returnself.get_data(r)zeus=Zeus(host=ZEUS_HOST,port=ZEUS_PORT)zeus.get_app_info("123456)
Package: win-nic
Interface with network interface cards (NICs) on Windows-based computers. This package heavily
wraps the Windows management instrumentation command-line (WMIC) and the netsh command-line utility
via subprocess calls. No C dependencies or building from source files, just a lightweight and
straightforward wrapper of utilities built into your Windows system.Quick StartFirst, obtain a NIC instance via theNetworkAdaptersclass. To do this, instantiateNetworkAdaptersand specify the desired NIC. Specify the target NIC by registry index,
name, or connection ID (control panel name):>>> from win_nic import NetworkAdapters
>>> this_pc_nics = NetworkAdapters()
>>> ethernet_nic = this_pc_nics.get_nic(connection_id="Local Area Connection 1")Now, interface with the NIC instance as needed by getting attributes or calling methods:>>> ethernet_nic.property.ip_addresses
['192.168.0.2']
>>> ethernet_nic.net_connection_status
<NicNetConnectionStatus.CONNECTED: 2>
>>> ethernet_nic.set_static_address('192.168.0.3', '255.255.255.0', '192.168.0.1')
0
Package: winnotify
This package provides a Python extension module written in C to show native
Windows notifications.
Notifications appear as toasts on Windows 10 and as balloons on earlier
versions.There is alreadywin10toastPython module which does more or less the
same thing, but as it depends onpywin32it is not usable inmingwenvironment, aspywin32does not compile undermingw.InstallationJust do:pip install winnotifyor alternatively run:python setup.py installfrom root directory.Requirementswinnotifydoes not depend on any 3rd party modules.
You will need Python 3.6 or later.If you’re compiling from source you’ll needmingwor Windows SDK.Example>>> import notify
>>> notify.init('python.ico', callback)
>>> notify.notify('This notification body', 'Title', 'python.ico', False,
... 5, notify.dwInfoFlags.NIIF_USER | notify.dwInfoFlags.NIIF_LARGE_ICON)
>>> notify.uninit()To check if notification is currently visible:>>> notify.isvisible()
TrueFor complete documentation seehelp(). Supported file types areicoandpng, either as standalone files, resources in binaries or memory buffers.
Package: winnow
# winnowWinnow is a json interchange format for publishing families of configurable products. It has several distinct parts:+ A set of json schemata for documents describing products and associated information.+ A schema for defining sets of configuration options in products.+ A defined set of basic logical operations for manipulating documents with options.+ A python library that implements these operationsIn order to write and publish winnow documents you use the first two of these as they define how winnow documents are constructed. To apply logical operations to, and manipulate, winnow documents you will need to understand winnow's operations and it's library that implements them.## resources and documentsSome winnow documents describe named resources others do not.Resource documents have certain features: they are discoverable at a permanent url defined in the document itself; they are versioned and use Semantic Version numbers; these versions are themselves discoverable and resources may inherit from another resource of the same type.Eight resource types are currently defined in winnow. Follow links to see their full descriptions.+ [*range*](docs/range.md) - A collection of related designs with common authorship+ [*design*](docs/design.md) - A design+ [*product*](docs/product.md) - A family of versions of a design defined by a common set of options+ [*fileset*](docs/fileset.md) - A set of files that are useful for making all or a subset of a product family+ *finish* - A finish for a product defined by a set of materials and processes+ *material* - A material+ *process* - A process that is applied to a material+ *context* - An collection of options used to filter or extend a product's optionsWinnow also defines two document types that are not named resources, but are created as intermediate files during processing:+ *choice*+ *quantified_configuration*## validationIn winnow.schemata there are json schemata that can be used to validate winnow documents. This can be done using tools available from [json-schema.org](http://json-schema.org/implementations.html), or using winnow's python library like this:```pythonwith open(filepath, "r") as f:doc = json.loads(f.read())winnow.validate(doc)```## optionsSome winnow documents have a top level ```options``` attribute.  This object describes a related family of products by defining a set of possible configurations for a product, for example available colours or sizes.```json{"options":{"colour": ["red", "blue", "green"],"size": ["big", "small],"wheels": [4, 6]}...}```This describes the product family for a toy that comes in three colours, two sizes and can have either four or six wheels. Winnow provides both a json language for defining these options and a set of operations for manipulating them.You can read more about winnow's values here [options](docs/options.md)## operationsWinnow defines a set of simple, but powerful, operations to help manipulate winnow documents.+ *add_doc*+ *allows*+ *merge*+ *scope*+ *default_choices*+ *quantify*+ *filter_allows*+ *filter_allowed_by*+ *is_allowed_by*+ *expand*+ *asset_props*+ *validate*## library
Package: winnow-filters
Winnow is a framework for server-side filtering of data. It is designed to be expressive, extensible, and fast. Winnow’s inputs look something like this:{"logical_op":"&","filter_clauses":[{"data_source":"Created","operator":"before","value":"2015-03-01"},{"data_source":"Owner","operator":"any of","value":[{"name":"Steven","id":23},{"name":"Margaret","id":41},{"name":"Evan","id":90}]}]}Winnow’s outputs look something like this:"WHERE created_date <%s::timestamp AND owner_id = ANY(VALUES (%s),(%s),(%s))",('2015-03-01',23,41,90)
Package: winnowing
WinnowingA Python implementation of the Winnowing (local algorithms for document
fingerprinting)Original WorkThe original research paper can be found athttp://dl.acm.org/citation.cfm?id=872770.InstallationYou may installwinnowingpackage viapipas follows:pip install winnowingAlternatively, you may also install the package by cloning this repository.git clone https://github.com/suminb/winnowing.git
cd winnowing && python setup.py installUsage>>>fromwinnowingimportwinnow>>>winnow('A do run run run, a do run run')set([(5,23942),(14,2887),(2,1966),(9,23942),(20,1966)])>>>winnow('run run')set([(0,23942)])# match found!Default Hash FunctionQuite honestly, I did not know what hash function to use. The paper did
not talk about it. So I decided to use a part of SHA-1; more precisely,
the last 16 bits of the digest.Custom Hash FunctionYou may use your own hash function as demonstrated below.defhash_md5(text):importhashlibhs=hashlib.md5(text)hs=hs.hexdigest()hs=int(hs,16)returnhs# Override the hash functionwinnow.hash_function=hash_md5winnow('The cake was a lie')Lower Bound of Fingerprint Density(TODO: Write this section)
Package: winontop
Hey folks this is an easy to use tool to keep windows on top of others.
You have to specify only a part of the name in windows name.If you want a notepad, excel, word or any application to be on top while you work this is the tool you are looking for, no need to install any third party software.For installation >> pip install winontopIf you want a chrome tab to be on top just mention any word in the title.For eg. if you want youtube video “Game of Thrones Season 6: Episode #9 Preview (HBO)” on top
>>> winontop thrones
or
>>> winontop gamesFor help doc
>>> winontop -hTested on Windows 10/Python2
Feel free to contribute or report any issues athttps://github.com/jithurjacob/winontop
Package: winot
#WiNoT®WiNoT® is a range of products from Qantom Software Private Limited that makes it easy for IOT implementors to create wireless enabled IOT solutions without the need for complex embedded or socket programming knowledge.
The core principles of WiNoT® products are
It must be easy for people who are not electronic engineers or computer science specialists to be able to create IOT solutions
Must follow the 3-Easy-C principle - Easy to a)Create, b)Configure and c)Customize
Wireless intelligence must be built into the product. Any developer who wants to create customized sensors and output devices must be able to do so in easy steps
Package: winotify
WinotifyA pure python module to show notification toast on Windows 10.No dependencies, no requirements, all you need is PowerShell installed on your machine
(which in every Windows computer have it).InstallationInstall winotify using pippipinstallwinotifyFeaturesNotification stays in action centerClickable notification with 5 additional buttonsUse function as a callback when clicking the notificationUsageA simple notification with iconfromwinotifyimportNotificationtoast=Notification(app_id="windows app",title="Winotify Test Toast",msg="New Notification!",icon=r"c:\path\to\icon.png")toast.show()Result:The notification stays in the action center!Note that the icon path must beabsoluteotherwise
the notification will not showSet sound of the notificationAll supported audio are in theaudiomodulefromwinotifyimportNotification,audiotoast=Notification(...)toast.set_audio(audio.Mail,loop=False)Add action buttonfromwinotifyimportNotificationtoast=Notification(...)toast.add_actions(label="Button text",launch="https://github.com/versa-syahptr/winotify/")You can add up to 5 buttons each notificationCLIwinotify^-id myApp^-t"A Title"^-m"A message"^-i"c:\path\to\icon.png"^--audio default^--open-url"http://google.com"^--action"open github"^--action_url"http://github.com"Usewinotify-ncinstead ofwinotifyto hide the console window.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.LicenceMIT
Package: winpath
WinPathWinPath is a python module for retrieving common Windows system paths as Unicode strings.
It is especially useful in cases where the default path to a system file has been changed by the user.
i.e When a user has changed the default path to their Documents folder.WinPath is a fork of the originalWinPathsmodule by Ryan Ginstrom. It includes bug fixes for issues present in theWinPathsmodule and allows its inclusion in platform agnostic projects.InstallingInstall and update using pip:pipinstall-UwinpathA Simple ExampleWinPath can be imported and used within your own project like so.The following example assumes that the user has chosen to sync their Documents directory with Onedrive.importsysimportwinpathifsys.platform=="win32":# WinPath will only work on Windowsmy_documents=winpath.get_my_documents()print(my_documents)# C:\\Users\\username\\Onedrive\\DocumentsAvailable Functionsget_local_appdata: Path to%LOCALAPPDATA%get_appdata: Path to%APPDATA%get_desktop: Path to the logged in user's desktop folderget_programs: current user -> Start menu -> Programsget_admin_tools: current user -> Start menu -> Programs -> Admin toolsget_common_admin_tools: all users -> Start menu -> Programs -> Admin toolsget_common_appdata: Path to program data folderget_common_documents: Path to public documents folderget_cookies: Path to internet explorer cookies folderget_history: Path to internet explorer history folderget_internet_cache: Path to internet explorer cache folderget_my_pictures: Path to the logged in user's pictures folderget_my_documents: Path to the logged in user's documents folderget_program_files: Path to Windows program files folderget_program_files_common: Path to Windows' program files -> common files folderget_system: Path to Windows' System32 folderget_windows: Path to Windows folderget_favorites: Path to the logged in user's favorites folderget_startup: current user -> start menu -> programs -> startupget_recent: Path to the logged in user's recently used files folderLicenseThis project is licensed under the terms of the MIT license.
Package: winping
winpingPing implementation which utilizes Windows ICMP API:heart: :heart: :heart:You can say thanks to the author by donations to these wallets:ETH:0xB71250010e8beC90C5f9ddF408251eBA9dD7320eBTC:Legacy:1N89PRvG1CSsUk9sxKwBwudN6TjTPQ1N8aSegwit:bc1qc0hcyxc000qf0ketv4r44ld7dlgmmu73rtlntwInstallationStandard Python package installation.UsageUtilitySynopsisC:\>winping --help
usage: winping [-h] [-w TIMEOUT] [-l SIZE] [-t | -n COUNT] [-4 | -6] address

Ping implementation which utilizes Windows ICMP API

positional arguments:
  address     specifies the host name or IP address of the destination

optional arguments:
  -h, --help  show this help message and exit
  -w TIMEOUT  timeout in milliseconds to wait for each reply (default: 1000)
  -l SIZE     number of data bytes to be sent (default: 32)
  -t          ping the specified host until stopped (default: False)
  -n COUNT    number of echo requests to send (default: 4)
  -4          force using IPv4 (default: False)
  -6          force using IPv6 (default: False)ExampleC:\>winping google.com

Pinging google.com [172.217.20.206] with 32 bytes of data:
Reply from 172.217.20.206: bytes=32 time=29ms TTL=57
Reply from 172.217.20.206: bytes=32 time=25ms TTL=57
Reply from 172.217.20.206: bytes=32 time=24ms TTL=57
Reply from 172.217.20.206: bytes=32 time=25ms TTL=57

Ping statistics for 172.217.20.206:
    Packets: Sent = 4, Received = 4, Lost = 0 (0.00% loss),
Approximate round trip times in milli-seconds:
    Minimum = 24ms, Maximum = 29ms, Average = 26ms

C:\>winping -6 google.com

Pinging google.com [2a00:1450:401b:804::200e] with 32 bytes of data:
Reply from 2a00:1450:401b:804::200e: time=79ms
Reply from 2a00:1450:401b:804::200e: time=77ms
Reply from 2a00:1450:401b:804::200e: time=76ms
Reply from 2a00:1450:401b:804::200e: time=75ms

Ping statistics for 2a00:1450:401b:804::200e:
    Packets: Sent = 4, Received = 4, Lost = 0 (0.00% loss),
Approximate round trip times in milli-seconds:
    Minimum = 75ms, Maximum = 79ms, Average = 77msAlso, if python scripts are not in your system path, you may run it like this:python -m winpingLibraryimportwinpingwithwinping.IcmpHandle()ash:resp=winping.ping(h,'8.8.8.8')print(resp[0].RoundTripTime)withwinping.Icmp6Handle()ash:resp=winping.ping6(h,'2a00:1450:401b:804::200e')print(resp[0].RoundTripTime)For example of working ping utility seewinping/__main__.py.LimitationsWorks only on Windows XP / Windows Server 2003 and newer.No asyncio support at this moment, but you may run ping in thread executor.
Package: winpip
#WIN-PIPA Python to automate the work of "PIP" command in command line interface through Python Programmes for WINDOWS PYTHON INTERPRETER USERS#USAGEThere are many functions that you can use to manage the pip module commands all at once1)pip_installed_list()it is a function that gets the list of all installed pip_modules except "pip" and "setuptools"
it returns the data to a list data structure
it won't take any Parameters2)pip_outdated_list()it is a function that gets the list of all OUTDATED Packages that are installed  except "pip"
it returns the data to a list data struucture
it won't take any Parameters3)install_pip_module()
This function lets you install one pip module at once,only one parameter is allowed
parameters :: module Name
parameter_type ::string4)install_pip_modules()
This function lets you install one or more modules at a time ,only one parameter is allowed
parameters :: a list contains all the names of pacakages
parameter_type ::list5)uninstall_pip_module()
This function lets you uninstall one pip module at once,only one parameter is allowed
parameters :: module Name
parameter_type ::string6)uninstall_pip_modules()
This function lets you uninstall one or more modules at a time ,only one parameter is allowed
parameters :: a list contains all the names of pacakages
parameter_type ::list7)update_pip_module()
This function lets you update one pip module at once,only one parameter is allowed
parameters :: module Name
parameter_type ::string8)update_pip_modules()
This function lets you update one or more modules at a time ,only one parameter is allowed
parameters :: a list contains all the names of pacakages
parameter_type ::list