Saravanan666/pypi-org huggingface dataset:
Package: aws-polly
TODO: Modify the whole file as necessary.This is a “long description” file for the package that you are creating.
If you submit your package to PyPi, this text will be presented on thepublic pageof your package.Note: This README has to be written usingreStructured Text, otherwise PyPi won’t format it properly.InstallationThe easiest way to install most Python packages is viaeasy_installorpip:$ easy_install aws_pollyUsageTODO: This is a good place to start with a couple of concrete examples of how the package should be used.The boilerplate code provides a dummymainfunction that prints out the word ‘Hello’:>> from awspolly import main
>> main()When the package is installed viaeasy_installorpipthis function will be bound to theaws_pollyexecutable in the Python installation’sbindirectory (on Windows - theScriptsdirectory).
Package: aws-portknock
aws-portknockPort knocking for AWS security groups"Port knocking"Unlike the traditional port knocking utilities, this tool relies on
the caller having the rights, through Amazon Web Services' Identity
and Access Management roles, to modify a security group.Usage$ aws-portknock --help
Usage: aws-portknock [OPTIONS]

Options:
  --port INTEGER  Port to open
  --profile TEXT  Configuration profile to use
  --sgid TEXT     Security group ID
  --help          Show this message and exit.aws-portknockwill determine the caller's public IP and add a rule
to the security group allowing access to the requested port from that
IP. It then sleeps until the user quits by using CTRL-C.If a matching rule already exists, nothing happens on exit; otherwise,
that added rule is deleted whenaws-portknockexits.For repeated use, create$HOME/.aws/portknock.inicontaining, for example:[default]
sgid = sg-12abcdef
port = 22

[webprofile]
sgid = sg-12abcdef
port = 443
Package: awsprocesscreds
A collection of process-based credential providers to be used with the AWS CLI
and related tools.This is an experimental package, breaking changes may occur on any minor
version bump.InstallationThe easiest way to install is to use pip:pip install awsprocesscredsRequirementsThis package requires a version of python to be installed. Currently supported
python versions are:2.7.9+3.3.x3.4.x3.5.x3.6.xSAML Forms-Based AuthenticationIf you have a SAML identity provider, you can useawsprocesscreds-samlto
configure programmatic access to your AWS resources. It has four required
arguments:-e/--endpoint- Your SAML idp endpoint.-u/--username- Your SAML username.-p/--provider- The name of your SAML provider. Currently okta and
adfs are supported.-a/--role-arn- The role arn you wish to assume. Your SAML provider
must be configured to give you access to this arn.This will cache your credentials by default, which will allow you to run
multiple commands without having to enter your password each time. You can
disable the cache by specifying--no-cache.Additionally, you can show logs by specifying-vor--verbose.To configure this provider, you need create a profile using thecredential_processconfig variable. See theAWS CLI Config docsfor more details on this config option.Example okta configuration:[profile okta]
region = us-west-2
credential_process = awsprocesscreds-saml -e https://example.okta.com/home/amazon_aws/blob/123 -u 'monty@example.com' -p okta -a arn:aws:iam::123456789012:role/okta-devExample adfs configuration:[profile adfs]
region = us-west-2
credential_process = awsprocesscreds-saml -e 'https://corp.example.com/adfs/ls/IdpInitiatedSignOn.aspx?loginToRp=urn:amazon:webservices' -u Monty -p adfs -a arn:aws:iam::123456789012:role/ADFS-DevCustom ProvidersThe mechanism this package uses to provide credentials is generally available,
and not specific to this package. It can be used to implement any custom
credential provider that will work with the AWS CLI, boto3, and other SDKs as
they implement support.A detailed breakdown of this mechanism along with a live demo of implementing a
credential provider that hooks into the macOS keychain can be seen on this
recorded talk from re:Invent 2017:AWS CLI: 2107 and BeyondThe CLI will call the process provided as the value forcredential_process.
This process must return credentials on stdout in the following JSON form:{
   "Version": 1,
   "AccessKeyId": "string",
   "SecretAccessKey": "string",
   "SessionToken": "string",
   "Expiration": "2019-01-31T21:45:41+00:00"
}WhereExpirationis an RFC 3339 compatible timestamp. As the expiration
time nears, the process will be called again to get a new set of credentials.
TheVersiondenotes the version of this format, whose only current valid
value is1. The remaining keys are the AWS credentials you wish to use.
Package: awsprocesscreds35
A collection of process-based credential providers to be used with the AWS CLI
and related tools.This is an experimental package, breaking changes may occur on any minor
version bump.InstallationThe easiest way to install is to use pip:pip install awsprocesscredsRequirementsThis package requires a version of python to be installed. Currently supported
python versions are:2.7.9+3.3.x3.4.x3.5.x3.6.xSAML Forms-Based AuthenticationIf you have a SAML identity provider, you can useawsprocesscreds-samlto
configure programmatic access to your AWS resources. It has four required
arguments:-e/--endpoint- Your SAML idp endpoint.-u/--username- Your SAML username.-p/--provider- The name of your SAML provider. Currently okta and
adfs are supported.-a/--role-arn- The role arn you wish to assume. Your SAML provider
must be configured to give you access to this arn.This will cache your credentials by default, which will allow you to run
multiple commands without having to enter your password each time. You can
disable the cache by specifying--no-cache.Additionally, you can show logs by specifying-vor--verbose.To configure this provider, you need create a profile using thecredential_processconfig variable. See theAWS CLI Config docsfor more details on this config option.Example okta configuration:[profile okta]
region = us-west-2
credential_process = awsprocesscreds-saml -e https://example.okta.com/home/amazon_aws/blob/123 -u 'monty@example.com' -p okta -a arn:aws:iam::123456789012:role/okta-devExample adfs configuration:[profile adfs]
region = us-west-2
credential_process = awsprocesscreds-saml -e 'https://corp.example.com/adfs/ls/IdpInitiatedSignOn.aspx?loginToRp=urn:amazon:webservices' -u Monty -p adfs -a arn:aws:iam::123456789012:role/ADFS-DevCustom ProvidersThe mechanism this package uses to provide credentials is generally available,
and not specific to this package. It can be used to implement any custom
credential provider that will work with the AWS CLI, boto3, and other SDKs as
they implement support.A detailed breakdown of this mechanism along with a live demo of implementing a
credential provider that hooks into the macOS keychain can be seen on this
recorded talk from re:Invent 2017:AWS CLI: 2107 and BeyondThe CLI will call the process provided as the value forcredential_process.
This process must return credentials on stdout in the following JSON form:{
   "Version": 1,
   "AccessKeyId": "string",
   "SecretAccessKey": "string",
   "SessionToken": "string",
   "Expiration": "2019-01-31T21:45:41+00:00"
}WhereExpirationis an RFC 3339 compatible timestamp. As the expiration
time nears, the process will be called again to get a new set of credentials.
TheVersiondenotes the version of this format, whose only current valid
value is1. The remaining keys are the AWS credentials you wish to use.
Package: aws-profile
Wrapper script to generate and pass AWS AssumeRole keys to other scriptsUsageThere are two primary ways to useaws-profile, inline using arguments and with environment variables.Inline Profile Nameaws-profile [-p, –profile <profile name> -r, –region <region>] <command>Profile Environment Variableaws-profile –profile dev –region us-west-2 <command>oraws-profile -p dev -r us-west-2 <command>OptionsAWS_CACHE: Set the AWS_CACHE environment variable to control caching.
UseAWS_CACHE=falseto disable caching, or any other value
(or unset) to keep caching enabled. When set to false the MFA
code will be requested every time.Configuring Profilesaws-profileuses the built in profiles from the AWS CLI. For full details seeNamed Profilesin the AWS Documentation.Here is an example of how to configure a profile for a role, with MFA:[profile my_profile]
role_arn = arn:aws:iam::<account_id>:role/<role_name>
source_profile = default
mfa_serial = arn:aws:iam::<account_id>:mfa/<username>Where<account_id>is your AWS Account ID,<role_name>is the name of the role you want to assume, and<username>is the username of the AWS User used fo your default profile.DevelopmentClone from github (or preferably from your own fork)git clonehttps://github.com/jrstarke/aws-profile.gitCreate a clean virtual environment examples for virtualenv and pyenv with virtualenv wrappervirtualenv venvsource venv/bin/activateorpyenv virtualenvaws-profilepyenv activateaws-profileInstall the development dependenciespip install-e".[dev]"Run the tests before making changes and then again before creating a pull request (There will be 3 warnings about external dependencies which can be ignored)pytest--cov=awsprofile--cov-reportterm-missing
Package: aws-profile-switcher
AWS Profile SwitcherThe tool which allows you to jump between your profiles in your~/.aws/credentialsProblematicsWell, if you are operating only one AWS account then you will not find this util useful. Problem appears when there are more than 3 accounts under your control. Sure, you can use--profileflag with any your aws cli command. But what if you need to run number of commands for several accounts, then make sure you don't forget to add--profileto your command or specified the right profile name.
Another example is about Hashicorp Terraform. Let's imagine that you have one module which you need to apply for several accounts. Unfortunately, terraform doesn't allow you to specify--profileand that's logically since Terraform is not about AWS. So, you will need to hardcode your AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY or go to~/.aws/credentialsand change the[default]profile.How to installThat's easy just runsudo pip install aws-profile-switcherOrclonethis repository and runmake installHow does it workSimple switchWhat have you seen:User calledaws-profile-switcheraws-profile-switcheridentified that current default is among of all profiles so it allowd to proceed without any aditional operationsaws-profile-switcherasked user to choose new default profileaws-profile-switcherswitched the defaultIn case you have a default but no backup for itWhat have you seen:User calledaws-profile-switcheraws-profile-switcherunderstood that there is no backup for profile that is currently set to default and suggested to make a backupUser agreed to make a backup and gave it the nameaws-profile-switcherasked user to choose new default profileVoila, default is changed and the old default is backed upIn case there is no default at allWhat have you seen:User calledaws-profile-switcheraws-profile-switcherasked user to choose new default profileThere was no defalut profile at all, soaws-profile-switcherhas created itIn case user doesn't want backing up the defaultWhat have you seen:User calledaws-profile-switcheraws-profile-switcherunderstood that there is no backup for profile that is currently set to default and suggested to make a backupUser disagreed to make a backupaws-profile-switcherasked to agreed that he/she doesn't want to make a backupDefault is changed and the old default was not backed up
Package: aws-prototyping-sdk
DEPRECATION NOTICE:Theaws-prototyping-sdkis on path to deprecation. This package is simply a wrapper around the individual@aws-prototyping-skd/*packages and has no unique code aside from bundling the other packages. Due to lack of significant value compared to maintenance overhead, this package will be deprecated soon in favor of using the individual packages directly. Please use the individual packages starting now to prevent future migration and loss of update capabilities.The aws-prototyping-sdk provides stable CDK and Projen constructs, allowing developers to have access to higher level abstractions than provided by the CDK or Projen alone.For detailed documentation, please refer to thedocumentation website.BundlingThis package simply bundles various packages from the@aws-prototyping-sdknamespace which have been marked asstable. As such, not all constructs or classes may be exported from this package and will need to be explicitly imported by creating a dependency on the individual packages.To illustrate, at the time of writing the following individual packages are published:@aws-prototyping-sdk
        |_ pipeline       : [stable]
        |_ nx-monorepo    : [stable]
        |_ static-website : [experimental]
        |_ identity       : [experimental]The aws-prototyping-sdk package will bundle all stable packages and export them as namespaces as follows:aws-prototyping-sdk
        |_ pipeline
        |_ nx_monorepoThis means if you wanted to access the PDKPipeline which is a stable construct, you simply add a dependency on theaws-prototyping-sdkand import it as follows:import{nx_monorepo,pipeline}from"aws-prototyping-sdk";To importexperimentalconstructs, a dependency on the individual package is required. In the case ofstatic-website, a dependency on@aws-prototyping-sdk/static-websiteis required. The constructs can then be imported as follows:import{StaticWebsite}from"@aws-prototyping-sdk/static-website";
Package: aws-prototyping-sdk.awsui-react-ts-website
Getting startedTo create a newAWS UIReact Typescript Project, there are a couple of options:Via Projen CLInpx projen new --from @aws-prototyping-sdk/awsui-react-ts-website awsui-react-ts-website [--application-name <your-app>]ProgrammaticallynewAwsUiReactTsWebsiteProject({defaultReleaseBranch:"mainline",name:"<name-of-package>",applicationName:"<name-of-app>",});Running your synthesized ApplicationTo run your synthesized application locally, runnpx projen dev.Developer NotesTo enable Cognito auth, ensure you have a runtime-config.json file in the root of your deployed project which at least contains the following:{"region":"<aws-region>","identityPoolId":"<identity-pool-id>","userPoolId":"<user-pool-id>","userPoolWebClientId":"<user-pool-web-client-id>"}The easiest way to get this set up is to use the static-website + identity packages to deploy your website.An example of how to do this is as follows:constuserIdentity=newUserIdentity(this,'UserIdentity');newStaticWebsite(this,'StaticWebsite',{websiteContentPath:'<relative>/<path>/<to>/<built>/<website>',runtimeOptions:{jsonPayload:{region:Stack.of(this).region,identityPoolId:userIdentity.identityPool.identityPoolId,userPoolId:userIdentity.userPool?.userPoolId,userPoolWebClientId:userIdentity.userPoolClient?.userPoolClientId,}},});For local development, you will need to copy the generated runtime-config.json file into your /public directory. An example on how to do this is as follows:curl https://dxxxxxxxxxx.cloudfront.net/runtime-config.json > public/runtime-config.json
Package: aws-prototyping-sdk.cloudscape-react-ts-website
Getting startedTo create a newCloudscapeReact Typescript Project, there are a couple of options:Via Projen CLInpx projen new --from @aws-prototyping-sdk/cloudscape-react-ts-website cloudscape-react-ts-website [--application-name <your-app>]ProgrammaticallynewCloudscapeReactTsWebsiteProject({defaultReleaseBranch:"mainline",name:"<name-of-package>",applicationName:"<name-of-app>",});Running your synthesized ApplicationTo run your synthesized application locally, runnpx projen dev.Developer NotesTo enable Cognito auth, ensure you have a runtime-config.json file in the root of your deployed project which at least contains the following:{"region":"<aws-region>","identityPoolId":"<identity-pool-id>","userPoolId":"<user-pool-id>","userPoolWebClientId":"<user-pool-web-client-id>"}The easiest way to get this set up is to use the static-website + identity packages to deploy your website.An example of how to do this is as follows:constuserIdentity=newUserIdentity(this,'UserIdentity');newStaticWebsite(this,'StaticWebsite',{websiteContentPath:'<relative>/<path>/<to>/<built>/<website>',runtimeOptions:{jsonPayload:{region:Stack.of(this).region,identityPoolId:userIdentity.identityPool.identityPoolId,userPoolId:userIdentity.userPool?.userPoolId,userPoolWebClientId:userIdentity.userPoolClient?.userPoolClientId,}},});For local development, you will need to copy the generated runtime-config.json file into your /public directory. An example on how to do this is as follows:curl https://dxxxxxxxxxx.cloudfront.net/runtime-config.json > public/runtime-config.json
Package: aws-prototyping-sdk.identity
BREAKING CHANGES(pre-release)> v0.15.5: updated defaults for UserPoolWithMfa will break deployments for already created userPools. If migrating to a newer version of this package, be sure to set the following in yourcdk.context.json:{
    "@aws-prototyping-sdk/identity:useLegacyMFAProps":true
  }This module by default deploys a configurable Identity Provider with a default Cognito User Pool. These resources can be used by your website to restrict access to only authenticated users if needed. All settings are configurable and the creation of these AuthN resources can be disabled if needed or configured to use custom AuthN providers i.e. Facebook, Google, etc.Below is a conceptual view of the default architecture this module creates:Cognito User Pool --------------------> Identity Pool
     |_ User Pool Client                     |_ Unauthenticated IAM Role
                                             |_ Authenticated IAM RoleMigrating UsersIf you ever need to migrate users from one cognito user pool to another, you can use this helper utility:https://www.npmjs.com/package/cognito-backup-restore
Package: aws-prototyping-sdk.pdk-nag
PDK NagPDKNag ships with a helper utility that automatically configures CDKNag within your application.constapp=PDKNag.app();conststack=newStack(app,'MyStack');...As shown above, this will configure your application to have CDKNag run on synthesis.By default, CDK will trigger a failure onsynthif any errors are encountered. To relax these, run the following:cdksynth--ignore-errorsConversely, CDK will not fail on synth if warnings are detected. To enforce that all warnings are resolved, run the following command:cdksynth--strictInstrumenting custom NagPacksBy default, when creating a PDKNag application theAwsSolutionsNagPack is instrumented. In order to specify custom NagPacks to instrument, you can configure the PDKApp as follows:import{PDKNag,AwsPrototypingChecks}from"@aws-prototyping-sdk/pdk-nag";constapp=PDKNag.app({nagPacks:[newAwsPrototypingChecks()]});In this example, theAwsPrototypingChecksNagPack has been configured to run instead of the default. Multiple NagPacks can also be instrumented by adding NagPack instances to thenagPacksarray;
Package: aws-prototyping-sdk.static-website
The static-website module is able to deploy your pre-packaged static website content into an S3 Bucket, fronted by Cloudfront. This module uses an Origin Access Identity to ensure your Bucket can only be accessed via Cloudfront and is configured to only allow HTTPS requests by default. Custom runtime configurations can also be specified which will emit a runtime-config.json file along with your website content. Typically this includes resource Arns, Id's etc which may need to be referenced from your website. This package uses sane defaults and at a minimum only requires the path to your website assets.Below is a conceptual view of the default architecture this module creates:Cloudfront Distribution (HTTPS only) -> S3 Bucket (Private via OAI)
|_ WAF V2 ACL                                |_ index.html (+ other website files and assets)
                                             |_ runtime-config.jsonA typical use case is to create a static website with AuthN. To accomplish this, we can leverage the UserIdentity to create the User Pool (Cognito by default) and Identity Pool. We can then pipe the respective pool id's as runtimeOptions into the StaticWebsite. After the website is deployed, these values can be interrogated from the runtime-config.json deployed alongside the website in order to perform authentication within the app using something like theAmplify Auth API.constuserIdentity=newUserIdentity(this,'UserIdentity');newStaticWebsite(this,'StaticWebsite',{websiteContentPath:'<relative>/<path>/<to>/<built>/<website>',runtimeOptions:{jsonPayload:{region:Stack.of(this).region,identityPoolId:userIdentity.identityPool.identityPoolId,userPoolId:userIdentity.userPool?.userPoolId,userPoolWebClientId:userIdentity.userPoolClient?.userPoolClientId,}},});
Package: aws-prototyping-sdk.type-safe-api
Type Safe APIDefine your APIs usingSmithyorOpenAPI v3, and leverage the power of generated client and server types, infrastructure, documentation, and automatic input validation!This package vends a projen project type which allows you to define an API using eitherSmithyorOpenAPI v3, and a construct which manages deploying this API in API Gateway, given an integration (eg a lambda) for every operation.The project will generate "runtime" projects from your API definition in your desired languages, which can be utilised both client side for interacting with your API, or server side for implementing your API. The project also generates a type-safe CDK construct which ensures an integration is provided for every API operation.Code is generated at build time, so when you change your API model, just rebuild and you'll see your changes reflected in the generated code.Project StructureTheTypeSafeApiProjectprojen project will create the following directory structure within itsoutdir:|_ model/
    |_ src/
        |_ main/
            |_ smithy - your API definition if you chose ModelLanguage.SMITHY
            |_ openapi - your API definition if you chose ModelLanguage.OPENAPI
|_ generated/
    |_ runtime/ - generated types, client, and server code in the languages you specified
        |_ typescript
        |_ python
        |_ java
    |_ infrastructure/ - generated infrastructure (you'll find only one directory in here based on your chosen infrastructure language)
        |_ typescript
        |_ python
        |_ java
    |_ documentation/ - generated documentation in the formats you specified
        |_ html2
        |_ html_redoc
        |_ plantuml
        |_ markdown
    |_ library/ - generated libraries if specified
        |_ typescript-react-query-hooksGetting StartedPlease see theGetting Started Guidefor how to get started!Developer GuidesFor more information about Type Safe API, take a look at the developer guides:Using SmithyUsing OpenAPIIntegrationsMocking ResponsesAuthorizersLambda HandlersReact Query HooksAPI KeysWalkthroughsFor detailed end-to-end examples, take a look at the walkthroughs:Custom Integration: ECS and NLBYou can also check out theFrequently Asked Questions.