Saravanan666/pypi-org huggingface dataset:
Package: py-attack
py-attackPython wrapper for using the ATT&CK framework.IntroductionThis python wrapper provides a simple interface for querying the ATT&CK framework.
Among other things, we provide the following functionality:Search by IDSearch by UUIDIterate over matrices (both overall and per domain)Iterate over tactics (both overall and per domain)Iterate over techniques (both overall and per domain)Iterate over sub_techniques (both overall and per domain)Iterate over mitigations (both overall and per domain)Iterate over groups (both overall and per domain)Iterate over software (both overall and per domain)Representation of the ATT&CK framework as a graph, where all items are linkedFinding related ATT&CK conceptsDocumentationWe provide an extensive documentation including installation instructions and reference atpy-attack.readthedocs.io.However, that documentation is currently not yet online, so instead, please refer to the/docs/directory.
To build the documentation, simply runmake htmlfrom within the/docs/directory.InstallationThepy-attackmodule can be installed using pip if downloaded locally.
There currently is no way of installing it directly from the pip repository.pip3 installl -e <path/to/dir/containing/setup.py>References[1] TODOBibtex@inproceedings{TODO

}
Package: py-attack-hyr
py_attack`1.0.12` fix 

`1.0.11` fix 

`1.0.10` fix 

`1.0.9` fix 

`1.0.8` fix 

`1.0.7` fix  

`1.0.6` forget write log in 1.0.5

`1.0.5` fix bug in 1.0.4

`1.0.4` support "clean mode" 

`1.0.3` show selected index also when using hotkey  

`1.0.2` first useable version

`1.0.1` fix bug

`1.0.0` first release
Package: pyattck-data-models
pyattck-data-modelsFeaturesIncludes data models for the following projects:pyattckpyattck-dataInstallationYou can installPyattck Data Modelsvia pip_ from PyPI_:$ pip install pyattck-data-models##UsagePlease see theCommand-line Reference <Usage_>_ for details.ContributingContributions are very welcome.
To learn more, see theContributor Guide_.LicenseDistributed under the terms of theMIT license_,Pyattck Data Modelsis free and open source software.IssuesIf you encounter any problems,
pleasefile an issue_ along with a detailed description.
Package: pyattention
pyAttentionA library to monitor information sourcesKey FeaturesRetrieves data from TCP servers, socketIO services, RSS feeds, and SQL databasesRetrieves basic system data from linux-based computers (disk space, IP address, temperatures)Provides a queue interface for retrieving received informationSupports polling and asynchronous monitoringSources can be run individually or monitored together as a collectionSources run in their own thread or can share a thread across a collectionInstallation# Installation from pypipippyAttention# or# Installation from github$gitclonehttps://github.com/dhrone/pyAttention# Install optional dependencies# Databases$pipinstallsqlalchemy
$pipinstallaiosqlite# For sqlite database support$pipinstallasyncpg# For PostgreSQL$pipinstallaiomysql# For mySQL# RSS Feeds$pipinstallhttpxlxmlbeautifulsoup4# socketIO services$pipinstallpython-socketio[client]==4.6.*aiohttp# Local system data$pipinstallpsutilnetifacesQuickstartTo retrieve data from a RSS feedfrompyattention.sourceimportrss# EXAMPLE: Pull 3 day forecast of Manchester, UK from the BBC News RSS feedurl='https://weather-broker-cdn.api.bbci.co.uk/en/forecast/rss/3day/2643123'frompyattention.sourceimportrsssrc=rss(url,frequency=21600)# Query feed every 6 hoursweather=src.get()To retrieve data from a socketIO service# EXAMPLE: monitor Volumio metadata from its socketIO API (see https://volumio.org)frompyattention.sourceimportsocketIOurl='http://localhost:3000'src=socketIO(url)asyncdefcallback(data):awaitsrc.put(data)src.subscribe('pushState',callback)src.emit('getState')# Command needed to get Volumio to send a pushState messagestate=src.get()To retrieve data from a database# EXAMPLE: pull data from a locally stored sqlite database# Create test dbimportsqlite3con=sqlite3.connect('songs.db')cur=con.cursor()cur.execute('''CREATE TABLE songs (artist text, title text, album text)''')cur.execute('''INSERT INTO songs VALUES ('Billie Eilish', 'bad guy', 'When We All Fall Asleep, Where Do We Go?')''')cur.close()frompyattention.sourceimportdatabaseuri='sqlite+aiosqlite:///./songs.db'src=database(uri,'select * from songs')songs=src.get()
Package: pyattest
pyattestpyattest provides a common interface that helps you verify attestations from eitherGoogleorApple. The package works standalone but if you use django and need a full implementation with key generation and storage thendjango-dreiattestcould be of interest for you.Installationpyattest is available on PyPI and can be installed via$ python -m pip install pyattestUsageIn it's most basic form you can create either aGoogleConfig,GooglePlayIntegrityApiConfigorAppleConfiginstance, create anAttestationand verify it.Google Play Integrity APIThe following parameters are important:decryption_key: A Base64 encoded AES key secret as describedhereverification_key: A Base64 encoded public key as describedhereapk_package_name: Name of your apkattest: The jwt object string representing the attestation, which is a jws nested in a jwe objectnonce: The nonce used to create the attestationconfig=GooglePlayIntegrityApiConfig(decryption_key=[decryption_key],verification_key=[decryption_key],apk_package_name='ch.dreipol.demo',production=True)attestation=Attestation(attest,nonce,config)try:attestation.verify()exceptPyAttestExceptionasexception:# Do your thingpassGoogle (Legacy: SafetyNet)The following parameters are important:key_id: A Base64 encoded SHA-256 hash of your apps certificateapk_package_name: Name of your apkproduction: Ignores basic integrity and cts profile check ifFalseattest: The jws object string representing the attestationnonce: The nonce used to create the attestationconfig=GoogleConfig(key_ids=[key_id],apk_package_name='ch.dreipol.demo',production=True)attestation=Attestation(attest,nonce,config)try:attestation.verify()exceptPyAttestExceptionasexception:# Do your thingpassAppleThe following parameters are important:key_id: SHA-256 hash of the public key form the cert you got back from the attestationapp_id: Your app’s App ID, which is the concatenation of your 10-digit team identifier, a period, and your app’s CFBundleIdentifier valueproduction: Checks for the appropriateaaguidattest: The apple attestation as binarynonce: The nonce used to create the attestationconfig=AppleConfig(key_id=key_id,app_id='1234ABCDEF.ch.dreipol.demo',production=True)attestation=Attestation(attest,nonce,config)try:attestation.verify()exceptPyAttestExceptionasexception:# Do your thingpassAssertionOnce you verified and obtained a public key, you can use it toassertfurther requests. For a full implementation on how to get to the public key check outdjango-dreiattest. To check if anassertionis valid we check if it was signed with givenpem_key.assertion: Raw bytes of the assertion you want to testexpected_hash: The hash we want to compare the signature againstpem_key: The public key to verify the signatureconfig: AAppleConfigorGoogleConfiginstanceassertion = Assertion(assertion, expected_hash, pem_key, config)
assertion.verify()
Package: pyattimo
This is a python wrapper forATTIMO, a fast algorithm for mining time series motifs, with probabilistic guarantees.The inner workings and guarantees of the algorithm are described inthis paper.If you find this software useful for your research, please use the following citation:@article{DBLP:journals/pvldb/CeccarelloG22,
  author    = {Matteo Ceccarello and
               Johann Gamper},
  title     = {Fast and Scalable Mining of Time Series Motifs with Probabilistic
               Guarantees},
  journal   = {Proc. {VLDB} Endow.},
  volume    = {15},
  number    = {13},
  pages     = {3841--3853},
  year      = {2022},
  url       = {https://www.vldb.org/pvldb/vol15/p3841-ceccarello.pdf},
  timestamp = {Wed, 11 Jan 2023 17:06:38 +0100},
  biburl    = {https://dblp.org/rec/journals/pvldb/CeccarelloG22.bib},
  bibsource = {dblp computer science bibliography, https://dblp.org}
}InstallationpyATTIMOis a Rust library wrapped in Python. Therefore, if a wheel is available for your platform, you can install it simply by invoking:pip install pyattimoOtherwise, you need the Rust toolchain installed to be able to compile it.
The simplest way is to visithttps://rustup.rs/and follow the instructions there. You will need thenightlytoolchain:curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain nightlyAfter that, you can just run:pip install pyattimoAt this point, you should have thepyattimolibrary available in your interpreter.UsageIn essence, the library provides an iterator over the motifs of the given time series.
The following snippet illustrates the basic usage:importpyattimo# Load an example time seriests=pyattimo.load_dataset("ecg",prefix=1000000)# Create the motifs iteratormotifs=pyattimo.MotifsIterator(ts,w=1000,max_k=100)# Get the top motif via the iterator interfacem=next(motifs)# Plot the motif just obtainedm.plot()Further information and examples can be foundhere
Package: pyattr
pyattrpyattrInstallationUsageExampleHow it worksBenchmarksWhile Python does have name mangling, it is not nearly as powerful as access modifiers found in languages such as C++.pyattrprovides an easy-to-use API for access modifiers in Python.InstallationInstallation viapip:pip install pyattrUsageAll you have to do is make your class inherit from thepyattr.Pyattrclass, and addsuper().__init__()as the first line in the__init__function of your class. And that's it!pyattrwill handle the magic to make sure variables cannot be accessed / set where the shouldn't be. It also provides useful error messages to users.ExampleHere is a simple example involving aprivatevariable.frompyattrimportPyattrclassExample(Pyattr):def__init__(self)->None:super().__init__()self.__name="pyattr"example=Example()print(example.__name)# Error - '__name' is a private attribute of 'Example'.As well as variables,pyattralso supports access control offunctions!frompyattrimportPyattrclassExample(Pyattr):def__init__(self)->None:super().__init__()def__example(self)->None:passexample=Example()print(example.__example())# Error - '__example' is a private attribute of 'Example'.How it worksNoteFor a more in-depth explanation on howpyattrworks, see myblog post.pyattroverrides the defaultsetandgetfunctions of your class. The overridden functions defined bypyattrare merged into your class when you inherit from thepyattr.Pyattrclass. As well as this, thepyattr.Pyattrclass inherits from thepyattr._PyattrDictclass, which provides a custom dictionary implementation. This is because you can change the variables in a class usingclass.__dict__["var"] = "val", meaning a custom dictionary would be the best way to prevent the access system being circumvented.The overridensetandgetfunctions of your class call the respectivesetandgetfunctions of the custom dictionary. This dictionary, usingsys._getframe(), works out the caller's function, and the caller's class (if any). It uses this data to work out if the caller should be allowed to access the specified variables. If it shouldn't, anAttributeErroris raised, with an error message explaining the cause.BenchmarksThe code for the benchmarks can be found in thebenchmarkfolder.
Package: pyAttributes
pyAttributesThe Python packagepyAttributesoffers implementations of .NET-like attributes
realized with Python decorators. The package also offers a mixin-class to ease
using classes having annotated methods.In addition, anArgParseAttributesmodule is provided, which allows users to
describe complex argparse command-line argument parser structures in a declarative
way.Attributes can create a complex class hierarchy. This helps in finding and
filtering for annotated properties and user-defined data. These search operations
can be called globally on the attribute classes or locally within an annotated
class. Therefore the provided helper-mixin should be inherited.Use CasesAnnotate properties and user-defined data to methods.Derived use cases:Describe a command line argument parser (argparse).SeepyAttributes Documentation -> ArgParse ExamplesMark class members for documentation.SeeSphinxExtensions-> DocumentMemberAttributePlanned implementations:Annotate user-defined data to classes.Describe test cases and test suits to get a cleaner syntax for Python's unit tests.TechniqueThe annotated data is stored in an additional__dict__entry for each
annotated method. By default, the entry is called__pyattr__. Multiple
attributes can be applied to the same method.Creating new AttributesSimple User-Defined AttributeclassSimpleAttribute(Attribute):passUser-Defined Attribute with DataclassDataAttribute(Attribute):data:str=Nonedef__init__(self,data:str):self.data=data@propertydefData(self):returnself.dataApplying Attributes to MethodsclassProgramWithHelper(AttributeHelperMixin):@SimpleAttribute()defMethod_1(self):"""This method is marked as simple."""@DataAttribute("hello world")defMethod_2(self):"""This method as annotated data."""Finding Methods with AttributesFinding Methods with Global Searchmethods=SimpleAttribute.GetMethods()formethod,attributesinmethods.items():print(method)forattributeinattributes:print("  ",attribute)Finding Methods with Class-Wide SearchclassProgramWithHelper(AttributeHelperMixin):@SimpleAttribute()defMethod_1(self):"""This method is marked as simple."""@DataAttribute("hello world")defMethod_2(self):"""This method as annotated data."""deftest_GetMethods(self):methods=self.GetMethods(filter=DataAttribute)formethod,attributesinmethods.items():print(method)forattributeinattributes:print("  ",attribute)deftest_GetAttributes(self):attributes=self.GetAttributes(self.Method_1)forattributeinattributes:print("  ",attribute)ContributorsPatrick Lehmann(Maintainer)and more...LicenseThis Python package (source code) licensed underApache License 2.0.The accompanying documentation is licensed underCreative Commons - Attribution 4.0 (CC-BY 4.0).SPDX-License-Identifier: Apache-2.0
Package: pyattyscomm
Attys is a lightweight wearable bluetooth data acquisition box which can measure anything from temperature to ECG.It’s cross platform and runs under Linux and WindowsIt has two 24 bit analogue channels, an accelerometer and a magnetometer.http://www.attys.techRequired packages under LinuxFor Ubuntu Linux install libbluetooth-dev and swig:sudo apt-get install libbluetooth-dev swigQuick start guideHere are the basic steps how to use the API:# load the module
import pyattyscomm

# Gets the AttysScan class which scans for Attys via bluetooth
s = pyattyscomm.AttysScan()

# Scan for Attys
s.scan()

# get the 1st Attys
c = s.getAttysComm(0)

# create a datacallback
class AttysCommCallback(pyattyscomm.SampleCallback):
  def hasSample(self,t,v):
    print(t,v) # so more than just printing!

cb = AttysCommCallback()

pyattyscomm.connectCallback(c,cb)

# Start data acquisition in the background
c.start()

# sleep here or start a GUI

# end the acqu
c.quit()API documentationQuery it via the python help system:import pyattyscomm
help(pyattyscomm)The Python classes have been generated with SWIG. The header files AttysComm.h, AttysCommBase,h and AttysScan.h provide detailed info about the classes:https://github.com/glasgowneuro/attys-commDemosOn github are python examples which show you how
to plot realtime data from the Attys:https://github.com/glasgowneuro/attys-comm/tree/master/examples
Package: pyatv
A client library for Apple TV and AirPlay devicesThis is an asyncio python library for interacting with Apple TV and AirPlay devices. It mainly
targets Apple TVs (all generations,including tvOS 15 and later), but also supports audio streaming via AirPlay
to receivers like the HomePod, AirPort Express and third-party speakers. It can act as remote control to the Music
app/iTunes in macOS.All the documentation you need is available atpyatv.dev.What can it do?Some examples include:Remote control commandsMetadata retrieval with push updatesStream files via AirPlayList and launch installed appsList and switch user accountsAdd, remove or set audio output devices (e.g. HomePods)Keyboard supportPersistent storage of credentials and settings...and lots more! A complete list is availablehere.Great, but how do I use it?All documentation (especially for developers) are available atpyatv.dev.
It is however possible to install withpipand set up a new deviceatvremote:$ pip install pyatv
$ atvremote wizard
Looking for devices...
Found the following devices:
    Name                      Model                    Address
--  ------------------------  -----------------------  -----------
 1  Receiver+                 airupnp                  10.0.10.200
 2  Receiver                  RX-V773                  10.0.10.82
 3  Pierre's AirPort Express  AirPort Express (gen 2)  10.0.10.168
 4  FakeATV                   Unknown                  10.0.10.254
 5  Vardagsrum                Apple TV 4K              10.0.10.81
 6  Apple TV                  Apple TV 3               10.0.10.83
Enter index of device to set up (q to quit): 4
Starting to set up FakeATV
Starting to pair Protocol.MRP
Enter PIN on screen: 1111
Successfully paired Protocol.MRP, moving on...
Pairing finished, trying to connect and get some metadata...
Currently playing:
  Media type: Music
Device state: Playing
       Title: Never Gonna Give You Up
      Artist: Rick Astley
    Position: 1/213s (0.0%)
      Repeat: Off
     Shuffle: Off
Device is now set up!After setting up a new device, other commands can be run directly:$ atvremote -s 10.0.10.254 playing
  Media type: Music
Device state: Playing
       Title: Never Gonna Give You Up
      Artist: Rick Astley
    Position: 1/213s (0.0%)
      Repeat: Off
     Shuffle: Off
$ atvremote -s 10.0.10.254 pause
$ atvremote -n FakeATV playYou can also run it inside a container (x86_64, aarch64, armv7):docker run -it --rm --network=host ghcr.io/postlund/pyatv:0.14.0 atvremote scanThemastertag points to latest commit on themasterbranch and canlatestpoints to the latest release.I need to change something?Want to help out withpyatv? Press the button below to get a fully prepared development environment and get started right away!Shortcuts to the good stuffTo save you some time, here are some shortcuts:Getting startedDocumentationDevelopmentAPI ReferenceSupport
Package: pyaubo-sdk
aubo_sdkARCS controller software secondary development interface1. User SDK InterfaceUsers connect to the extended AUBO_comm server of AUBO_Control through SocketTCP or shared memory, and send commands to the AUBO_control controller software to realize remote control of the robot1.1 JsonRPC interfaceJsonRPC communication ports based on SocketTCP and HTTP protocols are provided1.2 RTDE interfaceThe RTDE interface based on SocketTCP and HTTP protocol is provided1.3 C++/Python SDK 接口It includes JsonRPC interface and RTDE real-time data exchange interface2. Controller Software ExtensionAubo_control controller software built-in a plug-in framework, support on the AuboControlAPI interface layer on the controller software functions for functional extension.For example, Aubo_script extends the function of robot script running, Aubo_comm is a socket server that supports multi-user connections3. Key FeaturesAvailable on multiple platforms (Linux, Windows)Can be used from C++ and Python.Easy to install and setup.4. Documentation5. Quick InstallFrom PyPi:If you only want to the use the Python interface, you can install pyaubo_sdk through pip:pip3installpyaubo_sdkPrebuilt python wheels support matrix:Python3.6Python3.7Python3.8Python3.9Python3.10Python3.11linux x64✅✅✅✅✅✅windows 64 bit✅✅✅✅✅✅DependenciesIf you're running Linux , you may need to install gcc-7/g++-7If you're running windows , you may need to install visual studio 2019 or laterCompatible Operating SystemsCurrently tested on:Ubuntu 16.04Debian 10 (Buster)Windows 10  x64
Package: pyaud
Framework for writing Python package auditsThepyaudframework is designed for writing modular audits for Python packagesAudits can be run to fail, such as when using CI, or include a fixFixes can be written for whole directories or individual filesPlugins can be written for manipulating filesSupports single script pluginsInstallation$pipinstallpyaudUsageCommandlineusage: pyaud [-h] [-v] [-f] [-n] [-s] [--audit LIST] [--exclude EXCLUDE] MODULE

positional arguments:
  MODULE             choice of module: [modules] to list all

optional arguments:
  -h, --help         show this help message and exit
  -v, --version      show program's version number and exit
  -f, --fix          suppress and fix all fixable issues
  -n, --no-cache     disable file caching
  -s, --suppress     continue without stopping for errors
  --audit LIST       comma separated list of plugins for audit
  --exclude EXCLUDE  regex of paths to ignorePluginspyaudwill search for a plugins package in the project rootTo register a plugin package ensure it is importable and prefix the package withpyaud_The namepyaud_pluginsis reserved and will be automatically importedTo view available plugins seepyaud-pluginsREADMEor runpyaud modules allFor writing plugins seedocsConfigureConfiguration values are declared in the pyproject.toml file[tool.pyaud]audit=["commit-policy","const","docs","files","format","format-docs","format-str","imports","lint","params","test","typecheck","unused"]exclude='''
  (?x)^(
    | docs\/conf\.py
    | whitelist\.py
  )$
'''
Package: pyaudiere
PyAudiere is a very flexible and easy to use audio library.Available methods allow you to read soundfiles of various formats
into memory and play them, or stream them if they are large. You
can pass sound buffers as NumPy arrays of float32’s to play
(non-blocking). You can also create pure tones, square waves, or
‘on-line’ white or pink noise. All of these functions can
be utilized concurrently. Sweet!
Package: pyaudioai
PyAudioAI Python LibraryThe Python library combines the OpenAI ChatGPT API with audio input and output.
With this, questions can be recorded as audio,
sent to ChatGPT and the answer from ChatGPT can be output as audio again.
For the audio output, gTTS (Google Text-to-Speech), a Python library and
CLI tool to interface with Google Translate's text-to-speech API is used.InstallationYou don't need this source code unless you want to modify the package. If you just
want to use the package, just run:pipinstallpyaudioaiInstall from source with:pythonsetup.pyinstallUsagePortaudio needs to be configured to have access to your computers microphone.Linux:sudoapt-getinstalllibasound-devportaudio19-devlibportaudio2libportaudiocpp0Mac OS X:brewinstallportaudioWindows:pipinstallpipwin
pipwininstallpyaudioThe OpenAI library needs to be configured with your account's secret keyOPENAI_API_KEYwhich is available on thewebsite.Example:importosimportpyaudioaiaudio_file="question.wav"# question can be savedquestion_audio=pyaudioai.RecordQuestion(5,audio_file)question_audio.record()response_class=pyaudioai.OpenAiResponse("<OPENAI_API_KEY>")response_class.get_audio_response(audio_file)question_audio.delete_file()# delete question audio if requiredDeveloper DocumentationThe documentation of the source code for contributors can be foundhere.