Saravanan666/pypi-org huggingface dataset:
Package: armaclass
StatusAboutThis is a Python parser for Arma 3 class definitions such as those appearing inside unrapified mission files.It's based onFusselwurm's arma-class-parserthat is written
JavaScript.I grew tired of using it in conjunction with PyExecJS (complicated to set up and needing to patch things up on
Windows) and py2js (too slow to parse even 300KB sqm files) and decided to port the original JavaScript code to
Python.Installationpip install armaclassUsageParse the values from a stringIn[1]:importarmaclassIn[2]:armaclass.parse('version=12;\n\nclass Moo  {\r\nvalue = 1; };')Out[2]:{'Moo':{'value':1.0},'version':12.0}Keep the values ordered as they were in the original fileIn[3]:armaclass.parse('version=12;\n\nclass Moo  {\r\nvalue = 1; };',keep_order=True)Out[3]:OrderedDict([('version',12.0),('Moo',OrderedDict([('value',1.0)]))])Note: Starting with Python 3.7 onwards, dicts are always ordered so it
doesn't matter if you usekeep_orderor not.Generate the files based on a parsed (or manually created) structureIn[4]:fromcollectionsimportOrderedDictIn[5]:structure=OrderedDict([('version',12.0),('Moo',OrderedDict([('value',1.0)]))])In[6]:print(armaclass.generate(structure))version=12;classMoo{value=1;};Indent with tabs instead of spacesIn[7]:print(armaclass.generate(structure,indent=1,use_tabs=True))version=12;classMoo{value=1;};Extending the generatorYou can use this library to write a program that will port your Arma class files to DayZ, for example.
To do so, you will need to create your own generator by subclassingarmaclass.generator.Generatorand implementing
your own methods (the ones raisingNotImplemented).DevelopmentNotesThe naming conventions may not match Python's pep8 as I was trying to stay close to the original parsing names to
facilitate porting. Those (internal) names may be changed in the future.Making code changesCreate a virtualenv using your preferred method (mkvirtualenv, venv, etc...)pip install -r requirements.txtWrite code AND testspytestto test run your testsptw -nif you wantpytestto automatically be called whenever
you save any file from the projectContributingIf you feel something is missing or plain wrong, feel free to submit a Pull Request. You are encouraged to submit the
same PR/suggestion to the originalarma-class-parseras well.
Package: armada-airflow
armada-airflow-operatorAn Airflow operator for interfacing with the armada clientBackgroundAirflow is an open source project focused on orchestrating Direct Acylic Graphs (DAGs) across different compute platforms.  To interface Airflow with Armada, you should use our armada operator.AirflowTheairflow documentationwas used for setting up a simple test server.setup-local-airflow.shdemonstrates how to run airflow locally using Airflow's SequentialExecutor.  This is only used for testing purposes.Adding custom dags requires you to create a ~/airflow/dags folder and copying the dag files under examples in that location.  This allows you to test the DAG in your airflow test server.ExamplesFor documentation by example, seehello_armada.pyorbad_armada.py.Operator DocumentationArmada OperatorUsageThe operator is available onPyPipython3.8 -m venv armada38
source armada38/bin/activate
python3.8 -m pip install armada-airflowDevelopmentFrom the top level of the repo, you should runmake airflow-operator.  This will generate proto/grpc files in the jobservice folder.Airflow with the Armada operator can be run alongside the other Armada services via the docker-compose environment. It is manually started in this way:mage airflow startAirflow's web UI will then be accessible athttp://localhost:8081(login with admin/admin).You can install the package viapip3 install third_party/airflow.You can use our tox file that streamlines development lifecycle.  For development, you can install black, tox, mypy and flake8.python3.8 -m tox -e py38will run unit tests.python3.8 -m tox -e formatwill run a format checkpython3.8 -m tox -e format-codewill run black on your code.python3.8 -m tox -e docswill generate a new sphinx doc.Releasing the clientArmada-airflow releases are automated via Github Actions, for contributors with sufficient access to run them.Commit and merge a change tothird_party/airflow/pyproject.tomlraising the version number the appropriate amount. We are
usingsemverfor versioning.Navigate to theairflow operator release workflowin Github workflows, click the "Run Workflow" button on the right side, and choose "master" as the branch to use the
workflow from.Once the workflow has completed running, verify the new version of Armada client has been uploaded toPyPI.
Package: armada-client
Armada Python ClientThe Armada Python client wraps the gRPC services defined insubmit.protoandevents.proto.It supports the following Armada features:submitting, cancelling, and re-prioritising jobs, andwatching for job events.InstallationThese instructions are intended for end-users.If you wish to develop against armada_client, please see ourdocumentation on contributingPyPIThe Armada python client is available fromarmada_client. It can be installed
withpip install armada-client. Documentation and examples of how to use the python can be found on theArmada libraries webpage.Build from GitBuilding from Git is a multi-step process unlike many other Python projects. This project extensively uses generated
code, which is not committed into the repository.Before beginning, ensure you have:A working docker client, or docker-compatible client available underdocker.Network access to fetch docker images and go dependencies.To generate all needed code, and install the python client:From the root of the repository, runmage buildPythonInstall the client usingpip install client/python. It's strongly recommended you do this inside a virtualenv.
Package: armada-sde
armada-sdearmada-sde is a pluggable app for Django which provides models and tools for using Fuzzysteve's PostgreSQL dumps. Its
design allows you to automate upgrades of the SDE data and generate new models for any tables contained therein.UsageGrab the latest version of armada-sde directly from PyPI:pip install armada-sdeAdd it to Django'ssettings.py:INSTALLED_APPS=[# ...'armada_sde',]Download Fuzzysteve'slatest schema dumpfor postgres and unpack:wget https://www.fuzzwork.co.uk/dump/postgres-schema-latest.dmp.bz2
bunzip2 postgres-schema-latest.dmp.bz2Import the dumppython manage.py pg_import_sde -f postgres-schema-latest.dmpIf you want to handle the importing yourself, runpg_import_sdewith-sand no-f. This will rename the tables,
so to better fit with Django best practices.After import, the tables needs to be moved from the evesde schema to the public schema:python manage.py pg_move_sdeYou should now be able to import models and use them:fromdjango.dbimportmodelsfromarmada_sde.modelsimportInvType# Trit for the trit godtrit=InvType.objects.get(name='Tritanium')# Use it in your modelsclassShoppingListItem(models.Model):quantity=models.IntegerField(default=1)item=models.ForeignKey(InvType,on_delete=models.DO_NOTHING)Advanced usageGenerate modelsarmada_sde comes with a stock set of models which is generated automatically through a customized version of Django's
inspectdb command. You can generate your own set of models and do your own alterations, if you like. First, import the
dump as previously described, so it is present in the evesde schema. Then you can generate a models file:python manage.py pg_generate_models -o project/myapp/models.pyAfter generation, move the tables into the public schema and generate primary keys, with thepg_move_sdecommand.
You can now do any alterations you like. If you would like to generate migrations for your models, removemanaged = Falsefrom the Meta class.If you want, you can also ensure compatibility with other pluggable apps that use the SDE models, by configuring
armada_sde to load your custom variants instead of the stock models. Add this to yoursettings.py:ARMADA={'SDE':{'module':'project.myapp.models'}}Any other app importing models fromarmada_sde.models, will instead be loading your custom models from your project.Using a custom schema for the SDEIf you are sharing a database between several projects, it might be handy to have a shared schema for the SDE. You can
configure armada-sde to use a custom destination schema for tables, instead of moving them from evesde into public.To achieve this, set these parameters insettings.py:ARMADA={'SDE':{'schema':'<your_sde_schema>'}}It is not a good idea to use the evesde schema as your custom schema, as it might give you issues when upgrading the
SDE.
Package: armada-sde-rest
armada-sde-restarmada-sde-rest is a pluggable app for Django which providesDjango REST frameworkendpoints for the models generated byarmada-sde.UsageInstall the latest version of armada-sde-rest from PyPI:pip install armada-sde-restFollow the installation instructions forarmada-sde, then
add armada-sde-rest and its dependencies to Django's settings.py:INSTALLED_APPS=[# ...'rest_framework','armada_sde','armada_sde_rest',]Add the routes to your urls.py:fromdjango.urlsimportpath,includeurlpatterns=[path('sde/',include('armada_sde_rest.urls')),]
Package: armadillin
ArmadillinThis is an experimental tool under development. The recommended method for calling lineages remains normal Pangolin:https://github.com/cov-lineages/pangolinA Re-engineered Method Allowing DetermInation of viraL LINeagesArmadillin is an experimental alternative approach to training models onlineages designated by the PANGO team.Armadillin uses dense neural networks for assignment, which means it doesn't have to assume that positions with an N are the reference sequence. Armadillin is still very fast, in part because it sparsifies the feature input to this neural net during training.InstallationWith pipx (self-contained):pip install --local pipx
pipx install  armadillinor in your environment:pip3 install armadillinUsageWe'll use a NextStrain open sampled file for a demo:wget https://data.nextstrain.org/files/ncov/open/global/sequences.fasta.xzarmadillin sequences.fasta.xzorarmadillin sequences.fasta.xz > output.tsvIf you have sequences already aligned to the reference you can make inference much faster using the--seqs_are_alignedparameter:wget https://data.nextstrain.org/files/ncov/open/global/aligned.fasta.xz
armadillin aligned.fasta.xz --seqs_are_aligned > output.tsvRelated toolsPangolinis the OG for assigning lineages
Package: armagarch
armagarch packageThe package provides a flexible framework for modelling time-series data. The main focus of the package is implementation of the ARMA-GARCH type models.Full documentation is coming soon.InstallationThe latest stable version can be installed by using pippip install armagarchThe master branch can be installed withgit clone https://github.com/iankhr/armagarch
cd armagarch
python setup.py installExample: Modelling conditional volatility of the US excess market returnsThe code requires: NumPy, Pandas, SciPy, Shutil, Matplotlib, Pandas_datareader and Statsmodelsimport armagarch as ag
import pandas_datareader as web
import matplotlib.pyplot as plt
import numpy as np

# load data from KennethFrench library
ff = web.DataReader('F-F_Research_Data_Factors_daily', 'famafrench')
ff = ff[0]

# define mean, vol and distribution
meanMdl = ag.ARMA(order = {'AR':1,'MA':0})
volMdl = ag.garch(order = {'p':1,'q':1})
distMdl = ag.normalDist()

# create a model
model = ag.empModel(ff['Mkt-RF'].to_frame(), meanMdl, volMdl, distMdl)
# fit model
model.fit()

# get the conditional mean
Ey = model.Ey

# get conditional variance
ht = model.ht
cvol = np.sqrt(ht)

# get standardized residuals
stres = model.stres

# make a prediction of mean and variance over next 3 days.
pred = model.predict(nsteps = 3)

# pred is a list of two-arrays with first array being prediction of mean
# and second array being prediction of varianceAuthorsIan Khrashchevskyi-iankhrLicenseThis project is licensed under the MIT License - see theLICENSE.mdfile for detailsAcknowledgmentsSpecial thanks to Kevin Sheppard for hisPython for Econometrics, which was an inspiration to write current code
Package: arman-k
Performs Great OperationsThis module is for creating great operationsAuthor@armank3001BadgesFeaturesIt helps to perform fibonacci seriesIt helps to convert binary into decimalInstallationInstall arman-k with pippipinstallarman-kUpgradeUpgrade arman-k with pippipinstall--upgradearman-kUsage/Examplesfromarman_kimportyoyo.fibonacci(5)yo.binary_to_decimal(1101)📝 LicenseThis project is licensed underMITlicense.Feedback  ✨If you have any feedback, please reach out to us atarmank3001@gmail.com
Package: armar
URDF Files for Humanoid Robots of the ARMAR FamilyThis repository provides (unofficial) URDF files for some of the humanoid robots of the ARMAR family.Supported RobotsAs of now, the following robots are supported:robot_nameDOFDescriptionarmar452The humanoid robot Armar 4 with a fixed head.armar4_fixed_hands30Like armar4, but with rigid hands.armar4_fixed_hands_and_legs18Like armar4, but with rigid hands and fixed legs.armar617The humanoid robot Armar 6 with a fixed head and rigid hands.armar6_front17Like armar6, but the position of continuous joints is restricted such that the hands are mostly in front of the robot.armar6_x433A four-armed version of Armar 6 with a fixed head and rigid hands.armar6_x4_front33Like armar6_x4, but the position of continuous joints is restricted such that the hands are mostly in front of the robot.The corresponding URDF files can be found in thedescription directory.
As shown below, it is also possible to access the models directly from python.Installationpip install armarUsageThe following example shows how to receive the absolute path of a URDF file from python:importarmararmar.get_path_to_urdf_file(robot_name="armar6")Example: Models controlled by a Neural NetworkAcknowledgment and DisclaimerThe robots of the ARMAR family are designed and developed by theChair of High Performance Humanoid Technologies (H²T)at the Karlsruhe Institute of Technology (KIT).
The URDF files provided in this repository are based on models provided by the Chair of High Performance Humanoid Technologies.
The four-armed version of Armar 6 is not an official part of the ARMAR family developed at H²T.LicenseThe files of this repository are licensed under theCreative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)license.
Package: arm_archive
arm_archive.py is a Python module for accessing data from theARM archive.RequirementsPython 2.7, 3.3, 3.4.Sudswith Python 2.7.Suds-jurkowith Python 3.3/3.4.InstallTo install using pip use:pip install arm_archiveTo install from source in your home directory, use:python setup.py install --userTo install for all users on Unix/Linux:python setup.py installUseThe functions in the module can be used in Python after importing the module.The module can also be used from the command line using:python -m arm_archiveThis can be aliased in bash using:alias apu='python -m arm_archive'Command line examplesThese examples assume that the above alias has been created so that
‘python -m arm_archive’ can be executed using ‘apu’. Addition help for each
command can be obtained using ‘apu command -h’, for example ‘apu list -h’.List available datastreams which match a regular expression:$ apu datastreams sgpceil
sgpceilB1.b1
sgpceilB4.b1
sgpceilB5.b1
sgpceilB6.b1
sgpceilC1.b1
sgpceilpblhtC1.a0List available files for a specific time period:$ apu list sgpceilC1.b1 20141001 20141005
sgpceilC1.b1.20141001.000010.nc
sgpceilC1.b1.20141002.000008.nc
sgpceilC1.b1.20141003.000004.nc
sgpceilC1.b1.20141004.000002.nc
sgpceilC1.b1.20141005.000000.ncLeaving off the end date will find file for only a single day:$ apu list sgpceilC1.b1 20141015
sgpceilC1.b1.20141015.000009.ncOrdering data for a specific datastream and time period:$ apu order -d sgpceilC1.b1 20141001 20141005 username
Success 5 file(s) ordered, order_id: 123456Ordering data by supplying a list of filenames:$ apu order username sgpceilC1.b1.20141015.000009.nc
Success 1 file(s) ordered, order_id: 123456Check that status of an order:$ apu status 123456
processingList files in a complete order:$ apu files username 123456
AAA.files_not_found
sgpceilC1.b1.20141005.000000.nc
sgpceilC1.b1.20141015.000009.ncDownload file from a complete order to the current directory:$ apu download username 168977
Retrieving: AAA.files_not_found
Retrieving: sgpceilC1.b1.20141005.000000.nc
Retrieving: sgpceilC1.b1.20141015.000009.ncDownload a single file from a complete order:$ apu download username 168977 sgpceilC1.b1.20141005.000000.nc
Retrieving: sgpceilC1.b1.20141005.000000.ncCanceling an order:$ apu cancel username 123456
TrueList all orders with some files ready to download for a given user:$ apu ready username
123456
123457
Package: armarx
Python ArmarX - A Python toolbox for ArmarXfrom armarx import 🤖  as ❤This package provides Python 3 bindings for ArmarX.In addition, the package also includes some helper functions, such as
publishing or subscribing to images.Installationpip install --upgrade --extra-index-url https://pypi.humanoids.kit.edu/ armarxUsing the bindingsConnecting to an existing proxyFor proxies defined in a project'sVariants-*.xmlit is possible to import
the interface directly.fromarmarximportPlatformUnitInterfacePrxplatform_unit=PlatformUnitInterfacePrx.get_proxy('Armar6PlatformUnit')platform_unit.moveTo(0.0,0.0,0.0,50.0,0.1)Slice definitions can be loaded using theslice_loader.load_armarx_slicefunction. Default values for the proxy name will also be mapped.More examples can be found in theexamplesfolder.DocumentationSeehttps://armarx.humanoids.kit.edu/python
Package: armasec
AnOmnivectorinitiativeArmasecAdding a security layer on top of your API can be difficult, especially when working with an OIDC
platform. It's hard enough to get your OIDC provider configured correctly. Armasec aims to take the
pain out of securing your APIs routes.Armasec is an opinionated library that attempts to use the most obvious and commonly used workflows
when working with OIDC and making configuration as simple as possible.When using theArmasechelper
class, you only need two configuration settings to get going:Domain: the domain of your OIDC providerAudience: An optional setting that restricts tokens to those intended for your API.That's it! Once you have those settings dialed in, you can just worry about checking the permissions
scopes of your endpointsDocumentationDocumentation is hosted hosted ongithub.ioatthe Armasec homepage.QuickstartInstallarmasecanduvicorn:pipinstallarmasecuvicornSave th Minimal Example (example.py) locally:importosfromarmasecimportArmasecfromfastapiimportFastAPI,Dependsapp=FastAPI()armasec=Armasec(os.environ.get("ARMASEC_DOMAIN"),audience=os.environ.get("ARMASEC_AUDIENCE"),)@app.get("/stuff",dependencies=[Depends(armasec.lockdown("read:stuff"))])asyncdefcheck_access():returndict(message="Successfully authenticated!")Set the Armasec environment variables:ARMASEC_DOMAINARMASEC_AUDIENCERun the appuvicorn--host0.0.0.0example:appLicenseDistributed under the MIT License. SeeLICENSEfor more information.
Package: armcnc
🛠️ Python Framework SDK⚡ Python development framework for armcnc. ⚡已经内置在armcnc中，无需单独、重复安装，该仓库仅供学习参考。📖 Initialization安装相关依赖pip3installarmcncwebsocket-client==0.48.0requestspyserialcolorlog📖 Using templates#!/usr/bin/env python# -*- coding: utf-8 -*-importarmcncasframeworkdefarmcnc_start(cnc):whileTrue:passdefarmcnc_message(cnc,message):passdefarmcnc_exit(cnc):passif__name__=='__main__':framework_sdk=framework.Init()📖 Development安装相关依赖pip3installtwinesetuptoolswheel构建软件包python3setup.pysdistbdist_wheel上传软件包到PyPItwineuploaddist/*🌞 Development Teamhttps://www.armcnc.net
Package: arm-converter
ARM ConverterA local ARM converter for iOS Reverse Engineering. Download the toolchainshere. Currently,asandobjdumpare required for the script to work.BuildingRunpython -m buildto build the packageInstall withpip install --force-reinstall arm_converter --find-links=distPublishingCheck withtwine check dist/*Upload to TestPyPI before publishing ittwine upload -r testpypi dist/*Install withpip install arm_converter -i https://testpypi.python.org/pypiPublish it withtwine upload dist/*
Package: armetrics
armetricsOngoing work...Python implementation of some metrics proposed in:J. A. Ward, P. Lukowicz, and H. W. Gellersen, “Performance Metrics for Activity Recognition,” ACM Trans. Intell. Syst. Technol., vol. 2, no. 1, p. 6:1–6:23, Jan. 2011.InstallationThis system has been developed for a Linux environment.System-wide installationsudo pip3 install armetricsSingle-user installationpip3 install --user armetricsVirtualenv installation (recommended)pipenv install armetricsUninstallation[sudo] pip3 uninstall armetricsUpdateSystem-wide updatesudo pip3 install -U armetricsSingle-user update (recommended)pip3 install --user -U armetricsUsageThere are three examples in the repo (that should be improved)DevelopmentInstall locally from source (source directory will immediately affect the installed package
without needing to re-install):pip3 install --user --editable .Update version atsetup.pyand then create a source distributionpython3 setup.py sdist bdist_wheelUpload to PyPItwine upload dist/*
Package: arm-float-detector
🔍 arm-float-detectorUtility to detect soft float/double math library inclusion in arm binaries
(objects/archives/elfs).# install$pipinstallarm-float-detector# run$arm-float-detector--doublea.out&&echoOK
Nosoftdoublelibsfound!
OKRequirementsBesides python, needs thenmutility. If you're on *nix, you probably have it.What is thisSome processors do not have single- and/or double-precision floating point
hardware, but instead rely on float math software libraries, which are
relatively slow and add take up additional space in the application.Unfortunately I can't find options for gcc/ld to detect and prohibit (eg
warnings/errors/configuration options) using these functions; I believe the
definitions are in the compiler somehow (TODO actually research this).This utility enables detecting usage of this soft floating point libraries in
binaries, suitable for being integrated into a CI check to prevent them.Featuresdetect presence of single- or double-precision soft floating point librariesTODOwhitelist objects allowed to reference these libs (eg vsprintf)TODOenable printing objects containing the references for simpler
eliminationNOTEonly tested on linux, where grep supports-E 'string|string'. You use
a mac, good for you, no idea if this will work there. Dependency on grep will
probably be removed in the future.
Package: armine
Introductionarmineis a Association rule mining package for python3. It providesARMclass
to generate association rules from a set of transactions. It also provides aARMClassifierclass which uses CBA2 algorithm to classify given data.Installationpip install armineLinksDocumentationSourceAPI ReferenceLicenseThis project is licensed under the MIT License - see theLICENSE.txtfile for details.