package
stringlengths 1
122
| pacakge-description
stringlengths 0
1.3M
|
|---|---|
agrc-supervisor | No description available on PyPI. |
agrc-sweeper | agrc-sweeperThe data cleaning service.Available SweepersAddressesChecks that addresses have minimum required parts and optionally normalizes them.DuplicatesChecks for duplicate features.EmptiesChecks for empty geometries.MetadataChecks to make sure that the metadata meetsthe Basic SGID Metadata Requirements.TagsChecks to make sure that existing tags are cased appropriately. This mean that the are title-cased other than known abbreviations (e.g. UGRC, BLM) and articles (e.g. a, the, of).This check also verifies that the data set contains a tag that matches the database name (e.g.SGID) and the schema (e.g.Cadastre).--try-fixadds missing required tags and title-cases any existing tags.SummaryChecks to make sure that the summary is less than 2048 characters (a limitation of AGOL) and that it is shorter than the description.DescriptionChecks to make sure that the description contains a link to a data page on gis.utah.gov.Use LimitationsChecks to make sure that the text in this section matches theofficial text for UGRC.--try-fixupdates the text to match the official text.Parsing AddressesThis project contains a module that can be used as a standalone address parser,sweeper.address_parser. This allows developer to take advantage of sweepers advanced address parsing and normalization without having to run the entire sweeper process.Usage Examplefromsweeper.address_parserimportAddressaddress=Address('123 South Main Street')print(address)'''--> Parsed Address:{'address_number': '123','normalized': '123 S MAIN ST','prefix_direction': 'S','street_name': 'MAIN','street_type': 'ST'}'''Available Address class propertiesAll properties default to None if there is no parsed value.address_numberaddress_number_suffixprefix_directionstreet_namestreet_directionstreet_typeunit_typeunit_idIf nounit_typeis found, this property is prefixed with#(e.g.# 3). Ifunit_typeis found,#is stripped from this property.cityzip_codepo_boxThe PO Box if a po-box-type address was entered (e.g.po_boxwould be1forp.o. box 1).normalizedA normalized string representing the entire address that was passed into the constructor. PO Boxes are normalized in this formatPO BOX <number>.Installation (requires Pro 2.7+)clone arcgis conda environmentconda create -name sweeper --clone arcgispro-py3activate environmentactivate sweeperinstall sweeperpip install agrc-sweeperDevelopmentclone arcgis conda environmentconda create -name sweeper --clone arcgispro-py3activate environmentactivate sweepertest_metadata.pyuses a SQL database that needs to be restored viasrc/sweeper/tests/data/Sweeper.bakto your local SQL Server.Installing dependenciesclone arcgis conda environmentconda create -name sweeper --clone arcgispro-py3install only required dependencies to run sweeperpip install -e .install required dependencies to work on sweeperpip install -e ".[develop]"install required dependencies to run sweeper testspip install -e ".[tests]"run tests:pytest |
agrc-usaddress | usaddress is a python library for parsing unstructured address strings into
address components, using advanced NLP methods.From the python interpreter:>>> import usaddress
>>> usaddress.parse('123 Main St. Suite 100 Chicago, IL')
[('123', 'AddressNumber'),
('Main', 'StreetName'),
('St.', 'StreetNamePostType'),
('Suite', 'OccupancyType'),
('100', 'OccupancyIdentifier'),
('Chicago,', 'PlaceName'),
('IL', 'StateName')] |
agreement | AgreementInter-rater agreementAgreement library provides an implementation of popular metrics used to measure inter-rater agreement.
Inter-rater agreement (know also as a inter-rater reliability) is used to describe the degree of agreement among raters.
It is a score of how much homogeneity or consensus exists in the ratings given by various judges.If you want to learn more about this topic, you can start by reading thisWikipediapage.Implemented metricsThis library provides a pure numpy implementation of an extended formulas for following metrics:Observed agreementBennett et al.'s S scoreCohen's kappaGwet's gammaKrippendorff alphaScott's piAnd extended formulas can be used to measure agreement for;multiple raters- support for two or more raters,multiple categories- support for binary problems, as well as more categories,missing ratings- not all raters provided answers for all the questions.weighted agreement- used to model distance between categories (e.g.dist(5, 4) < dist(5, 1))More information about implemented metrics can be found here: TODOImplemented weights kernelsAgreement provides implementations for eight weight kernels:identity kernellinear kernelquadratic kernelordinal_kernelradical_kernelradio_kernelcircular_kernelbipolar_kernelMore information about implemented weights kernels can be found here: TODOInstallationAgreement can be installed via pip fromPyPI.pipinstallagreementExample usage1. Prepare datasetLet's assume you have a dataset in a format of a matrix with three columns:question id,rater idandanswer.importnumpyasnpdataset=np.array([[1,1,'a'],[1,2,'a'],[1,3,'c'],[2,1,'a'],[2,2,'b'],[2,3,'a'],[3,1,'c'],[3,2,'b'],])2. Transform dataset into matricesIn the next step we want to transform the dataset into matrices in a form accepted by the metrics functions.Most of the matrices require a "questions answers" matrix, which contains a frequency of answers for each question.
So more formally we could sayM = I x A, whereIis a list of all items andAis a list of all possible answers.
Matrix elementM_ijrepresents how many times answerjwas chosen for the questionsi.The second matrix can be required (currently it is only required by the Cohen's kappa metrics) is "users answers" matrix, which
contains a frequency of answers selected by each user.
So more formally we could sayM = U x A, whereUis a list of all users andAis a list of all possible answers.
Matrix elementM_ijrepresents how many times answerjwas chosen for the useri.The library provides a helper functions that can be used to prepare that.fromagreement.utils.transformimportpivot_table_frequencyquestions_answers_table=pivot_table_frequency(dataset[:,0],dataset[:,2])users_answers_table=pivot_table_frequency(dataset[:,1],dataset[:,2])3. Select kernelWeights are used to model situations, where categories are represented as (at least) ordinal data.
Using this approach, the agreement between raters is not binary, but it differs depending on the
weights between chosen categories.There is no formal rule that can be used for deciding which set weights should be used
in a particular study, so it all depends on your problem and the data your are working with.In a default, metrics are using theidentity_kernel, which do not provide any weighting between the answers.
If you want to use an alternative kernel, you can import it from:fromagreement.utils.kernelsimportlinear_kernel4. Compute the metricThe last step is to chose the metric you want to compute and run following code:fromagreement.metricsimportcohens_kappa,krippendorffs_alphakappa=cohens_kappa(questions_answers_table,users_answers_table)weighted_kappa=cohens_kappa(questions_answers_table,users_answers_table,weights_kernel=linear_kernel)alpha=krippendorffs_alpha(questions_answers_table)For more detailed example see: TODOReferenceAll equations are based on the Handbook of Inter-Rater ReLiability, Kilem Li. Gwet, 2014.
This book provides an extensive explanation to all topics related to inter-rater agreement.
The book provides a detailed description of all metrics implemented in this library, as well as
an example datasets that were used to this this implementation.I also recommend taking a look at MatLab implementation of the same metricsmReliability,
which provides a more detailed explanation of metrics' formulas then the one you will find here. |
agreement-api | Provides an Api powered by flask and connexion. |
agreement-phi | Agreement measure PhiSource code for inter-rater agreement measure Phi. Live demo here:http://agreement-measure.sheffield.ac.ukRequirementspython 3+, pymc3 3.3+. See requirements files for tested working versions on linux and osx.Installation - with pipSimply runpip install agreement_phi.
This will provide a module and a command line executable calledrun_phi.Installation - without pipDownload the folder.Example - from command linePrepare a csv file (no header, each row is a document, each column a rater), leaving empty the missing values. For exampleinput.csv:1,2,,3
1,1,2,
4,3,2,1And execute from the consolerun_phi --file input.csv --limits 1 4.
More details obtained runningrun_phi --h:usage: agreement_phi.py [-h] -f FILE [-v] [-l val val]
Phi Agreement Measure
optional arguments:
-h, --help show this help message and exit
-f FILE, --file FILE input FILE <REQUIRED>
-v, --verbose print verbose messages
-l val val, --limits val val Set limits <RECOMMENDED> (two values separated by a space)Example - from pythonInput is a numpy 2-dimensional array with NaN for missing values, or equivalently a python list of lists (where each list is a set of ratings for a document, of the same length with nan padding as needed). Every row represents a different document, every column a different rating. Note that Phi does not take in account rater bias, so the order in which ratings appear for each document does not matter. For this reasons, missing values and a sparse representation is needed only when documents have different number of ratings.Input exampleimport numpy as np
m_random = np.random.randint(5, size=(5, 10)).tolist()
m_random[0][1]=np.nanor equivalentlym_random = np.random.randint(5, size=(5, 10)).astype(float)
m_random[0][1]=np.nanRunning the measure inferencefrom agreement_phi import run_phi
run_phi(data=m_random,limits=[0,4],keep_missing=True,fast=True,njobs=4,verbose=False,table=False,N=500)data[non optional] is the matrix or list of lists of input (all lists of the same length with nan padding if needed).OPTIONAL PARAMETERS:limitsdefines the scale [automatically inferred by default]. It's a list with the minimum and maximum (included) of the scale.keep_missing[automatically inferred by default based on number of NaNs] boolean. If you have many NaNs you might want to switch to False,fast[default True] boolean. Whether to use or not the fast inferential technique.N[default 1000] integer. Number of iterations. Increase it ifconvergence_testis False.verbose[default False] boolean. If True it shows more informationtable[default False] boolean. If True more verbose output in form of a table.njobs[default 1] integer. Number of parallel jobs. Set it equal to the number of CPUs available.binning[default True] boolean. If False consider the values in the boundary of scale non binned: this is useful when using a discrete scale and the value in the boundaries should be considered adhering to the limits and not in the center of the corresponding bin. This is useful when the value of the boundaries have a strong meaning (for example [absolutely not, a bit, medium, totally]) where answering in the boundary of the scale is not in a bin as close as the second step in the scale.Note that the code will try to infer the limits of the scale, but it's highly suggested to include them (in case some elements on the boundary are missing). For this example the parameter limits would belimits=[0,4].Note thatkeep_missingwill be automatically inferred, but for highly inbalanced datasets (per document number of ratings distribution) it can be overriden by manually setting this option.Output example{'agreement': 0.023088447111559884, 'computation_time': 58.108173847198486, 'convergence_test': True, 'interval': array([-0.03132854, 0.06889001])}Where 'interval' represents the 95% Highest Posterior Density interval.
If convergence_test is False we recommend to increase N.ReferencesIf you use it for academic publications, please cite out paper:Checco, A., Roitero, A., Maddalena, E., Mizzaro, S., & Demartini, G. (2017). Let’s Agree to Disagree: Fixing Agreement Measures for Crowdsourcing. In Proceedings of the Fifth AAAI Conference on Human Computation and Crowdsourcing (HCOMP-17) (pp. 11-20). AAAI Press.@inproceedings{checco2017let,
title={Let’s Agree to Disagree: Fixing Agreement Measures for Crowdsourcing},
author={Checco, A and Roitero, A and Maddalena, E and Mizzaro, S and Demartini, G},
booktitle={Proceedings of the Fifth AAAI Conference on Human Computation and Crowdsourcing (HCOMP-17)},
pages={11--20},
year={2017},
organization={AAAI Press}
} |
agreementr | AgreementrIntroAgreementr is a package used to predict the value of agreement of texts.It is based on a fine tuned BERT model.InstallUse pipIfpipis installed, agreementr could be installed directly from it:pip install agreementrDependenciespython>=3.6.0
torch>=0.4.1
numpy
pandas
unidecode
pytorch-pretrained-bert
pytorch-transformersUsage and ExampleNotes: During your first usage, the package will download a model file automatically, which is about 400MB.predictpredictis the core method of this package,
which takes a single text of a list of texts, and returns a list of raw values in[1,5](higher means more agreement, while lower means less).Simplest usageYou may directly importagreementrand use the default predict method, e.g.:>>> import agreementr
>>> agreementr.predict(["I am totally agree with you"])
[4.3568916]Construct from classAlternatively, you may also construct the object from class, where you could customize the model path and device:>>> from agreementr import Agreementr
>>> ar = Agreementr()
# Predict a single text
>>> ar.predict(["I am totally agree with you"])
[4.3568916]
# Predict a list of texts
>>> preds = ar.predict(['I am totally agree with you','I hate you'])
>>> f"Raw values are {preds}"
[4.3568916 2.42935]More detail on how to construct the object is available in docstrings.Model using multiprocessing when preprocessing a large dataset into BERT input featuresIf you want to use several cpu cores via multiprocessing while preprocessing a large dataset, you may construct the object via>>> ar = Agreementr(CPU_COUNT=cpu_cpunt, CHUNKSIZE=chunksize)If you want to faster the code through multi gpus, you may construct the object via>>> ar = Agreementr(is_paralleled=False, BATCH_SIZE = batch_size)ContactJunjie Wu ([email protected]) |
agregator-mess | Агрегатор мессенджеровpython 3.5.2Используемые библиотеки:PyQt5vk_apitelethonpickleТочка входа в приложение core/Manager.pyИнструкция по сборке приложенияУстановить все зависимости с помощью pip install PyQt5 vk_api telethon pickleПерейти в директорию coreЗапустить приложение используя точку входа python Manager.pyЧто сейчас работает:Авторизация помощью VK user, VK group, telegram userЗагрузка диалогов пользователяЗагрузка изображений диалогов и кеширование ихЗагрузка сообщений из выбранного диалогаМакет пользовательского интерфейсаГлавная страница приложения |
agricore_sp_models | AGRICORE-synthetic-population-models |
agriculture-data-analytics | No description available on PyPI. |
agrid | agridA grid for modelling, analyse, map and visualise multidimensional and multivariate data. The module contains a class for generating grid objects with variables and functions that defines a multidimensional space with defined extent.Main features:Labelled dimensions coordinates using xarrayFast process of high resolution and low resolution dataUsing dask arrays2D map plots and cross-sections3D visualisationFeatures for modelling, analysis and visualisationThe repository contains:Module with class for functions and variables.Jupyter notebook tutorials:The grid objectImport dataVisualize dataIntroduction to processing and modelling using grid.Software paper availible here:JORSInstructions:The package can be installed by adding it to your Python path, but can also be an incorporated part of you project.Alternative 1Using pip:pip install agridorpip3 install agridSet up an envirinment for the installation. Use e.g.virtualenvorvenvto set up your environment. For more complex isnallations, have a look atpipenvorpoetry.OSX users can set up an environment directely in conda.conda install -c tobbetripitaka agridAlternative 2Download module and import agrid from local pathSee example in the Jupyter Notebook agrid.To get started:from agrid.grid import Grid
world = Grid()
# The grid is already populated with default coordinates
print(world.ds)Further tutorials are available atGitHub tutorialsMethods to import dataData can be imported from grids, vector data files, rasters or numerically.Methods to export dataData can be exported and saved as netCDF, raster files, text files.Methods to visualise dataVisualisation is not the core use of agrid, but it contains basic functions to plot maps and 3D renderings.Additional functionsAdditional functions are included to download data and structure the content.---If used in publication, please cite:@article{Staal2020a,
abstract = {Researchers use 2D and 3D spatial models of multivariate data of differing resolutions and formats. It can be challenging to work with multiple datasets, and it is time consuming to set up a robust, performant grid to handle such spatial models. We share 'agrid', a Python module which provides a framework for containing multidimensional data and functionality to work with those data. The module provides methods for defining the grid, data import, visualisation, processing capability and export. To facilitate reproducibility, the grid can point to original data sources and provides support for structured metadata. The module is written in an intelligible high level programming language, and uses well documented libraries as numpy, xarray, dask and rasterio.},
author = {St{\aa}l, Tobias and Reading, Anya M.},
doi = {10.5334/JORS.287},
issn = {20499647},
journal = {Journal of Open Research Software},
keywords = {Multivariate processing, Python, Regular grid, Spatial model},
month = {jan},
number = {1},
pages = {1--10},
publisher = {Ubiquity Press, Ltd.},
title = {{A grid for multidimensional and multivariate spatial representation and data processing}},
volume = {8},
year = {2020}
} |
agrimetscraper | agrimetscraperintroductionagrimetscraper crawls AgriMet weather data and summarise for later data usage.basic usagePython virtual environment is preferredpip install agrimetscraperstartproject -p <yourproject> -t <select database type: mongodb or sql or atlas>It will create a directory for your project, this folder will contain yourproject-config, yourproject-log, yourproject-database, yourproject-stationsIf you choose 'atlas', the program will prompt you for your atlas connection string and the passwordcd into your project, change .ini file if neededThere are two baseurls for agrimet API: one is for daily, the other is for instant, are all defined in ini filerun project: python runproject.py -f "instant"|"daily" -n dbtableset scheduler in .ini file (this program uses crontab)**For instant data, program will aggregate 15 minutes into 1 hour interval and average the parameters |
agrimpy | agrimpyutiliza pyproj para hacer algunas opreaciones con coordenadas geodésicas.InstalaciónEjecutar en la terminal:$ sudo pip install agrimpyUsoVer archivotest.pycon ejemplos.To do…ayudame con un pull-request enhttps://github.com/quijot/agrimpy-packageAutorSantiago Pestarini <[email protected]>Licenciaagrimpyis licensed under theMIT License. See the LICENSE file. |
agrippa | AgrippaThis python package is meant to assist in building/understanding/analyzing machine learning models. The core of the system is a markup language that can be used to specify a model architecture. This package contains utilities to convert that language into the ONNX format, which is compatible with a variety of deployment options and ML frameworks.InstallationAgrippa can be installed withpip install agrippa. Therequirements.txtfile contains dependencies to run both the package and the tests found in thetestsfolder.UsageThe principal function is export, which takes a project folder and compiles the contents into a .onnx file.import agrippa
model_dir = '../path/to/dir'
agrippa.export(model_dir, 'outfile_name.onnx')The function header for export is:def export(
infile, # the markup file
outfile=None, # the .onnx file name
producer="Unknown", # your name
graph_name="Unknown", # the name of the model
write_weights=True, # should this create a weights file, should none exist
suppress=False, # suppresses certain print statements
reinit=False, # reinitializes all weights from the weights file
bindings=None # a dictionary to bind variables present in the markup
):Markup Language SpecA project should be bundled into its own directory, which should have three files:One file with the extension.agror.xmlspecifying the model architectureAweights.pklfile to specify the parameter values in the model (optional)Ameta.jsonfile to define certain metadata, like the producer name (optional)The architecture file is parsed like XML, so it should be well-formed XML. Recall that tags with no respective end-tag should end with\>, and all attributes should be formatted like strings with quotes around them.Markup SyntaxEvery architecture file should be encased in a<model>tag, ideally with an attributescript-version="0.0.0"(the current version).An example script that does only one matrix multiply might look like this:<model script-version="0.0.1">
<import dim="[5, 1]" from="input" type="float32" />
<block title="Projection">
<import from="input" />
<node title="Linear" op="MatMul">
<params dim="[5, 5]" name="W" type="float32" />
<input dim="[var(features), 1]" src="input" />
<output dim="[5, 1]" name="y" />
</node>
<export from="y" />
</block>
<export dim="[5, 1]" from="y" type="float32" />
</model>There are only three types of root-level tags that are allowed:<import>,<export>, and<block>. The import and export tags specify the inputs and outputs of the entire model, respectively. There may be multiple of each type, but each type must appear at least once. Each import and export tag must have three attributes:dim,from, andtype. They are used like so:<import dim="[3, 1]" from="input" type="float32" />
<export dim="[3, 1]" from="y" type="float32" />Thefromname for the export matches the name you should expect from ONNX runtime. It should also match the output of the last node from which you are piping output.Most of the architechture should be contained inside<block>tags. These tags take a title attribute, which does not need to be unique. Importantly,<node>tags must be inside blocks. Block tags should contain<import>and<export>tags (with the attributes mentioned above) specifying all of the inputs/outputs the underlying nodes inside the block use.Nodes define operations. Theiropattribute defines the ONNX op type they will be converted to. They must also have atitleattribute, which is unique. Nodes must also contain appropriate<input>,<output>, and<params>tags. The<input>and<params>tags need to be in the order specified in the ONNX documentation for a particular node type. See an example node:<node title="Linear" op="MatMul">
<params dim="[3, 3]" name="W" type="float32" shared="no" />
<input dim="[3, 1]" src="input" />
<output dim="[3, 1]" name="linear" />
</node>Parameters, which are specified using the<params>tag, take anameattribute (unique only for non-shared parameters), adimattribute, atypeattribute, and an optionalsharedattribute. Thesharedattribute should equal "yes" or "no". It specifies whether a parameter name is meant to be unique; by default, parameters which share the same name (such as in a repitition) become independent values upon compilation.RepetitionsBlocks may take arepattribute, which defines how many times a block should be stacked on top of itself. Its outputs are passed to its inputs and so on. The number of inputs and the number of outputs need not match (they are matched based on order; note that if you want to use intermediate outputs, you must account for name mangling in repeated blocks). Even though the names of the outputs are mangled during repetitions, you may use the outputs in your markup with consideration to that fact: simply refer back to the name you specified, which is automatically mapped to the last name in the repetition.Variable BindingsTheagrippa.exportfunction takes an optional argument,bindings. Thebindingsparameter is meant to be a dictionary of variables, set by the user, to replace areas in the markup file where thevarfunction is used. For example, if an input tag has adimattribute set to"[var(image_width), var(image_height)]", a binding of{'image_width': 512, 'image_height': '256'}would set all occurances ofvar(image_height)to512and all occurances ofvar(image_height)to256. Note that in all cases, strings are used, since xml attributes require strings; the values are type-casted upon compilation.ExpressionsAttributes also support expressions usingexpr(). For example, in order to specify that a parameter should be initialized to the square of a variable (supplied in bindings), you could use:<params name="squared" dim="[2, 2]" init="constant" init_args="[expr(my_var^2)]">.Note that the expression goes inside the list (expressions do not support lists). They support to following binary operators:^,*,/,%,-,+.Also note thatexpr(my_var)andvar(my_var)are equivalent.Weight InitializationBy default, weights are initialized with a standard normal distribution. There are ways to specify other initializations for each parameter, however. Theparamstag takes an optionalinitattribute along with an optionalinit_argsattribute. Theinit_argsattribute must always be some value (non-string), such as a list (e.g.,init_args="[2, 3]"). Recall that all attributes are specified with double quotation marks) The options for initialization are:ValueDescriptionArgumentsnormalNormally distributedA list of two numbers, the first defining the mean and the second defining the standard deviation.uni_randomUniformly random in [a, b)A list of two numbers, the first defining the a and the second defining b.zerosAll zerosNoneonesAll onesNoneconstantInitializes tensor to specified valueThe first argument in the list is the valueFrozen ParametersIn order to freeze a parameter, you can set thefrozenattribute equal toyes. Internally, this option adds$constantto the ONNX initialization names. When importing the parameter into PyTorch using the conversion tool, the$constantindicates that the initializer should be added as a buffer (constant) rather than a parameter.Importing From Other FilesAnother file can be used in your model by using ablocktag with asrcattribute. Like so:<block src="path/to/file.agr" name="imported_file" />Thenameattribute defines how you refer to imports/exports of the imported model. For example, if the linked model has a root level import with nameinputs, an output (or import) (in the original file) with nameimported_file$inputswill be automatically passed to the imported model. Likewise, an export can be referred to in the original file by specifying an input with nameimported_file$out_name_from_imp_file.Other RulesNamesNode titles are optional (a default, unique game is given to them upon compilation). Parameter names should be unique only when they are not shared parameters; parameters inside repeated blocks will have their names mangled so that they are unique. Name mangling affects parameters, node titles, and output/input names separately.TypesTypes by default are set to float32.DimensionsSpecifying the dimensions of inputs and outputs are optional. Specifying the dimensions of imports and exports are only required at the root level, though it is recommended that you specify them for clarity.Any behavior not mentioned here is undefined.Supported TypesThe only currently supported type isfloat32.Supported ONNX OpTypesThe currently supported op types are:ONNX OpTypeTested ONNX Compile SupportTested Training SupportAddYesYesConcatYesYesIdentityYesYesLeakyReluYesYesLpNormalizationYesYesMatMulYesYesMulYesYesReluYesYesReduceMeanYesYesSoftmaxYesYesSqrtYesYesSubYesYesTransposeYesYesAdditional notes on functionality that might differ from ONNX. For most details, seethe Onnx documentation.ONNX OpTypeNotesTransposeImportant difference with the Onnx documentation: by default, when imported into PyTorch, the transpose operator will keep the first dimension the same so as to support batching. The Onnx default behavior is to reverse all the dimensions.Syntax Highlighting in VSCodeIf you'd like to use the extension.agrfor clarity, you can enable syntax highlighting in vscode by placing the following in a settings.json file:"files.associations": {
"*.agr": "xml"
}To create that settings file, use the command pallet (CTRL-SHIFT-P), typesettings.json, and choose the appropriate option.TrainingONNX is built for inference. However, various supporters of ONNX, including Microsoft (via the onnxruntime), have tried to implement training support. As far as I can tell, Microsoft gave up on trying to support training ONNX files directly. Many of the training tools in onnxruntime are either experimental or scheduled to be depricated. What they did end up implementing was a tool to train PyTorch models (i.e. objects of classes that inherit from torch.nn.Module). Their tool is more narrowly for speeding up training that you could already do natively in PyTorch, and it is not used in this project.Another option, besides trying to rely on existing ONNX training projects, would have been to make our own. It is actually relatively straightforward: the ONNX file itself is a highly expressive computational graph. We could build a separate graph for training, which has gradient nodes added. It could even take parameters as input and output new parameters while keeping all the data on a GPU. The key is having access to (or building from scratch) nodes that can compute the gradient of each operation (there are many, but they are relatively simple). I ultimately decided (like Microsoft) that this was not worth the pain.Instead, we opt for converting onnx files to PyTorch. We provide utilities to do that and to use the training features of PyTorch.Unfortunately, PyTorch does not natively support importing ONNX files. But there is a work-around: building on top of some community tools, we can make our own ONNX to PyTorch converter that is suitable for training. There is more information in the README.md under src/agrippa/onnx2torch for details on exactly how a particular community project was modified. It does not support all ONNX operations, but neither does our markup language.UsageThe following code snippet takes a project directory, converts it to an onnx file, then uses the build-in ONNX-to-PyTorch converter to create a PyTorch model, which can be trained in the usual way.import agrippa
proj_name = 'simple-project'
onnx_out = 'simple_testing.onnx'
agrippa.export(proj_name, onnx_out)
torch_model = agrippa.onnx_to_torch(onnx_out)UtilitiesSome utilities are available in agrippa.utils. This includesfind_params, which returns weight (parameter) names and values as a dictionary. It also includessave_torch_model, which takes trained weights from a PyTorch model and saves them into a freshweights.pklfile.Finding ParametersThe returned dictionary includes parameters whose names contain thenameargument (first argument) as a substring. Searching for weights in this way is recommended, since the names of parameters might be changed when the markup is compiled (for example, the names of weights that appear in repeated blocks). Thefind_paramsfunction takes two mandatory parameters and one optional: the substring that will be matched (mandatory), the directory of the project (mandatory), and the path to the weights file name within that directory (optional).Examplematches = agrippa.utils.find_params('bias', 'FNN')
print(matches)The above code might print:{'biases$1': array([[-0.77192398],
[-0.02351803],
[-0.00533084],
[ 0.13640493],
[-0.12087004]]), 'biases$2': array([[-0.18979854],
[-0.15769928],
[ 0.46656397],
[-0.10602235]])}Saving Model from PyTorchAfter importing your model to PyTorch usingagrippa.onnx_to_torch, you probably would like to save the trained weights. When imported into PyTorch, the names of the weights change slightly, so it is recommended that you save your models usingagrippa.utils.save_torch_model, which takes as parameters the PyTorch model, the project directory, and (optionally) the weights filename inside that directory. Under the hood, this function loops over thestate_dictof the PyTorch model, removesinitializer.from the parameter's name, and saves it inside a dictionary toweights.pkl.Example# ... training loop
agrippa.utils.save_torch_model(torch_model, "my-project", "weights.pkl")ExamplesThe following architecture is a simple feed forward network with five layers followed by a normalization. The architecture is organized into two blocks, the FFN and the norm layer. Inside the FFN is a FFN Layer block, which is repeated five times.<model script-version="0.0.1">
<import dim="[3, 1]" from="input" type="float32" />
<block title="FFN">
<import from="input" />
<block title="FFN Layer" rep="5">
<import from="input" />
<node title="Linear" op="MatMul">
<params dim="[3, 3]" name="W" type="float32" />
<input dim="[3, 1]" src="input" />
<output dim="[3, 1]" name="linear" />
</node>
<node title="Bias" op="Add">
<params dim="[3, 1]" name="B" type="float32" />
<input dim="[3, 1]" src="linear" />
<output dim="[3, 1]" name="biased" />
</node>
<node title="ReLu" op="Relu">
<input dim="[3, 1]" src="biased" />
<output dim="[3, 1]" name="relu" />
</node>
<export from="relu" />
</block>
</block>
<block title="Norm">
<import from="relu" />
<node title="ReLu" op="LpNormalization" axis="0" p="1">
<input dim="[3, 1]" src="relu" />
<output dim="[3, 1]" name="y" />
</node>
<export from="y" />
</block>
<export dim="[3, 1]" from="y" type="float32" />
</model>You can find more example projects inside thetestsfolder. |
agri-sense | No description available on PyPI. |
agri-tech | agri_techLoading and using LidardataFree software: MIT licenseDocumentation:https://agri-tech.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2021-08-16)First release on PyPI. |
agrivoltaics-supply-side-management | Agrivoltaics Supply Side ManagementOptimizes Supply Side Management with Agrivoltaics (Solar sharing between
Photovoltaics and Agriculture) by Artificial Intelligence.InstallationUse the package managerpipto install
agrivoltaics-supply-side-management.Case 1When using by cloning this GIT repository:pipinstall-e[ABSOLUTEPATHTOTHISPROJECT]Case 2When using a package available in PyPI:pipinstallagrivoltaics-supply-side-managementSolversWe use Python library for mathematical optimization, called Pyomo.
As in any mathematical optimization tool, it requires a solver.For Linear Programming, glpk is used as a solver by default following Pyomo
tutorial.In Macintosh, install it through Homebrew:brewinstallglpkFor other platforms, seehttps://www.gnu.org/software/glpk/Usage[To be added]References[1] P. E. Campana, B. Stridh, S. Amaducci, and M. Colauzzi,
“Optimisation of vertically mounted agrivoltaic systems,”
Journal of Cleaner Production, vol. 325, p. 129091, Nov. 2021,
doi: 10.1016/j.jclepro.2021.129091.
[2] C. B. Honsberg, R. Sampson, R. Kostuk, G. Barron-Gafford,
S. Bowden, and S. Goodnick, “Agrivoltaic Modules Co-Designed
for Electrical and Crop Productivity,”
in 2021 IEEE 48th Photovoltaic Specialists Conference (PVSC),
Jun. 2021, pp. 2163–2166. doi: 10.1109/PVSC43889.2021.9519011.
[3] B. Willockx, B. Uytterhaegen, B. Ronsijn, B. Herteleer, and J. Cappelle,
“A standardized classification and performance indicators of agrivoltaic
systems.,” Oct. 2020. doi: 10.4229/EUPVSEC20202020-6CV.2.47.
[4] H-W, Heldt, ”Plant Biochemistry,” Elsevier Academic Press,
Burlington, MA, USA, 2005.
[5] R. W. Langhans and T. W. Tibbits, “Plant Growth Chamber Handbook
- Chapter 1 Radiation,” in Plant Growth Chamber Handbook,
Iowa State University, 1997.
[6] O. A. Martin, R. Kumar, and J. Lao, "Bayesian Modeling and Computation
in Python," Boca Ratón, 2021.
[Online]. Available:https://bayesiancomputationbook.com[7] R. Retkute, S. E. Smith-Unna, R. W. Smith, A. J. Burgess, O. E. Jensen,
G. N. Johnson, S. P. Preston, E. H. Murchie, ”Exploiting heterogeneous
environments: does photosynthetic acclimation optimize carbon gain in
fluctuating light?,” Journal of Experimental Botany, May 2015, vol. 66,
no. 9, pp. 2437–2447, doi: 10.1093/jxb/erv055. |
agrograph-processing-toolbox | Example PackageThis is a simple example package. You can useGithub-flavored Markdownto write your content. |
agro-kit | An API to facilitate interaction with an agriculture tech sensor kit. The sensor kit
contains the following hardware modules in addition to the Raspberry Pi Zero W:Quectel L70-M39 GPSAdafruit MCP3008 ADCSeeed Studio 10102008 Moisture SensorAdafruit TCS34725 Light SensorLicensingFree software: GNU General Public License v3FeaturesSensor readingGPSMoistureLuxCreating sensor profilesLogging data to text filesSending configuration commands GPSSetupEnsure SPI, I2C and UART are enabled on the Raspberry Pi. This can be done using the sudo raspi-config command in the Linux terminal.Install required packages. These can be done as follows:pip3 install Adafruit_GPIO Adafruit_MCP3008 Adafruit-Blinkapip3 install file-read-backwards requests pynmea2pip3 install RPi.GPIO adafruit-circuitpython-tcs34725pip3 install agro-kitNote that this API can has to be used on a Raspberry Pi.Hardware ConfigurationPin numbers according to datasheets are shown in []Adafruit TCS34735 -> Raspberry PiVDD [1] -> GPIO-17 [11]GND [2] -> GNDSDA [3] -> SDA1_I2C [3]SCL [4] -> SCL1_I2C [5]Seeed Studio -> Raspberry Pi[3] -> GPIO23 [16][4] -> GNDMCP3008 -> Seed StudioCHO 0 [1] -> [1]MCP3008 -> Raspberry PiGND [9] -> GNDCS [10] -> GPIO_SPI_CE0 [24]D-IN [11] -> GPIO_SPI_MOSI [19]D-OUT [12] -> GPIO_SPI_MISO [21]CLK [13] -> GPIO_SPI_CLK [23]GND [14] -> GNDVREF [15] -> 3.3 V [17]VDD [16] -> 3.3 V [17]QUECTEL L70-M39TXD [2] -> GPIO_15_UART_RXD [10]RXD [3] -> GPIO_14_UART_TXD [8]VCC [8] -> 3.3 V [1]GND [1] -> GNDAboutThe library includes 4 main classes: MoistureSensor, light_sensor, GPS and AgroKit.The AgroKit is an aggregated class built with attributes of the other sensor classesThe AgroKit class can use any instance method available in the other sensor classes as well as its own aggregated methodsLink to documentationCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.The pynmea2 python library was used for GPS parsing of NMEA 0183 messages. |
agrolens | No description available on PyPI. |
agromet | Uma biblioteca com equaçoes agrometeorológicas |
agrometeo-geopy | agrometeo-geopyPythonic interface to accessagrometeo.chdata.InstallationThe agrometeo-geopy library requiresgeopandas, which can be installed using conda/mamba as in:condainstall-cconda-forgegeopandasThen, agrometeo-geopy can be installed using pip:pipinstallagrometeo-geopyOverviewimportagrometeoasagmstart_date="2021-08-13"end_date="2021-08-16"agm_ds=agm.AgrometeoDataset(region="Canton de Genève")ts_df=agm_ds.get_ts_df(start_date=start_date,end_date=end_date)ts_dfnameDARDAGNYLA-PLAINESATIGNYPEISSYANIERESLULLYLULLIERBERNEXTROINEXMEINIERtime2021-08-13 00:00:0019.317.818.517.920.618.420.318.619.425.82021-08-13 00:10:0019.617.918.417.720.018.319.618.719.128.62021-08-13 00:20:0019.017.718.217.619.418.419.118.719.224.12021-08-13 00:30:0018.318.018.117.419.118.319.118.618.922.52021-08-13 00:40:0018.718.018.117.619.118.019.018.718.521.5.................................2021-08-16 23:10:0017.517.817.316.917.917.617.317.217.922.22021-08-16 23:20:0017.417.917.417.117.917.617.317.218.022.02021-08-16 23:30:0017.217.917.517.317.817.617.317.318.021.72021-08-16 23:40:0017.217.917.717.117.717.417.217.118.121.92021-08-16 23:50:0017.117.817.517.117.717.317.117.118.122.0576 rows × 10 columnsSeethe user guidefor more details.AcknowledgementsThis package was created withCookiecutterand thezillionare/cookiecutter-pypackageproject template. |
agro-met-equations-dynalogic | Agrometeorological Equations PackageLibrary for agrometeorological calculation like evapotranspiration, water balance, degree days, etcAuthors:Bruno Ducraux ([email protected])Mariana Gonçalves dos Reis ([email protected])Based on:PyEtoAboutThis library was adapted to fit some needs of a private project,
and I decided to disponibilize as open source since the original project
that we used as base is.All calculations and formulas were reviewed by the agrometeorologist Mariana Gonçalves dos Reis, based on the documents:Conversion factors and general equations applied in agricultural and forest meteorologyEvapotranspiration_Equation.pdfIn case of questions related to the python code, bug fix ...
please contact Bruno Ducraux, who is the python developer responsible for the project.Installationpip install agro-met-equations-dynalogicUsagefrom AgroMetEquations importSteps to calculate FAO56Day of year: days_passed_on_current_year()Solar declination: sol_dec(day_of_year)Sunset hour angle: sunset_hour_angle(latitude_rad, solar_declination)Daylight hours: daylight_hours(sunset_hour_angle)Inverse relative distance between earth and sun: inv_rel_dist_earth_sun(day_of_year)Extraterrestrial radiation: et_rad(latitude_rad, solar_declination, sunset_hour_angle, inv_rel_dist_earth_sun)Clear sky radiation: cs_rad(altitude, extraterrestrial_radiation)Saturation vapour pressure Min: svp_from_t(temperature_min)Saturation vapour pressure Max: svp_from_t(temperature_max)Saturation vapour pressure: svp(svp_min, svp_max)Actual vapour pressure: avp_from_rhmin_rhmax(svp_min, svp_max, relative_humidity_min, relative_humidity_max)Net outgoing longwave radiation: net_out_lw_rad(temperature_min:kelvin, temperature_max:kelvin, solar_radiation, clear_sky_radiation, actual_vapour_pressure)Net income solar radiation: net_in_sol_rad(solar_radiation)Net radiation at the crop surface: net_rad(net_in_sol_rad, net_outgoing_longwave_radiation)Soil heat flux: soil_heat_flux_by_nightday_period(net_rad)Latent heat: latent_heat(temperature_mean)Delta: delta_svp(temperature_mean)Psychrometric constant: psy_const(atmosphere_pressure, latent_heat)Wind speed measured at different heights: wind_speed_2m(wind_speed, sensor_height)FAO56: fao56_penman_monteith(net_rad, temperature_mean, wind_speed, latent_heat, svp, actual_vapour_pressure, delta, psychrometric_constant, soil_heat_flux)TestingTo test the code you need to have pytest installed.pip install pytestInside the AgroMetEquations folder run the command:pytest |
agron-load | Load module of agron data collection microservices (is loaded to all functions to make connections to the API) |
agrossuite | Agros Suite - An application for solution of physical fieldsAgros Suite is a multiplatform application for the solution of physical problems based on the deal.II library, developed by the group at the University of West Bohemia in Pilsen. Agros Suite is distributed under the GNU General Public License.Supported Physical fieldsElectrostaticsElectric CurrentsMagnetic fieldHeat TransferStructural MechanicsAcousticsIncompressible FlowRF FieldKey FeaturesCoupled field solution with the possibility of weak and hard couplingNewton and Picard solvers for nonlinear problemsSteady state, harmonic, or transient analysisAutomatic space (h, p and hp) and time adaptivityTriangle and quad meshing using Triangle or GMSHCurvilinear elements and arbitrary level hanging nodesComputing of the trajectory of charged particles in electromagnetic fieldintuitive and powerful preprocessor and postprocessorvisualization of field variables, calculations of local values, surface and volume integralsscripting using Python |
agroutils | Failed to fetch description. HTTP Status Code: 404 |
agrspy | left blank |
agsadmin | agsadmin provides a convenient Python front-end to several REST calls on the ArcGIS Server 10.1+ REST Admin API.FeaturesArcGIS Server (RestAdmin)Services (Map/Image/Geoprocessing/Geometry/Geocode/GeoData/Globe/Search)start and stopget statisticsget statusget or set the item info (description, summary, tags, etc.)set service propertiesrename servicesMachinesstart and stopSystemDirectorieslist directoriesregister new directoriesunregister directoriesclean directoriesUploadslist uploadsget a specific upload itemupload a fileThese functions can be used to automate management of ArcGIS Services (e.g. start/stop services on a schedule,
start/stop services to perform maintenance on associated datasets, etc.)ArcGIS Portal (SharingAdmin)Contentget itemadd/get/move/delete/update user itemget user/folder contentCommunityget userget groupcreate groupupdate groupExampleThe following is a simplistic example to stop and start a map service.importagsadminhostname="<ServerNameHere>"username="<UsernameHere>"password="<PasswordHere>"rest_admin=agsadmin.RestAdmin(hostname,username,password)service=rest_admin.services.get_service("<MapServiceNameHere>","MapServer","<OptionalFolderHere>")service.stop_service()service.start_service()service.delete() |
agsci.blognewsletter | DescriptionA Blog/Newsletter product which is distilled from multiple PSU AgSci
products.Changelog0.1 (Unreleased)Initial version0.4 (PSE2012)Added testsFixed JavaScript in IE |
ags_client | Accessing GaaP Services ClientPython package providing a WSGI middleware for accessing GaaP services.Installationpip3installags_clientUsageRegistrationYou will need aclient IDandclient secretfrom the GaaP Identity Broker.
You can’t get these yet, but soon will by emailing us with a brief summary of:who you arewhat project you’re going to be using it onQuick StartFlaskFor example: given your Flask app is defined inwebservice.pyin a variable
namedapp, create a file calledwsgi.py:importagsfromwebserviceimportappapp.wsgi_app=ags.Client(app.wsgi_app)Then start your app with a WSGI server such as Gunicorn or uWSGI. Eg:gunicornwsgi:appConfigurationThe middleware looks for certain environment variables for settings. The
following variables areREQUIRED:AGS_CLIENT_ISSUERThe URL of the OIDC identity brokerAGS_CLIENT_IDThe client ID that you have been issuedAGS_CLIENT_SECRETThe client secret that you have been issuedAGS_CLIENT_AUTHENTICATED_PATHSComma separated list of paths in your web application that require
authentication. May include regular expressions.AGS_CLIENT_SIGN_OUT_PATHPath to sign out view in your application - default:sign-outThe following variables areOPTIONAL:AGS_CLIENT_DEBUGIf set toTrue, errors will be handled by the Werkzeug debugger. DO NOT
USE IN PRODUCTION!AGS_CLIENT_LOG_PATHLog to the specified file, in addition to consoleAGS_CLIENT_SESSION_COOKIEThe name of the cookie used to store the session ID - default:ags_client_sessionAGS_CLIENT_SESSION_SECRETThe secret key use to encrypt the session cookie - default: generates a new
secret on start-upNoteOverride this value when deploying across multiple hosts, otherwise
sessions may become invalid across requestsThe following variables can be used to override defaults, but usually should
not be used:AGS_CLIENT_CALLBACK_PATHOverrides default OIDC callback pathAGS_CLIENT_FEATURE_FLAG_COOKIEThe name of the cookie used to store the feature flag status - default:ags_client_activeAGS_CLIENT_FEATURE_FLAG_DEFAULTThe default state of the feature flag if the cookie is not set - default:TrueAGS_CLIENT_VERIFY_SSLIfFalse, verification of the broker’s SSL certificate is skippedUsageWhen activated, the middleware will intercept requests to the paths specified in
theAGS_CLIENT_AUTHENTICATED_PATHSenvironment variable and perform OpenID
Connect authentication before passing the user authentication details on to the
wrapped application.It will also intercept requests to theAGS_CLIENT_SIGN_OUT_PATHand end the
session on the identity broker before passing through to the wrapped
application.ActivationThe middleware is activated by default, unless theAGS_CLIENT_FEATURE_FLAG_DEFAULTenvironment variable is set toFalse.The middleware is activated or deactivated via a feature flag cookie, which can
be toggled by browsing to/toggle-feature/{FLAG}, where{FLAG}is the
value of theAGS_CLIENT_FEATURE_FLAG_COOKIEenvironment variable or the
default valueags_client_active.SupportThis source code is provided as-is, with no incident response or support levels.
Please log all questions, issues, and feature requests in the Github issue
tracker for this repo, and we’ll take a look as soon as we can. If you’re
reporting a bug, then it really helps if you can provide the smallest possible
bit of code that reproduces the issue. A failing test is even better!ContributingCheck out the latest master to make sure the feature hasn’t been implemented
or the bug hasn’t been fixedCheck the issue tracker to make sure someone hasn’t already requested
and/or contributed the featureFork the projectStart a feature/bugfix branchCommit and push until you are happy with your contributionMake sure your changes are covered by unit tests, so that we don’t break it
unintentionally in the future.Please don’t mess with setup.py, version or history.CopyrightCopyright © 2016 HM Government (Government Digital Service). See
LICENSE for further details. |
agsconfig | agsconfig ·agsconfig is a Python library for editing ArcGIS Server service configuration, either before deployment by editing a Service Definition Draft file (generated by either ArcMap, ArcGIS Pro, or via arcpy), or after deployment by editing the JSON configuration provided by ArcGIS Server (via the ArcGIS Server REST Admin API).This helps to programmatically configure services as part of automated service deployment or configuration patching processes.Installationagsconfig is made available on PyPi, simply install it withpip.> pip install agsconfigUsageagsconfig contains many classes to alter the configuration of different service types. However, it is not recommended these classes be instantiated directly. Helper functions are available in the top-level module to load different types of services with either Service Defintion Draft based configuration, or ArcGIS Server JSON configuration. These functions are:agsconfig.load_image_sddraftagsconfig.load_image_serviceagsconfig.load_map_sddraftagsconfig.load_map_serviceagsconfig.load_vector_tile_sddraftagsconfig.load_vector_tile_serviceEach function expects one or more file or file-like objects to be passed in. For functions dealing with Service Definition Drafts, only one file-like object is required. For ArcGIS Server JSON based functions, two are required, the first being the main service JSON, and the second being theItemInfoJSON. Each file should be opened in binary mode, and with write enabled if you wish to save the changes (as opposed to just reading settings). Save changes seeks the file-like object back to the beginning and overwrites the stream.Example: Load/Save a MapServer Service Definiton Draftimportagsconfigsddraft_path="path/to/MyService.sddraft"withopen(sddraft_path,mode="rb+")assddraft:map_service=agsconfig.load_map_sddraft(sddraft)# Edit your map service configurationmap_service.capabilities=[agsconfig.MapServer.Capability.map]map_service.min_instances=3map_service.max_instances=6map_service.summary="This is my awesome map service."map_service.kml_server.enabled=True# Save configuration changesmap_service.save()DevelopmentTo get started on developing agsconfig, simply fork the repository and get it with your favourite Git client. In the root of the repository is a standalone task runner,pie.py, that can excute tasks contained inpie_tasks.py.You'll need a Python install withpipandvirtualenv, but other than that, no pre-installed dependencies are necessary.On a shell, simply run the setup task as follows to create a virtual environment for development work:> python .\pie.py setupTo get a list of all available tasks, exceute the following:> python .\pie.py -l |
agsem-data-crawler | No description available on PyPI. |
ag-sensormodules | Sensor ModulesVersion =0.1dCreated:14/10/2019 20:30 UTC-8Author:Joshua Kim Rivera | email:[email protected] Sunga | email:InstallationCompilingpython setup.py bdist_wheelInstallationpip install .DependenciesNanPy |
agsi | No description available on PyPI. |
agspiel-python-api | AG-Spiel API für PythonDie ultimative Python API für dasAG-Spiel. Made by KingKevin23. (Aktuell benötigt man einen Premiumaccount um die API fehlerfrei zu benutzen. Bei entsprechender Nachfrage kann ich dies in zukünftigen Versionen beheben)InhaltsverzeichnisFeaturesInstallationBeispieleHinweiseFeatures:AG Kennzahlen ausgebenMarktdaten ausgebenInstallation:pip install agspiel-python-apiBeispiele:AG-Namen und CEO-Namen ausgeben lassen:importagspielapi=agspiel.api.Api("DEINE PHPSESSID")ag=api.get_ag(175353)print(ag.name)print(ag.ceo.name)>KingKompany>KingKevin23Weitere Beispiele und Hilfestellungen findest du in derDokumentation.Hinweise:Diese API oder dieses Projekt stehen in keinerlei Verbindung mit dem Betreiber des Spiels, sondern stellen ein
unabhängiges Userprojekt dar. Desweiten müssen bei allen Projekten, die durch diese API ermöglicht werden oder in denen
diese API eingesetzt wird, dieoffiziellen Regelndes AG-Spiels
beachtet werden. Hierzu zählt insbesondere §5, der im folgenden nochmals zitiert wird:Das Benutzen von Programmen/Bots, die einen Spielvorteil ermöglichen, Funktionen bieten die sich mit Premiumfeatures
überschneiden oder hohe Serverbelastungen erzeugen (z.B. Parsen der Seite mit mehr als einem Aufruf pro Sekunde),
ist verboten. Die Bewerbung/Verbreitung von Browserplugins oder anderer clientseitiger Software zur
Erweiterung/Veränderung der Webseite ist verboten.Bei Fragen zur Legalität des persönlichen Projektes mit dieser API, sollte man sich im Zweifel an die Börsenaufsicht des
AGS wenden (Hier). |
agssearch | Python client for the official German directory of cities by DeStatis,
called “Gemeindeverzeichnis“. Allows
you to look up the official city key (“Amtlicher Gemeindeschluessel”, in
brief: AGS) for a city name and vice versa.Note that the AGS is still in common use, but to be replaced by the
“Regionalschluessel” (RS). Read more in the German Wikipedia pageAmtlicher
Gemeindeschluessel.Installpip install agssearchUse in your codeFinding the AGS for a city:>>> import agssearch.agssearch as ags
>>> result = ags.search("Bonn")
>>> for r in result:
>>> print r['ags'], r['name']
05314000 Stadt Bonn
08337022 VVG der Stadt Bonndorf im Schwarzwald
08337022 Stadt Bonndorf im SchwarzwaldLook up an AGS:>>> import agssearch.agssearch as ags
>>> result = ags.lookup("05314000")
>>> if result is not None:
>>> print result['ags'], result['name']
05314000 Stadt BonnUse as command line client$ agssearch Bonn
[05314000] Stadt Bonn, Bonn, Stadt, Nordrhein-Westfalen
[08337022] VVG der Stadt Bonndorf im Schwarzwald, Waldshut, Baden-Wuerttemberg
[08337022] Stadt Bonndorf im Schwarzwald, Waldshut, Baden-Wuerttemberg
$ agssearch 05314000
[05314000] Stadt Bonn, Bonn, Stadt, Nordrhein-WestfalenLike agssearch?Feel free totip me! |
agstd | No description available on PyPI. |
agstoolbox | AGS Toolbox is a PyQt tool to manage different versions of the
Adventure Game Studio Editor, side by side, along with your
game projects!Windows install and runIn Windows, install Python 3, and then opencmd.exeand type (press enter after):python -m pip install agstoolboxTo run, you can type the following incmd.exeor therun…promptpython -m agstoolbox |
ags_tool_deploy | OverviewThis tool provides a command-line interface for packaging and publishing
python toolboxes to ArcGIS Server (10.2.x).InstallationTo install the latest stable version:pip install python-agsLatest changes:pip install https://bitbucket.org/databasin/ags_tool_deploy/get/develop.zip#egg=ags_tool_deployInstalling manually:Download the latest changes from thedevelop
branch,
extract, and executepython setup.py installThis will install the script to your local python packages folder asags_tool_deploy/deploy.pyConsider adding this folder to your PATH.UsageThis tool is intended to be run from within a console.For information on usage, simply runpython deploy.py --helpThe commands below allow you to include Mercurial repository
information. This does not bundle the full repository, but instead
includes the link to the source repository and current branch, so that
you can runhg pull --updateon the server to pull down the full repository.PackagingUse thepackagecommand to bundle your python toolbox into a service
definition (*.sd) file.Usage: deploy.py package [OPTIONS] <toolbox_path> <service_name> <outfile_name>
Package a python toolbox into a service definition file (*.sd). Local
python modules this toolbox references are included automatically.
Requires 7Zip to be installed and on the system PATH.
WARNING: this will overwrite the file <outfile_name> if it already exists.
Aguments:
<toolbox_path>: Filename of python toolbox (*.pyt) to deploy
<service_name>: Name of service, including folder(s). Example: SomeFolder/MyTool
<outfile>: Name of the service definition file to create
Options:
--files <files> Wildcard patterns of additional files to
include (relative to toolbox). Example:
*.csv,some_data.*
--hg Include Mercurial (hg) repository
information?
--sync Execute tool synchronously instead of
asynchronously (default)
--messages [None|Info|Error|Warning]
Level of messaging for service
--help Show this message and exit.PublishingUse thepublishcommand to deploy your python toolbox to an ArcGIS
server.Usage: deploy.py publish [OPTIONS] <toolbox_path> <service_name> <server:port> <user>
Publish a python toolbox to an ArcGIS server. Local python modules this
toolbox references are included automatically. Requires 7Zip to be
installed and on the system PATH.
Aguments:
<toolbox_path>: Filename of python toolbox (*.pyt) to deploy
<service_name>: Name of service, including folder(s). Example: SomeFolder/MyTool
<server:port>: Hostname and port number of ArcGIS server
<user>: ArcGIS server administrator user name
Options:
--password <password> ArcGIS administrator password. You will be
prompted for this if you do not provide it
--files <files> Wildcard patterns of additional files to
include (relative to toolbox). Example:
*.csv,some_data.*
--hg Include Mercurial (hg) repository
information?
--sync Execute tool synchronously instead of
asynchronously (default)
--messages [None|Info|Error|Warning]
Level of messaging for service
--overwrite Delete and replace the service, if it
already exists?
--help Show this message and exit.Requirements:lxmlclickags (from:https://bitbucket.org/databasin/python-ags)7Zip: must be installed manually from7Zip
websiteAssumptionsonly Python 2.7 is supportedonly tested on Windowsonly ArcGIS 10.2.x is supportedLicenseSee LICENSE file. |
agstools | UNKNOWN |
agstream | AgspStreamAgriscope data interface for pythonThis module allows to get data from yours Agribases programmatically
Data are retreived as an Pandas DatagramsThe development map will introduce data computing capabilities, to enhance
data analysis comming from agricultural field.What's New(2023/05) v2.0.12 : - syntax error correction when something dirty is coming(2022/09) v2.0.10 : - add excluded_virtual_types_pattern to exclude some virtual
on demand
- Add some robust thing agains dirty event (DST switch, sensor id move)(2022/09) v2.0.9 : Use Https(2022/01) v2.0.8 : Bug correction in logger(2022/01) v2.0.7 : Add a retry API when something wrong seems to be there(2022/01) v2.0.6 : Improve capabilities to select virtual datasources to update(2022/01) v2.0.0 : Add capabilities to get virtual datasources(2021/06) v1.0.4 : Again optimize exception reporting when server is not joinable(2021/06) v1.0.3 : Optimize exception reporting when server is not joinable(2021/03) v1.0.2 : Optimize sensor data retrieving(2020/09) v0.0.13 : Better support of module and sensor position(2020/01) v0.0.12 : export some internals methods(2019/09) v0.0.10 : solve some display problems(2019/08) Porting to python 3(2018/05) Add functionnal information on Agribases (type, sampling)(2018/05) Solve bug on from, to date(2018/02) First versionDependenciesAgstream is written to be use with python 3
It requires Pandas (>= 0.12.0)::pip install pandasInstallationspip install agstreamUses casescode :from agstream.session import AgspSession
session = AgspSession()
session.login("masnumeriqueAgStream", "1AgStream", updateAgribaseInfo=True)
session.describe()
for abs in session.agribases :
print ("****************************************")
print (abs)
df = session.getAgribaseDataframe(abs)
print (df.tail())
print("Fin du programme")Output :**************************************************
* Example 1 : simplest way to get data
* get the data, and feed an xlsfile
**************************************************
****************************************
Compteur Mourvedre Rang 9(2301) AGRIBASE3S_STC SIGFOX containing 3 sensors
Récuperation de 864 données
compteur d'eau alimentation #4 humectation foliaire
2021-03-28 14:18:28+02:00 0.0 3.312 0.0
2021-03-28 14:33:29+02:00 0.0 3.316 0.0
2021-03-28 14:48:29+02:00 0.0 3.318 0.0
2021-03-28 15:03:29+02:00 0.0 3.314 0.0
2021-03-28 15:18:29+02:00 0.0 3.310 0.0
Ecriture des données dans le fichier Compteur Mourvedre Rang 9.xlsx
****************************************
Debitmetre Grenache Rang 10(2299) AGRIBASE3S_STC SIGFOX containing 3 sensors
Récuperation de 39 données
humectation foliaire compteur d'eau alimentation #4
2021-03-31 11:07:31+02:00 0.0 0.0 0.000
2021-03-31 11:22:20+02:00 0.0 0.0 3.298
2021-03-31 11:37:20+02:00 0.0 0.0 3.299
2021-03-31 11:52:20+02:00 0.0 0.0 3.298
2021-03-31 12:07:20+02:00 0.0 0.0 3.301
Ecriture des données dans le fichier Debitmetre Grenache Rang 10.xlsxCode for UTC:from agstream.session import AgspSession
session = AgspSession(timezoneName='UTC')
session.login("masnumeriqueAgStream", "1AgStream", updateAgribaseInfo=True)
session.describe()
for abs in session.agribases :
print ("****************************************")
print (abs)
df = session.getAgribaseDataframe(abs)
print (df.tail())
print("Fin du programme")Output :**************************************************
* Example 1 : simplest way to get data
* get the data, and feed an xlsfile
**************************************************
****************************************
Compteur Mourvedre Rang 9(2301) AGRIBASE3S_STC SIGFOX containing 3 sensors
Récuperation de 864 données
compteur d'eau alimentation #4 humectation foliaire
2021-03-28 12:18:28+00:00 0.0 3.312 0.0
2021-03-28 12:33:29+00:00 0.0 3.316 0.0
2021-03-28 12:48:29+00:00 0.0 3.318 0.0
2021-03-28 13:03:29+00:00 0.0 3.314 0.0
2021-03-28 13:18:29+00:00 0.0 3.310 0.0
Ecriture des données dans le fichier Compteur Mourvedre Rang 9.xlsx
****************************************
Debitmetre Grenache Rang 10(2299) AGRIBASE3S_STC SIGFOX containing 3 sensors
Récuperation de 39 données
humectation foliaire compteur d'eau alimentation #4
2021-03-31 09:07:31+00:00 0.0 0.0 0.000
2021-03-31 09:22:20+00:00 0.0 0.0 3.298
2021-03-31 09:37:20+00:00 0.0 0.0 3.299
2021-03-31 09:52:20+00:00 0.0 0.0 3.298
2021-03-31 10:07:20+00:00 0.0 0.0 3.301
Ecriture des données dans le fichier Debitmetre Grenache Rang 10.xlsx |
agt | Agent (agt)Agent is a high-level toolkit for building chatbots using conversational components.
Try Agent if you want to make your chatbot modular using composable components.InstallationGetting StartedChannelsNLUInstallation# optional: create a virtual environmentpython3-mvenvmyvenvsourcemyvenv/bin/activate# install agtpip3installagtAdditional dependeciesYou may want to install dependencies to connect to channels such as telegram and discord or share components on cocohub.Available dependeciesdiscord - to connect your bot/component to discordtelegram - to connect your bot/component to telegrammsbf - to connect your bot/component to microsoft bot frameworkvendor - publish component on cocohubdsl - Hy DSL for nicer syntax when building components/nluExamples:pipinstallagt[telegram]# or for multiple dependeciespipinstallagt[telegram,dsl]Getting StartedCreate your first botAgent components are python coroutines (note theasync def)We takestateas the first parameter - which is an object that allow us to interact with the environment the component/bot is running onasyncdefmybot(state):# state.user_input() waits for the next user inputuser_input=awaitstate.user_input()# state.say sends a responseawaitstate.say(user_input)Paste this code in a file called example.pyTry it in the terminalpython3-magtexample.mybotChannelsConnecting to channels is easy and just requires using regular Agent componentsTelegramMake sure to install agt with telegram support -pip install agt[telegram]Create a new bot and get telegram token from Telegram botfather using this guide:https://core.telegram.org/bots#6-botfatherexportTELEGRAM_TOKEN=<Yourtelegrambottoken>
python3-magt.channels.telegramexample.mybotDiscordMake sure to install agt with discord support -pip install agt[discord]Create a new bot account and get a token using this guide:https://discordpy.readthedocs.io/en/latest/discord.htmlexportDISCORD_KEY=<Yourdiscordbottoken>
python3-magt.channels.discordexample.mybotMicrosoft bot frameworkMake sure to install agt with microsoft bot framework support -pip install agt[msbf]exportMicrosoftAppId=<YourbotMicrosftAppId>exportMicrosoftAppPassword=<YourbotMicrosoftAppPassword>
python3-magt.channels.msbfexample.mybotBasic Language UnderstandingInside agt.nlu we have simple patterns to regex compiler to perform basic understanding tasksCompile simple word patterns to regexSome Examples:intent=Intent(Pattern("the","boy","ate","an","apple"))assertintent("the boy ate an apple")==Trueassertintent("the boy ate an orange")==Falseintent=Intent(Pattern("the","boy","ate","an",AnyWords(min=1,max=1)))assertintent("the boy ate an apple")==Trueassertintent("the boy ate an orange")==Trueintent=Intent(Pattern("the",Words("boy","girl"),"ate","an",AnyWords(min=1,max=1)))assertintent("the boy ate an apple")==Trueassertintent("the boy ate an orange")==Trueassertintent("the girl ate an orange")==Trueassertintent("the girl ate a banana")==Falseintent=Intent(Pattern("the",("boy","girl"),"ate",WordsRegex(r"an?"),AnyWords(min=1,max=1)))assertintent("the boy ate an apple")==Trueassertintent("the boy ate an orange")==Trueassertintent("the girl ate an orange")==Trueassertintent("the girl ate a banana")==Trueassertintent("a nice boy ate an apple")==Falseintent=Intent(Pattern(WILDCARD,Words("boy","girl"),"ate",WordsRegex(r"an?"),AnyWords(min=1,max=1)))assertintent("a nice boy ate an apple")==TruePatterntakes sentence elements and translate each one to optmized regular expression.Intentgroups multiple patterns so if any of the patterns match the intent evals toTrue |
agtl | AGTL, the all-in-one solution for on- and offline geocaching, makes geocaching paperless!
It downloads geocaches including their description, hints, difficulty levels and images. No premium account needed. Searching for caches in your local db is a matter of seconds.
.
- Map view - supporting Open Street Maps and Open Cycle Maps by default, configurable for other map types, including google maps.
- GPS view - shows the distance and direction to the selected geocache.
- Cache details - all necessary details are available even in offline mode.
- Paperless geocaching features - take notes for a geocache on the go, see the hints and spoiler images, check the latest logs.
- Multicache calculation help - Let your phone do the math for you. Working for the most multi-stage geocaches, AGTL finds the coordinate calculations and let you enter the missing variables. (N900 only)
- Fieldnotes support - Ever came home after a long tour and asked yourself which geocaches you found? Never again: Log your find in the field and upload notes and log text when you’re at home. Review them on the geocaching website and post the logs.
- Text-to-Speech-Feature! - Select a target, activate TTS and put your headphones on to enjoy completely stealth geocaching. (N900 only)
- Download map tiles for selected zoom levels - for offline use.
- Advanced waypoint handling - AGTL finds waypoints in the geocache descriptions, in the list of waypoints and even in your notes. For your convenience, they’re displayed on the map as well - see where you have to go next.
- Search for places - in the geonames.org database to navigate quickly. (N900 only)
- Sun compass - Compensates the lack of a magnetic compass. (N900 only)
- Instant update feature - Follow web site updates as soon as possible.
.
AGTL is Open source and in active development. |
agtool | Algorithm ToolsThis library serves useful algorithm tools for python. 😄Anyone can be install this library from pypi from this link:https://pypi.org/project/agtool/pip install agtoolQ. How to manage packages? see fromTo DoThis check lists will be implemented soon. 🔥negative sampling: draw negative samples from rating matrix.DeployDeploy to pypi as follows. 🥳# setup.py version up
# doc/conf.py version up
python setup.py bdist_wheel
python -m twine upload dist/*.whlDocumentationUpdate documentation using sphinx.sphinx-apidoc -f -o docs agtoolAnd then,cd docs && make html.Serving the documetation.sphinx-autobuild --host [IP] --port [PORT] docs docs/_build/html |
agt-server | CS1440 AGT ServerIntroductionTheAGT Serveris a python platform designed to run and implement game environments that autonomous agents can connect to and compete in. Presently the server only supportsComplete Information and Incomplete Information Matrix Games (e.g. Rock-Paper-Scissors, BotS, etc...)However, at its core the server is also designed to be flexible so that new game environments can be easily created, modified, and adjusted.Getting StartedInstallationEnsure that you have the latest version of pip installedFirst clone the respositiorygit clone https://github.com/JohnUUU/agt-server-remastered.gitPlease create a virtual environment firstpython3 -m venv .venv
source .venv/bin/activateFor Userspipinstall--upgradepip
pipinstallagt_serverFor DevelopersIn the root directory, install the project in an editable statepipinstall--upgradepip
pipinstall-e.
pipinstall-rrequirements.txtUsageFrom here you can start a server insrc/serverby runningpython server.py [server_config_file] [--ip [ip_address]] [--port [port]]Then you can run any of the example agents insrc/agt_agents/test_agentsby runningUsage:
python [agent_file].py [name] [--join_server] [--ip [ip_address]] [--port [port]]Or you can write a agent file that implements any of thesrc/agt_agents/base_agentsand then useagent.connect(ip, port)Frequently Asked QuestionsWhat do each of the options in the server configurations do?
Here is a quick description of each of the server configuration options.game_name: The name of the game being playedgame_path: The Python import path for the game modulenum_rounds: The number of rounds to be played in the gamesignup_time: The duration (in seconds) allowed for players to sign up before a game starts (60 seconds tends to work best for Lab)response_time: The maximum time (in seconds) allowed for each player to respond with their movenum_players_per_game: The number of players required in each gameplayer_types: The list of available player types in the game. This can be used to specify different permissions for each player and also can be used flexibly to change the rules for different players inside the game_path file.permissions: This is a dictionary of permissions for each player type restricting the amount of information that each player will recieve at the end of each round.allmeans that the player will recieve all information. All other key words correspond to specific information sent each round likemy_action,opp_action,my_utils,opp_utils, etc...If you wish to change or add more permissions please edit the corresponding game underserver/gamesand the corresponding agent underagents/base_agentstype_configurations: The configuration for player type combinations, if it'sall, then every combination of player types will be played for each game. Otherwise, it can be specified to be a list like [[type1,type2], [type1,type1]] for example so that player 1 will always be type 1 and play against player 2 as both type 1 and type 2.invalid_move_penalty: The penalty for submitting an invalid movedisplay_results: Flag indicating whether to display/print the game resultssave_results: Flag indicating whether to save the game resultssave_path: Ifsave_resultsis set to true, then this is the path where the game results should be savedsend_results: Flag indicating whether to send the game results to the agentscheck_dev_id: Flag indicating whether to check the device ID so that each device can only connect once. This is to stop collusion bots.What purpose do the local arenas serve?The local arenas allow you to run the games locally and allow the user to be able to catch exceptions and invalid moves ahead of time, as well as test out their agent.I cant run rps_test.sh or any of the other .sh test filesUnfortunately this is currently only supports Mac'sterminal.app. If you are using the Mac terminal then make sure tochmod +xthe shell command before running it.You may also need to change the IP address of each agent to be the ip address of your computers hostname as well.I am recieving an error concerning my hostnamePlease find your ip address usingifconfig(Mac) oripconfig(Windows) underen0oreth0. Find your hostname usingecho $HOSTand then set the host in\etc\hosts. That usually fixes the problem.Alternatively if that doesn't work you can just supply the ip address that you found to server.py when you run it using the optional--iparguement.This is mostly a bandaid solution by overriding the hostname locally and you'll have to do it everytime the ISP switches, if anyone has more experience with DNS resolution and wants to help please reach out!What if the server hangs for some unexpected reason?These things can be hard to debug but the backup solution is that the server code will catch any interrupts (^C) commands
that you give it and return the currently compiled results to the best of its ability so that the agents will know who was winning at that point. |
agu | No description available on PyPI. |
agua | # AguaA system that helps you test the coverage and accuracy of your data
applications.InstallationpipinstallaguaExample UsagecdexampleaguatestTestresultsforexample.csvColumn:namevsfinal_nameCoverage(3/4):▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇75.00%Accuracy(2/3):▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇66.67%Column:agevstest_ageCoverage(4/4):▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇100.00%Accuracy(4/4):▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇100.00%Column:fruitvstest_fruitCoverage(4/4):▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇100.00%Accuracy(4/4):▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇▇100.00%ConfigurationCheck outexample/agua.ymlfor configuration options.To compare columns, you may use one of the existing comparators or
specify a python path to a callable. Check outagua/comparators.pyfor example comparators.List built-in comparators with,agualistAny keyword arguments that need to be passed to the comparator may be
specified with akwargsparameterGraphs are printed with a slightly modified version oftermgraph |
aguaclara | aguaclaraaguaclarais a Python package developed byAguaClara CornellandAguaClara Reachfor designing and performing research on AguaClara water treatment plants. The package has several main functionalities:DESIGNof AguaClara water treatment plant componentsMODELINGof physical, chemical, and hydraulic processes in water treatmentPLANNINGof experimental setup for water treatment researchANALYSISof data collected byProCoDA(process control and data acquisition tool)InstallingTheaguaclarapackage can be installed from Pypi by running the following command in the command line:pipinstallaguaclaraTo upgrade an existing installation, runpipinstallaguaclara--upgradeUsingaguaclaraaguaclara's main functionalities come from several sub-packages.Core: fundamental physical, chemical, and hydraulic functions and valuesDesign: modules for designing components of an AguaClara water treatment plantResearch: modules for process modeling, experimental design, and data analysis in AguaClara researchTo useaguaclara's registry of scientific units (based on thePint package), usefrom aguaclara.core.units import u. Any other function or value in a sub-package can be accessed by importing the package itself:Example Usage: Designimportaguaclaraasacfromaguaclara.core.unitsimportu# Design a water treatment plantplant=ac.Plant(q=40*u.L/u.s,cdc=ac.CDC(coag_type='pacl'),floc=ac.Flocculator(hl=40*u.cm),sed=ac.Sedimentor(temp=20*u.degC),filter=ac.Filter(q=20*u.L/u.s))Example Usage: Core# continued from Example Usage: Design# Model physical, chemical, and hydraulic propertiescdc=plant.cdccoag_tube_reynolds_number=ac.re_pipe(FlowRate=cdc.coag_q_max,Diam=cdc.coag_tube_id,Nu=cdc.coag_nu(cdc.coag_stock_conc,cdc.coag_type))Example Usage: Researchimportaguaclaraasacfromaguaclara.core.unitsimportuimportmatplotlib.pyplotasplt# Plan a research experimentreactor=ac.Variable_C_Stock(Q_sys=2*u.mL/u.s,C_sys=1.4*u.mg/u.L,Q_stock=0.01*u.mL/u.s)C_stock_PACl=reactor.C_stock()# Visualize and analyze ProCoDA dataac.iplot_columns(path="https://raw.githubusercontent.com/AguaClara/team_resources/master/Data/datalog%206-14-2018.xls",columns=[3,4],x_axis=0)plt.ylabel("Turbidity (NTU)")plt.xlabel("Time (hr)")plt.legend(("Influent","Effluent"))The package is still undergoing rapid development. As it becomes more stable, a user guide will be written with more detailed tutorials. At the moment, you can find some more examples in specific pages of theAPI reference.ContributingBug reports, features requests, documentation updates, and any other enhancements are welcome! To suggest a change,make an issuein theaguaclaraGithub repository.To contribute to the package as a developer, refer to theDeveloper Guide. |
aguaclara_research | No description available on PyPI. |
aguantest | No description available on PyPI. |
aguan-test | No description available on PyPI. |
aguan-testpip-installs | No description available on PyPI. |
aguiardafa-libpythonpro | projetopytoolsProjeto criado para estudo sobre Python no curso PyToolsCurso PyTools da PythonproMódulo para exemplificar construção de projetos Python no curso PyToolsNesse curso é ensinado como contribuir com projetos de código abertoLink para o cursoPython ProSuportada versão 3 de PythonPara instalar:python3 -m pip install pipenvpipenv sync --devPara conferir qualidade de código:pipenv run flake8Tópicos a serem abordados:GitVirtualenvPipPytestCodecovPipenv |
agung96tm-funniest | To use (with caution), simply do:>>> import agung96tm_funniest
>>> print agung96tm_funniest.joke() |
agunua | AgunuaAgunua is a Python library for the development of Gemini clients.InstallationYou need Python 3,netaddr,PySocksandPyOpenSSL. You
can install the dependencies with pippip3 install agunua.Usageimport Agunua
...
u = Agunua.GeminiUri(url)
print(u)Parameters in theGeminiUri()constructor (you can find their
default values at the beginning of the fileAgunua/__init__.py):url: the URL to loadinsecure: accept invalid certificates (signed by unknown CA, for
instance)tofu: performs TOFU (Trust On First Use) validation. It is a
string, not a boolean. If empty, we disable TOFU. Otherwise, it is
the directory of TOFU data.accept_expired: accept expired certificates (insecure = Trueis
not sufficient for that)get_content: retrieve the actual resource (default is to get
metadata only)parse_content: if it is gemtext (text/gemini), parse and extract
linksmaxlines: if it is text, maximum number of lines retrieved. Set to
None if you don't want a limitmaxsize: maximum size in bytes to retrieve. Set to
None if you don't want a limitbinary: (automatic if the content is text). Retrieve as binary
content, don't play with end-of-linesfollow_redirect: automatically follow Gemini redirectionsredirect_depth: maximum number of redirections followedignore_missing_tls_close: ignore the lack of a proper TLS close (may lead to truncation attacks but many Gemini servers don't send it)iri: handle IRI (URI in Unicode)force_ipv4: use the IPv4 protocol onlyforce_ipv6: use the IPv6 protocol onlysend_sni: send the TLS Server Name Indicationconnect_to: use the host name in the URI for the Gemini request but
connect only to this host (name or address). Useful when the host is
multihomed.clientcert: the filename of a client certificate that will be sent
to the server.clientkey: the filename of the private key of the above
certificate.use_socks: use a SOCKS5 proxy (for instance for.onioncapsules). The value must be a tuple (socks proxy name, socks proxy port).If the URL is invalid (wrong syntax), you won't get aGeminiUriobject. If you get one, it does not mean the resource has been
retrieved successfully. See the attributenetwork_successfor that,
and then the attributestatus_code(that you have to interpret
yourself, in most cases).Attributes ofGeminiUriobjects (not all of them will always be
present; for instance, if you did not ask to get content, you won't
have an attributesize; if the status code is not 20 - OK - you
won't get a mediatype; etc):network_success: resource was retrieved successfullystatus_code: if retrieved successfully, the Gemini two-digit
status codeerror: ifnetwork_successis false, this is the reasonip_address: IP address used for the retrieval (except is SOCKS was used)meta: themetafield of the Gemini protocol. It depends on the
status code. Read the Gemini specification for detail.binary: if you asked for binary access, it will be True. If you
asked for text access (binary=False in the constructor) and asked to
ge the content (get_content=True), it will be set to False if
decoding went well and True if the decoding failed, for instance
because the file did not match the announced "charset".links: an array of the links found in the document (if you've setparse_content)payload: the contentsize: the size of the payload. Since Gemini does not have a way to
indicate at the beginning the payload size, this will be obtained
only ifget_contentis true, and it will be limited by the
parametermaxsizemediatype: the media type (MIME type) of the resource, such astext/geminiorimage/jpeglang: the human language of the resource, as standardized inBCP 47charset: actually the encoding of the resource such as UTF-8 or US-ASCIItls_version: the TLS version, for instance, "TLSv1.3"no_shutdown: [DEPRECATED See https://framagit.org/bortzmeyer/agunua/-/issues/50] set to True if the server did not properly close the TLS session. It may mean that the content was truncated. Meaningful only withget_content=Trueand if you asked for the whole file.possible_truncation_issue: set to True if we got a TLS error which may indicate that the data were truncated.The rest is related to certificates:issuer: the CA (Certificate Authority)subject: the name in the certificate (X.509 calls it "subject")expired: the certificate has expiredcert_not_after: expiration datecert_not_before: inception datecert_algo: algorithm used by the CAcert_key_type: algorithm of the public keykeystring: the public keycert_key_size: size of the public keyFor an example, seesample-client.py. (In the source code, the test suite undertests/is also a good way to learn about how to use the library.) Agunua is used in theManisha monitoring tooland in theLupa crawler.Command-line clientagunuais a simple Gemini command-line client, a bit like curl. Seeits documentation. Most parameters of the libraryGeminiUri()constructor can be set via options. Important: the
default value is not always the same with the command-line tool. For
instance, it defaults to actually retrieving the content.Download an entire capsuleAnother command-line client,geminitrack, allows you to retrieve an entire capsule, for instance for backups. Seeits documentation.NameAgunua is a melanesian serpent god. Caduceus would have been better
for a Python + Gemini project since there are two snakes on a caduceus
but it was already used.LicenseGPL. See LICENSE.Recent changesSee the file CHANGES.AuthorsStéphane [email protected] sitehttps://framagit.org/bortzmeyer/agunua/Use the Gitlab issue tracker to
report bugs or wishes. But you can of course also access it with
gemini at gemini://gemini.bortzmeyer.org/software/agunua/Other Gemini clients in Pythonhttps://tildegit.org/solderpunk/gemini-demo-1Very simple but working clienthttps://github.com/cbrews/ignitionModelled on therequestslibrary so very convenient for programmershttps://git.carcosa.net/jmcbray/gusmobile/Good codehttps://git.sr.ht/~fkfd/picrosshttps://github.com/apellis/pygeminiNo longer maintained |
agutil | agutilA collection of python utilitiesVersion:Tools:search_range (A utility for manipulating numerical ranges)status_bar (A simple progress bar indicator)Logger (A class for fast, simple, logging)ActiveTimeout (A class for enforcing a timeout for a set of operations)Several standalone utility methods (See theagutil module pageon the wiki)Theiopackage:Socket (A low-level network IO class built on top of the standard socket class)SocketServer (A low-level listen server to accept connections and return Socket classes)MPlexSocket (A low-level network IO class which multiplexes I/O through multiple channels. Threadless version ofQueuedSocket)Theparallelpackage:parallelize (A decorator to easily convert a regular function into a parallelized version)parallelize2 (A similar parallelization decorator with a slightly different flavor)IterDispatcher (Logical backend for dispatching calls with parallelize)DemandDispatcher (Logical backend for dispatching calls with parallelize2)ThreadWorker (Task management backend for dispatching parallel calls to threads)ProcessWorker (Task management backend for dispatching parallel calls to processes)Thesecuritypackage:SecureSocket (A mid-level network IO class built to manage encrypted network communications)SecureConnection (A high-level, multithreaded class for sending and receiving encrypted files and messages)SecureServer (A low-level listen server to accept connections and return SecureConnection instances)agutil-secure (A command line utility for encrypting and decrypting files)EncryptionCipher and DecryptionCipher (Twin classes for agutil's modular encryption format)Several other utility functions and classes for encrypting and decrypting dataDocumentation:Detailed documentation of these packages can be found on theagutil Github wiki page |
aguy11 | Aguy11 Useful PackageThis is a package used to find stuff that might take you a while to find otherwise.Aguy11 Advice FunctionThis is a function that gives you a slip of advice from an API that can be found here:https://api.adviceslip.com/adviceIt takes one parameter, display which is a bool that either prints the advice to the terminal or not. It is called by a .advice() function.Aguy11 AsciiMake FunctionThis is a not-yet-complete function that can find ASCII for the following:A fish: Use 'fish' for model parameterA cat: Use 'cat' for model parameterA wolf: Use 'wolf' for model parameterAn egyptian Queen: Use 'egypt' for model parameterYoda: Use 'yoda' for model parameterPikachu: Use 'pikachu' for model parameterThis function takes two parameters: The aforementioned model parameter that finds your model, and the also aforementioned display parameter.This function can be called by an .asciimake() function.Volume FunctionThis is a simple function that takes for parameters: x, y, z, display. If you read the above you know what display is and the other parameters are the x, y, and z axis lengths of the model. This function finds the volume of an object, and can be called by a .volume() functionAstros_CurrentThis is another simple function that finds the number of astronauts currently in space. It takes the familiar display parameter and can be called by a .astros_current() function.Rhyme FunctionThis function can rhyme words using an API. It takes two parameters: word, and display. You already know what display is, and word is your word test subject. It can be called by a .rhyme() function.Lastly, the corona function.This function finds a few things about the coronavirus statistics of a state:Number of people confirmed (Found at index 0 of the result)Number of people who died (Found at index 1 of the result)Number of people tested (Found at index 2 of the result)
This function, as you might understand returns its result in a list. It takes two paramenters:State: The initials of the state you want to find out aboutDisplay: Responsible for whether or not you want to print your resultThis function can be called by a .corona() function. |
agvarannot | Test Project Package |
agv-fact | READMECambios en esta versiónVersion 1.0.1.0Se agrega la versión 4.0 de facturaciónSe modifica el data que recibe la libreria para el timbradoNueva información en el data para poder timbrarLink |
agview | No description available on PyPI. |
agvis | LTB AGVisGeographical visualizer for energy system.LatestStableDocumentationWhy AGVisAGVis is a geovisualization tool that facilitates the visualization oflarge-scale real-timepower system simulation.AGVis visualizing the entire North America system topology:AGVis visualizing the WECC system:Quick StartAGVis runs on Linux or Windows, a quick start guide is available atQuick StartCiting AGVisIf you use AGVis for research or consulting, please cite the following publications in your publication:Parsly, N., Wang, J., West, N., Zhang, Q., Cui, H., & Li, F. (2022). "DiME and AGVIS A Distributed Messaging Environment and Geographical Visualizer for Large-scale Power System Simulation". arXiv.https://doi.org/https://arxiv.org/abs/2211.11990v1Please refer asLTB AGVisfor the first occurence and then refer asAGVis.Sponsors and ContributorsThis work was supported in part by the Engineering Research Center
Program of the National Science Foundation and the Department of Energy
under NSF Award Number EEC-1041877 and the CURENT Industry Partnership
Program.This work was supported in part by the Advanced Grid Research and Development Program
in the Office of Electricity at the U.S. Department of Energy.AGVis is originally developed by Nicholas West and currently developed and maintained by Nicholas Parsly.See [GitHub contributors][GitHub contributors] for the contributor list.LicenseAGVis is licensed underGPL v3 License |
agvtool_port | Automating Version and Build NumbersBased on:https://developer.apple.com/library/archive/qa/qa1827/_index.htmlInstallationpip3 install agvtool_portUsageagvtool new-version -all 1722agvtool new-marketing-version 1.0.0agvtool what-versionagvtool what-marketing-versionTODOInterpret options for new version commandsValidate file if it is in invalid format |
agw | No description available on PyPI. |
agwui | # SampleCodesample.py |
agx | AGX DynamicsThe purpose of this package is to enable other packages to depend on the the AGX Dynamics version that is installed and used locally.You should not install this package from pypi.orgInstead, after installing AGX Dynamics, do:On Windows:setup_env.bat
pip install %AGX_DATA_DIR%/agx-pypiOn OSX, Linux:sourcesetup_env.sh
pip3install$AGX_DATA_DIR/agx-pypiYou may now go ahead andpip installthe package(s) depending on AGX. Pip versioning will make sure the correct one is installed.Why you should not install this packageAGX Dynamics will be available via pip, but until then:To get started – apply for afree trialWe also recommend taking a look at thedocumentationfor AGX Dynamics.If you need additional support we provide training courses and onboarding packages to help you succeed with your project. Pleasecontact usfor more information.If you already have a license file you candownload AGX Dynamics. |
agxBrick | agxBrickagxBrick is a python package (with C# runtime implementation) for loading Brick.yml files withAGX Dynamics.The development of agxBrick has come to an end, since the ReBRICK C++ project will replace and go beyond the experience of "old" BRICK.This distributable is free to use for anyone, but do not expect any additional features or bugfixes.LicenseApache License 2.0 |
agxclick | agxclickagxclick usespclick,AGX DynamicsandagxBrickto a implement a simulation application that implements Click out of the box for a provided Brick model.You can use click_application.py (see below) to load any Brick model and it will find the robots and connect their signals to Click. See Brick Model Requirements below for more info.You can Inherit agxclick.ClickApplication and override it's methods to customize your own application.You can connect with any Click client to the simulation.The flow is the same as for ClickClient controller connects and sends HandshakeInitServer responds with HandshakeClient receives Handshake and validates the setup.Client sends ControlMessageServer steps Simulation, and responds with SensorMessageThe loop 4-5 is repeated.NOTE: The Controller step and the simulation step is in full sync, meaning that the simulation will only progress on ControlMessages.InstallPrerequisites: AGX and agxBrick# Latest versionpipinstallagxclick-U# Specific versionpipinstallagxclick==0.3.0Usage ExamplesVisit theGitHub repofor usage examples.LicenseApache License 2.0 |
agx.core | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] version output of generator listing inIConfLoader.generators.
[rnix, 2013-02-23]1.0a1initial releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.dev | This is the installation and development buildout for AGX.This packages includes buildout configurations to use AGX for development, and
to develop AGX itself.Full documentation is availablehere.Install for using AGXRun bootstrap.py:python bootstrap.py --version 1.7And buildout:./bin/buildoutInstall for developing AGXRun bootstrap.py:python bootstrap.py --version 1.7 -c dev.cfgAnd buildout:./bin/buildout -c dev.cfgRun TestsYou can run tests for a single package, e.g.:bin/test agx.generator.pyeggOr test them all:./test.shIssues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] ReleaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.buildout | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.dexterity | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.generator | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.plone | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.pyegg | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.sql | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.uml | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.generator.zca | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.transform.uml2fs | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agx.transform.xmi2uml | This Package is part ofAGX. Seehttp://agx.mefor Details.Issues and FeedbackFor reporting issues, please use tracker athttps://github.com/bluedynamics/agx.core/issues.For direct feedback or questions send an email [email protected] releaseLicenseCopyright (c) 2010-2013, BlueDynamics Alliance, Austria
All rights reserved.Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.Neither the name of the BlueDynamics Alliance nor the names of its
contributors may be used to endorse or promote products derived from this
software without specific prior written permission.THIS SOFTWARE IS PROVIDED BY BlueDynamics AllianceAS ISAND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL BlueDynamics Alliance BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
agymc | agymcFor reinforcement learning and concurrency lovers out there ...TL;DRMostly the same API as gym, except now multiple environments are run.Envs are run concurrently, which means speedup with time consuming operations such as backprop, render etc..IntroThis is a concurrent wrapper for OpenAI Gym library that runs multiple environments concurrently, which means running faster in training* without consuming more CPU power.What exactly isconcurrency?Maybe you have heard ofparallel computing? When we say we execute things in parallel, we run the program onmultipleprocessors, which offers significant speedup.Concurrency computinghas a broader meaning, though. The definition of aconcurrentprogram, is that it is designed not to execute sequentially, and will one day be executed parallelly**. Aconcurrent programcan run on a sigle processor or multiple processors. These tasks may communicate with each other, but have separate private states hidden from others.Why do we needconcurrencyon a single processor ?Some tasks, by nature, takes a lot of time to complete. Downloading a file, for example. Without concurrency, the processor would have to wait for the task to complete before starting to execute the next task. However, with concurrency we could temporarily suspend the current task, and come back later when the task finishes.Without using extra computing power.So much for introducing concurrency... now, what is gym ?OpenAI gym, is aPythonlibrary that helps research reinforcement learning. Reinforcement learning is a branch from control theory, and focusing mainly on agents interacting with environments. And OpenAI gym provides numerous environments for people to benchmark their beloved reinforcement learning algorithms. For you agents totrainin agym, they say.Um, so why do we need agymc, do you say ?Despite its merits, OpenAI gym has one major drawback. It is designed to runone agent on a processor at a time, only. What if you want to run multiple environments on the same processor at a time? Well, it will run,sequentially. Which means slow if you want to train a robot inbatches.ExperimentsUsingenv.renderas our bottlenecking operation, runing 200 environments, our versionagymccompletes 50 episodes in 4 minutes, while naivegymversion takes around twice as long. This is what the madness looks like:Wow, how to use agymc ?agymc, which combines the power ofPythonasync API and OpenAI gym, hence the name, designed for users to make final Except now the returns are inbatches(lists). And except serveral environments are run asynchronously.Example Usage Code Snippetimportargparseimportagymcif__name__=="__main__":parser=argparse.ArgumentParser()parser.add_argument("--num-envs",type=int)parser.add_argument("--episodes",type=int)parser.add_argument("--render",action="store_true")parser.add_argument("--verbose",action="store_true")flags=parser.parse_args()num_envs=flags.num_envsnum_episodes=flags.episodesrender=flags.renderverbose=flags.verboseenvs=agync.make("CartPole-v0",num_envs)ifverbose:importtqdmiterable=tqdm.tqdm(range(num_episodes))else:iterable=range(num_episodes)for_initerable:done=list(Falsefor_inrange(num_envs))envs.reset()whilenotall(done):ifrender:envs.render()action=envs.action_space.sample()(_,_,done,_)=envs.step(action)envs.close()* When doing puregymoperation such as sampling, stepping, this library runs slower since this is a wrapper for gym. However, for actions thattakes a while to execute, such as backprop and update, sending data back and forth, or even rendering, concurrency makes the operations execute much faster than anaive gym implementation** If you would like to learn more about concurrency patterns,thisvideo is really informative. |
agzline | No description available on PyPI. |
ah | ahDenis Brogniart "Ah" command in Python |
aha | Aha is a framework made specially for Google App Engine. Here are some quick instruction getting started with it. For more details, visit our website :-).http://coreblog.org/ahaOr you can get source code from the repository.http://code.google.com/p/aha-gae/What is ahaAha is a web application framework. It has been developed hoping it will be the best way to propagate your ‘aha!’ into the cloud :-).Aha has following features.rails like routingclass base controllermako template ( for speed ;-) )db / query cacheform, field generationpluginsdevelopment with buildouteasy to make admin/crud interfaceinteractive debug interface using werkzeugappstats integrationdecorator based authentication mechanizmplagable authentication mecanizmi18nDRYQuickstartTo start playing with aha, download bootstrap from url bellow.http://aha-gae.googlecode.com/files/project.zipAfter extracting the archive, move to the folder you’ll get and just typepython bootstrap.pyNext step is to launch buildout command. Make sure that you have internet connection, because it will download libraries via the internet.bin/buildoutThen, launch app in local development environment. All the stuff required to run application are under app directory. So you may give ‘app’ argument to the command.bin/dev_appserver appNow it’s time to visit your fiest aha application’s screen :-). Typehttp://127.0.0.1:8080/to see initial page of aha’s default application. |
aha.application.coreblog3 | A blog application works on Google App Engine. |
aha.application.default | A default appliction for aha framework. It has only simple controller and say ‘aha :-)’ . |
aha.application.microneimageboard | A image bbs application that needs authenticate via twitter build on the top of microne.’ . |
ahab | It’s easy to install Ahab:pipinstallahabTo get detailed information about Docker events from the command line:ahab--consoledebugTo use Ahab as library, you can pass functions to theAhab()constructor:deff(event,data):pass# Handle the Docker event (and extended info, as available)ahab=Ahab(handlers=[f])ahab.listen()Or subclassAhab:classQueequeg(Ahab):defhandle(self,event,data):pass# Your code here |
ahabclient | No description available on PyPI. |
ahab-py | Python scripts in this directory talk to ORCA native API. Using '-h' option with each script should provide usage information.You can create/delete/modify/extend slices, as well as retrieve and modify properties of existing reservations. |
ahadith | ahadithMotivationA little python library to consumehadith.json.Installationpip install ahadithUsageGet bukhari book by idfromahadithimportbukharibook=bukhari(1)first_hadith=book[0]print(first_hadith)LicenseThis project is licensed under the GPL-3 license. |
aha_nester | UNKNOWN |
ahapi | This is a simple, asynchronous HTTP API server for serving dynamic content |
aha.plugin.microne | A plugin that makes aha framework work as microframework. |
aha.plugin.twitteroauth | A plugin that ssupplies authentication support of twitter oauth. |
ahapy | ahapyA small Aha.io API client. The package handles authentication and pagination, giving the user exactly the information they seek.This is in no way associated with Aha.io. For Aha.io API documentation, please visitaha.io/api.Installpip install ahapyUsageAfter importing the library, create an instance of AhaV1 by providing your subdomain from https://[my-subdomain].aha.io/ and your API key.fromahapyimportAhaV1aha=AhaV1('<your-sub-domain>','<your-api-key>')Create a simple query by running the query method, giving the method the desired endpoint.data=aha.query('initiatives')foriindata:print(i)While using the query method, you can specify page size and customize the fields to be returned.data=aha.query('initiatives',per_page=200,fields='name,id')foriindata:print(i)After running a query, you can check if the number of record receieved is the number that was expected.data=aha.query('initiatives')iflen(data)==aha.count:print('Records returned match expectation.')The endpoint argument can be 'overloaded' to accommodate searches for objects by foriegn key. The actual endpoint is parsed and available on .endpoint memberaha.query('initiatives/'+initiative_id+'/epics')print(aha.endpoint)# epics |
aha.recipe.gae | a buildout recipe for web application framework aha |
aha-scrapyd | Scrapyd is a service for runningScrapyspiders.It allows you to deploy your Scrapy projects and control their spiders using an
HTTP JSON API.The documentation (including installation and usage) can be found at:http://scrapyd.readthedocs.org/ |
ahasura | ahasuraAsync and syncHasuraclient.Installahasura is available on PyPi:pip install ahasura
# Or
poetry add ahasuraQuick examplefrom ahasura import ADMIN, Hasura
hasura = Hasura("http://localhost:8080", admin_secret="fake secret")
data = hasura(
"""
query($id: uuid!) {
item_by_pk(id: $id) {
name
}
}
""",
auth=ADMIN,
id="00000000-0000-0000-0000-000000000001",
)
item = data["item_by_pk"]
assert item["name"] == "Some name"Create clienthasura = Hasura(...)Args:endpoint: str-HASURA_GRAPHQL_ENDPOINT, without trailing/or/v1/graphqladmin_secret: Optional[str]-HASURA_GRAPHQL_ADMIN_SECRET, required forauth=ADMINonlytimeout: Optional[float] = 10- Seconds of network inactivity allowed.Nonedisables the timeouthasuraclient just keeps the configuration above, so you can reuse global client(s)Shortcuts:hasura(...)is a shortcut for sync GraphQL client:hasura.gql(...)You can define a shortcut for Async GraphQL client:ahasura = hasura.agqlExecute GraphQL queryWith shortcuts:Sync:data = hasura(...)Async:data = await ahasura(...)Without shortcuts:Sync:data = hasura.gql(...)Async:data = await hasura.agql(...)Args:query: str- GraphQL query, e.g.query { item { id }}auth: str- EitherADMINor value ofAuthorizationheader, e.g.Bearer {JWT}headers: Optional[Dict[str, str]]- Custom headers, if any**variables- Variables used inquery, if anyReturns: GraphQL response data, e.g.{"item": [{"id": "..."}]}Raises:HasuraError- If JSON response from Hasura containserrorskeyExecute SQL querySync:rows = hasura.sql(...)Async:rows = await hasura.asql(...)Args:query: str- SQL query, e.g.SELECT "id" FROM "item"headers: Optional[Dict[str, str]]- Custom headers, if anyReturns:Rows selected bySELECTquery, e.g.[{"id": "..."}]Or[{"ok": True}]for non-SELECTqueryRaises:HasuraError- If JSON response from Hasura containserrorkeyAuthSQL queries areadmin-onlyGraphQL queries can use both admin and non-adminauthauth=ADMINis not default, because:sudois not defaultIt's easy to forget to propagateAuthorizationheader of the user to HasuraDeclarative Hasura permissions are better than checking permissions in PythonWhen we set Hasura permissions, we should test them for each role supportedHow to testtest_item.pyfrom typing import Any, Dict
from ahasura import Hasura, HasuraError
import pytest
def test_reader_reads_item_ok(
hasura: Hasura,
reader_auth: str,
ok_item: Dict[str, Any],
) -> None:
data = hasura(
"""
query($id: uuid!) {
item_by_pk(id: $id) {
name
}
}
""",
auth=reader_auth,
id=ok_item["id"],
)
item = data["item_by_pk"]
assert item["name"] == "Some name"
def test_error(hasura: Hasura, reader_auth: str) -> None:
with pytest.raises(HasuraError) as error:
hasura("bad query", auth=reader_auth)
assert error.value.response == {"errors": [...]}conftest.pyfrom typing import Any, Dict, Generator, List
from ahasura import ADMIN, Hasura
import jwt
import pytest
_TABLE_NAMES = ["item"]
@pytest.fixture(scope="session")
def hasura() -> Hasura:
return Hasura("http://localhost:8080", admin_secret="fake secret")
@pytest.fixture(scope="session")
def reader_auth() -> str:
decoded_token = ...
encoded_token = jwt.encode(decoded_token, "")
return f"Bearer {encoded_token}"
@pytest.fixture(scope="session")
def test_row_ids() -> List[str]:
"""
When a test function creates a row in any table,
it should append this `row["id"]` to `test_row_ids`
UUIDs are unique across all tables with enough probability
"""
return []
@pytest.fixture(scope="function")
def ok_item(hasura: Hasura, test_row_ids: List[str]) -> Dict[str, Any]:
data = hasura(
"""
mutation($item: item_insert_input!) {
insert_item_one(object: $item) {
id
name
}
}
""",
auth=ADMIN,
name="Some name",
)
item: Dict[str, Any] = data["insert_item_one"]
test_row_ids.append(item["id"])
return item
@pytest.fixture(scope="function", autouse=True)
def cleanup(hasura: Hasura, test_row_ids: List[str]) -> Generator[None, None, None]:
"""
When the test function ends,
this autouse fixture deletes all test rows from all tables
"""
yield
if test_row_ids:
for table_name in _TABLE_NAMES:
hasura(
"""
mutation($ids: [uuid!]!) {
delete_{table_name}(where: {id: {_in: $ids}}) {
affected_rows
}
}
""".replace(
"{table_name}", table_name
),
auth=ADMIN,
ids=test_row_ids,
)
test_row_ids.clear() |
aha-tools | No description available on PyPI. |
ahbcwin | No description available on PyPI. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.