Saravanan666/pypi-org huggingface dataset:
Package: wire-st-sdk
WireST SDKWireST SDK is a library for Linux gateways that allows easy access to the data exported by an IO-Link device that implements theIOLinkST Protocol.DocumentationDocumentation can be foundhere.CompatibilityThis version of the SDK is compatible withPython3.5 and runs on a Linux system.PreconditionsThe WireST SDK makes use of thepySerialPython interface to serial ports on Linux.$sudopip3installpyserialMoreover, it uses theconcurrent.futuresmodule to run pools of threads in background, that serve listeners' callbacks.$sudopip3installfuturesInstallationThe WireST SDK can be installed through the Python pip package manager.$sudopip3installwire-st-sdkSetting up the application examplesBefore running the application examples, please prepare your devices as described here below:Theexample_iolink_1.pyapplication example shows how to connect IO-Link devices to a Linux gateway, to set their parameters, and to get data from them. The application requires to have a masterboard, e.g. the STEVAL-IPD004V1 evaluation board, connected to IO-Link devices, e.g. the STEVAL-IPD005V1 evaluation board, with a FW compatible with theIOLinkST Protocol.Other application examples which show how to send data to the cloud can be found within theEdgeST SDKfor Linux, an IoT edge computing abstraction library for Linux gateways.Running the application examplesTo run the application examples please follow the steps below:Install the WireST SDK as described by theInstallationchapter.Clone the WireST SDK git repository to download the application examples:$gitclonehttps://github.com/STMicroelectronics/WireSTSDK_Python.gitEnter the "wire_st_examples/iolink" folder and run the desired script:$sudopython3example_iolink_x.pyLicenseCOPYRIGHT(c) 2019 STMicroelectronicsRedistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.Neither the name of STMicroelectronics nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
Package: wireui-TheTimmoth
wireuiA tool for creating and managing wireguard configsVersion 0.1.0b4© 2020-2021 Tim SchlottmannInstallationPlease runpython3 -m pip install wireui-TheTimmothUsagePlease runpython3 -m wireuiHintsPlease note: the documentation for the API will not be created until release 0.1.0rc1
Package: wireup
WireupDependency Injection Container with a focus on developer experience, type safety and ease of use.[!TIP]
Simplify Dependency injection for Flask using the newFlask integration!Automatically inject dependencies without having to manually call autowire.Expose flask application configuration in the container.⚡ Key FeaturesInject Services and ConfigurationInterfaces / Abstract classesMultiple ContainersStatic factoriesSingleton/Transient dependenciesFramework AgnosticSimplified usage in Flask and FastAPI using the first-party integrations.📋 QuickstartExample showing a Database service, a repository and a web view which uses the repository to fetch all posts
from a fictional blog db.1. Register dependenciesfromwireupimportcontainer# Optionally wire parameters, they serve as configuration for services.# Think of a database url or environment name.container.params.update(existing_dict_config)# Register a class as a service in the container.@container.registerclassDatabaseService:# connection_url will contain the value of the parameter# with the given name in the annotation.def__init__(self,connection_url:Annotated[str,Wire(param="db_connection_url")]):self.engine=create_engine(connection_url)# Initializer injection is supported for regular classes as well as dataclasses.@container.register@dataclassclassPostRepository:db:DatabaseServicedeffind_all(self)->list[Post]:returnself.db.query...2. Inject@app.get("/posts")@container.autowire# Decorate all targets where the library must perform injection, such as views in an Api.# Services are automatically injected based on annotated type.# Optional for views when using flask or fastapi integration.defget_posts(post_repository:PostRepository):returnpost_repository.find_all()Installation# Install using poetry:poetryaddwireup# Install using pip:pipinstallwireup📑 DocumentationFor more informationcheck out the documentation🎮 Demo applicationA demo flask application is available atmaldoinc/wireup-demo
Package: wireviz-web
AboutWireViz-Web is a wrapper around the excellentWireVizbyDaniel Rojasfor bringing it to the web.Originally, it has been conceived within aWireViz forkbyJürgen Key.
For compatibility withPlantUML, it includes aPlantUML Text Encoding formatdecoder byDyno FuandRudi Yardley.Thanks!DetailsWireVizWireViz is a tool for easily documenting cables, wiring harnesses and connector pinouts.
It takes plain text, YAML-formatted files as input and produces beautiful graphical output
(SVG, PNG, …) thanks toGraphviz.
It handles automatic BOM (Bill of Materials) creation and has a lot of extra features.WireViz-WebWireViz-Web wraps WireViz with a REST API using Flask. It also provides specific rendering
endpoints for PlantUML.SetupInstall prerequisites:{apt,brew,dnf,yum,zypper} install python3 graphvizInstall package:pip install wireviz-webUsageRun server:wireviz-webInvoke requests:# Acquire WireViz YAML file.
wget https://raw.githubusercontent.com/daq-tools/wireviz-web/main/tests/demo01.yaml

# Render images.
http --form http://localhost:3005/render yml_file@demo01.yaml Accept:image/svg+xml
http --form http://localhost:3005/render yml_file@demo01.yaml Accept:image/png

# Render HTML page with SVG image and BOM table.
http --form http://localhost:3005/render yml_file@demo01.yaml Accept:text/html

# Render BOM in TSV format.
http --form http://localhost:3005/render yml_file@demo01.yaml Accept:text/plain

# Render BOM in JSON format.
http --form http://localhost:3005/render yml_file@demo01.yaml Accept:application/json

# Render a PlantUML request.
http http://localhost:3005/plantuml/svg/SyfFKj2rKt3CoKnELR1Io4ZDoSa700==
http http://localhost:3005/plantuml/png/SyfFKj2rKt3CoKnELR1Io4ZDoSa700==NoteThehttpcommand used in the examples is the excellentHTTPieprogram.For visiting the Swagger OpenAPI spec, go tohttp://localhost:3005/doc.Project informationContributionsEvery kind of contribution, feedback, or patch, is much welcome.Create an
issueor submit a patch if you think we should include a new feature, or to
report or fix a bug.In order to follow the general development discussion, please seeBringing
WireViz to the Web.DevelopmentIn order to setup a development environment on your workstation, please head
over to thedevelopment sandboxdocumentation. When you see the software
tests succeed, you should be ready to start hacking.ResourcesSource code repositoryDocumentationPython Package Index (PyPI)LicenseThe project is licensed under the terms of the GNU AGPL license.
Package: wirewalk
wirewalkReferencesWire Before You Walk. T. Asmara, D. Bhaskar, I. Adelstein, S.
Krishnaswamy, M. Perlmutter. In proceedings for Asilomar
2023.Asilomar 2023 ProceedingsTo reproduce the results, please see the instructions in theAsilomar_2023.pyfile.InstallpipinstallwirewalkPrerequisitesYou will needPython3NetworkxNumpyGensimeditdistanceI highly recommend installing anAnacondaenvironment. Future versions of WireWalk will be available on PyPI and
conda.How to useimportnetworkxasnxfromwirewalk.coreimportWireWalk,jaccard_coefficient,max_flow# Create a graphgraph=nx.fast_gnp_random_graph(n=10,p=0.5)# Instantiate a WireWalk objectwireWalk=WireWalk(graph,dimensions=128,window=10,walk_length=80,num_walks=10,workers=1)# Compute transition probabilities using jaccard coefficient transformation, generate walks, and embed nodesmodel=wireWalk.fit(jaccard_coefficient)# **MAX_FLOW and MIN_COST_MAX_FLOW ONLY WORK WITH GIVEN capacity**# If weight exists, then# nx.set_edge_attributes(graph, nx.get_edge_attributes(graph, "weight"), "capacity").# Otherwise,nx.set_edge_attributes(graph,1,"capacity")model=wireWalk.fit(max_flow)
Package: wire-web
WireEasy, fast, stableWire is designed to provide the user with the greatest possible comfort when creating Rest APIs or entire websites.
Everything is simple and, above all, intuitively designed. No focus on superfluous configurations. Everything works, simply.🔑 Key featuresintuitive, due to the clear designsimple, due to the fast learning curvepractical, through the great editor supportminimalistic, no superfluous functionsWhat is Wire and what is notWire is not a HighSpeed framework. Wire is probably not ready for production. Wire is a spare time project of mine. Wire is self-contained. It doesn't need anything, except for an ASGI server. So it's like Starlette.
I would appreciate if you use Wire, try it and give me your feedback.Participate in WireYou are welcome to collaborate on Wire. However, you should maintain the codestyle, and also follow PEP 8 (the Python style guide).Wire disadvantagesWire is still deep in development, which is why some features are still missing.WebsocketsExamplesHere is the most basic example of wirefromwireimportWire,Requestapp=Wire()@app.get("/home")asyncdefhome(req:Request):return"Welcome home"You want to build a RestAPI? No problemfromwireimportWire,Requestapp=Wire()templates=FoxTemplates("templates")@app.get("/api")defapi(req:Request):return{"name":"Leo","age":16}You want to send HTML files? Wire got your backfromwireimportWire,Requestfromwire.responsesimportHTMLResponseapp=Wire()@app.get("/html")asyncdefhome(req:Request):withopen("home.html","r")asf:data=f.read()returnHTMLResponse(data)You want to use some templates ? You want to load templates? No problem withFuchsfromwireimportWire,Requestfromwire.templatingimportFoxTemplatesapp=Wire()templates=FoxTemplates("templates")@app.get("/home")asyncdefhome(req:Request):returntemplates.render("home.html",name="Leo")Changes incomingJoin ourdiscord!
Package: wirexfers
WireXfers is an online payments library, written in Python, supporting
various online payment protocols (IPizza, Solo/TUPAS) using a simple API.FeaturesSingle API for different providersSupported protocols:IPizzaEstonia:Danske BankKrediidipankLHV BankSEB BankSwedBankSolo/TUPASEstonia:Nordea Bank (Estonia)InstallationTo install WireXfers, simply:$ pip install wirexfersOr, if you absolutely must:$ easy_install wirexfersBut, you really shouldn’t do that.Usage exampleBasic usage in pseudocode:# Create provider-specific keychain...
keychain = PaymentProtocol.KeyChain(...)

# ...and initialize the provider
provider = PaymentProtocol(user, keychain, endpoint)

# Creating the payment request
payment = provider(payment_info, return_urls)

# Parsing the payment response
response = provider.parse_response(request.form)
if response.successful:
    # do something
else:
    # report failureHistory0.1 (10.12.2012)First release!Added Estonian banks:Danske bank (IPizza)Krediidipank (IPizza)LHV pank  (IPizza)Nordea (Solo/TUPAS)SEB bank (IPizza)Swedbank (IPizza)
Package: wirikiki
Wirikikiaims at being a productivity orientedmarkdown notebook.
It's compatible with the most common features supported by GitHub's markdown and adds a few other.Aims atfast /smallfootprintsimplicityof useunclutteredUI supporting bothdark & bright modesadvanced markdown supportviamarkItDownand plugins andMarkedfor the editorautoarchival(using git)InstallationBuilding3 ways to get a runnable code:install a release (eg: usingpip)make devmanual installationsh ./makevueApps.sh
npm install
DIST=1 ./node_modules/.bin/rollup -c rollup.config.jsUsageCreate one wikiwirikiki new myNewWikiRun the wikiGo to the newly created folder "myNewWiki" and run:wirikikiZero-install modeYou can just open the html file to get a degraded experience, data will not be saved.Keyboard shortcutsKeyDescriptionEscapeClose editor or modal, else toggles the sidebarDelDelete current pageEEdit current noteFSearch/Find somethingNCreate a new noteLeft/RightSwitch to previous/next noteAdvanced usageBasic git support is provided, to enable it just typegit initin themyKBfolder.cdmyKB
gitinitDependenciesPython 3if you want to run itwithout the virtualenvyou will need the following python packages:aiofilesfastapiuvicornnodejs and npm (BUILD ONLY)inotify-tools (DEV ONLY)Developers noteThis is built usingVue.js version 3for the front
andFastAPIfor the server side.
Package: wiringpi
This is an unofficial port of Gordon’s WiringPi library. Please do not
email Gordon if you have issues, he will not be able to help.For support, comments, questions, etc please join the WiringPi Discord
channel:https://discord.gg/SM4WUVGWiringPi for PythonWiringPi: An implementation of most of the Arduino Wiring functions for
the Raspberry Pi.WiringPi implements new functions for managing IO expanders.Quick InstallThe library is packaged on PyPI and can be installed with pip:pip install wiringpiUsageimportwiringpi# One of the following MUST be called before using IO functions:wiringpi.wiringPiSetup()# For sequential pin numbering# ORwiringpi.wiringPiSetupSys()# For /sys/class/gpio with GPIO pin numbering# ORwiringpi.wiringPiSetupGpio()# For GPIO pin numberingGeneral IO:wiringpi.pinMode(6,1)# Set pin 6 to 1 ( OUTPUT )wiringpi.digitalWrite(6,1)# Write 1 ( HIGH ) to pin 6wiringpi.digitalRead(6)# Read pin 6Setting up a peripheral:WiringPi supports expanding your range of available “pins” by setting up
a port expander. The implementation details of your port expander will
be handled transparently, and you can write to the additional pins
(starting from PIN_OFFSET >= 64) as if they were normal pins on the Pi.wiringpi.mcp23017Setup(PIN_OFFSET,I2C_ADDR)This example was tested on a quick2wire board with one digital IO
expansion board connected via I2C:wiringpi.mcp23017Setup(65,0x20)wiringpi.pinMode(65,1)wiringpi.digitalWrite(65,1)Soft Tone:Hook a speaker up to your Pi and generate music with softTone. Also
useful for generating frequencies for other uses such as modulating A/C.wiringpi.softToneCreate(PIN)wiringpi.softToneWrite(PIN,FREQUENCY)Bit shifting:wiringpi.shiftOut(1,2,0,123)# Shift out 123 (b1110110, byte 0-255) to data pin 1, clock pin 2Serial:serial=wiringpi.serialOpen('/dev/ttyAMA0',9600)# Requires device/baud and returns an IDwiringpi.serialPuts(serial,"hello")wiringpi.serialClose(serial)# Pass in IDSPI:ThewiringPiSPIDataRW()function needs to be passed abytesobject in Python 3. In Python 2, it takes a string. The following should
work in either Python 2 or 3:wiringpi.wiringPiSPISetup(channel,speed)buf=bytes([yourdatahere])retlen,retdata=wiringpi.wiringPiSPIDataRW(0,buf)Now,retlenwill contain the number of bytes received/read by the
call.retdatawill contain the data itself, and in Python 3,bufwill have been modified to contain it as well (that won’t happen in
Python 2, because thenbufis a string, and strings are immutable).Full details of the API at:http://www.wiringpi.comManual BuildGet/setup repogitclone--recursivehttps://github.com/WiringPi/WiringPi-Python.gitcdWiringPi-PythonDon’t forget the--recursive; it is required to also pull in the
WiringPi C code from its own repository.PrerequisitesTo rebuild the bindings youmustfirst have installedswig,python-dev, andpython-setuptools(or theirpython3-equivalents). WiringPi should also be installed system-wide for access
to thegpiotool.sudoapt-getinstallpython-devpython-setuptoolsswigwiringpiBuild & install withsudo python setup.py installOr Python 3:sudo python3 setup.py install
Package: wiring-rs
Wiring (with Rust)The code is in active development and subject to frequent changes.Feedback and PRs are welcome! There is always more to do and things to improve.wiringreads OWL axioms serialised asthick triplesand generatesOWL Functional Notation S-expressions(OFN S-expression).
For example, the OWL axiomobo:OBI_1110023 equivalentTo obo:RO_0000087 some obo:OBI_1110082is encoded by the thick triple{"object":{"owl:onProperty":[{"object":"obo:RO_0000087"}],"owl:someValuesFrom":[{"object":"obo:OBI_1110082"}],"rdf:type":[{"object":"owl:Restriction"}]},"predicate":"owl:equivalentClass","subject":"obo:OBI_1110023"}which can be translated withwiringinto the OFN S-expression["EquivalentClasses","obo:OBI_1110023",["ObjectSomeValuesFrom","obo:RO_0000087","obo:OBI_1110082"]].An OFN S-expression can be processed inwiring, e.g. by replacing named entities with their corresponding labels:["EquivalentClasses","'immunogen@en'",["ObjectSomeValuesFrom","'has role@en'","obo:OBI_1110082"]]. Such (processed) OFN S-expressions can be serialised into Manchester Syntax:EquivalentClasses: 'immunogen@en', 'has role@en' some obo:OBI_1110082.tl;drThemain.rsfile contains example code showcasing the basic functionality ofwiringby translating thick triples into OFN S-expressions and serialising them in Manchester Syntax.Things to dowiringcurrently only supports class expression axioms (excluding data types) and should be extended to all of OWL
Package: wis
MPC wis.py Projectwis.py tells you the position of a satellite (e.g. in heliocentric coordinates).wis.py uses JPL spice kernels, so you need spicypy.wis.py goes and gets the spice-kernels if you don’t have them.wis.py is essentially a means to automate the retrieval of
useful spice-kernels.
All of the positional calculations are handled using spice/spiceypy.wis.py doesnotknow aboutallsatellites.So far it only knows about:
* TESS
* K2
* CASSINIwis.py is very light & wispy …wis
* ~ Where Is Satellite
* ~ Where Is Satellite-spice-kernelFree software: MIT licenseDocumentation:https://wis.readthedocs.io. or  orhttps://mpcutilities.readthedocs.io. ???FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History1.0.0 (2019-04-06)First release on PyPI.
Package: wisardpkg
wisardpkgDescription:This is a project to make available the different models based on WiSARD,
with high performance, easy to use and to install and following a pattern of use.
These provided models are machine learning models,
with supervised, unsupervised and semi-supervised learning.to install:python:pip install wisardpkgWorks to python2 and pyhton3.If you are on Linux and not in a virtual environment, you may need to run as superuser.obs:To install on windows platform you can useanacondaand do:python -m pip install wisardpkgc++:
copy the file wisardpkg.hpp inside your projectinclude/wisardpkg.hppto uninstall:pip uninstall wisardpkgto import:python:importwisardpkgaswpc++:#include"wisardpkg.hpp"namespacewp=wisardpkg;to use:WiSARDWiSARD with bleaching by default:python:# load input data, just zeros and onesX=[[1,1,1,0,0,0,0,0],[1,1,1,1,0,0,0,0],[0,0,0,0,1,1,1,1],[0,0,0,0,0,1,1,1]]# load label data, which must be a string arrayy=["cold","cold","hot","hot"]addressSize=3# number of addressing bits in the ramignoreZero=False# optional; causes the rams to ignore the address 0# False by default for performance reasons,# when True, WiSARD prints the progress of train() and classify()verbose=Truewsd=wp.Wisard(addressSize,ignoreZero=ignoreZero,verbose=verbose)# train using the input datawsd.train(X,y)# classify some dataout=wsd.classify(X)# the output of classify is a string list in the same sequence as the inputfori,dinenumerate(X):print(out[i],d)c++:vector<vector<int>>X(4);X[0]={1,1,1,0,0,0,0,0};X[1]={1,1,1,1,0,0,0,0};X[2]={0,0,0,0,1,1,1,1};X[3]={0,0,0,0,0,1,1,1};vector<string>y={"cold","cold","hot","hot"};wp::Wisardw(3,{{"ignoreZero",false},{"verbose",true}});w.train(X,y);vector<string>out=w.classify(X);for(inti=0;i<4;i++){cout<<"i: "<<i<<"; class: "<<out[i]<<endl;}ClusWiSARDClusWiSARD with bleaching by default:addressSize=3# number of addressing bits in the ram.minScore=0.1# min score of training processthreshold=10# limit of training cycles by discriminatordiscriminatorLimit=5# limit of discriminators by clusters# False by default for performance reasons# when enabled,e ClusWiSARD prints the progress of train() and classify()verbose=Trueclus=ClusWisard(addressSize,minScore,threshold,discriminatorLimit,verbose=True)# train using the input dataclus.train(X,y)# optionally you can train using arbitrary labels for the data# input some labels in a dict,# the keys must be integer indices indicating which input array the entry is associated to,# the values are the labels which must be stringsy2={1:"cold",3:"hot"}clus.train(X,y2)# classify some dataout=clus.classify(X)# the output of classify is a string list in the same sequence as the inputfori,dinenumerate(X):print(out[i],d)Documentation:You can find the complete documentation in thepage.Build on libraries:pybind11nlohmann/json
Package: wisbec
Copyright (c) 2020 wisbecPermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.Description: python wrappers
Platform: any
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: Unix
Classifier: Operating System :: POSIX
Classifier: Operating System :: Microsoft :: Windows
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Programming Language :: Python :: Implementation :: PyPy
Classifier: Topic :: Utilities
Description-Content-Type: text/markdown