Saravanan666/pypi-org huggingface dataset:
Package: pyarr
PyarrA Python library for interacting with the `arr` API'sReport Bug·Request FeatureTable of ContentsAbout The ProjectBuilt WithGetting StartedFeaturesCompatibilityRoadmapSponsorContributingLicenseContactAcknowledgmentsAbout The ProjectA Python library for the followingarrAPI's:SonarrRadarrReadarrLidarrThe library returns results in JSON format for ease of use, this also reduces the risk of failue when the arr APIs are updated.(back to top)Built With(back to top)Getting StartedQuickStart GuideFull DocumentationRelease Notes(back to top)FeaturesSupport for multiple Arr APIsSonarrRadarrReadarrLidarrType checkingCompatibilityThe below versions are based on our last tests, This will be updated as tests fail and updates are published.VersionSonarrRadarrReadarrLidarrv5.0.0from: v3.0.10.1567from: v4.3.2.6857from: v0.1.4.1596from: v1.0.2.2592(back to top)RoadmapSee thefeature requestsfor a full list of requested features.(back to top)SponsorMy projects arent possible without the support of the community, please consider donating a small amount to keep these projects alive.ContributingGot something you would like to add? check out the contributing guide in thedocumentation(back to top)LicenseCopyright ©Total Debug.(back to top)ContactDiscordDiscussionsProject Link(back to top)AcknowledgmentsBelow are a list of resources that I used to assist with this project.None at this time(back to top)
Package: pyarray
Array utilityA simple python utility libraryWhat is PyArray ?Well, PyArray is a simple python-array-utlity library.
It contains a  set of a array methods which can speed up your development.How to use it?Create a  pyarray listimportpyarrayPyArray typesStringspyarray.string()# stringsIntegerspyarray.integer()# integerFloatspyarray.floating()# floating pointDictionaried , booleans and lists#dictionariespyarray.dictionary()#boolean valuespyarray.boolean()# listspyarray.lists()Create a listarr=pyarray.List(pyarray.integer())MethodsLengtharr.len()Addarr.add(4)# The array don't support duplicate elements# no element is added if it already exists# int the listelementAt(index:integer)index=1arr.elementAt(index)median# find the median# only for integers and floatsarr.median()delete_index(index:integer)arr.delete_index(-1)search_insert_positiontarget=9arr.search_insert_postion(target)indexarr.index()peak# the index of maximum elementarr.peak_index()allarr.all()# returns all the elementcountarr.count(5)Maximum and minimum# maximumarr.range().maximum()# minimumarr.range().minimum()Choicearr.choice()# gives a random elementOther methods# sort the arrayarr.sort()# find an elementarr.find()# delete an elementarr.delete(3)# clear all the elementarr.clear()# reverse an arrayarr.reverse()arr.alternate_index()
Package: pyarrfs
PyarrFS is a FUSE based file system to access the content of RAR archives as if
they were just normal files and directories. PyarrFS owes technically to FUSE
and rarfile, while the idea originates out of YarrFS - a similar file system
written a few years back by a colleague (and based on my idea).This code was inspired by the xmp.py example written by Jeff Epler and Csaba
Henk. Thank you!Thanks to the folks who wrote FUSE and thanks to Marko Kreen for putting
together rarfile!PyarrFS is developed on Ubuntu and is thus known to work on that platform
together with fairly recent versions of Debian. Other Linux platforms are also
likely to work. Have you tried it on a different platform, please do tell :)
Package: pyarrow
Python library for Apache ArrowThis library provides a Python API for functionality provided by the Arrow C++
libraries, along with tools for Arrow integration and interoperability with
pandas, NumPy, and other software in the Python ecosystem.InstallingAcross platforms, you can install a recent version of pyarrow with the conda
package manager:condainstallpyarrow-cconda-forgeOn Linux, macOS, and Windows, you can also install binary wheels from PyPI with
pip:pipinstallpyarrowIf you encounter any issues importing the pip wheels on Windows, you may need
to install theVisual C++ Redistributable for Visual Studio 2015.DevelopmentSeePython Developmentin the documentation subproject.Building the documentationSeedocumentation build instructionsin the documentation subproject.
Package: pyarrow-cramjam
Python library for Apache ArrowThis library provides a Python API for functionality provided by the Arrow C++
libraries, along with tools for Arrow integration and interoperability with
pandas, NumPy, and other software in the Python ecosystem.InstallingAcross platforms, you can install a recent version of pyarrow with the conda
package manager:condainstallpyarrow-cconda-forgeOn Linux, macOS, and Windows, you can also install binary wheels from PyPI with
pip:pipinstallpyarrowIf you encounter any issues importing the pip wheels on Windows, you may need
to install theVisual C++ Redistributable for Visual Studio 2015.DevelopmentSeePython Developmentin the documentation subproject.Building the documentationSeedocumentation build instructionsin the documentation subproject.
Package: pyarrow-hotfix
DescriptionThis is a hotfix for the PyArrow security vulnerabilityCVE-2023-47248.We generally recommend upgrading to PyArrow 14.0.1 or later, but if you
cannot upgrade, this package disables the vulnerability on older versions.InstallationUsepipto install:pip install pyarrow_hotfixNoteBothpyarrow-hotfixandpyarrow_hotfixare accepted and point to
the same package.Usagepyarrow_hotfixmust be imported in your application or library code for
it to take effect:importpyarrow_hotfixSupported versionspyarrow_hotfixsupports all Python versions starting from Python 3.5,
and all PyArrow versions starting from 0.14.0.Dependenciespyarrow_hotfixis a pure Python package that does not have any explicit
dependencies, and assumes you have installedpyarrowthrough other means
(such aspiporconda).Example>>>importpyarrowaspa>>>importpyarrow_hotfix>>>>>>pa.ipc.open_file('data.arrow')Traceback (most recent call last):[ ... ]
RuntimeError:forbidden deserialization of 'arrow.py_extension_type': storage_type = null, serialized = b"\x80\x03cbuiltins\neval\nq\x00X\x15\x00\x00\x00print('hello world!')q\x01\x85q\x02Rq\x03.", pickle disassembly:0: \x80 PROTO      3
    2: c    GLOBAL     'builtins eval'
   17: q    BINPUT     0
   19: X    BINUNICODE "print('hello world!')"
   45: q    BINPUT     1
   47: \x85 TUPLE1
   48: q    BINPUT     2
   50: R    REDUCE
   51: q    BINPUT     3
   53: .    STOP
highest protocol among opcodes = 2LicenseLikepyarrow,pyarrow_hotfixis distributed under the terms of theApache License, version 2.0.
Package: py-arrow-lang
An implementation ofArrowin Python.Running Arrow code$ arrow --help

usage: arrow [-h] [file]

positional arguments:
  file        A file to run. Use - for stdin without prompt.

optional arguments:
  -h, --help  show this help message and exitExample Arrow programfunction
/--> int factorial(int n)
| require not (n < 0)
| int return
| /--< n != 0
| | return = 1
| \-->
| /--< n == 0
| | return = n * factorial(n - 1)
| \-->
^ return

main
int n
print "Enter number:"
n = input int
print "Factorial of", n, "is", factorial(n)Which outputs:Enter number:
5
Factorial of 5 is 120
Package: pyars
The pyARS python module allows developers to use BMC’s ARSystem  and Atrium CMDB
functions from within python. Using Python’s interactive shell, it
is extremely easy to research or massage data entries as well as workflow
objects (filters, activelinks, etc.).ARSystem, also known as ARS or Remedy, is a powerful enterprise workflow engine.
Atrium is a Configuration Management Data Base, a.k.a. Installed Base built on
top of ARSystem.
Package: pyart
This library is a thin python wrapper around ART implementation inhttps://raw.github.com/armon/hlldInstallingpystat can be installed via pypi:pip install pyartBuildingGet the source:git clone https://github.com/blackwithwhite666/pyart.gitCompile extension:python setup.py build_ext --inplaceUsageWork with tree as with plain mapping:from pyart import Tree
t = Tree()
t[b'foo'] = 1
t[b'bar'] = 2
assert t[b'foo'] == 1
assert t[b'bar'] == 2
assert b'foo' in t
assert b'bar' in t
assert len(t) == 2
del t[b'foo']
assert b'foo' not in t
assert len(t) == 1Iteration over each element of tree:from pyart import Tree
t = Tree()
t['foo'] = object()
def cb(key, value): print(key, value)
t.each(cb)
>>> ('foo', <object object at 0x7f186020bd70>)
t['foobar'] = object()
t.each(cb)
>>> ('foo', <object object at 0x7f186020bd70>)
>>> ('foobar', <object object at 0x7f186020bd80>)
t.each(cb, prefix=b'foo')
>>> ('foo', <object object at 0x7f186020bd70>)
>>> ('foobar', <object object at 0x7f186020bd80>)
t.each(cb, prefix=b'bar')Find minimum and maximum:from pyart import Tree
t = Tree()
t[b'test'] = None
t[b'foo'] = None
t[b'bar'] = None
assert t.minimum == (b'bar', None)
assert t.maximum == (b'test', None)Copy tree:from pyart import Tree
t = Tree()
t[b'test'] = object()
c = t.copy()
assert c[b'test'] is t[b'test']
assert len(c) == len(t)TODOImplement plain python iterator over tree;Running the test suiteUse Tox to run the test suite:toxChangelog0.2.3Fix reference counting;0.2.2Fix iteration with single element;0.2.1Fix segmentation fault on iterator destruction;0.2.0Proper exception handling ineach;Support for python native iteration;0.1.0 (initial release)Prototype.
Package: pyartemis
ARTEMIS: A Robust Toolkit of Explanation Methods for Interaction SpottingA Python package with explanation methods for extraction of feature interactions from predictive modelsOverviewartemisis aPythonpackage for data scientists and machine learning practitioners which exposes standardized API for extracting feature interactions from predictive models using a number of different methods described in scientific literature.The package provides both model-agnostic (no assumption about model structure), and model-specific (e.g., tree-based models) feature interaction methods, as well as other methods that can facilitate and support the analysis and exploration of the predictive model in the context of feature interactions.The available methods are suited to tabular data and classification and regression problems. The main functionality is that users are able to scrutinize a wide range of models by examining feature interactions in them by finding the strongest ones (in terms of numerical values of implemented methods) and creating tailored visualizations.DocumentationFull documentation is available athttps://pyartemis.github.io/.InstallationLatest released version of theartemispackage is available onPython Package Index (PyPI):pip install -U pyartemisThe source code and development version is currently hosted onGitHub.AuthorsThe package was created as a software project associated with the BSc thesisMethods for extraction of interactions from predictive modelsin the field of Data Science (pl.Inżynieria i analiza danych) at Faculty of Mathematics and Information Science (MiNI), Warsaw University of Technology in cooperation with NASK National Research Institute.The authors of theartemispackage are:Paweł FijałkowskiMateusz KrzyzińskiArtur ŻółkowskiBSc thesis and work on theartemispackage was supervised byPrzemysław Biecek, PhD, DSc.
Package: pyarti
pyartiIt is a Python module to allow creating of SOCKS5 proxy usingArtiproject from theTor Project.By default it runs the proxy at port 9150 on localhost.How to build?First installRustup toolchainfor your user.Build dependencies in Fedorasudo dnf install python3-devel openssl-develBuild dependencies in Debian Bullseyesudo apt install -y python3-dev python3-pip python3-venvThen create a virtual environment and follow along.python3 -m venv .venv
source .venv/bin/activate
python3 -m pip install -r requirements-dev.txt
python setup.py developFor a release build use the following command.python setup.py bdist_wheelHow to use?```
proxy = OnionProxy()
assert proxy.verify(blocking=True)
```

Read the [documentation](https://pyarti.readthedocs.io/en/latest/) for detailed API usage and examples.
Package: pyartifact
pyArtifactPythonic wrapper around Valve's Artifact API, with object mapping, filtering and hopefully moreCurrent phase:alpha-> feedback neededHere's what we can do so far>>>frompyartifactimportCards>>>cards=Cards()>>>cards.load_all_sets()>>>repr(cards.get('Storm Spirit').includes[0])<Artifactcard:{'id':10538,'base_id':10538,'name':'Ball Lightning','type':'Spell','text':"Move an <span style='font-weight:bold;color:#736e80;'>allied black hero</span> to an empty combat position in any lane.",'mini_image':'https://steamcdn-a.akamaihd.net/apps/583950/icons/set01/10538.aeb7a6a47e1d8b1a26307ae25e329df3e3bb0843.png','large_image':'https://steamcdn-a.akamaihd.net/apps/583950/icons/set01/10538_large_english.9b39d2d2bb4769b68fa3ac42abee35b1685a57de.png','ingame_image':None,'_CardBase__references':[],'color':'black','rarity':None,'item_def':None,'mana_cost':3,'illustrator':'JiHun Lee'}>>>>filtered=cards.filter.type('Spell').mana_cost(gt=4).color('black').rarity('Rare')>>>len(filtered)1>>>forcardinfiltered:...print(card)...TheCoverofNight# Deck encoding (wrapper not done)>>>frompyartifactimportdecode_deck_string>>>deck_contents=decode_deck_string('ADCJQUQI30zuwEYg2ABeF1Bu94BmWIBTEkLtAKlAZakAYmHh0JsdWUvUmVkIEV4YW1wbGU_')>>>print(deck_contents['name'])Blue/RedExample>>>print(deck_contents['heroes'])[{'id':4003,'turn':1},{'id':10006,'turn':1},{'id':10030,'turn':1},{'id':10033,'turn':3},{'id':10065,'turn':2}]>>>frompyartifactimportencode_deck>>>print(encode_deck(deck_contents))ADCJQUQI30zuwEYg2ABeF1Bu94BmWIBTEkLtAKlAZakAYmHh0JsdWUvUmVkIEV4YW1wbGU_PlansProvide text sanitizers (text atm. has html) - to markdown, strip, etc., use for deck encoding/decodingAdd more filtering optionsCleanup code structure (possible performance improvements)
Package: pyartifacts
pyartifactsThe pyartifacts project provides a Python library for processing
forensic artifact definition files.InstallationPython installation can be easily done via pip:pipinstallpyartifactsUsagefrompyartifacts.registryimportRegistryif__name__=='__main__':registry=Registry()registry.read_folder("test/artifacts/valid")print(registry)ContactFor feedback, questions and discussions you can use theOpen Source DFIR Slack.AcknowledgmentThe development of this software was partially sponsored by Siemens CERT, but
is not an official Siemens product.
Package: pyart-mch
The Python ARM Radar Toolkit, Py-ART, is an open source Python module containing
a growing collection of weather radar algorithms and utilities build on top of
the Scientific Python stack and distributed under the 3-Clause BSD license.
Py-ART is used by the Atmospheric Radiation Measurement (ARM) Climate Research
Facility for working with data from a number of precipitation and cloud radars,
but has been designed so that it can be used by others in the radar and
atmospheric communities to examine, processes, and analyse data from many types
of weather radars.
Package: pyartnet
pyartnetPyArtNet is a python implementation of the ArtNet protocol usingasyncio.
Supported protocols are ArtNet, sACN and KiNet.DocsDocs and examples can be foundhereChangelog1.0.1 (2023-02-20)Fixed an issue where consecutive fades would not start from the correct valuerenamedchannel.add_fadetochannel.set_fade(channel.add_fadewill issue aDeprecationWarning)1.0.0 (2023-02-08)Complete rework of library (breaking change)Add support for sACN and KiNet0.8.4 (2022-07-13)Added linear fade (closes #14)Updated max FPS (closes #17)All raised Errors inherit now from PyArtNetErrorSome refactoring and cleanupActivated tests for Python 3.100.8.3 (2021-07-23)No more jumping fades when using output correction with bigger channelsReformatted files0.8.2 (2021-03-14)Using nonblocking socketsAdded option to send frames to a broadcast address0.8.1 (2021-02-26)Fixed an issue with the max value for channels with 16bits and more0.8.0 (2021-02-11)Added support for channels with 16, 24 and 32bits0.7.0 (2020-10-28)renamed logger topyartnetto make it consistent with the module namecallbacks on the channel now get the channel passed in as an argumentAdding the same channel multiple times or adding overlapping channels raises an exceptionAddedpyartnet.errorsoptimized logging of sent frames0.6.0 (2020-10-27)ArtnetNode.startis now an async functionArtnetNode.step_time_msrenamed toArtnetNode.step_time(shouldn't be used manually anyway)removed support for python 3.6added more and better type hintsswitched to pytestsmall fixesArt-Net™ Designed by and Copyright Artistic Licence Engineering Ltd
Package: pyarubacentral
Aruba Central Python RESTful moduleA Python module for use with Aruba Central. The aim is to make life easier for people who are not primarily programmers, but need to interact with services in a programmatic manner (e.g. automation).This python module is used primarily to refresh expired access tokens and generate new refresh tokens as well. It also supports profiles, so you can setup multiple Aruba Central accounts and easily include those tokens in your script and easily switching between accounts by passing the profile variable.The example script is included to show a list of users in Aruba Central or display when an access token will expire.ContentsFeaturesInstallationPrerequisitesUsagePython ModuleLicenseContributeDisclaimerFeaturesCLI script to refresh access tokensCLI script to generate a new refresh and access tokenPython module to import to generate and refresh tokens automatically as the script it executed.InstallationTo install directly into your python environment please install with the following command:pip install pyarubacentralIf you prefer to clone this GitHub project, please be sure to rungit clone git@github.com:michaelrosejr/pyarubacentral.git
pipenv shellbefore you start coding.PrerequisitesThe following Python module assumes you have already created an API account on Aruba Central, requested a code and exchanged that code for a token. For details on how to do setup an account for API access in Aruba Central, please go to thehelp documentationin Aruba Central.Usagearubacentral --configureOnce configured, open your editor and edit the following files~/.arubacentral/accounts.yml
~/.arubacentral/config.yml
~/.arubacentral/regions.ymlAll tokens are stored in~/.arubacentral/tokens/profilename.tokens.jsonshould you need to edit them.To refresh an expired token:arubacentral --refresh [profile_name]To generate a new access and refresh token:arubacentral --newtoken [profile_name]Python ModuleTo use it as a python module within your code. See theexampleimport pyarubacentral
profile = "ACME"

# Return User List from Aruba Central
session = pyarubacentral.start_session(profile)
access_token = pyarubacentral.check_if_expired(profile, session)
print(session.get_user_account_list(access_token))LicenseContributeIf you're interested in contributing to add feature or fix bugs, please open an issue to discuss and Pull Requests to fix an identified bug. PR's are always welcome! Please be sure to have a detailed PR description that clearly describes the problem and solution.DisclaimerThis module is incomplete. It does not have all the API calls available via Aruba Central. If you see something you need from the swagger client, let us know and we'll do our best to add it to this module. Even better, add it yourself and we'll help you merge your code in this repository.This is not an 'official' SDK and is not guaranteed to always work with Aruba Central's APIs, on all platforms, or without eating up all your machine's resources. But we'll do our best to keep it in good shape, are happy to take suggestions for improvements, and are open to collaborations. License info ishere.
Package: pyarubaswitch
Aruba switch API python  clientPython based REST-API client for Aruba switches (not ArubaOSX).See workflows for examples on how to use.RequirementsOnly tested with REST-API version 7 on aruba switch. The older REST-APIs where very slow anyhow.
Seehttps://asp.arubanetworks.comfor latest firmware.
You can check firmware version here:
http:///switch-ip-adress/rest/versionAlso requires the requests module.Installationpip install pyarubaswitchBasic Usage examplesfrom pyarubaswitch import ArubaSwitchClient
client = ArubaSwitchClient("192.168.1.4","username","password")


client.get_lldp_aps()              client.get_port_vlan()             client.get_system_status()
client.get_lldp_info()             client.get_snmpv3()                client.get_telnet_server_status()
client.get_lldp_switches()         client.get_sntp()                  
client.get_loop_protected_ports()  client.get_stp_info()              

client.get_loop_protected_ports()
['2'] 

client.get_system_status()
name: switch-name, hw: J9774A, fw: YA.16.10.0007, sn: XXXXXXX

client.logout()Always do .logout() after your done with API calls. Otherwise the switch might run out of API-sessions and you must either reset rest-api interface on the switch or wait for the session timer to run out.notethat method above uses HTTP and is not secure. To use HTTPS you must first install a certificate on the switch and then use the client with ssl.
To use ssl for all calls, no validation of cert:ssl_client = ArubaSwitchClient("192.168.1.4","username","password",SSL=True)To use validate ssl:ssl_client = ArubaSwitchClient("192.168.1.4","username","password",SSL=True,validate_ssl=True)The runners in workslows can also be used with a variable file in yaml-format like so:username: "username"
password: "supersecretpassword"
switches:
  - "192.168.1.4"
  - "192.168.1.5"How to generate self-signed cert on switch from cliConfiguration example: 
    (config)# crypto pki identity-profile Test_Profile subject
    Enter Common Name(CN) : myTestSwitch
    Enter Org Unit(OU) : myOrgUnit
    Enter Org Name(O) : myOrg
    Enter Locality(L) : myLocation
    Enter State(ST) : myState
    Enter Country(C) : NL
    (config)# crypto pki enroll-self-signed certificate-name Test_Certificate
    or : crypto pki enroll-self-signed certificate-name test2 key-type ecdsa
    (config)# web-management sslVery simplle self-signed cert sample with rest-enabled samplerest-interface
crypto pki enroll-self-signed certificate-name sll-self subject common-name switchmgmt
web-management ssl
Package: pyARXaaS
PyARXaaSPython Package for interfacing with ARXaaS in PythonRead more about PyARXaaS at:https://pyarxaas.readthedocs.io/Getting StartedInstallationpipinstallpyarxaasBasic Usage# import dependenciesfrompyarxaasimportARXaaSfrompyarxaas.privacy_modelsimportKAnonymityfrompyarxaasimportAttributeTypefrompyarxaasimportDatasetimportpandasaspdarxaas=ARXaaS(url)# url contains url to AaaS web servicedf=pd.read_csv("data.csv")# create Datasetdataset=Dataset.from_pandas(df)# set attribute typedataset.set_attributes(AttributeType.QUASIIDENTIFYING,'name','gender')dataset.set_attribute(AttributeType.IDENTIFYING,'id')# get the risk profle of the datasetrisk_profile=arxaas.risk_profile(dataset)# get risk metricsre_indentifiation_risk=risk_profile.re_identification_riskdistribution_of_risk=risk_profile.distribution_of_risk