CPAN::Groonga

bel in the output manifest file.


=head2 LabelCategoryConfigS3Uri => Str

The S3 location of the JSON file that defines the categories used to
label data objects. Please note the following label-cate

d labeling: 20 labels

=item *

Box bounding labeling jobs (all): 10 labels

=back

The file is a JSON structure in the following format:

C<{>

C<"document-version": "2018-11-28">

C<"labels": [>

C<

choose C<AugmentedManifestFile>, S3Uri identifies an object that
is an augmented manifest file in JSON lines format. This file contains
the data you want to use for model training. C<AugmentedManifest

 might look like this: C<s3://bucketname/example.manifest>

A manifest is an S3 object which is a JSON file consisting of an array
of elements. The first element is a prefix which is followed by one o

/custdata-1",>

C<"relative/path/custdata-2",>

C<...>

C<"relative/path/custdata-N">

C<]>

This JSON is equivalent to the following C<S3Uri> list:

C<s3://customer_bucket/some/prefix/relative/path/t

sful, the service sends back an HTTP 200
response. Amazon SageMaker returns the following data in JSON format:

=over

=item *

C<CompilationJobArn>: The Amazon Resource Name (ARN) of the compiled
job

IPTION

Contains input values for a task.

=head1 ATTRIBUTES


=head2 B<REQUIRED> Input => Str

A JSON object that contains values for the variables defined in the
template. It is made available to th

 if you define a variable
C<task.input.text> in your template, you can supply the variable in the
JSON object as C<"text": "sample text">.



=head1 SEE ALSO

This class forms part of L<Paws>, describ

QUIRED> MonitoringScheduleSummaries => ArrayRef[L<Paws::SageMaker::MonitoringScheduleSummary>]

A JSON array in which each element is a summary for a monitoring
schedule.


=head2 NextToken => Str

If

erences in the C<ManifestFile> is shuffled. If you use
C<AugmentedManifestFile>, the order of the JSON lines in the
C<AugmentedManifestFile> is shuffled. The shuffling order is determined
using the C<

atest/dg/batch-transform-data-processing.html).

=head1 ATTRIBUTES


=head2 InputFilter => Str

A JSONPath
(https://docs.aws.amazon.com/sagemaker/latest/dg/batch-transform-data-processing.html#data-pr

.

For JSON or JSONLines objects, such as a JSON array, Amazon SageMaker
adds the transformed data to the input JSON object in an attribute
called C<SageMakerOutput>. The joined result for JSON must b

JSON file. In the new JSON file, and the
input data is stored under the C<SageMakerInput> key and the results
are stored in C<SageMakerOutput>.

For CSV data, Amazon SageMaker takes each row as a JSON

ax: 255
              OutputFormat =>
                'PARQUET',    # values: PARQUET, ORC, AVRO, JSON, TEXTFILE
              OutputS3Uri       => 'MyS3Uri',              # max: 1024
              Qu

> TemplateData => Str

A list of replacement values to apply to the template. This parameter
is a JSON object, typically consisting of key-value pairs in which the
keys correspond to replacement tags 

<REQUIRED> Payload => Str

A zip archive in binary format. The archive should contain one file, a
JSON file containing the resource to import. The resource should match
the type specified in the C<res

lication/vnd.docker.distribution.manifest.v1+json> |
C<application/vnd.docker.distribution.manifest.v2+json> |
C<application/vnd.oci.image.manifest.v1+json>



=head2 B<REQUIRED> ImageIds => ArrayRef[

package Paws::Net::RestJsonResponse;
  use Moose;
  with 'Paws::Net::ResponseRole';
  use JSON::MaybeXS;
  use Carp qw(croak);
  use Paws::Exception;

  sub process {
    my ($self, $call_object, $res

 }
 
  sub unserialize_response {
    my ($self, $response) = @_;

    my $struct = eval { decode_json( $response->content ) };
    if ($@) {
      return Paws::Exception->throw(
        message => $@

::CallerRole';

  use Paws::Net::APIResponse;
  use File::Slurper qw(read_text write_text);
  use JSON::MaybeXS;
  use Moose::Util::TypeConstraints;
  use Path::Tiny;

  has file => (is => 'rw', isa =

    lazy => 1,
    default => sub { '' },
    );

  has _encoder => (is => 'ro', default => sub { JSON::MaybeXS->new(canonical => 1) });

  sub send_request {
    my ($self, $service, $call_object) = 

package Paws::Net::JsonResponse;
  use Moose;
  use JSON::MaybeXS;
  use Carp qw(croak);
  use Paws::Exception;
  use feature 'state';

  sub process {
    my ($self, $call_object, $response) = @_;

 

 if (not defined $response->content or $response->content eq '');

    my $struct = eval { decode_json( $response->content ) };
    if ($@) {
      return Paws::Exception->throw(
        message => $@

package Paws::Net::JsonCaller;
  use Paws;
  use Moose::Role;
  use JSON::MaybeXS;
  use POSIX qw(strftime);
  requires 'json_version';

  use Paws::Net::JsonResponse;

  has response_to_object => (
 

ault => sub {
      Paws::Net::JsonResponse->new;
    }
  );

  # converts the objects that represent the call into parameters that the API can understand
  sub _to_jsoncaller_params {
    my ($self, 

$_; ( $k => [ map { $self->_to_jsoncaller_params($_) } @{$params->Map->{$_} } ] ) } keys %{ $params->Map } };
      } else {
        return { map { $_ => $self->_to_jsoncaller_params($params->Map->{$_

ww.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
  # perl 5.6 ready UTF-8 encoding adapted from JSON::PP
  our %escapes = map { chr($_) => sprintf("%%%02X", $_) } 0..255;
  our $unsafe_char = qr/[^A

t::RestJsonCaller;
  use Paws;
  use Moose::Role;
  use HTTP::Request::Common;
  use POSIX qw(strftime); 
  use URI::Template;
  use JSON::MaybeXS;
  use Scalar::Util;

  use Paws::Net::RestJsonRespon

 => sub {
      Paws::Net::RestJsonResponse->new;
    }
  );

  # converts the objects that represent the call into parameters that the API can understand
  sub _to_jsoncaller_params {
    my ($self, 

       $p{ $key } = $params->$att;
          } else {
            $p{ $key } = [ map { $self->_to_jsoncaller_params($_) } @{ $params->$att } ];
          }
        } elsif ($att_type->isa('Moose::Meta

is => 'ro', isa => 'Str');
  has PolicyHashCondition => (is => 'ro', isa => 'Str');
  has PolicyInJson => (is => 'ro', isa => 'Str', required => 1);
  has ResourceArn => (is => 'ro', isa => 'Str');

 

'Glue');
    my $PutResourcePolicyResponse = $glue->PutResourcePolicy(
      PolicyInJson          => 'MyPolicyJsonString',
      EnableHybrid          => 'TRUE',                 # OPTIONAL
      Poli

meter if no previous
policy has been set.



=head2 B<REQUIRED> PolicyInJson => Str

Contains the policy document to set, in JSON format.



=head2 ResourceArn => Str

Do not use. For internal use onl

/www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
# perl 5.6 ready UTF-8 encoding adapted from JSON::PP
our %escapes = map { chr($_) => sprintf("%%%02X", $_) } 0..255;
our $unsafe_char = qr/[^A-Za-

se Moose::Role;
  use JSON::MaybeXS;
  use URI::Template;

  use Paws::Net::JsonResponse;

  has response_to_object => (
    is => 'ro',
    default => sub {
      Paws::Net::JsonResponse->new;
    }

ects that get json-encoded to API calls, we
      #will have to "hand-encode" the Session Parameter
      $qparams = { Action => $call->_api_call,
                   SessionType => 'json',
           

ionDuration)?(SessionDuration => $call->SessionDuration):(),
                   Session => encode_json({
                     sessionId    => $call->SessionId,
                     sessionKey   => $ca