Saravanan666/pypi-org huggingface dataset:
Package: yalesmartalarmclient
Yale Smart Alarm ClientYale Smart Alarm client is a python client for interacting with the Yale Smart Alarm System API.Supported functions:Arm full (away)Arm partial (away/night)DisarmGet alarm statusDoor sensor statusTrigger alarm panic buttonUsageCreate a client with:from yalesmartalarmclient.client import YaleSmartAlarmClient
client = YaleSmartAlarmClient(username, password)where username and password are your Yale Smart Alarm credentials.For full listing of function see functions.mdLocksIterate the connected locksclient = YaleSmartAlarmClient(username, password)
for lock in client.lock_api.locks():
    print(lock)lock a single locklock = client.lock_api.get(name="myfrontdoor"):
lock.close()unlock:lock = client.lock_api.get(name="myfrontdoor"):
lock.open(pin_code="1234566")DEPRECATED! Get connected locks states:client.get_locks_status() # Returns an array of locks and statusAlarmsChange the alarm state with:client.arm_full()
client.arm_partial()
client.disarm()orclient.set_alarm_state(<mode>)where 'mode' is one of:from yalesmartalarmclient.client import (YALE_STATE_ARM_PARTIAL,
                                         YALE_STATE_DISARM,
                                         YALE_STATE_ARM_FULL)Is the alarm armed fully or partially:client.is_armed() # == Trueor return alarm status. eg.client.get_armed_status() is YALE_STATE_ARM_FULLTrigger panic buttonclient.trigger_panic_button()
Package: yalexs-ble
Yale Access BLEBluetooth control of Yale and August locksInstallationInstall this via pip (or your favourite package manager):pip install yalexs-bleFork historyThanks to:https://github.com/Friendly0Fire/augustpyhttps://github.com/terrcin/augustctlhttps://github.com/ethitter/augustctlhttps://github.com/robson83/augustctlContributors ✨Thanks goes to these wonderful people (emoji key):This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditsThis package was created withCookiecutterand thebrowniebroke/cookiecutter-pypackageproject template.
Package: yalice
yalicePython library for writing applications on yandex voice assistantGetting startedpip install yaliceThis library is a wrapper for Yandex Alice, not independent library for writing web based applications, so initialization takes in an object of the type FlaskfromflaskimportFlaskfromyaliceimportAliceBot,Message,Chatapp=Flask(__name__)bot=AliceBot(app)Your bot is going to be located on page '/post'
If you would like to change this, you can change this by adding str parameter pagebot=AliceBot(app,page='/alice')Also Yandex Alice can store user state and session state, pyalice give you abbility to save all that data automatically, but you can remove this abbility by adding bool parameter remember_state (to read more about statesclick here)bot=AliceBot(app,page='/alice',remember_state=False)message handlerTo hangle messages you can use decoratormessage_handler@bot.message_handler(start_handler=True)defstart(chat:Chat,message:Message):chat.send_message('Hello, I am annoying Alice. I will repeat each your word!')@bot.message_handler(tokens=['stop'],filter_func=lambdamessage:message.request.type=='ButtonPressed')defstop(chat:Chat,message:Message):chat.send_message('It was a fun game!')chat.end_session()@bot.message_handler(unknown_handler=True)defecho(chat:Chat,message:Message):chat.send_message(message.request.original_utterance)chat.send_button('Stop!')imagesYou can initialise images at the start to access easily
There is 3 ways to initialise images# 1 image at a timebot.set_image('fox','123456/123456')bot.set_image('cat','654321/654321')# several images at a timeimages={'fox':'123456/123456','cat':'654321/654321'}bot.set_images(images)# several images at a time by using bot.images variablebot.images={'fox':'123456/123456','cat':'654321/654321'}To send BigImage you can just usechat.send_image('fox')But if you would like to send ItemsListchat.send_images('fox')chat.send_images('cat')chat.edit_images(header_text='Animals')AliceBot objectAliceBot object stores information about images, sessions states and message_handlers. Now it has methodsset_image()set_images()message_handler()Chat objectChat object stores request to return. Now is has methodssend_message()send_button()send_image()send_images()edit_images()end_session()set_session_state()set_user_state()Message objectMessage object is parsed json, to see json structureclick hereLinksTelegram@cutefluffyfoxVK@cutefluffyfoxExpired bypyTelegramBotAPI
Package: yalign
AboutYalign is a tool for extracting parallel sentences from comparable corpora.Statistical Machine Translationrelies onparallel corpora(eg..europarl) for training translation models. However these corpora are limited and take time to create. Yalign is designed to automate this process by finding sentences that are close translation matches fromcomparable corpora. This opens up avenues for harvesting parallel corpora from sources like translated documents and the web.InstallationYalign requires that you installscikit-learn.After that you can install Yalign from PyPi via pip:sudo pip install yalignUsageFirstly we need to download and unpack the english to spanish model.wget http://yalign.machinalis.com/models/0.1/en-es.tar.gz
tar -xvzf en-es.tar.gzNow we can use theyalign-alignscript along with the english to spanish model to align two web pages.yalign-align en-es http://en.wikipedia.org/wiki/Antiparticle http://es.wikipedia.org/wiki/Antipart%C3%ADculaYalign is not limited to any one language pair. By creating your own models you can align any two languages. For more details on how to use yalign and on yalign’s implementation pleaseread the docs.Yalign is aMachinalisproject.
You can view our other open source contributionshere.The Yalign Team:Andrew VineGonzalo García BerrotaránRafael CarrascosaElías AndrawosLaura Alonso Alemany
Package: yalm
SPDX YALM: Yet Another License MatcherSPDX YALM is a license matching library based onthe SPDX License Matching Guideline.SPDX is an open standard for communicating software bill of material information. SPDX reduces redundant work by providing common formats for organizations and communities to share important data, thereby streamlining and improving compliance, security, and dependability.Project YALM is implemented as the matching guideline compliant library - this library provides a way to compare license documents and templates in a standardized way.FeaturesAn Interface which compares text against a license template using the license matching guidelines.An Interface which returns all matching SPDX listed license ID's for any license text.An interface which compares 2 license texts and returns a boolean indicating if the 2 licenses match per the license matching guidelines.When there is no match, a return value is provided to describe where and why the license does not match.InstallationEnsure you have installed Python 3.9 or higher.You can install this library viaPyPI.pip install yalmLicenseCopyright (c) 2021, SPDX YALM Developers.
Files in this repository are licensed underApache License Version 2.0.CreditsThis Project isinitially developed by@anshuldutt21as a part of CommunityBridge Linux Foundation 2020.updated by@m1kitand released
as a part of Google Summer of Code 2021.with thanks to mentors@goneall
Package: yalow
yalowYet Another LOgging WrapperOverviewThis package provides a generic wrapper for Python'sloggingmodule. A log directory is created in the project root directory. The log generated by yalow is intended for use
in situations where you need a single project log that all of the packages in your project write to.Installationpip install yalowHow Does DoGet the root path of your project in whatever way you would like. Once that's accomplished
provide it to Yalow along with your project name:from yalow import Yalow
logger = Yalow(root_path=I_AM_GROOT, project_name='logalog').loggerExample log output format:2020-03-06 21:16:13,495 - logalog - INFO: Logging initialized for project: logalog
2020-03-06 21:16:13,495 - logalog - INFO: IT'S ALIVE!!!!!
2020-03-06 21:16:13,496 - logalog.example_package - ERROR: And its minion is HUGE!Refer to examples for usage details.
Package: yalp_grok
Forked fromhttps://github.com/garyelephant/pygrokas it seems to be dead. If
pygrok becomes active again this fork may be closed.Python implementaion of Jordan Sissel’sGrok.Installpipinstallyalp_grokBasic Usage>>>importyalp_grokaspygrok>>>text='gary is male, 25 years old and weighs 68.5 kilograms'>>>pattern='%{WORD:name} is %{WORD:gender}, %{NUMBER:age} years old andweighs%{NUMBER:weight}kilograms'>>>printpygrok.grok_match(text,pattern){'gender':'male','age':'25','name':'gary','weight':'68.5'}Reusing PatternsSince compiling a pattern can be time consuming, patterns can be compiled once
and then reused for searching.>>>importyalp_grokaspygrok>>>pattern="%{COMMONAPACHELOG}">>>compiled_pattern=pygrok.compile_pattern(pattern)>>>withopen('/var/log/apache/access.log','r')aslog_file...matches=[pygrok.grok_search(line,compiled_pattern)forlineinlog_file]
Package: yalr
Yet Another LR ImplementationThis is another implementation of the classic LR(1) parsing
algorithm, along with Knuth’s LR(1) table generation algorithm.Rather than follow the model of tools like yacc and require
external code generation, this library is driven dynamically
from Python code.An obvious question is, “why?”Two reasons:firstly, to experiment with surface syntax for expressing
grammars in Python code in as uninvasive a way as possible.The package “ptk” takes a similar approach here.secondly, to provide a playground to look at other
“cutting-edge” parsing algorithms, as a basis for improving
my own understanding of them.By “cutting-edge” I’m largely referring to the late 1970s.The current implementation is largely inspired by yacc,
including yacc’s various deficiencies:there’s a linearisation used for reduce/reduce conflict
resolution;there’s a linearisation used for token precedence.In practice, it’s easy to get bitten by both of these - as
it is for the default shift/reduce resolution to mask
errors. A more flexible partial ordering is certainly feasible.CreditsSome of the example grammars included in the tests are derived
from the (Red) Dragon Book, which I’ve had since I was about 16;
it’s a book which definitely shaped my life.I’ve no idea how the reference numbers line up with later
additions.Compilers: Principles, Techniques, and Tools (1986)
by Alfred V. Aho, Ravi Sethi and Jeffrey D. Ullman
Package: yaltapy
YALTAPy is a Python toolbox dedicated to the stability analysis of (possibly fractional) delay systems with commensurate delays given by their transfer function.The questions YALTA and YALTAPy can answer are:In the case of neutral systemsFind the position of asymptotic axes.If the imaginary axis is asymptotic axis, find if the asymptotic poles of the chain are left or right the imaginary axis.In the case of retarded systems or of neutral systems with asymptotic axes in {Re(s) < 0}, find:For a given delay, the number and the position of unstable poles.For which values of the delay the system is stable.For a set of values of the delay, the position of unstable poles (root locus).Find (for non fractional systems) the coprime factors (N, D) of the transfer function as well as an approximation (Nn, Dn) in H∞-norm
Package: ya-ma
ya_mais unofficial client library for the YANDEX MAPS API
This client can request data for bus stops and present it on python dictionaryInstallationJust usepip(You have pip, right?) to installya_maand its dependencies:pip install ya_maExample>>> from ya_ma import YandexMapsRequester
    >>> client = YandexMapsRequester()
    >>> print(client.get_stop_info(9639579))
>>> client = YandexMapsRequester()
>>> print(client.get_stop_info(9639579))Or you can use it in your shell:python -m ya_ma -s 9966346
Package: yamada-mst
yamadaPython implementation of the Yamada-Kataoka-Watanabe algorithm to find all minimum spanning trees in an undirected graph.Implementation mostly follows theALL_MST2algorithm outlined in the original paper. The implementation differs slightly by performing a breadth-first search in liue of a depth-first search. This modification was made so that more variable spanning trees were returned when capping the total number of trees returned.Original PaperYamada, T. Kataoka, S. Watanabe, K. "Listing all the minimum spanning trees in an undirected graph".International Journal of Computer Mathematics. Vol 87, No. 14. pp. 3175 - 3185. November 2010.InstallationThis module is not currently hosted through popular package managing tools such aspiporconda. Therefore, simply cloning, downloading, or forking this repository is the best way to install the package. To ensure global access to the module, you'll want to add the repository location to yourPYTHONPATH.TestsProper implementation was tested using the examples found in the original paper, and implementation of those tests can be found in thetestsubdirectory. The graph structure used in Figure 3 of the original paper, is used to explicitly test for exact minimum spanning tree membership. Meanwhile, the unit-weight, complete graphs kiare tested for unique membership and expected length for i in {3, 4, 5, 6}. TheSubstitute()algorithm is tested using the example found in table 3 of the original paper.To run the tests simply execute the following command:python tests/test_yamada.pyDependenciesThis module depends on thenumpy,networkx,collections,sortedcontainers,sys, andunittestpackages, and was written in Python 3.6. The exact requirements can be found in therequirements.txtfile. Ayamada.yamlfile is also provided forcondaenvironment creation.Exampleimportyamadaimportnetworkxasnxexample={1:{2:{'weight':2},3:{'weight':1}},2:{1:{'weight':2},3:{'weight':3},4:{'weight':1}},3:{1:{'weight':1},2:{'weight':3},4:{'weight':2},5:{'weight':2}},4:{2:{'weight':1},3:{'weight':2},5:{'weight':1},6:{'weight':3}},5:{3:{'weight':2},4:{'weight':1},6:{'weight':3}},6:{4:{'weight':3},5:{'weight':3}}}graph=nx.Graph(example)# retrieve all minimum spanning treesgraph_yamada=yamada.Yamada(graph)all_msts=graph_yamada.spanning_trees()print(len(all_msts))# retrieve fixed number of minimum spanning treesgraph_yamada=yamada.Yamada(graph,n_trees=3)msts=graph_yamada.spanning_trees()print(len(msts))
Package: yamager
Yamager - Simple module for parsing images from Yandex and Google.-How to use?-fromyamagerimportYamagerimportrandomyamager=Yamager()############Yandex Images############images=yamager.search_yandex_images('anime')#get image previewspreviews=random.choice(images)#get previews of random imageprint(yamager.get_best_image(previews))#get best image of previews with high resolution#################################################Yandex Images with ZenRows bypasser############images=yamager.search_yandex_images('anime',zenrows='API_KEY')previews=random.choice(images)print(yamager.get_best_image(previews))#################################################Yandex Images pages############images=yamager.search_yandex_images('anime',page=30)previews=random.choice(images)print(yamager.get_best_image(previews))#################################################Google Images############images=yamager.search_google_images('anime')print(random.choice(images))#get random image from search#####################################
Package: yaman
yaman - Yakuake terminal managerManager forYakuake, a drop-down, tabbed & tiled terminal emulator.What?You know how working on a project you often need, besides an open IDE and browser, a number of separate terminals (npm, git, docker environment, ... ). You also need to run some scripts before you start and after you finish (e.g. docker containers). It's a hassle, right? Everything just becomes a nightmare when working on multiple projects.Well, no more. Now you can setup your project environment with a single command.What isn't covered?The only thing I have not figured out how is to automateTab Session Manager- i.e. the browser tabs.Everything else - docker, vscode, yakuake can be handled by this tool.PS: This is obviously a solution for a very specific set of tools. It's not meant to be a general purpose tool.FeaturesDefine tabs and terminals to open as part of a profileOpen, close and switch profilesTabs can define custom tiling per tabEach created terminal can run any predefined set of commandsRun predefined commands when opening and when closing a profile (i.e. start/stop dockers)How does it work?You define a profile config file where you define the tabs, how they are split and what commands should be run (cd-ing into folders, tailing logs, starting file watchers, sshing into a server etc.) that looks like this:version: 1
variables:
  path: /your/path 
pre:
  - cd %path%
  - docker-compose start
tabs:
  yourTabName: 
    - "cd %path%"
    - "git status"
  htop:
    - "htop"
  splitTab:
    left:
      top:
        - "ls -la"
      bottom: 
        - "ll"
    right:
      - "ps faux"
  server:
    - ssh server
down:
  - cd %path%
  - docker-compose stopHow do I use it?Create a new profileThis creates a config file and opens it in your default editor.yaman create <profileName>List all profilesyaman listOpen a profileyaman open <profileName>Stop a profileyaman close <profileName>Switch profileThis will close the open profile(s) and open the specified one.yaman switch <profileName>Edit profileyaman edit <profileName>How to installRequiredYou'll needqdbusfound in the following packages:Arch: qt5-toolsDebian/Ubuntu: qttools5-dev-tools (not tested!)Developmentgit clone <path>
poetry install
poetry run yaman
Package: yamanifest
General YAML manifest formatPython package to generate YaML formatted manifests. This means multiple
checksums can be stored for each file, allowing cheap checksum operations
to cascade to more expensive hashes if required.InstallConda install:conda install -c coecms yamanifestPip install (into a virtual environment):pip install yamanifestUseDevelopDevelopment install:git checkout https://github.com/aidanheerdegen/yamanifest
cd yamanifest
conda env create -f conda/dev-environment.yml
source activate yamanifest-dev
pip install -e '.[dev]'Thedev-environment.ymlfile is for speeding up installs and installing
packages unavailable on pypi,requirements.txtis the source of truth for
dependencies.Run tests:py.testBuild documentation:python setup.py build_sphinx
firefox docs/_build/index.htmlUpload documentation:git subtree push --prefix docs/_build/html/ origin gh-pages
Package: ya-market
## Yagna Market The Yagna Market is a core component of the Yagna Network, which enables computational Offers and Demands circulation. The Market is open for all entities willing to buy computations (Demands) or monetize computational resources (Offers). ## Yagna Market API The Yagna Market API is the entry to the Yagna Market through which Requestors and Providers can publish their Demands and Offers respectively, find matching counterparty, conduct negotiations and make an agreement.  This version of Market API conforms with capability level 1 of the &lt;a href&#x3D;&quot;https://docs.google.com/document/d/1Zny_vfgWV-hcsKS7P-Kdr3Fb0dwfl-6T_cYKVQ9mkNg&quot;&gt; Market API specification&lt;/a&gt;.  Market API contains two roles: Requestors and Providers which are symmetrical most of the time (excluding agreement phase).   # noqa: E501
Package: yamb
yambYAml Meta Binding microframeworkDefine schema for YAML documents a-la SQLAlchemy to read, write and manipulate data like a python object.Basic examplefromyambimportLiteral,Nested,Collection,YAMBObjectclassAddress(YAMBObject):city=Literal(default='New York')street=Literal()classPerson(YAMBObject):name=Literal()phone=Literal()address=Nested(Address)deflives_close_to(self,another_person):returnself.address.city==another_person.address.cityclassPhonebook(YAMBObject):title=Literal()people=Collection(Person)friends=Phonebook(title='Friends',people=[])friends.people.append(Person(name='Sue',phone='+12345',address=Address(street='Some blvd')))sam=Person(name='Sam',phone='+123456',address=Address(city='London',street='Picadilly'))friends.people+=[sam]withopen('friends.yml','w')asf:f.write(friends._dump())parsed=Phonebook._load(open('friends.yml'))assertparsed.title=='Friends'assertparsed.people[0].address.city=='New York'assertparsed.people[1].name=='Sam'
Package: yamcs-pymdb
Yamcs PyMDB[!WARNING]
This software is in beta development status. Documentation is limited, and API is subject to change.If you'd like to try it out, have a look at theexampleswhich explain the base setup for either CCSDS or CSP-style packets. Other common formats will be added over time.pip install yamcs-pymdbUse this Python library to generate XTCE XML files for use withYamcs Mission Control:fromyamcs.pymdbimport*spacecraft=System("Spacecraft")param1=IntegerParameter(system=spacecraft,name="param1",signed=False,encoding=uint8_t,)param2=EnumeratedParameter(system=spacecraft,name="param2",choices=[(0,"SUCCESS"),(-1,"ERROR"),],encoding=int8_t,)# Emit an XML that conforms to XTCEprint(spacecraft.dumps())LicenseLGPL-3.0. SeeLICENSE
Package: yamelish
yamelishyamelish is a non-parsable YAML-ish output format that was designed as a convenience to diff JSON files."non-parsable" means that yamelish was not designed to be parsed by computers. It might actually be parsable with some care and caveats (e.g. no way to distinguish boolean/null values from their string counterparts), but this is not the object of this project.YAML-ish means that it looks like YAML but is not YAML. Specifically, it looks like YAML, without quotes (except for empty strings), indicators like>or|and advanced features:postId:1id:1name:id labore ex et quam laborumemail:Eliseo@gardner.bizbody:laudantium enim quasi est quidem magnam voluptate ipsam eostempora quo necessitatibusdolor quam autem quasireiciendis et nam sapiente accusantiumexamples:booleans:-True-Falsenull_value:Noneinteger:4float:4.4empty_string:""empty_array:[]empty_object:{}yamelish's main limitation is that it offers no way to distinguish non-string values from their textual representation: the "True" string and the true boolean values will both end up asTrue. Consequently, yamelish remains relevant to spot changing values and structures but not changing types.Command-line usage$yamelishfile1.jsonfile2.jsonGit usageGit configuration (typically~/.config/git/config):[diff "json_diff"]textconv=/path/to/yamelish; Optional:[alias]showobject=show --ext-diffRepository's.gitattributesfile:*.json diff=json_diffPython usagefromyamelish.handlersimporthandleyamelish=handle(your_data)[0]print(yamelish)Why not ... ?Why not JSON?JSON diff is hard to read because of:escaped strings:"this\nis\na\nmultiline\nstring\nand\nthis\nis\npainful""\"wait, what?\""extra commas when appending to an array:{"array": ["a",-       "b"+       "b",+       "c"]}Why not gron?Because the gron format reflects array indices, inserting an element into an array makes diff way longer than expected:json = {};json.array = [];-json.array[0] = "a";-json.array[1] = "b";+json.array[0] = "z";+json.array[1] = "a";+json.array[2] = "b";Why not YAML?YAML is better but it still clutters the output with quotes, escaped values and/or little things like|-; this is because YAML is a format that is meant to be parsed, so it has to keep this kind of things.array:- "# this string is double-quoted because otherwise it would be a YAML comment"-- "# this string is double-quoted because otherwise it would be a YAML comment"+- this string is no longer double-quoted- "# this string is double-quoted because otherwise it would be a YAML comment"Licenseyamelish is licensed under WTFPL.
Package: yamet
YAMETFeaturesTODORequirementsTODOInstallationYou can installYAMETviapipfromPyPI:$pipinstallyametUsagePlease see theCommand-line Referencefor details.ContributingContributions are very welcome.
To learn more, see theContributor Guide.LicenseDistributed under the terms of theMIT license,YAMETis free and open source software.IssuesIf you encounter any problems,
pleasefile an issuealong with a detailed description.CreditsThis project was generated from@cjolowicz'sHypermodern Python Cookiecuttertemplate.