Saravanan666/pypi-org huggingface dataset:
Package: terra-pandas
terra-pandasImport and export Terra data tables to Pandas DataFrames.InstallationFrom the CLI:pip install terra-pandasIn a Jupyter notebook (note the ipython magic "%pip"):%pip install terra-pandasUpgradingIt is often useful to keep up to date with new features and bug fixes. Installing the latest version of
terra-pandas depends on your host environment.From any Jupyter notebook, use the following (and note the leading "%")%pip install --upgrade --no-cache-dir terra-pandasFrom the CLI on standard Terra notebook runtimes, which are available using the terminal button in the Terra user
interface, use/usr/local/bin/pip install --upgrade --no-cache-dir terra-pandasNote that all standard notebook runtimes on Terra are based onthis Docker image.For other environments, it is often enough to dopip install --upgrade --no-cache-dir terra-pandasCredentialsMuch of the terra-pandas functionality requires credentialed access through a Google Cloud Platform account.
Credentials are already available when running in a Terra notebook environment. Otherwise, credentials may be obtained
with the commandgcloud auth application-default loginTestsReleaseThe commands mentioned incommon.mkfile are used for the release process.
Steps:if you don't have aPyPIaccount, please create oneyou should be a collaborator in PyPI for Terra Notebook Utils. If you are not, please ask Brian Hannafious to add
you as a collaboratorfollow the setup instructions as mentioned inTestssection above for env Prod; make sure you have access
to the DRS urls, workspaces and bucketsrunmake all_testfrom inside the docker container created inLocal Developmentsection.
Once tests pass, you can move to the release stepRelease:For non-breaking API changes, usemake release_patchFor breaking API changes, usemake release_minorFor a major release, usemake release_majorIf a release needs to be rolled back for some reason, please contact Brian Hannafious for help.LinksProject home pageGitHubPackage distributionPyPIBugsPlease report bugs, issues, feature requests, etc. onGitHub.
Package: terraplanfeed
terraplanfeedThis tool parses Terraform plan files in JSON format and gives feedback about the changes.DescriptionThis tool aims to parse Terraform plan files (in JSON format) and gives feedback to several types of outputs.Outputs can be:stdout: stdoutazuredevops: Azure DevOps pull request commentgithub: Github pull request comment (not yet implemented)To create the Terraform plan file:terraforminit
terraformplan-out=plan.out
terraformshow-no-color-jsonplan.out>plan.jsonUsageTo write to stdout you just need to pass a JSON file:❯terraplanfeed../tfplan/example.json

Summaryofchanges:===================(✨):<knownafterapply>(module.failover_rg.azurerm_resource_group.rg)(✨):<knownafterapply>(module.failover_rg.module.naming.random_string.first_letter)(✨):<knownafterapply>(module.failover_rg.module.naming.random_string.main)(✨):<knownafterapply>(module.rg.azurerm_resource_group.rg)(✨):<knownafterapply>(module.rg.module.naming.random_string.first_letter)(✨):<knownafterapply>(module.rg.module.naming.random_string.main)(✨):<knownafterapply>(module.sql.azurerm_storage_account.audit1)(✨):<knownafterapply>(module.sql.azurerm_storage_account.audit2[0])(✨):<knownafterapply>(module.sql.module.naming.random_string.first_letter)(✨):<knownafterapply>(module.sql.module.naming.random_string.main)(✨):<knownafterapply>(module.sql.module.naming_failover.random_string.first_letter)(✨):<knownafterapply>(module.sql.module.naming_failover.random_string.main)❯terraplanfeed../tfplan/example.json-oazuredevopsTo use this on Azure DevOps you need the following environment variables:SYSTEM_TEAMFOUNDATIONSERVERURISYSTEM_TEAMPROJECTBUILD_REPOSITORY_IDSYSTEM_PULLREQUEST_PULLREQUESTIDSYSTEM_ACCESSTOKENthese environment variables are present when you run Azure DevOps pipelines.Note:TheSYSTEM_PULLREQUEST_PULLREQUESTIDis only present when you run
pipeline in a pull request.If any of these environment variables are not present, output defaults to stdoutRun and test locallypython3-mpipinstall--editable.Build and upload to PyPITo build and upload to Test PyPI repository:python3-mpipinstall--user--upgradesetuptoolswheel
python3setup.pysdistbdist_wheel
python3-mpipinstall--user--upgradetwine
python3-mtwineupload--repositorytestpypidist/*To upload to PyPI repository:python3-mtwineuploaddist/*pre-commit hooksRead thepre-commit hooksdocument for more info.git-chglogRead thegit-chglogdocument for more info.ReferencesMaking a Python packageDocumenting Python codePython Docstrings GooglePython ClickTerraform JSON output format
Package: terrapyn
terrapynToolkit to manipulate Earth Observation Data: Remote Sensing, Climate and Weather models. Designed to work withPandas/GeoPandasandXarraydata structures, implementingDaskwhere possible.The name is pronounced the same as "terrapin", a type offresh water turtleDocumentation:https://colinahill.github.io/terrapyn.Free software: BSD-3-ClauseSetup/InstallationPython environment setupAn environment with Python version3.10or later is required. If you don't have this, it can be created usingPyenvwhich should be installed first. After installing Pyenv, download and install Python3.10usingpyenvinstall3.10If you already have Python version3.10or later you can skip this step.InstallVia PipThe package can be installed in an existing Python environment via pip:pipinstallterrapynFrom sourceClone the repo and install the package:gitclonehttps://github.com/colinahill/terrapyn.git&&cdterrapynThis project usesPoetryto manage dependencies. In the case where Poetry doesn't automatically find the correct Python path, you can set it withpyenvlocal3.10
poetryenvuse3.10Then install the packagepoetryinstall# Creates a virtualenv and installs package into itpoetryshell# Opens a sub-shell in the virtualenv
Package: terrapyst
TerrapystTerrapyst is a Python wrapper around the Terraform CLI.UsageQuick StartTerrapyst usage centers around the Workspace object, which can be used to run the typical Terraform commands in that workspace. Just like with the CLI you have to initialize the workspace before you can run plans or applies.fromterrapystimportWorkspaceworkspace=Workspace(path="./")workspace.init()results,plan=workspace.plan()if!results.successful:raiseException(f"Terraform run failed without output:{results.stdout}")ifplan.deletions>0:raiseException("Deletions not expected from this plan")results,apply_log=workspace.apply(plan_path=plan.plan_path,auto_approve=True)if!results.successful:print("Terraform Apply was not successful.")forresource_name,resource_datainapply_log.resources.items():print(f"${resource_name}: ${resource['message']}")foroutput_name,output_datainapply_log.outputs.items():print(f"{output_name}:\n")print(yaml.dumps(output_data))print("\n\n\n")The plan step can be skipped if you are auto approving.fromterrapystimportWorkspaceworkspace=Workspace(path="./")workspace.init()results,apply_log=workspace.apply(auto_approve=True)InstallationTerrapyst can be installed with pip.pipinstallterrapystIn addition to Terrapyst you should have the Terraform binary installed on your system.
Package: terra-python
Terra Python PackageA wrapper in python for the Terra endpoints and models.User Guide:https://docs.tryterra.co/docs/python-project-1Install usingpipinstallterra-pythonThen import theTerraclass from terra.base_clientInitialise a new Terra instance with:fromterra.base_clientimportTerraterra=Terra(api_key='YOUR API KEY',dev_id='YOUR DEV ID',secret='YOUR TERRA SECRET');Now you can call the following functions from the instance:from_user_idget_activity_for_userget_body_for_userget_daily_for_userget_sleep_for_userget_athlete_for_userget_menstruation_for_userget_nutrition_for_usergenerate_widget_sessiongenerate_authentication_urlget_user_infodeauthenticate_userlist_userslist_providerscheck_terra_signaturehandle_flask_webhookshandle_webhooksThe documentation for the wrapper is available here:https://tryterra.github.io/terra-client-python/In addition, all the data models documented on [https://docs.tryterra.co/docs/data-models] are available to import and use.The models support autocompleting the types to manipulate data coming from Terra
Package: terraref-laser3d
# laser3d science packageThis repository contains utilities for scientific operations on 3D laser scanner data.### laser3d.pygenerate_las_from_ply(inp, out, pco)Convert a list of PLY input files into a single merged LAS output.generate_tif_from_ply(inp, out, mode=’max’)Convert an PLY file to a raster, using mode as the pixel aggregation rule.### Authors:Maxwell Burnette, National Supercomputing Applications, Urbana, Il
Package: terraref-stereo-rgb
# stereo_rgb science packageThis repository contains utilities for scientific operations on Stereo RGB camera data.### stereo_rgb.pyget_image_shape(metadata, side)Parse LemnaTec metadata JSON for a particular side (left/right) to get image dimensions.process_raw(shape, bin_file, out_file=None)Convert a raw BIN file to a georeferenced GeoTIFF.calculate_canopycover(pxarray)Calculate the percentage of given pixel array over greenness threshold to be considered canopy.### Authors:Zongyang Li, Donald Danforth Plant Science Center, St. Louis, MOMaxwell Burnette, National Supercomputing Applications, Urbana, IlRobert Pless, George Washington University, Washington, DC
Package: terraria-pc-player-api
terraria PC player APIAPI for reading and modifying PC terraria player files.ExamplesChange player max life to 300>>>importterraria_pc_player_api>>>player=terraria_pc_player_api.TerrariaPCPlayer("PLAYER1.PLR")>>>player.max_life=300>>>player.write_to_file("PLAYER1.PLR")Set 999 dirt items to first inventory slot>>>importterraria_pc_player_api>>>player=terraria_pc_player_api.TerrariaPCPlayer("PLAYER1.PLR")>>>player.inventory[0][0]=terraria_pc_player_api.Item(2,999,0)>>>player.write_to_file("PLAYER1.PLR")Read player name>>>importterraria_pc_player_api>>>terraria_pc_player_api.TerrariaPCPlayer("PLAYER1.PLR").name'test_plr'Dependenciesbitarraybinary-rwpycryptodometerraria-pc-apis-idsterraria-apis-objectsInstallationpip install terraria-pc-player-apiLicenseGPL v3© Filip K.
Package: terraria-pc-xbox360-player-converter
terraria pc xbox360 player converterLibrary for converting between TerrariaPCPlayer and TerrariaXbox360Player.ExamplesConvert xbox360 player file to pc>>>importterraria_xbox360_player_api>>>importterraria_pc_xbox360_player_converter>>>player=terraria_xbox360_player_api.TerrariaXbox360Player("PLAYER1.PLR")>>>player=terraria_pc_xbox360_player_converter.convert_xbox360_to_pc(player)>>>player.write_to_file("PLAYER1.plr")Convert pc player file to xbox360>>>importterraria_pc_player_api>>>importterraria_pc_xbox360_player_converter>>>player=terraria_pc_player_api.TerrariaPCPlayer("PLAYER1.plr")>>>player=terraria_pc_xbox360_player_converter.convert_pc_to_xbox360(player)>>>player.write_to_file("PLAYER1.PLR")Dependenciesterraria-pc-player-apiterraria-xbox360-player-apiInstallationpip install terraria-pc-xbox360-player-converterLicenseGPL v3© Filip K.
Package: terraria-xbox360-player-api
terraria xbox360 player APIAPI for reading and modifying xbox 360 terraria player files.ExamplesChange player max life to 300>>>importterraria_xbox360_player_api>>>player=terraria_xbox360_player_api.TerrariaXbox360Player("PLAYER1.PLR")>>>player.max_life=300>>>player.write_to_file("PLAYER1.PLR")Set 999 dirt items to first inventory slot>>>importterraria_xbox360_player_api>>>player=terraria_xbox360_player_api.TerrariaXbox360Player("PLAYER1.PLR")>>>player.inventory[0][0]=terraria_xbox360_player_api.Item(2,999,0)>>>player.write_to_file("PLAYER1.PLR")Read player name>>>importterraria_xbox360_player_api>>>terraria_xbox360_player_api.TerrariaXbox360Player("PLAYER1.PLR").name'test_plr'Dependenciesbitarraybinary-rwterraria-apis-objectsInstallationpip install terraria-xbox360-player-apiLicenseGPL v3© Filip K.
Package: terrario
Présentation du projet :Terrario 2 (suite du mondialement connuTerrario) est un jeu de minage en 2D dans un monde infini créé de manière procedurale, avec différents biomes, des prairies, des montagnes et des grottes.
Vous incarnez une foreuse dont le but est d'aller le plus profondément possible en améliorant celle-ci en collectant divers minerais trouvable dans différentes grottes.Le but du jeu estd'améliorer sa foreuse au niveau maximum, pour miner dans denouveaux environnements.Pour ouvrirl'interface d'améliorations, il faudra appuyer sur latouche "A"de votre clavier.Pour améliorer votre foreuse, il faudra unnombre de minerais requis, affiché dans l'interface d'améliorations.Les minerais que vous avez minés sont affichés dansl'inventairedu joueur, qui s'affiche en appuyant sur latouche "E"du clavier.Comment jouer ?Il vous suffit d'exécuter les commandes suivantes :$pipinstallterrario# Pour installer le jeu.$terrario# Pour le lancer.Ou alors, vous pouvez également installer Terrario manuellement, en installant le module python Pygame version 2.1.1 minimum et Opensimplex en exécutant la commande suivante :$pipinstall-rrequirements.txtEt en ouvrant "terrario.pyw".Fonctionnalités :Un monde infini généré de manière procédurale.Différents environnements.Un système de sauvegarde.Un inventaire.Des améliorations pour le joueur.Textures :La plupart des textures utilisées pour les tuiles de la map proviennent d'un pack nomméBare BonesLicense: All Rights Reserved.Captures d’écran :
Package: terrarium
InstallationDocumentationRelease NotesGithub PageIssue TrackingPackage and ship relocatable python virtual environments,
like a boss.Terrarium will package up
and compress a virtualenv for you based on pip requirements
and then let you ship that environment around.
Do the complex dependency math one time
and then every subsequent install is basically at the speed of
file transfer + decompression.The Problem Terrarium SolvesPip and virtualenv are awesome,
but pip is not designed to allow
consistent and reproducible updates of existing environments.
Pip is also a general installation tool,
meaning that it’s not near as fast as shipping around compressed source code.
This means that even if you have well-made requirements files,
your pip-based deploys are either slow or inconsistent.To get started using terrarium,
see theQuick Startguide.
Package: terrariumai
Example usageimport random
from terrariumai import connectRemoteModel, createAction

def randomAction():
    return random.randint(0, 1)
def randomDirection():
    return random.randint(0, 3)

def modelFunc(obsv):
    action = createAction(obsv.id, randomAction(), randomDirection())
    return action


connectRemoteModel(
  # Find your secret key in your dashboard at http://terrarium.ai
  secret='secret-key', 
  modelFunc=modelFunc, 
)Converting Compiled gRPC FilesWhen gRPC files are compiled into this package, they need to be edited slightly in order to fit in.The import at the top ofcollective_pb2_grpc.pymust be changed tofrom . import collective_pb2 as collective__pb2This is because of the way python 3 handles relative imports.Any kind of workaround would be appreciated, this is super annoying!
Package: terrarium-assembler
terrarium-assemblerGenerate Portable Linux Applications,
mostly using python packages and any system package,
that can be run on any Linux,
without Docker, Snap, Flathub, etc.Just portable folder.Free software: MIT licenseDocumentation:https://terrarium-assembler.readthedocs.io.FeaturesTODOCreditsHistory0.1.5 (2020-08-11)Adapt to new interface in “magic”Don’t touch tmpfs to save memory to nuitka compilation–stage-pack-me0.1.0 (2020-07-31)First release on PyPI.Actually couple of months testing in intranet.
Package: terrarium-assembler-win
terrarium-assemblerGenerate Portable Linux Applications,
mostly using python packages and any system package,
that can be run on any Linux,
without Docker, Snap, Flathub, etc.Just portable folder.Free software: MIT licenseDocumentation:https://terrarium-assembler.readthedocs.io.FeaturesTODOCreditsHistory0.1.5 (2020-08-11)Adapt to new interface in “magic”Don’t touch tmpfs to save memory to nuitka compilation–stage-pack-me0.1.0 (2020-07-31)First release on PyPI.Actually couple of months testing in intranet.
Package: terrasafe
Terrasafehttps://github.com/PrismeaOpsTeam/TerrasafeTerrasafe provide a way to secure your automated terraform pipeline and fail if an unauthorized deletion is planned.Usageterraformplan-out=tfplan
terraformshow-jsontfplan|terrasafe--configterrasafe.json
terraformapply--auto-approvetfplanConfigurationThe--configoption allows to specify the path of the JSON configuration file.{"ignore_deletion":["aws_ecs_task_definition*"],// Resource can be deleted"ignore_deletion_if_recreation":["aws_ecs_task_definition*"],// Resource can be replaced"unauthorized_deletion":["aws_ecs_task_definition*"]// Resource can't be deleted by any way}How to delete a resource ?Comment itOr rename the file with the extension.tf.disabledOr define the Env varTERRASAFE_ALLOW_DELETIONto the addresses of resources to delete, separated by;.
Example:export TERRASAFE_ALLOW_DELETION=aws_ecs_task_definition.a;aws_lambda.b
Package: terrasnek
terrasnekA Python Client for theTerraform Cloud API.OverviewThe goal of this project is to support all endpoints available in theTerraform Cloud APIandTerraform EnterpriseAPI.
In general,terrasnekis developed against the Terraform Cloud APIs first (as
most features are released there first and may not be available in Terraform
Enterprise), but all endpoints are loved equally and this project intends to
support both types of users.Note: This project is tested against Terraform Enterprise often, but the code coverage
represented in this repo will always represent coverage against Terraform Cloud
Business Tier (skipping alladminmodules), so the coverage percentage
is higher than represented in the badge.Terraform Enterprise Release NotesTerraform Cloud API ChangelogNote: Terraform Enterprise is the self-hosted distribution of Terraform Cloud.
It offers enterprises a private instance of the Terraform Cloud application,
with no resource limits and with additional enterprise-grade architectural
features like audit logging and SAML single sign-on.UsingterrasnekFor more details on using each endpoint, check out thedocsor thetestdirectory.fromterrasnek.apiimportTFCimportosTFC_TOKEN=os.getenv("TFC_TOKEN",None)TFC_URL=os.getenv("TFC_URL",None)# ex: https://app.terraform.io# set to True if you want to use HTTP or insecure HTTPSSSL_VERIFY=os.getenv("SSL_VERIFY",False)if__name__=="__main__":api=TFC(TFC_TOKEN,url=TFC_URL,verify=SSL_VERIFY)api.set_org("YOUR_ORGANIZATION")terrasnekto Terraform Cloud API Spec CompletenessTo compareterrasnekimplemented endpoints to those listed on the Terraform
Cloud API docs, view the auto-generatedTERRASNEK_API_COVERAGE_COMPLETENESS.mdfile. The goal is to always have over 95% of all published endpoints implemented
at any time.terrasnekCommon Use Case ExamplesSee theterrasnekdocs. You
can download the docs as a PDF directly fromreadthedocs.io.Contributing toterrasnekIf you'd like to contribute toterrasnek, reviewCONTRIBUTING.md.Relevant BlogsMigrating a Lot of State with Python and the Terraform Cloud APIThe Power of the Terraform API: How to Easily Migrate Any Data Between Enterprise and CloudNote: This repo is not officially maintained by HashiCorp.
Package: terrastack
TerrastackThis simple project provides a way to define terrastack specifications through the Python language,
which in turn can be used to output Terraform json specifications.The library itself does not try to create abstractions for every type of resource and attribute that
can be defined in Terraform. The goal for the API is to be as thin as possible - with the help of
using standard python objects and kwarg handling. Sacrificing type safety in order to be feature
compatible with Terraform.Example use:import terrastack as ts

stack = ts.Stack()
stack.extend(ts.Provider("aws",
    region  = "eu-west-1",
    version = "1.30.0",
))

# extend supports variable number of components
stack.extend(
    ts.Resource("aws_instance", "my-instance-1",
        ami="some-ami",
    ),
    ts.Resource("aws_instance", "my-instance-2",
        ami="some-ami",
    ),
    ts.Output("my_output", "some_value"),
)

print(stack.render_json())

# output:
        {
            "output": {
                "my_output": {
                    "value": "some_value"
                }
            },
            "provider": [
                {
                    "aws": {
                        "region": "eu-west-1",
                        "version": "1.30.0"
                    }
                }
            ],
            "resource": {
                "aws_instance": {
                    "my-instance-1": {
                        "ami": "some-ami"
                    },
                    "my-instance-2": {
                        "ami": "some-ami"
                    }
                }
            }
        }
Package: terra-submersa-cli
# Terra Submersa - Command Line InterfaceWe propose a CLI toolbox to interact with the Terra Submersa data portal## usagets-cli tiles listts-cli tiles list --id-only## DevelopmentOnce in the cloned directory, the smoothest way to load the package in an interactive way (thus pursuing code creation)pip install -e .### Dealing with dependenciesThe Python package deals with its own dependences definition in the `setup.py`file.Go check for more infromation https://packaging.python.org/tutorials/distributing-packages#### Util dependenciesIt is nonetheless possible to install devlopment utilities (for testing or such), in a virtual environmentpip3 install virtualenvvirtualenv ts-venv/#sets the correct paths. bin/activatepip install -r requirements-dev.txt#### Save the libraries you install in your envpip freeze > requirements-dev.txt### testing
Package: terratalk
terratalkTerratalkis a simple tool to add an opinionated terraform plan output
into your pull-request as a comment. This allows you to have a quick feedback on
infrastructure changes without having to leave the context of your pull-request
view.SetupPrerequisiteThis tool relies on eitherBitbucket Branch SourceorGitHub Branch Sourceto
be installed as a plugin on your Jenkins. Alternatively you can set the
environment variableCHANGE_URLto the URL of the pull-request which will
allowterratalkto construct the proper API request to your SCM.GitLab is currently only supported from gitlab-pipelines.InstallationOn the build agent, installterratalk:$pipinstall--userterratalkIf you are using GitHub you will additionally need to install the following:$pipinstall--userPyGithubIf you are using GitLab you will additionally need to install the following:$pipinstall--userpython-gitlabRunningExecute in the same directory, optionally with the sameTF_DATA_DIRas you
would normally runterraform. If you usetfenvthat will work as well.$terraformplan-outWORKSPACE.plan
$terratalkcomment-wWORKSPACESupported environment variablesBitbucket ServerSTASH_USERSTASH_PASSBitbucket CloudBITBUCKET_USERNAMEBITBUCKET_APP_PASSWORDGitHubGITHUB_TOKENGitLabGITLAB_TOKENResultsLicenseMIT
Package: terratools
TerraToolsTools to read, analyse and visualise models written by the TERRA mantle convection code.
TerraTools is released under an MIT License.Homepage:https://terratools.readthedocs.io/en/latest/Documentation:https://terratools.readthedocs.io/en/latest/Source code:https://github.com/mantle-convection-constrained/terratoolsCiting TerraToolsWe are currently writing a paper for submission to JOSS. Watch this space.Reporting bugsIf you would like to report any bugs, please raise an issue onGitHub.Contributing to TerraToolsIf you would like to contribute bug fixes, new functions or new modules to the existing codebase, please fork the terratools repository, make the desired changes and then make a pull request onGitHub.Acknowledgement and SupportThis project is supported byNERC Large Grant MC-squared.