Saravanan666/pypi-org huggingface dataset:
Package: tropo
Python library to create Azure Resource TemplatesOverviewAzure Resource Template GeneratorInstallation / UsageTo install use pip:$ pip install tropoOr clone the repo:$ git clonehttps://github.com/hoffmann/tropo.git$ python setup.py installContributingTBDExampleTBDDocumentationClone the resource manager json schemas$ git clonehttps://github.com/Azure/azure-resource-manager-schemas.gitClone Azure Management Python Api$ git clonehttps://github.com/Azure/azure-sdk-for-python.gitAzure Compute Modelshttps://github.com/Azure/azure-sdk-for-python/tree/master/azure-mgmt-compute/azure/mgmt/compute/models
Package: tropokta
tropoktaCustom AWS Cloudformation Resource for Okta Users and GroupsCAUTIONThis is ALPHA and has only been testing on a developer instance of Okta and a test AWS account *DO NOT USE IN PRODUCTION WITHOUT TESTINGInstallTo just use as a custom resourceMake sure to fill out the environment variablesOKTA_URLOKTA_TOKENencryptedFollow online instructions on generating an Okta API Token# Replace YOUR_S3_ARTIFACTS_BUCKET
aws cloudformation package --template-file template.yaml --output-template-file cfn-transformed-template.yaml --s3-bucket YOUR_S3_ARTIFACTS_BUCKET
aws cloudformation deploy --template-file ./cfn-transformed-template.yaml --stack-name okta-cf-resourceNow you haveCustom::OktaUserCustom::OktaGroupCustom::OktaUserGroupAttachmentAvailable in CloudFormationIf you install tropokta withpython setup.py install
# or
pip install tropoktaYou can do the following within tropospherefrom troposphere import Template
from tropokta.okta import OktaUser

t = Template()

user = t.add_resource(OktaUser(
    firstName="test",
    lastName="user",
    email="test@test.com",
    login="test@test.com"
    ))

print(t.to_json())TO DO[] Tests
Package: troposim
troposimSimulate tropospheric noise for InSAR dataUsageTo simulate one turbulence image, you can specify the shape:fromtroposimimportturbulencenoise=turbulence.simulate(shape=(500,500))or add a 3rd dimension to simulate a stack of imagesnoise=turbulence.simulate(shape=(10,500,500))Thebetaargument is the slope of the log10(power) vs log10(frequency) graph.
The default is to use a single linear slope of $\beta = 2.5$:$$
P(f) = \frac{1}{f^\beta}
$$For smaller-scale turbulence, you can use a differentbeta:flatter_noise=turbulence.simulate(beta=2.2)Since real InSAR data typically have a power spectrum that is not a single slope, you canestimate the spectrum from an imageand use that to simulate new data:fromtroposim.turbulenceimportPsdpsd=Psd.from_image(noise)new_noise=psd.simulate()Here thepsdobject has the following attributes:p0: the power at the reference frequencyfreq0beta: a numpy Polynomial which was fit to the log-log PSDThe two attributespsd.freqandpsd.psd1dare the radially averaged spectrum values. You can see these with the.plot()method.# assuming maptlotlib is installedpsd.plot()# Or, to plot a side-by-side of image and 1D PSDfromtroposimimportplottingplotting.plot_psd(noise,freq=freq,psd1d=psd1d)# Or just the PSD plot, no imageplotting.plot_psd1d(freq,psd1d)To simulate a stack of new values, you can pass the estimatedp0andbetaback tosimulate:noise=turbulence.simulate(shape=(10,400,400),p0=p0,beta=beta)Note that the default fit will use a cubic polynomial.
To request only a linear fit,psd=Psd.from_image(noise,deg=1)You can also save the PSD parameters for later use:psd.save(outfile="my_psd.npz")# Later, reload from this filepsd=Psd.load(outfile)CitationTODO
Package: troposphere-awscommunity-applicationautoscaling-scheduledaction
AwsCommunity::ApplicationAutoscaling::ScheduledActionTroposphere object for theAwsCommunity::ApplicationAutoscaling::ScheduledActionresource.SeeThe AWS CFN Community Registryor the original
resourcehereTheresoure propertiesdetail
what attributes to assign for the resourceExampleCreates a scheduled action for a dynamodb tablefromtroposphereimportTemplatefromtroposphere_awscommunity_applicationautoscaling_scheduledactionimport(ScheduledAction,ScalableTargetAction,)deftest_scheduled_action():props:dict={"ScheduledActionName":"cfn-testing-resource","ServiceNamespace":"dynamodb","ScalableDimension":"dynamodb:table:ReadCapacityUnits","ScalableTargetAction":ScalableTargetAction(**{"MinCapacity":1,"MaxCapacity":4}),"Schedule":"cron(5 2 ? * FRI)","Timezone":"Europe/London","ResourceId":"table/awscommunityscheduledactiontesttable",}tpl=Template()action=tpl.add_resource(ScheduledAction("MyAction",**props))print(tpl.to_yaml())Renders, with the template, the followingResources:MyAction:Properties:ResourceId:table/awscommunityscheduledactiontesttableScalableDimension:dynamodb:table:ReadCapacityUnitsScalableTargetAction:MaxCapacity:4MinCapacity:1Schedule:cron(5 2 ? * FRI)ScheduledActionName:cfn-testing-resourceServiceNamespace:dynamodbTimezone:Europe/LondonType:AwsCommunity::ApplicationAutoscaling::ScheduledAction
Package: troposphere-cli
Command line interface to manage troposphere CloudFormation stacks.Installationpip install troposphere-cliUsageUsage: trop [OPTIONS] COMMAND [ARGS]...

  Troposphere CLI.

Options:
  -r, --region TEXT  The `AWS` region.  [required]
  --help             Show this message and exit.

Commands:
  create      Create a new stack.
  events      Display stack events.
  list        List stacks.
  outputs     Show stack output values.
  parameters  Show templates parameter values.
  template    Show template as json.
  update      Update an existing stack.ConfigurationAWS_REGION=<aws_region>
STACK_TEMPLATE=<path.to.template>
Package: troppo
TROPPOTroppo(Tissue-specific RecOnstruction and Phenotype Prediction using Omics data) is a Python package containing methods
for tissue specific reconstruction to use with constraint-based models. The main purpose of this package is to provide
an open-source framework which is both modular and flexible to be integrated with other packages, such as cobrapy, framed
or cameo whose already provide generic data structures to interpret metabolic models.A (MI)LP solver is required to use most of the present methods. The current methods support optlang, which in turn allow
the use of solvers like CPLEX or Gurobi.The current methods implemented are:FastCORECORDAGIMME(t)INITiMATMethods to be implemented later:MBAmCADREPRIMEDocumentationInstalation from PyPI (stable releases)pip install troppoInstalation from github (latest development release)pip install https://github.com/BioSystemsUM/troppoCredits and LicenseDeveloped at the Centre of Biological Engineering, University of MinhoReleased under the GNU Public License (version 3.0).
Package: troptumps
Trop TumpsA statistics-duelling deck generator using data from wikipedia.Trop Tumps chooses random categories fromdbpedia.organd turns them into
(mostly-useless) printable decks of cards representing things from that
category, complete with exciting statistics.InstallationNote: Trop Tumps requires Python 3.6+The simplest way to install Trop Tumps is usingpip. With Python and pip
installed, Trop Tumps can be installed from the Python Package Index with:pip install troptumpsor directly from the source repository with:pip install git+https://github.com/Frimkron/troptumps#egg=troptumpsAlternatively you can download the source and install it with thesetup.pyscript.UsageIf you have installed Trop Trumps, it can be run using thetroptumpsexecutable (troptumps.exeon Windows), otherwise the package can be run
directly withpython -m troptumps.The script will connect todbpedia.organd keep trying to find a suitable
category of things to turn into a card deck. Eventually, with a bit of luck, a
directory nameddeck_(something) will be written to the current working
directory, containing a printable .pdf file.To re-generate the PDF for an existing deck (e.g. to change the paper size),
use the--datadiroption to indicate the path of adeck_directory. The PDF
will be overwritten.Use the--helpflag to see the full list of options.LicenceTrop Tumps is released under theGPL 3 licence. For the full text of this
licence seeLICENCE.txt.CreditsCreated by Mark FrimstonGithub:https://github.com/FrimkronWebsite:http://markrimston.co.ukEmail:mark@markfrimston.co.ukTwitter:@frimkronMastodon:frimkron@mastodon.social
Package: trotter
TrotterWelcome to trotter, a set of Python classes for representing sequences
of structures of item selections commonly encountered in combinatorics.Classes have been defined according to whether order is important, items may be repeated, and length is specified:ClassOrder ImportantRepetition AllowedSpecified LengthAmalgamsYesYesYesPermutationsYesNoYesCompoundsYesNoNoCompositionsNoYesYesCombinationsNoNoYesSubsetsNoNoNoInstances of these classes are indexable pseudo-lists containing all possible selections of items. Since the number of possible arrangements can grow very quickly with the number of items available (and the number of items taken at a time, where applicable), instances do not actuallystoreall arrangements but are rather containers ofmappings between integers and arrangements. This makes it possible to create instances that "contain" very large numbers of arrangements.Installationpip install trotterExample: combinations of wordsfromtrotterimportCombinationsitems=["the","parrot","is","not","pining"]combos=Combinations(3,items)print(repr(combos))Combinations(3, ['the', 'parrot', 'is', 'not', 'pining'])print(str(combos))A pseudo-list containing 10 3-combinations of ['the', 'parrot', 'is', 'not', 'pining'].print(len(combos))10forcomboincombos:print(" ".join(combo))the parrot is
the parrot not
the parrot pining
the is not
the is pining
the not pining
parrot is not
parrot is pining
parrot not pining
is not piningprint(combos.index("the parrot pining".split()))2print(combos[2])['the', 'parrot', 'pining']Example: subsets of characters in a stringThe items can be presented as a list of objects or a string, which is interpreted as a list of characters. Here's an example where we use a string.fori,subsetinenumerate(Subsets("spam")):print(f"[{i}] '{subset}'")[0] ''
[1] 's'
[2] 'p'
[3] 'sp'
[4] 'a'
[5] 'sa'
[6] 'pa'
[7] 'spa'
[8] 'm'
[9] 'sm'
[10] 'pm'
[11] 'spm'
[12] 'am'
[13] 'sam'
[14] 'pam'
[15] 'spam'Example:manypermutations!fromtrotterimportPermutationsletters="abcdefghijklmnopqrstuvwxyz"permutations=Permutations(10,letters)print(permutations)A pseudo-list containing 19275223968000 10-permutations of 'abcdefghijklmnopqrstuvwxyz'.That's almost twentytrillion! Luckily, we're only dealing with a pseudo-list, and those permutations are not actually stored!Notice that the wordalgorithmsis a ten-letter permutation of the letters of the alphabet. At what position in the pseudo-list is this word?print(permutations.index("algorithms"))6831894769563Luckily, we were able to find it without a brute-force search! Let's check that result...print(permutations[6831894769563])algorithms
Package: troubadix
TroubadixA linting and QA check tool for NASL filesInstallationRequirementsPython 3.9 and later is supported.Install using pippip 19.0 or later is required.You can install the latest stable release oftroubadixfrom the Python
Package Index (pypi) usingpippython3 -m pip install --user troubadixInstall using poetryBecausetroubadixis a Python application you most likely need a tool to
handle Python package dependencies and Python environments. Therefore we
strongly recommend usingpipenvorpoetry.You can install the latest stable release oftroubadixand add it as
a dependency for your current project usingpoetrypoetry add troubadixFor installation via pipenv please take a look at theirdocumentation.Developmenttroubadixusespoetryfor its own dependency management and build
process.First install poetry via pippython3 -m pip install --user poetryAfterwards runpoetry installin the checkout directory oftroubadix(the directory containing thepyproject.tomlfile) to install all dependencies including the packages only
required for development.Afterwards activate the git hooks for auto-formatting and linting viaautohooks.poetry run autohooks activateValidate the activated git hooks by runningpoetry run autohooks checkMaintainerThis project is maintained byGreenbone AGContributingYour contributions are highly appreciated. Pleasecreate a pull requeston GitHub. Bigger changes need to be discussed with the development team via theissues section at GitHubfirst.LicenseCopyright (C) 2021-2022Greenbone AGLicensed under theGNU General Public License v3.0 or later.
Package: troublebox
A very limitedSentrycompatible end point.
Use it for very small installations where the Sentry docker images are too big and Sentry as a service isn’t an option.WarningDo not expose to the public internet! There is no authentication or anything built in.Basic usageThis readme usesplaster_pastedeployfor deployment.Copyproduction.iniand adjust to your needs.Run withpserve [your ini file name].As the Sentry DSN use a URL similar to this:http://key@localhost:7777/42Replacelocalhost:7777with the address of the box your Troublebox instance is running on.
Thekeypart is currently not checked, but required by Sentry libraries.
The42is the internal project id and can be an arbitrary number.The actual address used by Sentry libraries in this example is:http://localhost:7777/api/42/store/
Package: troup
[![Build Status](https://travis-ci.org/troup-system/troup.svg?branch=master)](https://travis-ci.org/troup-system/troup)Take control of your home grid.* run applications across multiple computers and platforms transparently, just as you would from your terminal. The application will run on the most appropriate node, determined by algorithm.* run tasks (run code fragments or processes) transparently across the system. The tasks can be either automatically assigned to a node, similar as the applications; or they can be assigned explicitly to a node.Installation============Install it with pip:```bashpip install troup```Requirements============* psutil* ws4pyGet started===========Check out the the [Getting Started](https://github.com/troup-system/troup/wiki/GettingStarted) guide on the wiki.Documentation=============Read the full documentation [here](http://troup.readthedocs.io/en/latest/).License=======Licensed under the Apache License, Version 2.0.See the file LICENSE or you may obtain a copy at:http://www.apache.org/licenses/LICENSE-2.0
Package: trout
troutis a bioinformatics software package that uses suffix trees to
compute the distances between genomes.SetupBuild from sourcewget https://bitbucket.org/NDBL/trout/get/trout-0.9.tar.gz
tar -xvzf trout-0.9.tar.gz
mv NDBL-trout-<commit> trout-0.9
cd trout-0.9
makeRequirements/usr/bin/make/usr/bin/g++/usr/bin/pythonUsagetrout-suffixbuilds a suffix tree from afastqand searches that
tree for kmers to generate a binary sketch (.trout.sketch)usage:    trout-suffix <input_fastq> <kmer_markers> <output_sketch>trout-matrixgenerates a distance matrix from the binary sketches
(.trout.sketch) produced bytrout-suffixusage:    trout-matrix <sketch_dir>trout-comparecomputes the difference between two distance matricesusage:    trout-compare <distance_matrix> <distance_matrix>trout-matchcomputes the number of matches of the kmer-markers
across binary sketches (.trout.sketch)usage:    trout-match <sketch_dir>Example UsageFor an example usage with sample data:make sampleTo remove generated files when finished:make sample-cleanContactNotre Dame Bioinformatics
LabWill Markley:wmarkley@nd.edu
Package: trouting
TroutingTrouting (short for Type Routing) is a simple class decorator that allows to define multiple interfaces for a method that behave differently depending on input types.To install for PyPI trouting, run:pipinstalltroutingThe logo of trouting was generated usingStable Diffusionwith prompt"A Kandinsky painting titled The Trout Who Routes"and slightly edited by the author.ExampleImagine you want to define a class whose method behaves differently depending on whether the input is a string or an integer. You can do this with trouting as follows:fromtypingimportAny,UnionfromtroutingimporttroutingclassMyClass:@troutingdefadd_one(self,a:Any)->Any:# fallback methodraiseTypeError(f"Type{type(a)}not supported")@add_one.add_interface(a=(int,float))defadd_one_int(self,a:Union[int,float])->float:# a is an int or floatreturnfloat(a+1)@add_one.add_interface(a=str)defadd_one_str(self,a:str)->str:# a is a strreturna+"1"Now, when usingMyClass, the methodadd_onewill behave differently depending on the input type:my_class=MyClass()my_class.add_one(1)# returns 2.0my_class.add_one("1")# returns "11"my_class.add_one([1])# raises TypeError
Package: trouve
TrouveA package to search for events in time-series data that match a boolean condition. Varioustransformation functions are built in to filter and alter events.See Trouve’s documentation athttps://trouve.readthedocs.ioInstalltrouveis on the Python Package Index (PyPI):pip install trouveDependenciesnumpypandastoolzExampleThis finds events in a short sample of 1Hz, time-series data and filters out events basedon their duration>>>importnumpyasnp>>>fromtrouveimportfind_events>>>importtrouve.transformationsastt>>>x=np.array([1,2,2,2,0,1,2,0,2,2])>>>period=1# period = 1 / sample_rate>>>duration_filter=tt.filter_durations(2,3)>>>events=find_events(x==2,duration_filter,period=1)>>>len(events)2>>>events.as_array()array([0.,1.,1.,1.,0.,0.,0.,0.,1.,1.])
Package: trovares-connector
trovares_connector PackageThis Python package is for connecting the Trovares xGT graph analytics engine to other applications.
Trovares xGT cansignificantly speedup Neo4j queries.The default connector provided is for Neo4j or AuraDB.
The package also provides an optional ODBC connector for connecting to databases or applications that support ODBC.
Information about the ODBC connector can be foundin the documentation.Homepage:trovares.comDocumentation:trovares.github.io/trovares_connectorGeneral Help:github.com/trovares/trovares_connector/discussionsRequirementsNeo4j PythonxGT PythonPyarrowTrovares xGTInstallationYou can install this python package by executing this command:python-mpipinstalltrovares_connectorIf you want to use the ODBC connector, you can install the optional dependencies like so:python-mpipinstall'trovares_connector[odbc]'If you don't have Trovares xGT, you can install and run theDeveloper versionfrom Docker:dockerpulltrovares/xgt
dockerrun--publish=4367:4367trovares/xgtUsing the trovares_connectorFrom any Python environment, simply importing bothxgtandtrovares_connectoris all that is needed to operate this connector.A simple example below shows connecting to Neo4j and xGT, transferring the whole graph database to xGT, running a query in xGT, and printing the results:importxgtfromtrovares_connectorimportNeo4jConnector,Neo4jDriver# Connect to xGT and Neo4j.xgt_server=xgt.Connection()xgt_server.set_default_namespace('neo4j')neo4j_server=Neo4jDriver(auth=('neo4j','foo'))conn=Neo4jConnector(xgt_server,neo4j_server)# Transfer the whole graph.conn.transfer_to_xgt()# Run the query.query="match(a:foo) return a"job=xgt_server.run_job(query)# Print results.print("Results: ")forrowinjob.get_data():print(row)APIThe available properties are:neo4j_relationship_typesneo4j_node_labelsneo4j_property_keysneo4j_node_type_propertiesneo4j_rel_type_propertiesneo4j_nodesneo4j_edgesThe available methods are:get_xgt_schemascreate_xgt_schemascopy_data_to_xgttransfer_to_xgttransfer_to_neo4jExamplesSome examples can be found here:Python examplesJupyter notebooks
Package: trove
Trove is Database as a Service for OpenStack.Getting StartedIf you’d like to run from the master branch, you can clone the git repo:git clonehttps://opendev.org/openstack/troveFor information on how to contribute to trove, please seeCONTRIBUTING.rstandHACKING.rstWikiDeveloper DocsYou can raise bugs here:Bug TrackerThe plan for trove can be found atTrove SpecsRelease notes for the project can be found at:https://docs.openstack.org/releasenotes/trovePython clientPython-troveclientis a client for Trove.Dashboard pluginTrove-dashboardis OpenStack dashbaord plugin for Trove.ReferencesInstallation docsManual installation docsBuild guest image
Package: trove-classifiers
Canonical source forclassifiersonPyPI.Classifierscategorize projectsperPEP 301. Use this package to
validate classifiers in packages for PyPI upload or download.UsageTo installfrom PyPI:$ pip install trove-classifiersThis package can be invoked as a module to print a list of classifiers:$ python -m trove_classifiers | grep -Ei pyramid
Framework :: PyramidIn addition, this package's API is two importable objects:Classifiers (trove_classifiers.classifiers)Asetcontaining classifiers (as strings). Useful for determining membership.Example - determine if a classifier is valid:>>>fromtrove_classifiersimportclassifiers>>>'License :: OSI Approved'inclassifiersTrue>>>'Fuzzy :: Wuzzy :: Was :: A :: Bear'inclassifiersFalse>>>Deprecated classifiers (trove_classifiers.deprecated_classifiers)Adict, mapping a deprecated classifier (string) to a list of classifiers
which replaces it (strings).Example - determine if a classifier is deprecated:>>>fromtrove_classifiersimportdeprecated_classifiers>>>'License :: OSI Approved'indeprecated_classifiersFalse>>>'Natural Language :: Ukranian'indeprecated_classifiersTrue>>>deprecated_classifiers["Natural Language :: Ukranian"]['Natural Language :: Ukrainian']
Package: trove-classifiers-cli
Trove Classifiers CLICLI for PyPI Trove ClassifiersTrove Classifiers CLIInstallationpipxpipUsageExamplesBasic usage--tree--quoted-listInstallationpipxThis is the recommended installation method.$ pipx install trove-classifiers-clipip$ pip install trove-classifiers-cliUsage$ trove-classifiers --help
usage: trove-classifiers [-h] [-I] [-q] [-t] [MATCH ...]

CLI for PyPI Trove Classifiers

positional arguments:
  MATCH              String(s) to search for (default: [None])

options:
  -h, --help         show this help message and exit
  -I, --case         Perform case sensitive matching. (default: False)
  -q, --quoted-list  Output a quoted list (default: False)
  -t, --tree         Format output as a tree (default: False)ExamplesBasic usage$ trove-classifiers macos
Environment :: MacOS X
Environment :: MacOS X :: Aqua
Environment :: MacOS X :: Carbon
Environment :: MacOS X :: Cocoa
Operating System :: MacOS
Operating System :: MacOS :: MacOS 9
Operating System :: MacOS :: MacOS X--tree$ trove-classifiers macos -t
Environment :: MacOS X
        Environment :: MacOS X :: Aqua
        Environment :: MacOS X :: Carbon
        Environment :: MacOS X :: Cocoa
Operating System :: MacOS
        Operating System :: MacOS :: MacOS 9
        Operating System :: MacOS :: MacOS X--quoted-list$ trove-classifiers macos -q
"Environment :: MacOS X",
"Environment :: MacOS X :: Aqua",
"Environment :: MacOS X :: Carbon",
"Environment :: MacOS X :: Cocoa",
"Operating System :: MacOS",
"Operating System :: MacOS :: MacOS 9",
"Operating System :: MacOS :: MacOS X",
Package: trove-fm
TroveFM is an online store and headless CMS built withFastAPILinksFramework Documentation:https://brianfarrell.gitlab.io/trove-fm/License:https://www.gnu.org/licenses/agpl.htmlPyPi Release:https://pypi.org/project/trove-fm/REST APIEndpoint:https://trove-supply.com/api/SwaggerUI:https://trove-supply.com/docs/ReDoc:https://trove-supply.com/redoc/