package
stringlengths 1
122
| pacakge-description
stringlengths 0
1.3M
|
|---|---|
ae-parse-date | parse_date 0.3.5ae namespace module portion parse_date: parse date strings more flexible and less strict.installationexecute the following command to install the
ae.parse_date module
in the currently active virtual environment:pipinstallae-parse-dateif you want to contribute to this portion then first forkthe ae_parse_date repository at GitLab.
after that pull it to your machine and finally execute the
following command in the root folder of this repository
(ae_parse_date):pipinstall-e.[dev]the last command will install this module portion, along with the tools you need
to develop and run tests or to extend the portion documentation. to contribute only to the unit tests or to the
documentation of this portion, replace the setup extras keydevin the above command withtestsordocsrespectively.more detailed explanations on how to contribute to this projectare available herenamespace portion documentationinformation on the features and usage of this portion are available atReadTheDocs. |
ae-paths | paths 0.3.26ae namespace module portion paths: generic file path helpers.installationexecute the following command to install the
ae.paths module
in the currently active virtual environment:pipinstallae-pathsif you want to contribute to this portion then first forkthe ae_paths repository at GitLab.
after that pull it to your machine and finally execute the
following command in the root folder of this repository
(ae_paths):pipinstall-e.[dev]the last command will install this module portion, along with the tools you need
to develop and run tests or to extend the portion documentation. to contribute only to the unit tests or to the
documentation of this portion, replace the setup extras keydevin the above command withtestsordocsrespectively.more detailed explanations on how to contribute to this projectare available herenamespace portion documentationinformation on the features and usage of this portion are available atReadTheDocs. |
aeplab | A package for Auditory ElectroPhysiology (AEP) LaboratoryThis is a package designed to provide necessary tools and methods for an AEP Lab. |
aepp | Adobe Experience Platform API made for humansThis repository will document the AEP wrapper on python.
It is focusing on helping accessing the different endpoints of Adobe Experience Platform API.
Documentation on the different endpoints can be found here :AEP API docThe wrapper is currently namedaepp, it stands for Adobe Experience Platform Python.InstallationYou can install the module directly from a pypi command:pipinstallaeppThe version of the wrapper can be seen by the following command (once loaded):importaeppaepp.__version__Consider upgrading regularypipinstallaepp--upgradeNOTE TO PYTHON 3.10.XAt the moment, not all packages are supported on python 3.10.X, therefore, please use this module with a python 3.9.X version.You can use pyenv to generate a local environment if required.Getting StartedIn order to get started, I have compile a guide to help you initialize this module and what is required.
You can find this documentationhereAEPP docsAt the moment the current wrapper is containing the following sub modules:schemaSchemaManagerFieldGroupManagerDataTypeManagerqueryservice(see note below)identitysandboxesdataaccesscatalogcustomerprofilesegmentationdataprepflowservicepolicydatasetsingestiondestination Authoringdestination Instanceobservabilityaccesscontrolprivacyservice(see 2nd note below)Last but not least, the core methods are described here:mainqueryservice moduleThe queryservice Module contains 2 classes:QueryService classThe QueryService class is the wrapper around the AEP Query Service API.It provides access to the different endpoints available from the API.Use-Case example : At the moment the capability to scheduled query is only accessible from the API.Detail documentationInteractiveQuery and InteractiveQuery2 classesThese classes are based on the pyGreSQL and psycopg2 module for python.It provides you the capability to realize query directly from your local Jupyter notebook and returns a dataframe.
In order to use these classes, you would need to install these module and a PSQL server.
On top of that, you would need to the psql server accessible in the environment path.PrivacyService moduleThe privacy service module is part of the AEP python wrapper but requires a different JWT connection in console.adobe.io.
Be careful that your JWT connection has the correct setup to access this API endpoints.ReleasesRelease notes are accessiblehere. |
aep-parser | aep_parserAn After Effects file parser in Python!Report Bug·Request FeatureTable of ContentsAbout The ProjectInstallationUsageRoadmapContributingLicenseContactAcknowledgmentsAbout The ProjectThis as a .aep (After Effects Project) parser in Python. After Effects files (.aep) are mostly binary files, encoded in RIFX format. This parser usesKaitai Structto parse .aep files and return a Project object containing items, layers, effects and properties.(back to top)Installationpipinstallaep-parser(back to top)Usagefromaep_parser.parsers.projectimportparse_projectaep_file_path="01_empty.aep"project=parse_project(aep_file_path)(back to top)RoadmapSee theopen issuesfor a full list of proposed features (and known issues).(back to top)ContributingAny contributions you make aregreatly appreciated.If you have a suggestion that would make this better, please fork the repo and create a merge request. You can also simply open an issue with the tag "enhancement".Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull Request(back to top)LicenseDistributed under the MIT License.(back to top)ContactBenoit Delaunay [email protected] Link:https://github.com/forticheprod/aep_parser(back to top)Acknowledgmentsaftereffects-aep-parserKaitai StructLottieAfter Effects Scripting Guide(back to top) |
aeppl | No description available on PyPI. |
aeppl-nightly | aepplprovides tools for a[e]PPL written inAesara.FeaturesConvert graphs containing AesaraRandomVariables into joint
log-probability graphsTransforms forRandomVariables that map constrained support spaces to
unconstrained spaces (e.g. the extended real numbers), and a rewrite that
automatically applies these transformations throughout a graphTools for traversing and transforming graphs containingRandomVariablesRandomVariable-aware pretty printing and LaTeX outputExamplesUsingaeppl, one can create a joint log-probability graph from a graph
containing AesaraRandomVariables:importaesarafromaesaraimporttensorasatfromaepplimportjoint_logprob,pprint# A simple scale mixture modelS_rv=at.random.invgamma(0.5,0.5)Y_rv=at.random.normal(0.0,at.sqrt(S_rv))# Compute the joint log-probabilitylogprob,(y,s)=joint_logprob(Y_rv,S_rv)Log-probability graphs are standard Aesara graphs, so we can compute
values with them:logprob_fn=aesara.function([y,s],logprob)logprob_fn(-0.5,1.0)# array(-2.46287705)Graphs can also be pretty printed:fromaepplimportpprint,latex_pprint# Print the original graphprint(pprint(Y_rv))# b ~ invgamma(0.5, 0.5) in R, a ~ N(0.0, sqrt(b)**2) in R# aprint(latex_pprint(Y_rv))# \begin{equation}# \begin{gathered}# b \sim \operatorname{invgamma}\left(0.5, 0.5\right)\, \in \mathbb{R}# \\# a \sim \operatorname{N}\left(0.0, {\sqrt{b}}^{2}\right)\, \in \mathbb{R}# \end{gathered}# \\# a# \end{equation}# Simplify the graph so that it's easier to readfromaesara.graph.rewriting.utilsimportrewrite_graphfromaesara.tensor.rewriting.basicimporttopo_constant_foldinglogprob=rewrite_graph(logprob,custom_rewrite=topo_constant_folding)print(pprint(logprob))# s in R, y in R# (switch(s >= 0.0,# ((-0.9189385175704956 +# switch(s == 0, -inf, (-1.5 * log(s)))) - (0.5 / s)),# -inf) +# ((-0.9189385332046727 + (-0.5 * ((y / sqrt(s)) ** 2))) - log(sqrt(s))))Joint log-probabilities can be computed for some terms that arederivedfromRandomVariables, as well:# Create a switching model from a Bernoulli distributed indexZ_rv=at.random.normal([-100,100],1.0,name="Z")I_rv=at.random.bernoulli(0.5,name="I")M_rv=Z_rv[I_rv]M_rv.name="M"# Compute the joint log-probability for the mixturelogprob,(m,z,i)=joint_logprob(M_rv,Z_rv,I_rv)logprob=rewrite_graph(logprob,custom_rewrite=topo_constant_folding)print(pprint(logprob))# i in Z, m in R, a in Z# (switch((0 <= i and i <= 1), -0.6931472, -inf) +# ((-0.9189385332046727 + (-0.5 * (((m - [-100 100][a]) / [1. 1.][a]) ** 2))) -# log([1. 1.][a])))InstallationThe latest release ofaepplcan be installed from PyPI usingpip:pip install aepplThe current development branch ofaepplcan be installed from GitHub, also usingpip:pip install git+https://github.com/aesara-devs/aeppl |
aepp-sdk | aepp-sdk-pythonWelcome to theAeternitySDK for PythonFor support visit theforum, for bug reports or feature requests visit open anissue.DocumentationStablefor themasterbranch (current release).Latestfor thedevelopbranchRelevant repositoriesAeternity nodeProtocol documentationUseful linksMainnet API GatewayMainnet frontend and middleware(Aeternal)Testnet API GatewayTestnet frontend and middleware(Aeternal)Testnet faucet |
aep-python-sdk-v3 | # Aep-python-sdk PackageThis is a sdk package. You can use
[Github-flavored Markdown](https://guides.github.com/features/mastering-markdown/)
to write your content. |
ae-prob-19 | No description available on PyPI. |
ae-probability | No description available on PyPI. |
ae-progress | progress 0.3.10ae namespace module portion progress: display progress of long running processes.installationexecute the following command to install the
ae.progress module
in the currently active virtual environment:pipinstallae-progressif you want to contribute to this portion then first forkthe ae_progress repository at GitLab.
after that pull it to your machine and finally execute the
following command in the root folder of this repository
(ae_progress):pipinstall-e.[dev]the last command will install this module portion, along with the tools you need
to develop and run tests or to extend the portion documentation. to contribute only to the unit tests or to the
documentation of this portion, replace the setup extras keydevin the above command withtestsordocsrespectively.more detailed explanations on how to contribute to this projectare available herenamespace portion documentationinformation on the features and usage of this portion are available atReadTheDocs. |
aep-sdk | Experience-Platform-Python-SDKThis Python SDK is designed to facilitate access to the Adobe Experience Platform Rest APIs and the associated tools.In order to use this SDK you will first need to have an account with the Adobe Experience Platform along with the necessary authentication information.See theAdobe Experience Platform API Documentationfor more information.Getting StartedTo begin first install the required dependencies using "pip install -r requirements.txt" in the terminal |
aepsicro | A python library to perform psychrometrics analysisCalculations are made by implementing equations described in 2009 ASHRAE Handbook—Fundamentals (SI).There are three main classes to use this package: AIRE_HUMEDO, FLUJO, PSICROMETRICO.AIRE_HUMEDO represents a psychrometric state.
FLUJO represents a stream in a particular state.
PSICROMETRICO shows a psychrometric diagram in a window that allows to plot statesInstall:
pip install aepsicroUsage:from aepsicro import aepsicro as ps
s1 = ps.AIRE_HUMEDO(tseca=20, humrel=(0.5, ‘%1’))
s2 = ps.AIRE_HUMEDO(tseca=(30,’ºC’), humrel=(0.9, ‘%1’))
print(s1)
print(s2)
f1 = ps.FLUJO(s1,(1000, ‘m3/h’))
f2 = ps.FLUJO(s2,(500, ‘m3/h’))
# Adiabatic mixture
f3 = f1 + f2
psi = ps.PSICROMETRICO()
psi.marca_proceso(f1, f2, f3) |
aep-site-generator | aep.dev static site generatorThis is the site generator foraep.devand its forks. It
takes AEP files in a git repository and outputs a static website.Why?We are not fans of rolling our own tools when off-the-shelf alternatives exist.
However, the AEP project has grown sufficiently mature to warrant it.GitHub Pages normally automatically builds documentation withJekyll, but
as the AEP system has grown, we are beginning to reach the limits of what
Jekyll can handle, and other off-the-shelf generators had similar issues:AEP adoption is handled through fork-and-merge and top-down configuration
files will lead to repetitive merge conflicts.Our grouping and listing logic has grown complicated, and had to be
maintained using complex and error-prone Liquid templates.Jekyll is extensible but GitHub requires specific Jekyll plugins, meaning we
can not use off-the-shelf solutions for planned features (e.g. tabbed code
examples).Lack of meaningful build CI caused failures.Working with the development environment was (really) slow.There are some additional advantages that we unlock with a custom generator:We can override segments of AEPs using template extensions in new files
rather than modifying existing files.We can provide useful abstractions for common deviations between companies
(e.g. case systems) that minimize the need to fork AEPs.We can customize the Markdown parsing where necessary (tabs, hotlinking,
etc.).How does it work?This is essentially split into three parts:Python code (aep_site/):The majority of the code is models (aep_site/models/) that represent the
fundamental concept of an AEP site. These are rolled up into a singleton
object calledSitethat is used everywhere. All models aredataclassesthat get sent to templates.There is also a publisher class (aep_site/publisher.py) that is able to
slurp up a repo of AEPs and build a static site.There is some server code (aep_site/server.py) that can run a development
server.All remaining files are thin support code to avoid repeating things in or
between the above.Templates (support/templates/) areJinja2templates containing (mostly)
HTML that makes up the layout of the site.Assets (support/assets/andsupport/scss/) are other static files. SCSS
is automatically compiled into CSS at publication.Of the models, there are three models in particular that matter:Site:A singleton that provides access to all scopes, AEPs, and static
pages. This is sent to every template as thesitevariable.AEP:A representation of a single AEP, including both content and
metadata. This is sent to the AEP rendering template as theaepvariable.Scope:A group of AEPs that apply to a particular scope. The "general"
scope is special, and is the "root" group. This is sent to the AEPlistingtemplate as thescopevariable.Templates arejinja2files in thetemplates/directory.Note:We run Jinja in with "strict undefined", so referencing an undefined
variable in a template is a hard error rather than an empty string.Entry pointsThere are two entry points for the app. Thepublisher(aep_site/publisher.py) is the program that iterates over the relevant
directories, renders HTML files, and writes them out to disk. Theapp(aep_site/server.py) is a lightweight Flask app that provides a development
server.These entry points are routed through the CLI file (aep_site/cli.py); when
this application is installed using pip, it makes theaep-site-gen(publisher) andaep-site-serve(server) commands available.ExtensionsThis site generator includes a basic extension system for AEPs. When processing
AEPs as plain Markdown files, it will make any Markdown (level 2 or 3) header
into a block. Therefore...## Foo bar bazLorem ipsum dolor set ametBecomes...{% block foo_bar_baz %}
## Foo bar baz
Lorem ipsum dolor set amet
{% endblock %}That allows an overriding template to extend the original one and override
sections:{% extends aep.templates.generic %}
{% block foo_bar_baz %}
## My mo-betta foo bar baz
Lorem ipsum dolor set something-not-amet
{% endblock %}Developer SetupIf you want to contribute to this project you will want to have a setup where
you can make changes to the code and see the result of your changes as soon as
possible. Here is a quick way to set up a local development environment that
will enable you to work on the code without having to reinstall the command
line scripts.DependenciesYou'll need venv. On Linux, install with,sudo apt-get install python3-venvRunning dev envCheck out the source$mkdirsrc
$cdsrc
$gitclonehttps://github.com/aep-dev/site-generator.gitSetup python virtual environment$python3-mvenv.venv
$source.venv/bin/activatePIP Install with the editable option$pipinstall--editable.Serve the aep.dev site$aep-site-serve/path/to/aep/data/on/your/systemUsing the docker containerFor quick serving, a docker container can also be used, wrapped in
a convenience scriptserve.sh../serve.sh |
aepsych | AEPsychAEPsych is a framework and library for adaptive experimetation in psychophysics and related domains.InstallationAEPsychonly supports python 3.8+. We recommend installingAEPsychunder a virtual environment likeAnaconda.
Once you've created a virtual environment forAEPsychand activated it, you can installAEPsychusing pip:pip install aepsychIf you're a developer or want to use the latest features, you can install from GitHub using:git clone https://github.com/facebookresearch/aepsych.git
cd aepsych
pip install -r requirements.txt
pip install -e .UsageSee the code exampleshere.The canonical way of using AEPsych is to launch it in server mode (you can runaepsych_server--help to see additional arguments):aepsych_server --port 5555 --ip 0.0.0.0 database --db mydatabase.dbThe server accepts messages over either a unix socket orZMQ, and
all messages are formatted usingJSON. All messages
have the following format:{
"type":<TYPE>,
"version":<VERSION>,
"message":<MESSAGE>,
}Version can be omitted, in which case we default to the oldest / unversioned handler for this message
type. There are five message types:setup,resume,ask,tellandexit.SetupThesetupmessage prepares the server for making suggestions and accepting data. The setup
message can be formatted as either INI or a python dict (similar to JSON) format, and an example
for psychometric threshold estimation is given inconfigs/single_lse_example.ini. It looks like this:{
"type":"setup",
"version":"0.01",
"message":{"config_str":<PASTED CONFIG STRING>}
}After receiving a setup message, the server responds with a strategy index that can be used
to resume this setup (for example, for interleaving multiple experiments).ResumeTheresumemessage tells the server to resume a strategy from earlier in the same run. It looks like this:{
"type":"resume",
"version":"0.01",
"message":{"strat_id":"0"}
}After receiving a resume message, the server responds with the strategy index resumed.AskTheaskmessage queries the server for the next trial configuration. It looks like this:{
"type":"ask",
"version":"0.01",
"message":""
}After receiving an ask message, the server responds with a configuration in JSON format, for example{"frequency":100, "intensity":0.8}TellThetellmessage updates the server with the outcome for a trial configuration. Note that thetelldoes not need to match with a previouslyask'd trial. For example, if you are interleaving
AEPsych runs with a classical staircase, you can still feed AEPsych with the staircase data. A message
looks like this:{
"type":"tell",
"version":"0.01",
"message":{
"config":{
"frequency":100,
"intensity":0.8
},
"outcome":"1",
}
}ExitTheexitmessage tells the server to close the socket connection, write strats into the database and terminate current session.
The message is:{
"type":"exit",
}The server closes the connection.Data export and visualizationThe data is logged to a SQLite database on disk (by default,databases/default.db). The database
has one table containing all experiment sessions that were run. Then, for each experiment there
is a table containing all messages sent and received by the server, capable of supporting a
full replay of the experiment from the server's perspective. This table can be summarized
into a data frame output (docs forthcoming) and used to visualize data (docs forthcoming).ContributingSee theCONTRIBUTINGfile for how to help out.LicenseAEPsych licensed CC-BY-NC 4.0, as found in theLICENSEfile.CitingThe AEPsych paper is currently under review. In the meanwhile, you can cite ourpreprint:Owen, L., Browder, J., Letham, B., Stocek, G., Tymms, C., & Shvartsman, M. (2021). Adaptive Nonparametric Psychophysics. http://arxiv.org/abs/2104.09549 |
aepsych-client | AEPsych Python client v0.2.0This lets you use Python to interface with the AEPsych server to do model-based adaptive experimentation.InstallationWe recommend installing the client under a virtual environment likeAnaconda.
Once you've created a virtual environment forAEPsychClientand activated it, you can install through pip:pip install aepsych_clientIf you are a developer, you should also install themain AEPsych packageso that you can run the tests.ConfigurationThis interface uses AEPsych's ini-based config, which gets passed as a string to the server:# Instantiate a client
client = AEPsychClient(ip="0.0.0.0", port=5555)
# Send a config message to the server, passing in a configuration filename
filename = 'configs/single_lse_2d.ini'
client.configure(config_path=filename)Ask and tellTo get the next configuration from the server, we callask; we report on the outcome withtell.# Send an ask message to the server
trial_params = client.ask()
# Send a tell back
client.tell(config={"par1": [0], "par2": [1]}, outcome=1)Resume functionalityWe can run multiple interleaved experiments. When we callconfigure, we get back a strategy ID.
The client keeps track of all these strategy IDs and we can use them to resume experiments. By
doing this we can interleave different model runs.# Configure the server using one config
client.configure(config_path=file1, config_name='config1')
# Run some stuff on this config
...
# Configure the server using another config
client.configure(config_path=file2, config_name='config2')
# Run some stuff on this other config
...
# Resume the past config
client.resume(config_name="config1)Ending a sessionWhen you are done with your experiment, you should callclient.finalize(), which will stop the server and save your data to a database. |
aeptools | A package for Auditory ElectroPhysiology (AEP) LaboratoryThis is a package designed to provide necessary tools and methods for an AEP Lab. |
ae-pvalues | AE-pvaluesThis is the implementation ofAE-pvaluesproposed in the paperTowards Understanding Alerts raised by Unsupervised Network Intrusion Detection Systems, RAID2023(https://doi.org/10.1145/3607199.3607247).
The method allows you to obtain explanations of the anomalies identified by an auto-encoder (AE).Authors@mlanvinInstallationPip InstallationYou can install it through pippipinstallae-pvaluesUsage/Examplesfromae_pvaluesimportae_pvaluesmodel=# Any autoencoderx_train=np.load("./demo/example/x_train.npy")# Normal datax_test=np.load("./demo/example/x_test.npy")# Data to explainorder,pvalues=ae_pvalues(model,normal_data=x_train,data_to_explain=x_test)If you installed the module then you can use ae-pvalues directly from the command line :ae-pvalues-v./demo/example/x_train.npy./demo/example/rec_x_train.npy./demo/example/x_test.npy./demo/example/rec_x_test.npy-ooutputs-v: verbose mode-o: output folderThis produces two output files namely:dimensions_abnormal_order.npy : order of dimension by abnormalitydimensions_abnormal_pvalues.npy : raw pvalue scoresDemoA notebook is available in the demo folder to show an example of use.
Please note that the notebook requires the following dependencies :scikit-learntensorflowseabornplotlywhich can be installed with pip using the following comand line :python3-mpipinstallscikit-learntensorflowseabornplotly |
aep-web | Adversary Emulation Planner Web FrontendThis tool can be used to automatically build an ordered set of attack stages
withMITRE ATT&CKtechniques executed during each stage.The output is a set of attack stages that show all possible techniques that an
adversary might execute during each stage.InstallationInstall using pip:pipinstallaep-webYou will also need to clone theaep-datarepository, which contains a starting point witch example data:gitclonehttps://github.com/mnemonic-no/aep-dataRungitclonehttps://github.com/mnemonic-no/aep-data
aep-web--port<PORT>--data-dir/path/to/aep/data-dirOptionsAvailable options--reload Watch for file changes and reload webserver upon change
(Useful for development)
--web-reoot <PATH> Need if running behind a reverse proxy with another path than /
--data-dir <PATAH> Path to aep-data directory
--port <PORT> Listen on PORT (default is 3000)
--host <HOST> Host intefrace to listen to (default is 127.0.0.1) |
aepy | Place Holder! |
ae-python | After Effects scripts with pythonCreate After Effects scripts in Python. See thedocumentation. |
ae-python-imbalance | Contains methods to connect to the datalakes and handle files |
aeqtl | AeQTLeQTL analysis using region-based aggregation of rare variants.Requirementspython 3.5pipbx_interval_tree (see installation instructions below)git (optional)InstallationFirst, install IntervalTree from bx-python. We strongly recommend using a standalone package calledbx_interval_treewhich is smaller and easier to compile than bx-python.git clone https://github.com/ccwang002/bx_interval_tree
cd bx_interval_tree
python setup.py install
cd ..Continue to install AeQTL by choosing one of the options below.(1) From PyPIThe easiest way to install AeQTL is from PyPI.pip install aeqtl(2) From source codeAlternatively, download the source code of AeQTLgit clone https://github.com/Huang-lab/AeQTLThen install AeQTLcd AeQTL
pip install .Optional (but recommended)Append the path to AeQTL to your PATH environment variableexport PATH=/path/to/AeQTL/bin:$PATHRunaeqtl -v <vcf file> -b <bed file> -e <expression file> \
-cn <numerical covariates> -cc <categorical covariates> -s <covariate file> \
-o <output directory>Input data formatNote: demo input files with compatible format can be found in the "demo" folderVCF fileA standard multi-sample VCF file with file extension .vcf (or .vcf.gz). Sample IDs in VCF file, expression file, and covariate file should match exactly.BED fileA BED file (tab separated) with at least four columns and without header. The format of the file should follow:<chromosome> <start> <end> <region_name> <tested_genes>An example row:chr17 41197693 41197821 BRCA1 BRCA1;SLC25A39;HEXIM2The first four columns are required. The fifth column is a list of genes separated by ";". If the fifth column (tested_genes) is not provided, AeQTL by default will test each region with every gene from the expression file.Expression fileA matrix-format, tab separated .tsv file with gene expression from RNA-seq. The first row (header) of the file should follow:gene_id <sample_id_1> <sample_id_2> <sample_id_3> ...and the first column of the file should follow:gene_id
<gene_1>
<gene_2>
...Covariate fileA tab separated .tsv file with column names corresponding to covariates. A column of sample IDs with column name "sample_id" is required. Covariates entered in AeQTL and their corresponding column names must match exactly. However, the covariate file can contain other unused columns as well. If entering a categorical covariate, please make sure each category has the same value throughout the file (i.e. avoid instances such as having both "FEMALE" and "female" in the same column).Output data formatA tab separated .tsv file of summary statistics (up to 5 digits after the decimal point). Each row is an eQTL test between a region and a gene. The file contains the following fields:regiongenecoef_interceptcoef_genotypecoef_<covariate>(for each covariate)pvalue_interceptpvalue_genotypepvalue_<covariate>(for each covariate) |
aequilibrae | # AequilibraE[](https://github.com/AequilibraE/aequilibrae/actions/workflows/documentation.yml)[](https://github.com/AequilibraE/aequilibrae/actions/workflows/unit_tests.yml)[](https://github.com/AequilibraE/aequilibrae/actions/workflows/test_linux_with_coverage.yml)[](https://github.com/AequilibraE/aequilibrae/actions/workflows/build_linux.yml)[](https://github.com/AequilibraE/aequilibrae/actions/workflows/build_mac.yml)[](https://github.com/AequilibraE/aequilibrae/actions/workflows/build_windows.yml)[](https://github.com/AequilibraE/aequilibrae/actions/workflows/build_artifacts_qgis.yml)AequilibraE is a fully-featured Open-Source transportation modeling package and
the first comprehensive package of its kind for the Python ecosystem, and is
released under an extremely permissive and business-friendly license.It is developed as general-purpose modeling software and imposes very little
underlying structure on models built upon it. This flexibility also extends to
the ability of using all its core algorithms without an actual AequilibraE
model by simply building very simple memory objects from Pandas DataFrames, and
NumPY arrays, making it the perfect candidate for use-cases where transport is
one component of a bigger and more general planning or otherwise analytical
modeling pipeline.Different than in traditional packages, AequilibraE’s network is stored in
SQLite/Spatialite, a widely supported open format, and its editing capabilities
are built into its data layer through a series of spatial database triggers,
which allows network editing to be done on Any GIS package supporting SpatiaLite,
through a dedicated Python API or directly from an SQL console while maintaining
full geographical consistency between links and nodes, as well as data integrity
and consistency with other model tables.AequilibraE provides full support for OMX matrices, which can be used as input
for any AequilibraE procedure, and makes its outputs, particularly skim matrices
readily available to other modeling activities.AequilibraE includes multi-class user-equilibrium assignment with full support
for class-specific networks, value-of-time and generalized cost functions, and
includes a range of equilibration algorithms, including MSA, the traditional
Frank-Wolfe as well as the state-of-the-art Bi-conjugate Frank-Wolfe.AequilibraE’s support for public transport includes a GTFS importer that can
map-match routes into the model network and an optimized version of the
traditional “Optimal-Strategies” transit assignment, and full support in the data
model for other schedule-based assignments to be implemented in the future.State-of-the-art computational performance and full multi-threading can be
expected from all key algorithms in AequilibraE, from cache-optimized IPF,
to path-computation based on sophisticated data structures and cascading network
loading, which all ensure that AequilibraE performs at par with the best
commercial packages current available on the market.AequilibraE has also a Graphical Interface for the popular GIS package QGIS,
which gives access to most AequilibraE procedures and includes a wide range of
visualization tools, such as flow maps, desire and delaunay lines, scenario
comparison, matrix visualization, etc. This GUI, called QAequilibraE, is
currently available in English, French and Portuguese and more languages are
continuously being added, which is another substantial point of difference from
commercial packages.Finally, AequilibraE is developed 100% in the open and incorporates software-development
best practices for testing and documentation. AequilibraE’s testing includes all
major operating systems (Windows, Linux and MacOS) and all currently supported versions
of Python. AequilibraE is also supported on ARM-based cloud computation nodes, making
cloud deployments substantially less expensive.## Comprehensive documentation[AequilibraE documentation built with Sphinx ](http://www.aequilibrae.com)### What is available only in QGISSome common resources for transportation modeling are inherently visual, and therefore they make more sense if
available within a GIS platform. For that reason, many resources are available only from AequilibraE’s
[QGIS plugin](http://plugins.qgis.org/plugins/qaequilibrae/),
which uses AequilibraE as its computational workhorse and also provides GUIs for most of AequilibraE’s tools. Said tool
is developed independently and a little delayed with relationship to the Python package, and more details can be found in its
[GitHub repository](https://github.com/AequilibraE/qaequilibrae). |
aequilibrium | No description available on PyPI. |
aequitas | Aequitas: Bias Auditing & Fair ML Toolkitaequitasis an open-source bias auditing and Fair ML toolkit for data scientists, machine learning researchers, and policymakers. The objective of this package is to provide an easy-to-use and transparent tool for auditing predictors, as well as experimenting with Fair ML methods in binary classification settings.📥 Installationpip install aequitasorpip install git+https://github.com/dssg/aequitas.git🔍 Quickstart on Bias AuditingTo perform a bias audit, you need a pandasDataFramewith the following format:labelscoresens_attr_1sens_attr_2...sens_attr_N000AFY101CFN211BTN...N10ETYwherelabelis the target variable for your prediction task andscoreis the model output.
Only one sensitive attribute is required; all must be inCategoricalformat.fromaequitasimportAuditaudit=Audit(df)To obtain a summary of the bias audit, run:# Select the fairness metric of interest for your datasetaudit.summary_plot(["tpr","fpr","pprev"])We can also observe a single metric and sensitive attribute:audit.disparity_plot(attribute="sens_attr_2",metrics=["fpr"])🧪 Quickstart on Fair ML ExperimentingTo perform an experiment, a dataset is required. It must have a label column, a sensitive attribute column, and features.fromaequitas.flowimportDefaultExperimentexperiment=DefaultExperiment(dataset,label="label",s="sensitive_attribute")experiment.run()Several aspects of an experiment (e.g., algorithms, number of runs, dataset splitting) can be configured individually.🧠 Quickstart on Method TrainingAssuming anaequitas.flow.Dataset, it is possible to train methods and use their functionality depending on the type of algorithm (pre-, in-, or post-processing).For pre-processing methods:fromaequitas.flow.methods.preprocessingimportPrevalenceSamplingsampler=PrevalenceSampling()sampler.fit(dataset.train.X,dataset.train.y,dataset.train.s)X_sample,y_sample,s_sample=sampler.transform(dataset.train.X,dataset.train.y,dataset.train.s)for in-processing methods:fromaequitas.flow.methods.inprocessingimportFairGBMmodel=FairGBM()model.fit(X_sample,y_sample,s_sample)scores_val=model.predict_proba(dataset.validation.X,dataset.validation.y,dataset.validation.s)scores_test=model.predict_proba(dataset.test.X,dataset.test.y,dataset.test.s)for post-processing methods:fromaequitas.flow.methods.postprocessingimportBalancedGroupThresholdthreshold=BalancedGroupThreshold("top_pct",0.1,"fpr")threshold.fit(dataset.validation.X,scores_val,dataset.validation.y,dataset.validation.s)corrected_scores=threshold.transform(dataset.test.X,scores_test,dataset.test.s)With this sequence, we would sample a dataset, train a FairGBM model, and then adjust the scores to have equal FPR per group (achieving Predictive Equality).📜 Features of the ToolkitMetrics: Audits based on confusion matrix-based metrics with flexibility to select the more important ones depending on use-case.Plotting options: The major outcomes of bias auditing and experimenting offer also plots adequate to different user objectives.Fair ML methods: Interface and implementation of several Fair ML methods, including pre-, in-, and post-processing methods.Datasets: Two "families" of datasets included, namedBankAccountFraudandFolkTables.Extensibility: Adapted to receive user-implemented methods, with intuitive interfaces and method signatures.Reproducibility: Option to save artifacts of Experiments, from the transformed data to the fitted models and predictions.Modularity: Fair ML Methods and default datasets can be used individually or integrated in anExperiment.Hyperparameter optimization: Out of the box integration and abstraction ofOptuna's hyperparameter optimization capabilities for experimentation.Fair ML MethodsWe support a range of methods designed to address bias and discrimination in different stages of the ML pipeline.TypeMethodDescriptionPre-processingData RepairerTransforms the data distribution so that a given feature distribution is marginally independent of the sensitive attribute, s.Label FlippingFlips the labels of a fraction of the training data according to the Fair Ordering-Based Noise Correction method.Prevalence SamplingGenerates a training sample with controllable balanced prevalence for the groups in dataset, either by undersampling or oversampling.UnawarenessRemoves features that are highly correlated with the sensitive attribute.MassagingFlips selected labels to reduce prevalence disparity between groups.In-processingFairGBMNovel method where a boosting trees algorithm (LightGBM) is subject to pre-defined fairness constraints.Fairlearn ClassifierModels from the Fairlearn reductions package. Possible parameterization for ExponentiatedGradient and GridSearch methods.Post-processingGroup ThresholdAdjusts the threshold per group to obtain a certain fairness criterion (e.g., all groups with 10% FPR)Balanced Group ThresholdAdjusts the threshold per group to obtain a certain fairness criterion, while satisfying a global constraint (e.g., Demographic Parity with a global FPR of 10%)Fairness Metricsaequitasprovides the value of confusion matrix metrics for each possible value of the sensitive attribute columns To calculate fairness metrics. The cells of the confusion metrics are:CellSymbolDescriptionFalse Positive$FP_g$The number of entities of the group with $\hat{Y}=1$ and $Y=0$False Negative$FN_g$The number of entities of the group with $\hat{Y}=0$ and $Y=1$True Positive$TP_g$The number of entities of the group with $\hat{Y}=1$ and $Y=1$True Negative$TN_g$The number of entities of the group with $\hat{Y}=0$ and $Y=0$From these, we calculate several metrics:MetricFormulaDescriptionAccuracy$Acc_g = \cfrac{TP_g + TN_g}{|g|}$The fraction of correctly predicted entities withing the group.True Positive Rate$TPR_g = \cfrac{TP_g}{TP_g + FN_g}$The fraction of true positives within the label positive entities of a group.True Negative Rate$TNR_g = \cfrac{TN_g}{TN_g + FP_g}$The fraction of true negatives within the label negative entities of a group.False Negative Rate$FNR_g = \cfrac{FN_g}{TP_g + FN_g}$The fraction of false negatives within the label positive entities of a group.False Positive Rate$FPR_g = \cfrac{FP_g}{TN_g + FP_g}$The fraction of false positives within the label negative entities of a group.Precision$Precision_g = \cfrac{TP_g}{TP_g + FP_g}$The fraction of true positives within the predicted positive entities of a group.Negative Predictive Value$NPV_g = \cfrac{TN_g}{TN_g + FN_g}$The fraction of true negatives within the predicted negative entities of a group.False Discovery Rate$FDR_g = \cfrac{FP_g}{TP_g + FP_g}$The fraction of false positives within the predicted positive entities of a group.False Omission Rate$FOR_g = \cfrac{FN_g}{TN_g + FN_g}$The fraction of false negatives within the predicted negative entities of a group.Predicted Positive$PP_g = TP_g + FP_g$The number of entities within a group where the decision is positive, i.e., $\hat{Y}=1$.Total Predictive Positive$K = \sum PP_{g(a_i)}$The total number of entities predicted positive across groups defined by $A$Predicted Negative$PN_g = TN_g + FN_g$The number of entities within a group where the decision is negative, i.e., $\hat{Y}=0$Predicted Prevalence$Pprev_g=\cfrac{PP_g}{|g|}=P(\hat{Y}=1 | A=a_i)$The fraction of entities within a group which were predicted as positive.Predicted Positive Rate$PPR_g = \cfrac{PP_g}{K} = P(A=A_i | \hat{Y}=1)$The fraction of the entities predicted as positive that belong to a certain group.These are implemented in theGroupclass. With theBiasclass, several fairness metrics can be derived by different combinations of ratios of these metrics.📔Example NotebooksNotebookDescriptionAudit a Model's PredictionsCheck how to do an in-depth bias audit with the COMPAS example notebook.Correct a Model's PredictionsCreate a dataframe to audit a specific model, and correct the predictions with group-specific thresholds in the Model correction notebook.Train a Model with Fairness ConsiderationsExperiment with your own dataset or methods and check the results of a Fair ML experiment.Further documentationYou can find the toolkit documentationhere.For more examples of the python library and a deep dive into concepts of fairness in ML, see ourTutorialpresented on KDD and AAAI. Visit also theAequitas project website.Citing AequitasIf you use Aequitas in a scientific publication, we would appreciate citations to the following paper:Pedro Saleiro, Benedict Kuester, Abby Stevens, Ari Anisfeld, Loren Hinkson, Jesse London, Rayid Ghani, Aequitas: A Bias and Fairness Audit Toolkit, arXiv preprint arXiv:1811.05577 (2018). (PDF)@article{2018aequitas,title={Aequitas: A Bias and Fairness Audit Toolkit},author={Saleiro, Pedro and Kuester, Benedict and Stevens, Abby and Anisfeld, Ari and Hinkson, Loren and London, Jesse and Ghani, Rayid},journal={arXiv preprint arXiv:1811.05577},year={2018}}Back to top |
aequitas-core | Aequitas Core LibraryThis is a sketch repository for the Aequitas core library. It is a work in progress.
No definite decisions have been made yet.
Feel free to contribute and/or provide feedback in the issue section. |
aequitas-lib | Python project templateA simple template of a Python project, with a rigid file structure, and predisposition for unit testing and release on PyPi.Relevant featuresAll your project code into a single main package (aequitas-lib/)All your project tests into a single test package (test/)Unit testing support viaunittestAutomatic testing on all branches via GitHub ActionsSemi-automatic versioning via GitPackaging support viasetuptoolsAutomatic release onPyPivia GitHub ActionsDocker image support viaDockerfileAutomatic release onDockerHubvia GitHub ActionsSupport for semi-automatic development environment management viaPyenvAutomatic dependencies updates viaRenovateAutomatic conversion ofTODOcomments into GitHub issues via thealstr/todo-to-issue-actionProject structureOverview:<rootdirectory>
├──aequitas-lib/# main package (should be named after your project)│├──__init__.py# python package marker│└──__main__.py# application entry point├──test/# test package (should contain unit tests)├──.github/# configuration of GitHub CI│└──workflows/# configuration of GitHub Workflows│├──check.yml# runs tests on multiple OS and versions of Python│└──deploy.yml# if check succeeds, and the current branch is one of {main, master}, triggers automatic releas on PyPi├──MANIFEST.in# file stating what to include/exclude in releases├──LICENSE# license file (Apache 2.0 by default)├──pyproject.toml# declares build dependencies├──renovate.json# configuration of Renovate bot, for automatic dependency updates├──requirements-dev.txt# declares development dependencies├──requirements.txt# declares runtime dependencies├──setup.py# configuration of the package to be released on Pypi└──Dockerfile# configuration of the Docker image to be realsed on DockerhubTODO-list for template usageUse this template to create a new GitHub repository, sayaequitas-libthis name will also be used to identify the package on PyPiso, we suggest choosing a name which has not been used on PyPi, yetwe also suggest choosing a name which is a valid Python package name (i.e.using_snake_case)Clone theaequitas-librepositoryOpen a shell into your localaequitas-libdirectory and run./rename-template.shaequitas-libThis will coherently rename the template's project name with the one chosen by you (i.e.aequitas-lib, in this example)Commit & pushEnsure you like theApache 2.0 License. If you don't, change the content of theLICENSEfileEnsure the version reported in.python-versioncorresponds to the actual Python version you are willing to use to develop your projectCheck the Python version and OS tests should be run on in CI, by looking the file.github/workflows/check.ymlAdd your runtime dependencies torequirements.txtand development-only dependencies hererequirements-dev.txtSet your project's release metadata and dependencies by editingsetup.pyChange the assignee for pull-requests for automatic dependency updates by editingrenovate.jsoncurrently defaults to @gciattoAdd your PyPi credentials as secrets of the GitHub repositoryPYPI_USERNAME(resp.PYPI_PASSWORD) for your username (resp. password)this may require you to register on PyPi firstGenerate a GitHub token and add it as a secret of the GitHub repository, namedRELEASE_TOKENcf.https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/managing-your-personal-access-tokens#creating-a-personal-access-token-classicthe token must allow pushing to the repositoryPut your main (resp. test) code inaequitas-lib/(resp.test/)How to do stuffRun your code as an applicationThis will execute the fileaequitas-lib/__main__.py:python-maequitas-libRun unit testspython-munittestdiscover-stest-t.Tests are automatically run in CI, on all pushes on all branches.
There, tests are executed on multiple OS (Win, Mac, Ubuntu) and on multiple Python versions (from3.8to3.11).Restore dev dependenciespipinstall-rrequirements-dev.txtRelease a new version on PyPiThis paragraph is more understandable if the reader has some background aboutGitFlowGitHub actions automatically release a new version ofaequitas-libon PyPi whenever commits are pushed on either themain/masterordevelopbranches, as well as when new tags are pushed.Tags are assumed to consist ofsemantic versioningstrings of the formMajor.Minor.PatchwhereMajor,Minor, andPatchare non-negative integers.So, to release versionX.Y.Z, developers must:tag a commit on themaster/main/developbranch, usingX.Y.Zas the tag labelgittag-a'X.Y.Z'-m<amessageheredescribingtheversion>push the taggitpush--follow-tagsGitHub Actions will then run tests and, if all of them succeed, release the code on PyPi.
After the release, users will be able to install your code via Pip.Non-tagged commits pushed on themaster/main/developbranch will triggerdev releases.
Dev releases are automatically tagged asX.Y.Y.devN, whereX.Y.Yis the value of themost recentversion tagNis the amount of commits following the most recent version tag |
aequitas-lite | Aequitas is an open-source bias audit toolkit for data scientists, machine learning researchers, and policymakers to audit machine learning models for discrimination and bias, and to make informed and equitable decisions around developing and deploying predictive tools. |
aer | aerA CLI helper for usingEMRon AWS |
aerarium | A simple command line tool for tracking my finances.FeaturesCheck account balanceUse the--balanceor-bflag to print the current account balance.Withdraw amountUse the--withdraw<amount>or-w<amount>option to withdraw money, along with a description and category prompt.
Prints new account balance.Deposit amountUse the--deposit<amount>or-d<amount>option to deposit money, along with a description and category prompt.
Prints new account balance.List transactionsUse the--transactionsor-tflag to print a list of all transactions.Predict spendingUse the--predict<number_of_days>or-p<number_of_days>flag to print a prediction of spending for next n days.Help informationUse--helpto print usage help.UsageSome examples:$ aerarium --balance
Current balance: $1000
$ aerarium --withdraw 100
Enter withdrawal description: Groceries
Enter withdrawal category: Food
Balance: 900
$ aerarium --deposit 500
Enter deposit description: Salary
Enter deposit category: Income
Balance: 1400The configuration file contains the account name and starting balance.Note: This project is under active development. |
aeratable | Nicely format Aera interface-output to a table in ASCII or CSV format.TLDRIf you query a lot from aninterfacein Aera, you might want to format the output in a more readable way. This script does that for you. It takes the output from an interface and formats it into a table in ASCII or CSV format.InstallationIdeally install usingpipx, like any other command line tool:pipxinstallaeratableAlternatively, you can install using pip:pipinstallaeratableExampleIf you copy the output from an interface in Aera like below:It has the tendency to be in a very unusefull format. See the example of what the paste looks like:Theaeratablecommand line tool can be used to format this output into an ASCII (or CSV) table. The command line tool takes the 'ugly' formatted output directly from Windows' clipboard (using the wonderfullpyperclippackage) and creates a table in ASCII format. by default this will replace the clipboard content with the formatted table. If you provide the-vor--verboseflag, the table will additionally be printed to the console.aeratable-vThe output (when pasted back into theinterface) will now look like this:This can be very usefull if you query a lot from an interface in Aera, and want to store your intermediate results in a more readable format directly in the interface. Don't forget to put the table in a comment block (/* ... */) to prevent the interface from interpreting the table as a query.I want CSV instead of ASCIIsimple! use the-for--fmtflag with the valuecsv:aeratable-fcsvHappy SQL! |
aerende | Ærende is a small, python based note taking application.
Works offline and in the terminal via a curses interface.
Navigation via vim-esque keys.
Designed to slot easily into my comm workspace alongside weechat and neomutt. |
aerender | aerenderRender Adobe After Effects projects using Pythonaerenderis an asyncio wrapper overaerender(Adobe After Effects 2019)
built and tested on Windows 10. It can be used to automate the rendering of
After Effects projects.Install itpip install aerenderUsage exampleTo render just Comp 1 to a specified file:importasynciofrompathlibimportPathfromaerenderimportAERenderWrapperasyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())if__name__=='__main__':AERENDER_FULLPATH=Path('C:/Program Files/Adobe/Adobe After Effects CC 2019/Support Files/aerender')aerender=AERenderWrapper(exe_path=AERENDER_FULLPATH)coro=aerender.run(project_path=Path('C:/projects/proj1.aep'),comp_name='Comp 1',output_path=Path('C:/output/proj1/proj1.avi'),)asyncio.run(coro)aerender -helpBelow you can see the-helpoutput ofaerenderexecutable on Windows.USAGE:aerenderrenders After Effects comps. The render may be performed either
by an already running instance of AE or by a newly invoked instance. By
default,aerenderwill invoke a new instance of AE, even if one is
already running. To change this, see the-reuseflag below.aerendertakes a series of optional arguments.Some are single flags, like-reuse. Some come in flag-argument
pairs, like-project project_path. And one comes in a triplet,-mem_usage image_cache_percent max_mem_percent.aerenderwith 0 arguments, or with any argument equaling-helpor-h, prints this usage message.The arguments are:-hprint this usage message-helpprint this usage message-reuseuse this flag if you want to try and reuse
an already running instance of AE to perform the
render. By default, aerender will launch a new
instance of After Effects, even if one is already
running. But, if AE is already running, and the-reuseflag is provided, thenaerenderwill
ask the already running instance of AE to perform
the render. Wheneveraerenderlaunches a new
instance of AE, it will tell AE to quit when
rendering is completed; otherwise, it will not
quit AE. Also, the preferences will be written
to file upon quit when the-reuseflag is
specified; otherwise it will not be written.-project project_pathwhereproject_pathis a file path or URI
specifying a project file to open.
If none is provided, aerender will work with the
currently open project.
If no project is open and no project is provided,
an error will result.-teamproject project_namewhereproject_nameis a name of a
team project to open.-comp comp_namewherecomp_namespecifies a comp to be rendered.
If the comp is in the render queue already, and
in a queueable state, then (only) the first
queueable instance of that comp on the render
queue will be rendered. If the comp is in the
project but not in the render queue, then it will
be added to the render queue and rendered.
If no-compargument is provided,aerenderwill
render the entire render queue as is. In this
case (no-comp), the only other arguments used
will be-project,-log,-v,-mem_usage, and-close; the-RStemplate,-OMtemplate,-output,-s,-e, and-iarguments will be ignored.-rqindex index_in_render_queuewhereindex_in_render_queuespecifies a
render queue item to be rendered. Options that make
sense when rendering a single render queue item
are available like with the-compflag.-RStemplate render_settings_templatewhererender_settings_templateis the name of a template to apply to the render
queue item.If the template does not exist it is
an error.
Default is to use the render template already
defined for the item.-OMtemplate output_module_templatewhereoutput_module_templateis the name of a template to apply to the
output module. If the template does not exist
it is an error.
Default is to use the template already defined
for the output module.-output output_pathwhereoutput_pathis a file path or URI
specifying the destination render file.
Default is the path already in the project file.-log logfile_pathwherelogfile_pathis a file path or URI
specifying the location of the log file.
Default is stdout.-s start_framewherestart_frameis the first frame to render.
Default is the start frame in the file.-e end_framewhereend_frameis the last frame to render.
Note, this is "inclusive;" the final frame
will be rendered.
Default is the end frame in the file.-i incrementwhereincrementis the number of frames to
advance before rendering a new frame. A value
of 1 (the default) results in a normal rendering
of all frames. Higher increments will repeat the
same (frame increment-1) times and then render a
new one, starting the cycle again. Higher values
result in faster renders but choppier motion.
Default is 1.-mem_usage image_cache_percent max_mem_percentwhereimage_cache_percentspecifies the maximum
percent of memory used to cache already rendered
images/footage, andmax_mem_percentspecifies
the total percent of memory that can be
used by After Effects.-v verbose_flagwhereverbose_flagspecifies the type of
messages reported. Possible values areERRORS(prints only fatal and problem errors) orERRORS_AND_PROGRESS(prints progress of rendering
as well).
Default value isERRORS_AND_PROGRESS.-close close_flagwhereclose_flagspecifies whether or not to
close the project when done rendering, and
whether or not to save changes. If close_flag isDO_NOT_SAVE_CHANGES, project will be closed
without saving changes. If close_flag isSAVE_CHANGES, project will be closed and changes
will be saved. If close_flag isDO_NOT_CLOSEthe
project will be left open; but the project is
left open only if using an already-running
instance of AE, since new invocations of AE must
always close and quit when done.
Default value isDO_NOT_SAVE_CHANGES.-sound sound_flagwheresound_flagspecifies whether or not to play
a sound when rendering is complete. Possible
values are "ON" or "OFF".
Default value is "OFF".-versiondisplays the version number of aerender to the
console. Does not render.-continueOnMissingFootageDo not stop rendering on missing footage. Log and
render with placeholder color bars.EXAMPLES:
To render just Comp 1 to a specified file:aerender -project c:\projects\proj1.aep -comp "Comp 1"
-output c:\output\proj1\proj1.aviTo render everything in the render queue as is in the project file:aerender -project c:\projects\proj1.aepTo render frames 1-10 using multi-machine render:aerender -project c:\projects\proj1.aep -comp "Comp 1" -s 1 -e 10
-RStemplate "Multi-Machine Settings"
-OMtemplate "Multi-Machine Sequence"
-output c:\output\proj1\frames[####].psd |
aerforge | AerForgeA game engine made with pygame.Getting StartedInstall PythonOpen cmd/terminal and type:pip install AerForgeExamplesCreating a windowfromaerforgeimport*forge=Forge()@forge.eventdefupdate():passforge.run()Creating a cubefromaerforgeimport*forge=Forge()classCube(Entity):def__init__(self):super().__init__(window=forge,shape=shape.Rect,width=20,height=20,x=0,y=0,color=color.Color(0,255,255))self.center()cube=Cube()@forge.eventdefupdate():passforge.run() |
aergo-herapy | herapyHeraPy is a Python package for AERGO that provides the features below.FeaturesCommunication with AERGO nodeGetting AERGO blockchain informationCreating/Exporting/Importing an accountMaking and sending a transactionDeploying/Calling/Querying a smart contractQuerying and prooving contract/account statesInstallInstall the latest version inthe Python Package Indexpip install aergo-herapyor, install locallygit clone [email protected]:aergoio/herapy.git
cd herapy
make installRun examplesAfter installing aergo-herapy, you can run examplesmake exThe examples in the ‘examples’ directory connect the public Aergo testnet.BuildDownloading HeraPyDownload HeraPy from this repositorygit clone [email protected]:aergoio/herapy.gitInstalling Dependenciespip install -r requirements.txtBut, we recommend to use a virtual environment below.Virtual Environment (Pipenv)Using Pipenv, all dependencies will be installed automatically.pipenv shellIf you cleaned up and setup again,pipenv installIf you want to test or contribute, then do not forget ‘–dev’ optionpipenv install --dev
make testUpdating ProtocolIf need to upgrade a protocol,make protocAfter this command, all protocol related source files will be generated if it’s different.Updating Aergo ConfigurationsIf need to upgrade Aergo Configurations,make aergo-typesAfter this command, ‘aergo/herapy/obj/aergo_conf.py’ will be generated if it’s different.If occur the error message belowERROR: Cannot find 'AERGO_TYPES_SRC', find the source code ‘aergo/config/types.go’ and make this file path as an environment variable of ‘AERGO_TYPES_SRC’export AERGO_TYPES_SRC=`find ~ -path '*/aergo/config/types.go' 2>/dev/null`
make aergo-typesReleases and ContributingHeraPy follows a major release cycle of AERGO.
A minor release such as fixing bugs and errors are occasionally patched.
Please let us know if you encounter a bug byfilling an issue.If you are planning to contribute a new feature, class, or function,
pleaseopen an issueand discuss with us.We appreciate all contributions.Documentationhttps://aergo-herapy.readthedocs.ioLicenseHeraPy is MIT license as found in the LICENSE file.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History2.0.1 (2020-02-05)Add new Aergo Keystore support.Add ‘add_raft_member’, ‘del_raft_member’2.0.0 (2019-12-03)Add ‘transfer’ API for simple token transferingAdd ‘gas limit’, ‘fee delegation’ and ‘gas used’ for ‘TxResult’ object‘Account’ object encoding to/decoding from json dataBug fixException for encoding ‘TxResult’ to the json type, because of ‘tx_id’1.3.3 (2019-11-05)support TLS connectionBug fixcoinbase address encoding issue fromhttps://github.com/aergoio/herapy/issues/701.2.7 (2019-10-21)support Enterprise features (raft)issue fromhttps://github.com/aergoio/herapy/issues/75support ABIissue fromhttps://github.com/aergoio/herapy/issues/741.2.6 (2019-09-04)Bug fixissue fromhttps://github.com/aergoio/herapy/issues/681.2.5 (2019-08-26)support an empty string and governance string address forAddresssupportget_name_infoBug fixmiss value fromget_conf_change_progress1.2.3 (2019-08-22)support redploy tx typesupport ‘GetConfChangeProgress’ protocol to find a state of ‘changeCluster’ system contractsupport ‘name’ (string) addresssupport enterprise consensus infoBug fixmiss match a tx type in tx0.12.2 (2019-03-21)encrypt/decrypt logic moves to ‘util’ for a general usageBug fixwhen tx result handling, get error message from a changed varialbe0.12.0 (2019-03-08)Apply v0.12.0 protocolBug fixget a genesis block with a block height 00.11.0 (2019-02-20)Change the result type from the ‘get_tx_result’ function (‘SmartContractStatus’ –> ‘TxResultStatus’)Separate two function ‘send_tx’ and ‘batch_tx’ from the single ‘send_tx’ function for a single and multiple txsOpen the ‘generate_tx’ function for helping a new transaction manuallySupport multiple proof queries with the array of Storage KeysSimplify verifying proof as the ‘verify_proof’ function from ‘verify_inclusion’ and ‘verify_exclusion’0.9.0 (2018-12-31)Fit for the public Aergo testnet.First public release on PyPI.0.1.0 (2018-11-07)First release on PyPI. |
aerial | A Python library for receiving Unix style signals.This library is meant to be a simple way to deal with handling signals, while avoiding callbacks.Install it with pippipinstallaerialA simple use looks like this:>>>importtime>>>importsignal>>>>>>importaerial>>>defmain_loop():...whilenotaerial.received(signal.SIGTERM):...ifaerial.received(signal.SIGHUP):...print('Got a SIGHUP')...time.sleep(.5)...print('See you later')...>>>And try out the demo by running the module.python-maerial[PID10852]Hello,sendmeaSIGTERMtoexit,oraSIGHUPforatrick# In another terminal[PID10852]Neathuh?# kill -SIGHUP 10852[PID10852]Seeyoulater# kill -SIGTERM 10852 |
aerial-contamination | This is a simple example package about aerial contamination. |
aerialist | AERIALIST: UAV Test BenchAerialist(unmanned AERIAL vehIcle teST bench) is a novel test bench for UAV software that automates all the necessary UAV testing steps: setting up the test environment, building and running the UAV firmware code, configuring the simulator with the simulated world properties, connecting the simulated UAV to the firmware and applying proper UAV configurations at startup, scheduling and executing runtime commands, monitoring the UAV at runtime for any issues, and extracting the flight log file after the test completion.With Aerialist, we aim to provide researchers with an easy platform to automate tests on both simulated and real UAVs, allowing them to do experiments required to overcome the UAV simulation-based testing challenges.Table of ContentsIntroductionUAV TestsDemo VideoGetting StartedDocker Test ExecutionLocal Test ExecutionKubernetes Test ExecutionUsageTest Description FileCommand Line InterfacePython APIReferencesLicenseContactsIntroductionThe below figure demonstrates Aerialist's software architecture, with the current implementation supporting UAVs powered byPX4-Autopilot(a widely used open-source UAV firmware).The input is aTest Descriptionfile, which defines the UAV and environment configurations and the test steps.
TheTest Runnersubsystem (that abstracts any dependencies to the actual UAV, its software platform, and the simulation environment) prepares the environment for running the test case as described in the test description.After setting up the simulation environment (if testing a simulated UAV), the Test Runner connects to the (simulated or physical) UAV and configures it according to the startup instructions. Then, it sends runtime commands, monitors the UAV's state during the flight, and extracts flight logs at the end of the test for future analysis. Each module is detailed in theArchitecture Documents.UAV TestsThe de-facto testing standard of UAVs relies onmanually written system-level teststo test UAVsin the field.
These tests are defined assoftware configurations(using parameters, config files, etc.) in a specificenvironmentsetup (e.g., obstacles placement, lighting conditions) and a set of runtimecommands.
The runtime commands received during the UAV flight (e.g., from a remote controller) make the UAV fly with a specific human observablebehavior(e.g., trajectory, speed, distance to obstacles).Hence, Aerialist models a UAV test case with the following set oftest propertiesand uses aYAMLstructure to describe the test.Drone: Software configurations of the UAV model, including allAutopilot parametersand configuration files (e.g., mission plan) required to set up the drone for the test.Environment: Simulation settings such as the used simulator, physics of the simulated UAV, simulation world (e.g., surface material, UAV’s initial position), surrounding objects (e.g., obstacles size, position), weather conditions (e.g., wind, lighting), etc.Commands: Timestamped external commands from the ground control station (GCS) or the remote controller (RC) to the UAV during the flight (e.g., change flight mode, go in a specific direction, enter mission mode).Expectation (optional): a time series of certain sensor readings that the test flights are expected to follow closely.Demo VideoTake a look at theDemo Videoto get more insights on the test execution methods introduced later.Getting StartedYou can execute UAV test cases with Aerialist in three different ways.Docker Test Execution(Recommended): Execute Test Cases in pre-built Docker containers without the need to install PX4 dependencies on your machine.
This is the recommended option for most use cases and supports headless simulation (without the graphical interface).Local Test Execution: Execute Test Cases using PX4 dependencies installed on the same machine.
This allows you to easily develop new functionalities and run the UAV simulators with the graphical interface so you can visually follow the UAV behavior.
This is only recommended if you prefer to get more insights into UAV behavior.Kubernetes Test Execution: You can also deploy your test execution to a Kubernetes cluster for more scale.
This option is only recommended if you are using Aerialist to conduct large-scale experiments on test generation for drones.Docker Test ExecutionUsing Docker containers with pre-configured PX4 dependencies to execute test cases is the simplest and recommended way of executing UAV tests with Aerialist.
Aerialist's Docker image is hosted onDockerhub.Using Docker Container's CLIRequirements:DockerThis has been tested onWindows, Ubuntu and macOS with x86-64 processors.You may need to rebuild the docker image if you are using another OS or architecture.docker run -it skhatiri/aerialist bashYou can now use theCommand Line Interfacein the container's bash.checkpython3 aerialist exec --helpNote:The .env for the docker image comes fromtemplate.env. You can customize them usingenvironment variablesfor the Docker container.Using Host's CLIAlternatively, you can use the CLI on your local machine and instruct Aerialist to execute test cases inside a docker container.
This gives you more flexibility since the test results (flight logs) are directly stored on the host machine and you don't lose them.Requirements:DockerPython ≥ 3.8Your user should be able to run docker commands withoutsudo.check hereThis has been tested onUbuntu and macOS with x86-64 processors.You may need to rebuild the docker image if you are using another OS or architecture.Clone this repository andcdinto its root directorypip3 install -r requiremetns.txtCreate a file named.envin the repository's root directory. Then copy and customize the contents oftemplate.envinto it.Create a folder namedresultsin the repository's root directory.You can use the dockerfile to build a Docker image with all the requirements, or instead pull the latest image from the Image repository.docker build . -t skhatiri/aerialistordocker pull skhatiri/aerialistYou can now instruct Aerialist to execute test cases inside a docker containerJust add--agent dockerto the command line or update the test-description file (agent.engine:docker).You can now use theCommand Line Interfacein your local bash.checkpython3 aerialist exec --helpLocal Test ExecutionNote:InstallingPX4-Autopilot,PX4-Avoidanceand their requirements including ROS and Gazebo could be problematic in many cases. We only suggest this full installation to users who need direct visual access to the simulator or are curious to visually monitor the UAVs during the flight. Otherwise, test execution, extracting the flight logs, and plotting them can be achieved by thedocker exectionas well.We have prepared a ready-to-use virtual machine (download link) to help users onboaord fast. You can move on to usingdockerized test executionsif you don't need the simulation visualizations any more.If you prefer to run the simulations and PX4 on your own machine, followPX4 installation guide.Requirements:Ubuntu 18We have prepared abashsriptto automate all the steps of installing PX4 and Aerialist in one shot.Follow the instructions.You can also follow astep-by-step guideif needed.Clone this repository and cd into its root directorypip3 install -r requiremetns.txtCreate a file named.envin the repository's root directory. Then copy and customize the contents oftemplate.envinto it.UpdatePX4_HOMEandRESULTS_DIRvariables according to your installation.You can now use theCommand Line Interface.Kubernetes Test ExecutionAerialist can also deploy test executions on a Kubernetes cluster to facilitate running tests in the cloud. Specifically, as can be seen in the below figure, Aerialist can run multiple executions of the same test case in isolated Kubernets pods in parallel, and gather test results for further processing.This feature is specifically helpful when performing test generation tasks, where UAV's flight could be subject to non-determinism and multiple simulations are required.
Follow ourK8S Deployment Guideline.UsageTest Description FileUsing a predefinedtest-description yaml fileis the easiest way to define the test case.# template-test.yamldrone:port:sitl# type of the drone to connect to {sitl, ros, cf}#params: #PX4 parameters : https://docs.px4.io/main/en/advanced_config/parameter_reference.html# {parameter_name}: {parameter_value} #(keep datatype -> e.g, 1.0 for float, 1 for int)# CP_DIST: 1.0# POS_MOD: 2.5params_file:samples/flights/mission1-params.csv#csv file with the same structure as abovemission_file:samples/flights/mission1.plan# input mission file addresssimulation:simulator:ros# the simulator environment to run {gazebo,jmavsim,ros}speed:1# the simulator speed relative to real timeheadless:true# whether to run the simulator headlessobstacles:-size:# Object 1 size in l,w,hl:5w:5h:5position:# Object 1 position in x,y,z and it's rotationx:-8y:3z:0r:0# home_position: # home position to place the drone [lat,lon,alt]test:commands_file:samples/flights/mission1-commands.csv# runtime commands file addressassertion:log_file:samples/flights/mission1.ulg# reference log file address# variable: trajectory # reference variables to compareCommand-Line InterfaceTest ExecutionYou can utilize the toolkit with the following command line options:Make sure you are at the root directory of the repository:cd Aerialist/IMPORTANT NOTE: The following commands are assuming that you are using Aerialist directly on your machine (not inside a docker container).--agent dockeris asking Aerialist to create a docker container and execute test cases there as detailedabove.If you are executing the commandinside a docker container, exclude--agent dockerto let the test run locally there.The simplest way to execute a UAV test by Aerialist is by the following command:python3 aerialsit exec --test [test-file.yaml] --agent dockerReplaying a pre-recorded manual flight (RC commands are extracted and replayed from a .ulg log)python3 aerialist exec --test samples/tests/manual1.yaml --agent dockerExecuting an autonomous mission with a box-shaped obstacle in the environmentpython3 aerialist exec --test samples/tests/mission1.yaml --agent dockerMore sample tests can be foundhereWhen test exection is finished, you will have test results inresults/folder:Flight Log of the executed test (.ulg)Plot of the flight trajectory, as seen belowYou can usepython3 aerialist exec --helpanywhere to get help onother possible arguments.Plotting Executed Test CasesYou can plot flight trajectory of the executed test cases using the following comnmand. plots are stored inresults/folder.python3 aerialist plot --test [test-file.yaml] --log [test-log.ulg]Using Aerialist in Your CodeYou can integrate Aerialist's Python package in your own code and directly define and execute UAV test cases with it.
This can be specifically useful when you are working on test generation approaches for UAVs. An example of such usage of Aerialist can be found inSurrealist.pip3 install git+https://github.com/skhatiri/Aerialist.gitCreate an instance ofDroneTestclass and define your test caseconfigure and execute the test case using your preferred test execution agent (LocalAgent,DockerAgent,K8sAgent)Take a look at ourcode snippetsfor more details and sample codes.ReferencesIf you use this tool in your research, please cite the following papers:Sajad Khatiri, Sebastiano Panichella, and Paolo Tonella, "Simulation-based Test Case Generation for Unmanned Aerial Vehicles in the Neighborhood of Real Flights,"In 2023 IEEE 16th International Conference on Software Testing, Verification and Validation (ICST)PreprintExperiments Dataset@inproceedings{khatiri2023simulation,
title={Simulation-based test case generation for unmanned aerial vehicles in the neighborhood of real flights},
author={Khatiri, Sajad and Panichella, Sebastiano and Tonella, Paolo},
booktitle={2023 16th IEEE International Conference on Software Testing, Verification and Validation (ICST)},
year={2023},
}LicenseThe software we developed is distributed under MIT license. See thelicensefile.ContactsFeel free to use theDiscussionssection to ask your questions and look for answers.You can also contact us directly using email:Sajad Khatiri (Zurich University of Applied Sciences) [email protected] |
aerich | AerichEnglish |РусскийIntroductionAerich is a database migrations tool for TortoiseORM, which is like alembic for SQLAlchemy, or like Django ORM with
it's own migration solution.InstallJust install from pypi:pipinstallaerichQuick Start>aerich-h
Usage:aerich[OPTIONS]COMMAND[ARGS]...
Options:-V,--versionShowtheversionandexit.-c,--configTEXTConfigfile.[default:pyproject.toml]--appTEXTTortoise-ORMappname.-h,--helpShowthismessageandexit.
Commands:downgradeDowngradetospecifiedversion.headsShowcurrentavailableheadsinmigratelocation.historyListallmigrateitems.initInitconfigfileandgeneraterootmigratelocation.init-dbGenerateschemaandgenerateappmigratelocation.inspectdbIntrospectsthedatabasetablestostandardoutputas...migrateGeneratemigratechangesfile.upgradeUpgradetospecifiedversion.UsageYou need addaerich.modelsto yourTortoise-ORMconfig first. Example:TORTOISE_ORM={"connections":{"default":"mysql://root:[email protected]:3306/test"},"apps":{"models":{"models":["tests.models","aerich.models"],"default_connection":"default",},},}Initialization>aerichinit-h
Usage:aerichinit[OPTIONS]Initconfigfileandgeneraterootmigratelocation.
Options:-t,--tortoise-ormTEXTTortoise-ORMconfigmoduledictvariable,likesettings.TORTOISE_ORM.[required]--locationTEXTMigratestorelocation.[default:./migrations]-s,--src_folderTEXTFolderofthesource,relativetotheprojectroot.-h,--helpShowthismessageandexit.Initialize the config file and migrations location:>aerichinit-ttests.backends.mysql.TORTOISE_ORM
Successcreatemigratelocation./migrations
Successwriteconfigtopyproject.tomlInit db>aerichinit-db
Successcreateappmigratelocation./migrations/models
Successgenerateschemaforapp"models"If your Tortoise-ORM app is not the defaultmodels, you must specify the correct app via--app,
e.g.aerich --app other_models init-db.Update models and make migrate>aerichmigrate--namedrop_column
Successmigrate1_202029051520102929_drop_column.pyFormat of migrate filename is{version_num}_{datetime}_{name|update}.py.Ifaerichguesses you are renaming a column, it will askRename {old_column} to {new_column} [True]. You can chooseTrueto rename column without column drop, or chooseFalseto drop the column then create. Note that the latter may
lose data.Upgrade to latest version>aerichupgrade
Successupgrade1_202029051520102929_drop_column.pyNow your db is migrated to latest.Downgrade to specified version>aerichdowngrade-h
Usage:aerichdowngrade[OPTIONS]Downgradetospecifiedversion.
Options:-v,--versionINTEGERSpecifiedversion,defaulttolast.[default:-1]-d,--deleteDeleteversionfilesatthesametime.[default:False]--yesConfirmtheactionwithoutprompting.-h,--helpShowthismessageandexit.>aerichdowngrade
Successdowngrade1_202029051520102929_drop_column.pyNow your db is rolled back to the specified version.Show history>aerichhistory1_202029051520102929_drop_column.pyShow heads to be migrated>aerichheads
1_202029051520102929_drop_column.pyInspect db tables to TortoiseORM modelCurrentlyinspectdbsupport MySQL & Postgres & SQLite.Usage:aerichinspectdb[OPTIONS]IntrospectsthedatabasetablestostandardoutputasTortoiseORMmodel.
Options:-t,--tableTEXTWhichtablestoinspect.-h,--helpShowthismessageandexit.Inspect all tables and print to console:aerich--appmodelsinspectdbInspect a specified table in the default app and redirect tomodels.py:aerichinspectdb-tuser>models.pyFor example, you table is:CREATETABLE`test`(`id`intNOTNULLAUTO_INCREMENT,`decimal`decimal(10,2)NOTNULL,`date`dateDEFAULTNULL,`datetime`datetimeNOTNULLDEFAULTCURRENT_TIMESTAMPONUPDATECURRENT_TIMESTAMP,`time`timeDEFAULTNULL,`float`floatDEFAULTNULL,`string`varchar(200)COLLATEutf8mb4_general_ciDEFAULTNULL,`tinyint`tinyintDEFAULTNULL,PRIMARYKEY(`id`),KEY`asyncmy_string_index`(`string`))ENGINE=InnoDBDEFAULTCHARSET=utf8mb4COLLATE=utf8mb4_general_ciNow runaerich inspectdb -t testto see the generated model:fromtortoiseimportModel,fieldsclassTest(Model):date=fields.DateField(null=True,)datetime=fields.DatetimeField(auto_now=True,)decimal=fields.DecimalField(max_digits=10,decimal_places=2,)float=fields.FloatField(null=True,)id=fields.IntField(pk=True,)string=fields.CharField(max_length=200,null=True,)time=fields.TimeField(null=True,)tinyint=fields.BooleanField(null=True,)Note that this command is limited and can't infer some fields, such asIntEnumField,ForeignKeyField, and others.Multiple databasestortoise_orm={"connections":{"default":expand_db_url(db_url,True),"second":expand_db_url(db_url_second,True),},"apps":{"models":{"models":["tests.models","aerich.models"],"default_connection":"default"},"models_second":{"models":["tests.models_second"],"default_connection":"second",},},}You only need to specifyaerich.modelsin one app, and must specify--appwhen runningaerich migrateand so on.RestoreaerichworkflowIn some cases, such as broken changes from upgrade ofaerich, you can't runaerich migrateoraerich upgrade, you
can make the following steps:dropaerichtable.deletemigrations/{app}directory.rerunaerich init-db.Note that these actions is safe, also you can do that to reset your migrations if your migration files is too many.Useaerichin applicationYou can useaerichout of cli by useCommandclass.fromaerichimportCommandcommand=Command(tortoise_config=config,app='models')awaitcommand.init()awaitcommand.migrate('test')LicenseThis project is licensed under theApache-2.0License. |
aerics | AericsA networking library for multiplayer games.Getting StartedInstall PythonOpen cmd/terminal and type:pip install AericsExamplesCreating a serverfromaericsimport*server=Server("localhost",5656)@server.eventdefsetup():[email protected]():[email protected]_connection(connection,address,id,clients,globals):print("New connection")return{"x":0,"y":0}@server.eventdefon_disconnection(connection,address,id,clients,globals):print(f"Client{id}disconnected")@server.eventdefon_recv(connection,address,id,clients,globals,data):data=data.split(",")ifdata[0]=="move":clients[id]["x"],clients[id]["y"]=data[1],data[2]returnclientsifdata[0]=="close":server.disconnect(connection)returnNoneserver.listen()Creating a clientfromaerforgeimport*fromaericsimport*defupdate():client.send(f"move,{player.x},{player.y}")players=client.recv()foriinplayers:forge.draw(width=50,height=100,x=int(players[i]["x"]),y=int(players[i]["y"]))if__name__=="__main__":forge=Forge()client=Client("localhost",5656)client.connect()player=prefabs.TopViewController(forge)player.visible=Falseforge.run() |
aerie | AerieA wrapper around SQLAlchemy made to support asynchronous workloads.Aerie- is anavariel(or winged elf) from Baldur's Gate II game.InstallationInstallaerieusing PIP or poetry:pipinstallaerie[postgresql]# orpoetryaddaerie[postgresql]For SQLite use "sqlite" extra. To install all drivers use "full" extra.Featuresfull async/await supportplain SQL with bound paramsSQLAlchemy query builders supportSQLAlchemy ORM supportpaginationTODOsimplify column definition:sa.Column(sa.Integer)->models.IntergerField()integrate with Alembic CLIQuick startSee example application inexamples/directory of this repository.UsageAs this library is based onSQLAlchemy, it is strictly recommended
getting yourself familiar with it.A general usage is:create an instance of Aeriedefine ORM modelscreate tables in the database (or, preferably, use Alembic migrations)obtain a session and perform database queriesAerie instanceCreate an instance of Aerie class and pass a connection string to it:fromaerieimportAeriedb=Aerie('sqlite+aiosqlite:///tmp/database.sqlite2')# ordb=Aerie('postgresql+asyncpg://postgres:postgres@localhost/aerie')You need appropriate driver installed. Add "aiosqlite" for SQLite support, or add "asyncpg" for PostreSQL support.Raw SQL queriesAt this step Aerie is ready to work. Create a new transaction and execute any query you need.fromsqlalchemy.sqlimporttext# assuming "users" table existssql=text('select * from users where user_id = :user_id')rows=awaitdb.query(sql,{'user_id':1}).all()Full listingexamples/raw_sql.pyUsing query builderSure, you are not limited to plain SQL. SQLAlchemy query builders also supported (because Aerie is a tiny layer on top
of the SQLAlchemy)fromsqlalchemy.sqlimporttextimportsqlalchemyassafromaerieimportmetadatausers=sa.Table('users',metadata,sa.Column(sa.Integer,name='id',primary_key=True),sa.Column(sa.String,name='name'),)# create tablesawaitdb.schema.create_tables()stmt=select(users).where(users.c.id==2)rows=awaitdb.query(stmt).all()Full listingexamples/tables.pyUsing ORM models and sessionsAnother option to low-level query builder are ORM models. Aerie providesaerie.Modelclass that you should extend to
create your model.fromaerieimportBaseimportsqlalchemyassaclassUser(Base):__tablename__='users'id=sa.Column(sa.Integer,primary_key=True)name=sa.Column(sa.String)# create tablesawaitdb.schema.create_tables()asyncwithdb.session()assession:session.add_all([User(id=1,name='One'),User(id=2,name='Two'),User(id=3,name='Three'),])awaitsession.flush()# get first user in the row setuser=awaitsession.query(User).first()Make sure the module with models is imported before you create tables.
Otherwise they will not be added to themetadataand, thus, not created.Full listingexamples/orm.pyPaginationAerie's DbSession ships with pagination utilities out of the box. When you need to paginate a query just
callDbSession.paginatemethod.asyncwithdb.session()assession:page=awaitsession.query(User).paginate(page=1,page_size=10)foruserinpage:print(user)print('Next page:%s'%page.next_page)print('Previous page:%s'%page.previous_page)print('Displaying items:%s-%s'%(page.start_index,page.end_index))The page object has more helper attributes:PropertyTypeDescriptiontotal_pagesintTotal pages in the row set.has_nextboolTest if the next page is available.has_previousboolTest if the previous page is available.has_otherboolTest if there are another pages except current one.next_pageintNext page number. Always returns an integer. If there is no more pages the current page number returned.previous_pageintPrevious page number. Always returns an integer. If there is no previous page, the number 1 returned.start_indexintThe 1-based index of the first item on this page.end_indexintThe 1-based index of the last item on this page.total_rowsintTotal rows in result set.Alembic migrationsAlembic usage is well documented in the official
docs:Using Asyncio with AlembicNote, you need to useaerie.metadatawhen you configuretarget_metadataoption:# migrations/env.pyfromaerieimportmetadatatarget_metadata=metadataAlso, don't forget to import all your models in Alembic'senv.pyfile so their structure is fully loaded and no models
forgotten.Shared instancesYou can configure Aerie to populate Aerie.instances class-level variable, so you can access database instances from
anywhere of your code. For that, just passnameargument to Aerie constructor.# migrations/env.pyfromaerieimportAeriedb=Aerie(name='shared',...)# other filedb=Aerie.get_instance('shared')Note, instances without name cannot be shared. |
aeripy | Aeripy is a Python adapter for the Aeries Student Information System API. It’s goal is to simplify interaction with your district’s Aeries database.This library is mostly a wrapper for the popularrequestslibrary.Note: Aeripy is in no way affiliated with Aeries Software, Inc. This module is based on their publicly available documentation.InstallationAeripy is supported on Python 3.8+. The recommended way to install Aeripy is via pip.pip install aeripyQuickstartThe following example uses the Aeries demo database URL and API key.
Both are found in theirdocumentation.To use this module with your own Aeries database, you will need your district’s URL and API key. See theURL and API Keysection for details.# Aeries Demo URL and API keyhostname='demo.aeries.net/aeries/api/'api_key='477abe9e7d27439681d62f4e0de1f5e1'# In production the URL and API key should not be hardcoded.# For example, they can be retrieved from an environment variablehostname=os.getenv('AERIES_URL')api_key=os.getenv('API_KEY')Create an Aeripy instance and use that to interact with the API.fromaeripyimportAeripyaeries=Aeripy(hostname=hostname,api_key=api_key)# Get all staffstaff_list=aeries.get_staff()# Print the last name of the 55th staff memberprint(staff_list[55].last_Name)# Output:# Barrows# Print the first name of the 55th staff memberprint(staff_list[55].last_Name)# Output:# James# Print the ID of the 55th staff memberprint(staff_list[55].id)# Output:# 994748Check out thefull documentationfor a list of currently supported methods and more examples.URL and API KeyYou must have access to the Security section in Aeries Web to obtain or create the API key. |
aerisapisdk | Getting Started$ pip install aerisapisdk
$ aeriscli --help
Usage: aeriscli [OPTIONS] COMMAND [ARGS]...
Options:
-v, --verbose Verbose output
-cfg, --config-file TEXT Path to config file.
--help Show this message and exit.
Commands:
aeradmin AerAdmin API Services
aerframe AerFrame API Services
aertraffic AerTraffic API Services
config Set up the configuration for using this tool
ping Simple ping of the api endpointsMore InformationCheck out thewikifor more information. |
aerismodsdk | No description available on PyPI. |
aerisweather | The AerisWeather Python SDK allows a developer to quickly and easily add
weather content and functionality to their Python applications.It utilizes the Aeris API backend for data loading and is built on
top of an object mapping system that efficiently loads requested
weather content into third-party Python applications, greatly
reducing the amount of code and development needed on the developer end.RequirementsThe AerisWeather Python SDK is built using Python v3.6.You also need:An active AerisWeather API account (don’t have one?sign up here)Python v3.6 or Higheraenum v2.1.0 or Higherrequests libNote: To use the included Jupyter Notebook, you will also need to install the Jupyter kernelHow to get itDownload or link to the aerisweather package via The Python Package Index atpypi.org/project/aerisweatherGet the code at the AerisWeather Python SDK project onGitHubVisit the SDK’s home athttps://www.aerisweather.com/support/docs/toolkits/aeris-python-sdk/.DocsBrowse the code docs online |
aerleon | AerleonGenerate firewall configs for multiple firewall platforms from a single platform-agnostic configuration language through a command line tool and Python API.Aerleon is a fork ofCapircawith the following major additions:YAML policy and network definition files andpol2yaml, a converter from Capirca policy DSL to YAML.Network definitions with FQDN data.New firewall platforms can be added through plugins.Typed Python APIs for ACL generation and aclcheck queries.ASLSA-compatible verifiable release process.A detailed regression test suite.Many bug fixes and performance enhancements.InstallAerleon requires Python 3.7 or higher.pipinstallaerleonOverviewAerleon provides a command line tool and a Python API that will generate configs for multiple firewall platforms from a single platform-agnostic configuration language. It can generate configs for Cisco, Juniper, Palo Alto Networks andmany other firewall vendors.Agetting started guidewalking through the basics of using Aerleon is available on the docs website.DocumentationDocumentation can be found athttps://aerleon.readthedocs.io/en/latest/.ContributingContributions are welcome. Please review thecontributing guidelinesandcode of conductfor this project.ContactOfficial channels for communicating issues is viaGithub Issues.General discussions can be had either inGithub Discussionsor in ourSlack Server.Contact MaintainersYou can always reach out to us onSlack.
You many also reach out to us via e-mail.Rob Ankeny ([email protected])Jason Benterou ([email protected])ResourcesBrief Overview (4 slides):Nanog49; Enterprise QoSBlog Post: Safe ACL Change through Model-based AnalysisAerleon Slack#aerleon at NetworkToCode SlackContributors ✨Thanks goes to these wonderful people (emoji key):Ken Celenza📖Axel F📖Brandon Bennett💻Bastian Triller💻Arzhel Younsi💻This project follows theall-contributorsspecification. Contributions of any kind welcome!CreditFiles and code included in this project from Capirca are copyright Google and
are included under the terms of the Apache License, Version 2.0. You may obtain
a copy of the License athttp://www.apache.org/licenses/LICENSE-2.0Contributors who wish to modify files bearing a copyright notice are obligated
by the terms of the Apache License, Version 2.0 to include at the top of the
file a prominent notice stating as much. Copyright notices must not be removed
from files in this repository.This README file and other documentation files may contain phrases and sections that are copyright Google.
This file and other documentation files are modified from the original by the Aerleon Project Team. |
aermanager | aermanagerPython package for managing AER data, including .aedat4 files, live DV streams, and interfacing with pyTorch.This software is designed for the following purposes:Read aedat files (v2-4) containing DVS spike trains, accumulate them, and save them in a format that can be read by a pyTorch dataset in a faster way.Read the files into a pyTorch datasetReceive frames from the DV software, queue and batch them in order to feed them to a spiking neural network simulation (LiveDv).InstallationThe easiest way to install this repository is to clone it and install it with pip:pipinstallaermanagerAlternatively, you can checkout this repository and install it.gitclonehttps://gitlab.com/synsense/aermanager.gitcdaermanager
pipinstall.Documentationhttps://synsense.gitlab.io/aermanagerYou can generate local documentation by running the below command at the location of the source code.cdpath/to/aermanager
pythonsetup.pybuild_sphinx |
aero | UNKNOWN |
aeroapi-python | AeroApi PythonPython wrapper for the FlightAware's AeroAPIDescriptionAeroAPI (formerly FlightXML) is FlightAware's live flight data API that provides powerful, reliable information about real-time and historical flight information. This Python wrapper allows for easier interaction with the AeroAPI from Python applications.FlightAware AeroAPI ReferenceAeroAPIInstallationpipinstallaeroapi-pythonUsing test pypi, install with this command.pipinstall--index-urlhttps://pypi.org/simple/--extra-index-urlhttps://test.pypi.org/simple/aeroapi-pythonUsageAeroAPI ClassThe AeroAPI class is the main class for interacting with the FlightAware AeroAPI. It provides access to various resources such as airports, operators, flights, and more.InitializationTo use the AeroAPI class, you need to create an instance of it by passing your API key as an argument to the constructor:fromAeroAPIimportAeroAPIapi_key='your-api-key'aeroapi=AeroAPI(api_key)AirportsThe Airports class provides methods for retrieving information about airports. You can access an instance of the Airports class through the airports attribute of the AeroAPI instance:airports=aeroapi.airportsMethodsget_airport_info(airport_code: str) -> dict: Returns information about the specified airport.airport_info=airports.get_airport_info('KLAX')search_airports(query: str) -> list: Searches for airports that match the specified query.airport_list=airports.search_airports('Los Angeles')get_nearby_airports(latitude: float, longitude: float, radius: int) -> list: Returns a list of airports near the specified latitude and longitude within the specified radius.airport_list=airports.get_nearby_airports(33.9425,-118.408056,10)Example UsagefromAeroAPIimportAeroAPIapi_key='your-api-key'aeroapi=AeroAPI(api_key)airports=aeroapi.airportsairport_info=airports.get_airport_info('KLAX')print(airport_info)LicenseMITAuthors@derens99 |
aero-astro-calc | Aero-Astro-CalcA small python library with functions to assist engineers.Getting StartedInstall using pip:pip install aero-astro-calcImport into your Python projectfromaero_astro_calcimportPlaneStressUsageMake plane stress object:stress=PlaneStress(80,-40,25)View the stress on a 2D plane:stress.plane()View Mohr's circle of the stresses:stress.mohr()ContactAnson Biggs [email protected]@Anson_3D |
aerobridge | Python client for Aerobridge Management ServerThis repository is the python client for theAerobridge Management Server API.Usage InstructionsInstall requirementspip install aerobridgepyIn your code usefrom aerobridgepy import AerobridgeClient🎉Test driveGo toAerobridge.iofor a test drive of the stack.Change log[0.0.1] - 2022-02-17Initial Commit |
aerobulk-python | No description available on PyPI. |
aero-calc | AeroCalc is a pure python package that performs various aeronautical
engineering calculations. Currently it provides airspeed conversions,
standard atmosphere calculations, static source error correction calculations
and unit conversions. |
aerocalc3 | AeroCalc is a pure python package that performs various aeronauticalengineering calculations. Currently it provides airspeed conversions,
standard atmosphere calculations, static source error correction calculations
and unit conversions. |
aerocloud | Aerocloud Python clientAllows Python scripts to access the Aerocloud batch environment. |
aerodash-v1 | This is a CLI tool for fetching and downloading weather data from two public AWS S3 buckets: noaa-goes18 and noaa-nexrad-level2. The tool allows users to sign up, sign in, and view their remaining API calls.Installation'pip install aerodash-v1'UsageSign UpTo sign up, run the command below:'aerodash-v1 create_user'This command prompts the user to enter their details such as username, password, mobile, subscription type, and credit card details. The subscription type options are:Platinum - (100$)Gold - (50$)Free - (0$)Depending on the subscription type chosen, users are assigned an API call limit.Sign InTo sign in and get the remaining API calls limit, run the command below:'aerodash-v1 api_calls_limit'This command prompts the user to enter their username and password. On successful login, the remaining API calls are displayed.fetch filesTo fetch files from the noaa-goes18 or noaa-nexrad-level2 bucket, run the command below:'aerodash-v1 fetch DATATYPE YEAR [MONTH] DAY [HOUR] [STATION]'DATATYPE: The type of data to fetch. It can either be geos18 or nexrad.YEAR: The year to fetch files for.DAY: The day of the year to fetch files for.HOUR: The hour to fetch files for. This is only required when the DATATYPE is geos18.MONTH: The month to fetch files for. This is only required when the DATATYPE is nexrad.STATION: The station code to fetch files for. This is only required when the DATATYPE is nexrad.The command will prompt the user to enter their username and password. On successful login, the list of files found in the bucket for the given parameters is displayed.download filesTo download a file from the noaa-goes18 or noaa-nexrad-level2 bucket, run the command below:'aerodash download FILE_NAME'FILE_NAME: The name of the file to download.The command will prompt the user to enter their username and password. On successful login, the file is downloaded from the public S3 bucket to a personal S3 bucket, and the download link is displayed.Upgrade SubscriptionTo upgrade a user's subscription plan, run the command below:'aerodash-v1 plan_upgrade'The command will prompt the user to enter their username and password. On successful login, the user's remaining API calls are displayed.The user is then prompted to select a new subscription plan. The subscription plan options are:Platinum - (100$)Gold - (50$)Free - (0$)Depending on the subscription type chosen, the user's API call limit is updated.Forgot PasswordTo update a user's password, run the command below:'aerodash-v1 forgot_password'The command prompts the user to enter their username and new password. If the user is found, their password is updated.LimitationsThe tool only supports fetching and downloading files from the noaa-goes18 and noaa-nexrad-level2 public AWS S3 buckets.The user's subscription plan and API call limits may restrict the amount of data that can be accessed and downloaded using the tool.The tool may require a certain level of technical expertise and knowledge in order to effectively use and interpret the data it provides.The tool may not be compatible with all operating systems or devices, and may require specific hardware or software configurations in order to function properly. |
aerodynamics | A package for Aerodynamics Engineers and Scientists that enables them to use various numerical methods, unit conversions, useful functions and needed constants |
aerodynamicspy | No description available on PyPI. |
aeroet | aeroetSurface energy balance and atmospheric profiling algorithms for calculating
evapotranspiration from thermal imagery.See Morgan, B.E. & Caylor, K.K. (2023). Estimating fine-scale transpiration from
UAV-derived thermal imagery and atmospheric profiles.Water Resources Research,
59, e2023WR035251.https://doi.org/10.1029/2023WR035251Note: The API and documentation are under development. Please contact Bryn Morgan
([email protected]) with any questions.InstallationCreate a new conda environment.$condacreate-naeroetpython=3.10
$condaactivateaeroetNote: I'm not sure whether specifying the version of python is necessary, but likely depends the version of python install in yourbaseenvironment. Better to specify.pipinstall.$pipinstallaeroetUse as desired!UsageSeehttps://github.com/brynemorgan/uavet-wrrfor example usage. |
aerofiles | waypoint, task, tracklog readers and writers for aviationThis is a python library to read and write many important file formats
for aviation. It is compatible with python 3.0 (and newer) and
2.6. Please read the documentation underhttps://aerofiles.readthedocs.iofor further information.FeaturesFlarmconfiguration file writer
(aerofiles.flarmcfg)IGCfile reader and writer (aerofiles.igc)OpenAirfile
reader (aerofiles.openair)SeeYouCUP file reader and
writer (aerofiles.seeyou)WELT2000file reader
(aerofiles.welt2000)XCSoartask file writer (aerofiles.xcsoar)Development EnvironmentIf you want to work on aerofiles you should install the necessary dependencies
using:$ pip install -r requirements-dev.txtYou can run the testsuite with:$ make testBuilding DocsMake sure that you have checked out git submodules:$ git submodule update --initThen build docs using Sphinx and Make:$ cd docs
$ make htmlThe HTML output can be found in the_build/htmldirectory.LicenseThis code is published under the MIT license. See theLICENSEfile
for the full text. |
aerofoils | AerofoilsAerofoil Design ToolkitFree software: MIT licenseDocumentation:https://aerofoils.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2023-05-09)First release on PyPI. |
aeroframe | AeroFrame(Aeroelastic Framework) is a modular framework for partitioned aeroelastic analyses. The framework couples separate solvers for structure and CFD. It coordinates the analysis and the exchange of loads and deformations. Currently, AeroFrame supportsstaticaeroelastic analyses.Documentationhttps://aeroframe.readthedocs.io/LicenseLicense:Apache-2.0 |
aerokit | AeroKitPython packages for compressible flow computationsFeaturesMach dependent functions for isentropic total pressure, temperature and mass flowlocal Rankine-Hugoniot shock wave equations (or 2d planar shocks) and conical shock wavesFanno equations for momentum losses in a ductRayleigh equations for heating/cooling in a ductunsteady compressible 1D flows1D stability equations: Orr-Sommerfeld and linearized compressible inviscidapplications:nozzle flows(Riemann) shock tubeChannel incompressible flow stability (Poiseuille)degree based trigonometric functionsreal gaz and kerozen thermo functionsNewton iterative solve, ODE integration, Chebyshev spectral discretizationInstallation & usagepip install aerokitDocumentation is available onreadthedocs. More examples are available in the repository.Requirementsnumpy,scipyexamples are plotted usingmatplotlib |
aerolito | Aerolito is an AIML alternative based on YAML. Aerolito provides features
for natural language processing simulation. Example of usage:from aerolito import Kernel
kernel = Kernel('config.yml')
print kernel.respond(u'Hello') |
aerolyzer | A Python suite for analyzing images to infer aerosol types in the image. |
aeromancer | No description available on PyPI. |
aeromaps | AeroMAPS: Multidisciplinary Assessment of Prospective Scenarios for air transportAeroMAPS is a framework for performing Multidisciplinary Assessment of Prospective Scenarios for air transport. For
instance, it allows simulating and analyzing scenarios for reducing aviation climate impacts through various levers of
action. It is intended to become a sectoral Integrated Assessment Model (IAM) taking into account technological,
environmental, sociological, economic and other considerations. It aims to assess the sustainability of simulated air
transport transition scenarios on multiple criteria.AeroMAPS is licensed under theGPL-3.0license.Adocumentationis available for more details on AeroMAPS.Quick startFor a quick start in order to discover the different features of AeroMAPS,
a graphical user interface has been developed for facilitating the first uses.
It is available at the following address:https://aeromaps.isae-supaero.fr/Another solution is to use theBinder-hosted graphical user interface.Quick installationThe use of the Python Package Index (PyPI) is the simplest method for installing AeroMAPS.
More details and other solutions are provided in the documentation.Prerequisite: AeroMAPS needs at least Python 3.8.0.You can install the latest version with this command:$ pip install --upgrade aeromapsCitationIf you use AeroMAPS in your work, please cite the following reference. Other references are available in the
documentation.Planès, T., Delbecq, S., Salgas, A. (2023).
AeroMAPS: a framework for performing multidisciplinary assessment of prospective scenarios for air transport.
Submitted to Journal of Open Aviation Science. |
aero-metaflow | No description available on PyPI. |
aeromet-py | Aeromet-PyInspired from python-metar, a library writed in Python language to parse Meteorological Aviation Weather Reports (METAR and SPECI).This library will parse meteorological information of aeronautical land stations.
Supported report types:METARSPECITAFCurrent METAR reportsThe current report for a station is available at the URLhttp://tgftp.nws.noaa.gov/data/observations/metar/stations/<station>.TXTwherestationis the ICAO station code of the airport. This is a four-letter code.
For all stations at any cycle (i.e., hour) in the last hours the reports are available
at the URLhttp://tgftp.nws.noaa.gov/data/observations/metar/cycles/<cycle>Z.TXTwherecycleis the 2-digit cycle number (00to23).UsageA simple usage example:fromaeromet_pyimportMetarcode='METAR MROC 071200Z 10018KT 3000 R07/P2000N BR VV003 17/09 A2994 RESHRA NOSIG'metar=Metar(code)# Get the type of the reportprint(f"{metar.type}")# Meteorological Aerodrome Report# Get the wind speed in knots and direction in degreesprint(f"{metar.wind.speed_in_knot}kt")# 18.0 ktprint(f"{metar.wind.direction_in_degrees}°")# 100.0°# Get the pressure in hecto pascalsprint(f"{metar.pressure.in_hPa}hPa")# 1014.0 hPa# Get the temperature in Celsiusprint(f"{metar.temperatures.temperature_in_celsius}°C")# 17.0°CContributingContributions are what make the open source community such an amazing place to learn, inspire, and create.
Any contributions you make aregreatly appreciated.If you have a suggestion that would make this better, please fork the repo and create a pull request.
You can also simply open an issue with the tag "enhancement".
Don't forget to give the project a star! Thanks again!Fork the ProjectCreate your Feature Branch (git checkout -b feature/AmazingFeature)Commit your Changes (git commit -m 'Add some AmazingFeature')Push to the Branch (git push origin feature/AmazingFeature)Open a Pull RequestRoadmapAdd parsers for TAF and METAR reportsAdd functions to verificate the TAF with the observationsAdd a CLI API to interact with the verification functionsAdd parser for SYNOPTIC reportsAdd functions to verificate reports with rules ofAnnex 3Multi-language SupportPortugueseSpanishFeatures and bugsPlease file feature requests and bugs at theissue tracker.Current SourcesThe most recent version of this package is always available via git, only run the
following command on your terminal:git clone https://github.com/TAF-Verification/aeromet-py.gitAuthorsThepython-metarlibrary was originaly authored byTom Pollardin january 2005.
This packageaeromet-pyfor is inspired from his work in 2021 byDiego Garro.VersioningThis project usesBump2versiontool for versioning, so, if you fork this
repository remember install it in your environment.pip install bump2versionLicenseDistributed under the MIT License. SeeLICENSEfor more information. |
aeromiko | Aeromiko is a middle-man script to simplify extracting data from Aerohive APs using NetmikoInstallationTo install Aeromiko, simply use pip:$ pip install AeromikoAeromiko has the following requirements (which pip will install for you)netmiko >= 2.4.0Documentationhttps://andytruett.github.io/aeromiko/Usageimport aeromiko
ip = 127.0.0.1
username = "admin"
password = "password"
access_point = aeromiko.AP(ip, username, password)
access_point.connect()
hostname = access_point.get_hostname()
print(hostname)-or-see example script |
aeron | aeronA fast and dynamic python backend solution |
aeronaut | It’s alpha, it may have bugs, and it’s free!Seehttp://pythonhosted.org//aeronaut/for usage.See LICENSE.txt for licensing information. |
aeronet | Deep learning with remote sensing data. |
aeronet-convert | Raster-vector conversion for deep learning with remote sensing data. Based on opencv, rasterio, shapely. |
aeronet-learn | AeroNetAeroNet is a simple neural network library. It is written entirely using python, numpy, and scipy. This is an educational neural network library made with the hope of demystifying some of these modern deep learning libraries. Many modern deep learning libraries do not fundamentally differ from AeroNet all that much (minus automatic differentiation). Most of the code in modern libraries is just dedicated to efficiency and optimization of the algorithms used. Feel free to play around with AeroNet and see what deep learning projects you can make.Installing AeroNetAeroNet is now hosted on PyPi for your convenience. The only dependencies are numpy, scipy, and dill which are all installed automatically when AeroNet is installed. Python 3.10 is recommended for using AeroNet.pipinstallaeronet-learnRunning From The Source CodeCreating A Virtual EnvironmentYou may want to run AeroNet directly from the source code. Or maybe you want to directly run the training examples hosted on github. This can be done by cloning the code fromgithub. You can then create a virtual enviroment with the following code.python -m venv venvNeuralNetworkLibrary
venvNeuralNetworkLibrary/scripts/activate.bat
pip install -r requirements.txtYou will then be able to run training examples directly. As seen in the next section.Testing Out A NetworkTest your network against one of these datasets...# move into the training examples directorycdtraining_examples# then execute one of the scripts below...# Simple xor example with dense layerspythonxor.py# Mnist with dense layerspythonmnist.py# Convolutional neural network implementation for mnistpythonmnist_conv.py# Fully convolutional network implementation for mnistpythonmnist_fcn.py# Convolutional neural network implementation for mnist with max poolingpythonmnist_maxpooling.pyAeroNet Example Usage# Import all neural network classes.fromnnimport*# Network layers are initialized as a list of objectsnetwork_layers=[Dense(28*28,70),Sigmoid(),Dense(70,35),Sigmoid(),Dense(35,10),Softmax()]# Create a network objectnetwork=Network(network_layers,TrainingSet(input_train,output_train,input_test,output_test,post_processing),loss_function,loss_function_prime,epochs=10,batch_size=1)# Train the networknetwork.train()# Generate a prediction from the network given a single input arrayprediction_array=network.predict(input_array)# Save the network to a filesave_network(network,"network_filename.pkl")# Load the network from a filenetwork=load_network("network_filename.pkl")TrainingSet ExplainedThe TrainingSet object is simply an object that stores your training and validation set data for your network. As well as a post processing function that is applied to your network predictions and training set data before comparisons are made.TrainingSet(input_train,output_train,input_test,output_test,post_processing)input_train = training set inputsoutput_train = training set outputsinput_test = test / valdation set inputsoutput_test = test / valdation set outputspost_processing is a function applied to your network prediction and training set data before they are compared. For example with the xor problem your network makes predictions based on floats. So you may want to round to the nearest float before comparing the prediction to the desired output. So you could pass np.rint as the post processing function to round to the nearest int. This allows you to get accurate test accuracy output during training. The same applies to things like mnist. You may have a softmax output with percentage predictions based on 10 indices (0 through 9). You may want your prediction to be the indice with the highest percentage. Therefore, you could pass the np.argmax function as the post processing function. Hopefully you can see why this is useful.Supported Neural Layers# LayersDense(num_input_neurons,num_output_neurons)# For weight manipulationConvolutional((input_depth,input_height,input_width),kernel_size,num_kernels,stride=(int,int),padding=((int,int),(int,int)))Reshape()# Modifies the shape of the numpy arrays passed between layersFlatten()# Flattens a numpy array into a 2D matrix with a single columnDropout(probability)# Randomly drops layer outputs based on a probability to prevent overfitting. A probability of 0.25 would drop 25% of connections.MaxPooling2D((input_depth,input_height,input_width),kernel_size,stride=(int,int),padding=((int,int),(int,int)))# Activation FunctionsSigmoid()Tanh()Relu()LeakyRelu()# Leaky Relu not validatedSoftmax()# For output percentage predictionsSupported OptimizersSGD()# Stochastic Gradient DescentMomentumSGD()# Stochastic Gradient Descent with MomentumSupported InitializersUniform(low=-1,high=1)Normal(mean=0,std=1)Zero()# Zero initialized array for biasesXavier()The Network Classnetwork = Network(
layers,
TrainingSet(x_train, y_train, x_test, y_test, post_processing),
loss=loss_function,
loss_prime=loss_function_prime,
epochs=10,
batch_size=1,
layer_properties=LayerProperties(learning_rate, weight_initializer, bias_initializer, optimizer),
data_augmentation=[function1, function2, function3],
percent_error_threshold=None
verbose=true
)The data_augmentation parameter is a list of pure functions. These functions must take in a single numpy array and return a numpy array. To use functions that take multiple parameters you can pass in a lambda function that calls the multi-parameter function. It can be used for numpy array rotation, scaling, noise, and translation for datasets like mnist (that are uniform and centered). These functions are applied sequentially to every training sample, for every epoch, before they are passed into the network. If no data_augmentation list is supplied then no data_augmentation is performed. You can always choose to augment the dataset before network training begins.The percent_error_threshold parameters on the network class can be used to stop training when the network reaches a certain error percentage. For example, if you passedpercent_error_threshold = 0.05then the network would exit the training loop if the error percentage fell below 5%. This can be used to prevent overtraining or shorten training time if you are only aiming to get below a certain error rate.Network MetadataThe network class does track some metadata to help with debugging or generate training statistics.total_training_time (float).The total training time for the network in minutes.per_epoch_errors (list of floats)A list of the errors per epoch. This is only for the last time the train() method was called.Layer PropertiesLearning rates can be set at both a network level (every layer) or at individual layers themselves. This is done through the use of a layer properties class. Each layer with trainable parameters has a default learning rate, weight / bias initializer, and optimizer. So even if you input no layer properties for the layer (or network) it will be populated with some defaults.# This example would set these specific layer properties for the first and second dense layerlayer1_properties=LayerProperties(learning_rate=0.05,weight_initializer=Uniform(),bias_initializer=Uniform(),optimizer=SGD())layer2_properties=LayerProperties(learning_rate=0.03,weight_initializer=Uniform(),bias_initializer=Zero(),optimizer=SGD())network_layers=[Dense(28*28,70,layer_properties=layer1_properties),Sigmoid(),Dense(70,35,layer_properties=layer2_properties),Sigmoid(),Dense(35,10),Softmax()]# Optionally you can set the layer properties for every layer in the network.# This is done by setting layer properties on the network class itself.all_layer_properties=LayerProperties(learning_rate=0.05,weight_initializer=Uniform(),bias_initializer=Uniform(),optimizer=SGD())network=Network(network_layers,TrainingSet(input_train,output_train,input_test,output_test),loss_function,loss_function_prime,epochs=10,batch_size=1,layer_properties=all_layer_properties)# You can also choose to overwrite only some properties at both the network and layer level.# For example the following would only change the learning rate (for all layers) but leave all other defaults the same.all_layer_properties=LayerProperties(learning_rate=0.05)network=Network(network_layers,TrainingSet(input_train,output_train,input_test,output_test),loss_function,loss_function_prime,epochs=10,batch_size=1,layer_properties=all_layer_properties)Kernel, Stride, and Padding Notation:warning: Striding and Padding were only recently implemented. I cannot confirm that they work in all cases yet. So use at your own risk.Sometimes you might see notation likearray[x][y]. However, this is kind of a confusing syntax that people (including myself) write. Do not confuse the arbitrary variablexwith the width. It does not represent the "x" of a coordinate system; in reality it represents the height. If you view the array syntax from a coordinate perspective it is reallyarray[height][width]. So when you are inputting parameters for strides and padding it is really with the syntax(height, width).KernelThe kernel supports 3 different syntax listed below.kernel_size = 3 # Uses 3 for the height and width
kernel_size = (3) # Uses 3 for the height and width
kernel_size = (3,3)StridingStriding only has two dimensions, that is striding in the "height" dimension and striding in the "width" dimension. Striding follows the syntax(height_stride, width_stride). So a stride of (2, 3) would move the kernel 2 positions down and 3 positions to the right. Syntax example listed below.stride = (3, 3)PaddingThere are four different allowed padding formats.(pad_all_4_sides)padding = 1or...padding = (1)(pad_height, pad_width)padding = (1, 1)((pad_top_height,pad_bottom_height), (pad_left_width,pad_right_width))Alternatively you could think of the format as...((top, bottom), (left, right))padding = ((1,1), (2,2))CUDA SupportThis library no longer supports CUDA. It has been removed because it was too hard to maintain with more complex layer implementations.TODOPackage And Host The LibraryImplement Avg PoolingImplement Adaptive Avg PoolingImplement Batch NormalizationImplement Layer Input Size Calculations |
aeronet-raster | Raster operations for deep learning with remote sensing data. Based on Rasterio. |
aeronet-vector | Vector operations for aeronetlib. Based on shapely + r-tree indexing |
aeronist | No description available on PyPI. |
aeronpy | Failed to fetch description. HTTP Status Code: 404 |
aeron-python | No description available on PyPI. |
aeron-python-driver | No description available on PyPI. |
aeroolib | This is a security placeholder package.
If you want to claim this name for legitimate purposes,
please contact us [email protected]@yandex-team.ru |
aeroot | AERootis a command line tool that allows you to give the root privileges on-the-fly to any process running on the Android emulator with Google Play flavors AVDs.This project is a rewrite from scratch of theandroid-emuroottool (https://github.com/airbus-seclab/android_emuroot).
It comes with new features:Recent AVDs support (Android API > 27)Execution time optimizationSelection of a process by its PIDCompatible KernelsKernelx86x86_64Android version3.10.0+✓7.0 / 7.13.18.56+✓8.03.18.91+✓8.14.4.124+✓✓9.04.14.112+✓✓9.0 + 10.0 (TV / Automotive)5.4.36-00815-g3b29042c17b1✓✓10.05.4.43-00621-g90087296b3b1✓✓10.05.4.47-01061-g22e35a1de440✓✓10.05.4.54-android11-0-00619-g476c942d9b3e-ab6722723✓✓11.05.4.61-android11-0-00791-gbad091cc4bf3-ab6833933✓✓11.05.4.61-android11-2-00064-g4271ad6e8ade-ab6991359✓11.05.4.86-android11-2-00006-gae78026f427c-ab7595864✓11.0 (Automotive)5.4.86-android11-2-00040-g29b2beadc627-ab7157994✓✓11.0 (TV / Automotive)5.10.4-android12-0-03442-gf2684370d34d-ab7068937✓12.05.10.15-android12-0-01814-gfca78df78ef2-ab7137072✓12.05.10.21-android12-0-01012-gcc574f0d3698-ab7214561✓12.05.10.21-android12-0-01145-ge82381ad9a3f-ab7230153✓12.05.10.35-android12-4-00865-gd9d0c09e0a3b-ab7349034✓12.05.10.43-android12-6-00231-g54e7412d4ff9-ab7460289✓12.05.10.43-android12-9-00001-ga30f38980440-ab7882141✓12.05.10.66-android12-9-00022-g2d6a43c0364d-ab7992900✓12.0 (TV)5.10.66-android12-9-00041-gfa9c9074531e-ab7914766✓12.05.10.102-android13-0-00549-g255b30f804ac-ab8238117✓✓13.0 + 13.0 (TV)5.10.107-android13-2-00451-g7ba447d0399b-ab8409457✓13.05.15.32-android13-3-00067-g7b5e736d7c63-ab8474665✓13.05.15.41-android13-6-02245-g158384f20d1e-ab8610100✓13.05.15.41-android13-8-00205-gf1bf82c3dacd-ab8747247✓13.05.15.41-android13-8-00055-g4f5025129fe8-ab8949913✓13.05.15.83-android14-5-00138-g5e28b848962c-ab9412825✓14.06.1.12-android14-0-00356-g116e1532b95d-ab9618665✓14.06.1.21-android14-3-01811-g9e35a21ec03f-ab9850788✓14.06.1.23-android14-4-00257-g7e35917775b8-ab9964412✓14.0RequirementsAERoot requiresgdb(with Python support enabled) to run properly.InstallationLast Releasepip install aerootCurrent versiongit clone https://github.com/quarkslab/AERoot.gitpython3 setup.py install --userDockerA Docker image ofAERootis available ondockerhub.Also, you can build an image by yourself:docker build -t aeroot https://github.com/quarkslab/AERoot.gitLinuxUsagedocker run --rm \-v $HOME/.emulator_console_auth_token:$HOME/.emulator_console_auth_token \--network host \ha0ris/aeroot [aeroot options]Exampledocker run --rm \-v $HOME/.emulator_console_auth_token:$HOME/.emulator_console_auth_token \--network host \ha0ris/aeroot daemonmacOSUsagedocker run --rm \-v $HOME/.emulator_console_auth_token:$HOME/.emulator_console_auth_token \ha0ris/aeroot --host host.docker.internal [aeroot options]Exampledocker run --rm \-v $HOME/.emulator_console_auth_token:$HOME/.emulator_console_auth_token \ha0ris/aeroot --host host.docker.internal daemonQuick-startFirst of all, you must launch the Android emulator with the gdb qemu option (-qemu -s).emulator @Your_AVD -qemu -sThen runaerootby choosing the mode among:pid: give the root privileges to a process selected by itsPID.name: give the root privileges to a process selected by itsname.daemon: give the root privileges to the ADB daemon, so shells created with adb shell will automaticaly have root rigths.Usageaeroot [-h] [--verbose | --quiet] [--device DEVICE] [--host HOST] [--port PORT] {name,pid,daemon} ...Examplespidmode exampleaeroot pid 1337Gives the root privileges to the process with pid 1337namemode exampleaeroot name my_processGives the root privileges to the process named "my_process"daemonmode exampleaeroot daemonGives the root privileges to the ADB daemonAdditional optionsYou can find additional options by checking the help of the tool:aeroot -h |
aeroplatform | Aero |
aeroport | *This preview is pre-beta, pre-alpha, pre-anything, so its completely unsuseful in real projects.
More work is on the way.*Organize hub for data arrival / departuresIdea is to build server for running scraping jobs from multiple sources and input formats (web sites,
data feeds, etc…), adapt data and deliver it further to destinations (e. g. processing queues).So it’s like an airport where each airline “declares” its own arrivals, destinations and transport,
while using common hub insfrastructure. |
aeropress | aeropressis a CLI program for deploying Docker images to AWS ECS. It receives a folder path that includes
ECS task and service definitions and then does the jobs respectively;Register ECS task definitionsCreate Cloudwatch metrics for scaling policiesCreate or update scaling policies for ECS servicesCreate or update alarms on CloudwatchCreate or update ECS servicesInstallationaeropressworks with Python3.pip3 install aeropressUsage$ aeropress --help
usage: cli.py [-h] [--logging-level {debug,info,warning,error}] [--version]
{deploy,clean} ...
aeropress AWS ECS deployment helper
positional arguments:
{deploy,clean} sub-command help
deploy Deploy docker image to ECS.
clean Clean commands for stale entitites on AWS.
optional arguments:
-h, --help show this help message and exit
--logging-level {debug,info,warning,error}
Print debug logs
--version show program's version number and exitExampleYou must have defined an ECS cluster first. Then, you can define ECS tasks and services in a yaml file and runaeropresswith required arguments.aeropress deploy --path 'example/foo.yaml' --image-url 'registry.hub.docker.com/library/python' --service-name service-foo |
aeropy | This software is developed as a universal aerospace engineering toolbox.
This software is still under development and also includes third-party codes.
If you want to contribute please contact the author Lukas Müller. |
aeropython | No description available on PyPI. |
aeroscope | WelcomeAeroSCOPE is a project that aims to bring together various open data sources on air transport in order to better understand the geographical distribution of air transport.
More details on data collection and compilation can be found in the article accompanying this work:https://journals.open.tudelft.nl/joas/article/view/7201AeroSCOPE is licensed under theGPL-3.0license.Please contact us if your use case of the dataset it outside the academic framework: Although all sources used are open to everyone, the Eurocontrol database is only freely available to academic researchers. It is used in this dataset in a very aggregated way and under several levels of abstraction. As a result, it is not distributed in its original format as specified in the contract of use. As a general rule, we decline any responsibility for any use that is contrary to the terms and conditions of the various sources that are used. In case of commercial use of the database, please contact us in advance.Setup - app onlyIt is suggested to use a newcondavirtual environment to install the required packages.
Python 3.10 is recommended, although older versions may work.In the new virtual environment, navigate to the project folder. Most installations are done using poetry, except for poetry itself, which can be installed using pip or conda.pipinstallaeroscopeUsageAeroSCOPE can be used in two different ways.Simple usage: just using the graphical interface or downloading the final database, no external input is required. This use case is directly addressed to this repository.Advanced usage: to run all data collection and processing notebooks and to perform more complex analysis on the file. The GUI is an input to this mode (soon). External data inputs that are too large to be stored on git or whose distribution is restricted are required.
This mode is described inhttps://github.com/AeroMAPS/AeroSCOPE_dataset.Please read the dedicated paper to understand the global data collection and aggregation process.The idea behind the project is to collect all open-source air traffic data to build an extended air traffic route database for a given year, 2019.Due to the limited coverage of these sources, especially in Asia-Pacific, South America and Africa, a methodology has been developed to estimate the data in this case.
Wikipedia airport pages are automatically parsed to find information on the route network from each airport. This newly created database is merged with the previously mentioned open source data and a regressor is trained.
Traffic (seats offered) is then estimated on the remaining routes before all sources are aggregated into a single file.
It is then analysed and can be explored using a simple user interface.Simple usageAeroSCOPE app:To run the simple web app designed to explore the data, one can either visitwww.aeromaps.eu/aeroscope(soon) or navigate to the 04_app folder using a terminal and run the app using voila.aeroscoperunAdvanced usageThis mode is described inhttps://github.com/AeroMAPS/AeroSCOPE_dataset.Raw database csv file:If you simply want to access the compiled database; The last version of the processed database is stored on zenodo under the following doi:10.5281/zenodo.10143773. Make sure to download v1.0.1.Be sure to replace default NaN (such as 'NA') when reading the csv, to avoid mistakingly considering North America and Namibia codes as NaN.AuthorsAntoine Salgas, Junzi Sun, Scott Delbecq, Thomas PlanèsContact: [[email protected]] |
aerosense-tools | aerosense-toolsFunctions for working with aerosense data, useful in building dashboards, analysis notebooks and digital twin services |
aerosol-functions | A collection of tools to analyze and visualize atmospheric aerosol data.Installationpipinstallaerosol-functionsDocumentationSeehere |
aerosol-optprop | No description available on PyPI. |
aerospace-calculator | UNKNOWN |
aerospike | CompatibilityThe Python client for Aerospike works with Python 3.8 - 3.12 and supports the following OS’es:macOS 11 and 12CentOS 7 LinuxRHEL 8 and 9Amazon Linux 2023Debian 11 and 12Ubuntu 20.04 and 22.04Windows (x64)The client is also verified to run on these operating systems, but we do not officially support them (i.e we don’t distribute wheels or prioritize fixing bugs for these OSes):Alpine LinuxNOTE:Aerospike Python client 5.0.0 and up MUST be used with Aerospike server 4.9 or later.
If you see the error “-10, ‘Failed to connect’”, please make sure you are using server 4.9 or later.Installpip install aerospikeIn most casespipwill install a precompiled binary (wheel) matching your OS
and version of Python. If a matching wheel isn’t found it, or the--install-optionargument is provided, pip will build the Python client
from source.Please see thebuild instructionsfor more.Troubleshooting# client >=3.8.0 will attempt a manylinux wheel installation for Linux distros
# to force a pip install from source:
pip install aerospike --no-binary :all:
# to troubleshoot pip versions >= 6.0 you can
pip install --no-cache-dir aerospikeIf you run into trouble installing the client on a supported OS, you may be
using an outdatedpip.
Versions ofpipolder than 7.0.0 should be upgraded, as well as versions ofsetuptoolsolder than 18.0.0.Troubleshooting macOSIn some versions of macOS, Python 2.7 is installed aspythonwithpipas its associated package manager, and Python 3 is installed aspython3withpip3as the associated package manager. Make sure to use the ones that
map to Python 3, such aspip3 install aerospike.Attempting to install the client with pip for the system default Python may cause permissions issues when copying necessary files. In order to avoid
those issues the client can be installed for the current user only with the command:pip install--useraerospike# to trouleshoot installation on macOS try
pip install --no-cache-dir --user aerospikeBuildFor instructions on manually building the Python client, please refer toBUILD.md.DocumentationDocumentation is hosted ataerospike-python-client.readthedocs.ioand ataerospike.com/apidocs/python.ExamplesExample applications are provided in theexamples directory of the GitHub repositoryFor examples, to run thekvs.py:python examples/client/kvs.pyBenchmarksTo run the benchmarks the python module ‘tabulate’ need to be installed. In order to display heap information the moduleguppymust be installed.
Note thatguppyis only available for Python2. Ifguppyis not installed the benchmarks will still be runnable.
Benchmark applications are provided in thebenchmarks directory of the GitHub repositoryBy default the benchmarks will try to connect to a server located at 127.0.0.1:3000 , instructions on changing that setting and other command line flags may be displayed by appending the–helpargument to the benchmark script. For example:python benchmarks/keygen.py --helpLicenseThe Aerospike Python Client is made availabled under the terms of the
Apache License, Version 2, as stated in the fileLICENSE.Individual files may be made available under their own specific license,
all compatible with Apache License, Version 2. Please see individual
files for details. |
aerospike_connpool | No description available on PyPI. |
aerospike-rest | Python interface to the Aerospike REST Client.Provides a simple convenience wrapper aroundrequestsfor using theAerospike REST Clientin Python.Enable/disable compressionEnable/disable authentication (via Authorization header)Override default user-agent headerOverride default connect and read timeoutsMake use of keep-alive (for lifetime of object)Raise exceptions with Aerospike error codesSimple Examplefromaerospike_rest.apiimportAerospikeRestApiapi=AerospikeRestApi('http://localhost:8080/v1')bins={'mybin':"Hello World!"}api.post('/kvs/mynamespace/myset/mykey',bins)Advanced Examplefromaerospike_rest.apiimportAerospikeRestApifromaerospike_rest.exceptionsimportAerospikeRestApiErrorapi=AerospikeRestApi('http://localhost:8080/v1')api.http_compression=Falseapi.client_compression=Trueapi.authorization='Authorization: Basic YWRtaW46YWRtaW4='bins={'mybin':"Hello World!"}params={'recordExistsAction':"CREATE_ONLY"}headers={'X-Custom-Header':'hello'}try:api.post('/kvs/mynamespace/myset/mykey',bins,params,headers,timeout=10)exceptAerospikeRestApiErroraserr:iferr.code==KEY_EXISTS_ERROR:passelse:raiseerrTestRun unit tests from the root directory:python -m unittest -v -bView test coverage from root directory:coverage run --source=aerospike_rest/ -m unittest -v -b && coverage reportReleaseCreate version branch:git checkout -b version/v1.0.0)Bump version inaerospike_rest/__init__.pyand commit the changeTag the commit:git tag -a v1.0.0 -m 'Release v1.0.0Submit PR |
aerostat | aerostatexports tenant data from an OpenStack cloud to create a set
of Ansible playbooks for importing the data into another cloud.Installing and UsingThe project is in a very very early prototyping stage.aerostat usesos-client-configfor settings related to accessing
the cloud. Fill in yourclouds.yamlor use the environment
variables or command line arguments provided.Withtoxinstalled, experiment via:$ tox -e venv -- aerostatFree software: Apache licenseSource:http://git.openstack.org/cgit/openstack/aerostat |
aerostat-launcher | AerostatA simple CLI tool to deploy your Machine Learning models to cloud, with public API and template connections ready to go.Get startedInstallationThe nameAerostathas been used by another PyPI project, please install this package with:pipinstallaerostat-launcherOnce installed, it can be used directly viaaerostat. If it doesn't work, addpython -mprefix to all commands,
i.e.python -m aerostat deploy.Only three commands needed for deploying your model:install,login, anddeploy.SetupRun the following command to install all the dependencies needed to run Aerostat. Please allow installation in the pop-up window to
continue.aerostatinstallTo login to Aerostat, you need to run the following command:aerostatloginYou will be prompted to choose an existing AWS credentials, or enter a new one. The AWS account used needs to haveAdministratorAccess.DeployTo deploy your model, you need to dump your model to a file with pickle, and run the following command:aerostatdeployYou will be prompted to enter:the path to your model filethe input columns of your modelthe ML library used for your modelthe name of your projectOr you can provide these information as command line options like:aerostatdeploy--model-path/path/to/model--input-columns"['col1','col2','col3']"--python-dependenciesscikit-learn--project-namemy-projectConnectionsAerostat provides connection templates to use your model in various applications once it is deployed. Currently, it includes templates for:Microsoft ExcelGoogle SheetsPython / Jupyter NotebookVisit the URL produced by theaerostat deploycommand to test your model on cloud, and get the connection templates.Other CommandsListTo list all the projects you have deployed, run:aerostatlsInfoTo find deployment information of a specific project, such as API endpoint, run:aerostatinfothen choose the project from the list. You can also provide the project name as a command line option like:aerostatinfomy-projectFuture RoadmapImprove user interface, including rewrite prompts with Rich, use more colors and emojisAdd unit testsAdoptSemantic Versioningonce reach v0.1.0 and add
CI/CDSupport SSO loginSupport deploying to GCP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.