view release on metacpan or  search on metacpan

lib/FilmAffinity/UserRating.pm  view on Meta::CPAN

  my ($next, $page) = (1, 1);
  while ( $next ){
    my $url = $self->p_buildUrl( $page );
    my $response = $self->ua->get($url);
    if ($response->is_success){
      my $content = $response->decoded_content();
      $self->parseString($content);
      $next = $self->p_isNextPage($content);
      $page++;
    } else {
      $next = 0;

 view release on metacpan or  search on metacpan

CryptFile/lib/Filter/Crypto/CryptFile.pm  view on Meta::CPAN

given.

=item Can't decode odd-numbered (%d-byte) length hexadecimal text

The hexadecimal encoding of the encrypted source code, consisting of a pair of
hexadecimal digits for each byte of data, could not be decoded because an odd
number of hexadecimal digits were found.

=item Can't decode non-hexadecimal digit (byte %02x at position %d) in
      hexadecimal text

The hexadecimal encoding of the encrypted source code, consisting of a pair of
hexadecimal digits for each byte of data, could not be decoded because a byte
other than a hexadecimal digit was found.

=item Can't derive %d-byte key: %s

libcrypto's PKCS#5 v2.0 compatible key derivation algorithm failed to derive a

 view release on metacpan or  search on metacpan

lib/Filter/Dockerfile.pm  view on Meta::CPAN

            if ( -f $uri ) {
                local $/ = undef;
                open my $fh, $uri || die "$uri: $!";
                push @content, join("", <$fh>);
            } else {
                push @content, $self->{ua}->get($uri)->decoded_content();
            }
        }
        chomp(@content);
        @content = merge($merge, \@content, $include, $exclude);
        $_ = "print <<'EOM';\n".join("\n", @content)."\nEOM\n";

 view release on metacpan or  search on metacpan

lib/Filter/Encoding.pm  view on Meta::CPAN

=head1 DESCRIPTION

This module allows your code to be written in any ASCII-based encoding.
Just pass the name of the encoding as an argument to C<use
Filter::Encoding>.  The source code will be decoded and treated as though it had been written in UTF-8 with C<use utf8> in effect.  That's all this
module does.

It is intended as a simpler, saner replacement for L<encoding.pm|encoding>,
one that does not change the up- and downgrading of strings or touch your
file handles.

 view release on metacpan or  search on metacpan

examples/closure/UUdecode.pm  view on Meta::CPAN

	        }
        
	        # uudecode the line
	        $_ = unpack("u", $_) ;
        
	        # return the uudecoded data
	        return $status ;
            }
        })
        
}

 view release on metacpan or  search on metacpan

lib/Finance/BTCIndo.pm  view on Meta::CPAN

    log_trace("JSON API request: %s", $url);

    my $res = $self->{_http}->get($url);
    die "Can't retrieve $url: $res->{status} - $res->{reason}"
        unless $res->{success};
    my $decoded;
    eval { $decoded = $self->{_json}->decode($res->{content}) };
    die "Can't decode response from $url: $@" if $@;

    log_trace("JSON API response: %s", $decoded);

    $decoded;
}

sub tapi {
    my ($self, $method, %args) = @_;

lib/Finance/BTCIndo.pm  view on Meta::CPAN

    my $url = "$url_prefix/tapi/";
    my $res = $self->{_http}->post($url, $options);
    die "Can't retrieve $url: $res->{status} - $res->{reason}"
        unless $res->{success};
    my $decoded;
    eval { $decoded = $self->{_json}->decode($res->{content}) };
    die "Can't decode response from $url: $@" if $@;

    log_trace("TAPI response: %s", $decoded);

    die "API response not a hash: $decoded" unless ref $decoded eq 'HASH';
    die "API response is not success: $decoded->{error}" unless $decoded->{success};
    $decoded;
}

sub _check_pair {
    my $pair = shift;
    $pair =~ /\A(\w{3,5})_(\w{3,5})\z/

 view release on metacpan or  search on metacpan

lib/Finance/Bank/Kraken.pm  view on Meta::CPAN

Sets or gets the API key.

=item $api->secret($secret)

Sets the API secret to C<$secret> or returns the API secret base64 decoded.

=item $result = $api->call(Public, $method)

=item $result = $api->call(Private, $method)

 view release on metacpan or  search on metacpan

lib/Finance/Bank/LloydsTSB/Account.pm  view on Meta::CPAN

    if (! $self->_on_account_overview_page) {
# This is the one we want
#         my @links = $self->ua->find_all_links;
#         my $correct = $links[0]->text;

        # GRR!    gets decoded into \xa0 by HTML::TokeParser
        # (which uses HTML::Entities::decode_entities)
        unless ($self->ua->follow_link(text_regex =>
                                         qr/Account[ \xa0]overview/))
        {
#             my $dumpfile = '/tmp/dump.html';

 view release on metacpan or  search on metacpan

lib/HAL/Resource.pm  view on Meta::CPAN

    my $ua = WWW::Mechanize->new();
    my $res = $ua->get('https://api.example.com/');
    my $r = HAL::Resource->new(
        ua => $ua,
        %{ decode_json( $res->decoded_content ) },
    );

=head1 ABOUT

This module is just a very thin wrapper for HAL resources. If you find this

 view release on metacpan or  search on metacpan

lib/Finance/Bank/Paytrail.pm  view on Meta::CPAN

(Nice-to-have) Populated when you call submit. The entire unprocessed response content.

=cut

has 'server_response'      => ( is => 'rw' );    # the response as a perl data structure, decoded from json

=head2 result_code

(Nice-to-have) Populated when you call submit. The HTTP status code of the reply.

 view release on metacpan or  search on metacpan

lib/Finance/BitFlip.pm  view on Meta::CPAN

    my $url = "$url_prefix$method_args";
    my $res = $self->{_http}->get($url);
    die "Can't retrieve $url: $res->{status} - $res->{reason}"
        unless $res->{success};
    my $decoded;
    eval { $decoded = $self->{_json}->decode($res->{content}) };
    die "Can't decode response from $url: $@" if $@;

    log_trace("API GET response: %s", $decoded);

    die "API response not an array: $decoded" unless ref $decoded eq 'ARRAY';
    die "API response is not success: $decoded->[0] - $decoded->[1]" if defined $decoded->[0];
    $decoded;
}

sub post_request {
    my ($self, $method, %args) = @_;

lib/Finance/BitFlip.pm  view on Meta::CPAN

    my $url = "$url_prefix$method";
    my $res = $self->{_http}->post($url, $options);
    die "Can't retrieve $url: $res->{status} - $res->{reason}"
        unless $res->{success};
    my $decoded;
    eval { $decoded = $self->{_json}->decode($res->{content}) };
    die "Can't decode response from $url: $@" if $@;

    log_trace("API POST response: %s", $decoded);

    die "API response not an array: $decoded" unless ref $decoded eq 'ARRAY';
    die "API response is not success: $decoded->[0] - $decoded->[1]" if defined $decoded->[0];
    $decoded;
}

1;
# ABSTRACT: Trade with bitflip.li using Perl

 view release on metacpan or  search on metacpan

lib/Finance/Bitcoin/Yacuna.pm  view on Meta::CPAN

		elsif('POST' eq $httpMethod){
			my $req = new HTTP::Request('POST', $self->{'uri'} . $self->{'basePath'} . $self->{'apiVersion'}.'/'.$restPath);
			$req->content_type('application/x-www-form-urlencoded');
			$req->content($body);
			my $res = $self->{'httpClient'}->request($req);
			return $res->decoded_content;
		}

	};
	return $self->{'httpClient'}->response->decoded_content if $self->{'httpClient'}->response;
}

sub prepareAuth(){
	my ($path, $body, $httpMethod, $apiSecret, $debug) = @_;
	my $tokenSalt = ''.time*1000;

 view release on metacpan or  search on metacpan

lib/Finance/Card/Discover.pm  view on Meta::CPAN

    return unless $res->is_success;

    # The response content is a url-encoded string.
    my %data = do {
        my $u = URI->new;
        $u->query($res->decoded_content);
        $u->query_form
    };
    return if not %data or 'error' eq $data{action};
    return \%data;
}

 view release on metacpan or  search on metacpan

lib/Finance/CoinbasePro/Lite.pm  view on Meta::CPAN

    log_trace("JSON API request: %s", $url);

    my $res = $self->{_http}->get($url);
    die "Can't retrieve $url: $res->{status} - $res->{reason}"
        unless $res->{success};
    my $decoded;
    eval { $decoded = $self->{_json}->decode($res->{content}) };
    die "Can't decode response from $url: $@" if $@;

    log_trace("JSON API response: %s", $decoded);

    $decoded;
}

sub _request {
    my ($self, $is_private, $method, $request_path, $params) = @_;

 view release on metacpan or  search on metacpan

CompanyNames/TextSupport.pm  view on Meta::CPAN

declassification declassified declassify declassifying
declayed declaying
declination declinations decline declined decliner decliners declines declining
declinist declinists
declutched declutching
decodable decode decoded decoder decoders decodes decoding
decoked decoking
decollation decollators
decollete decolletes
decolonization decolonize decolonized decolonizing
decoloration decolored decoloring

CompanyNames/TextSupport.pm  view on Meta::CPAN

precursor precursors precursory
precusor precusors
predate predation predator predators
predecease predeceases
predecessor predecessors
predecoded predecoder
predefinable predefine predefined predefines predefining
predeterminable predeterminately predetermine predetermined predetermining
predicate predicated predicates
predict predictabilities predictability predictable predictably predictated predicted predicting prediction predictions predictive predictively predicts
predictor predictors

CompanyNames/TextSupport.pm  view on Meta::CPAN

decliner
decliners
declines
declining
decode
decoded
decoder
decoders
decodes
decoding
decodings

 view release on metacpan or  search on metacpan

lib/Finance/Crypto/Exchange/Kraken.pm  view on Meta::CPAN

    my $response = $self->ua->request($req);

    if ($response->is_success) {
        my $data;
        try {
            $data = decode_json($response->decoded_content);
        }
        catch {
            die "Unable to decode JSON from Kraken!", $/;
        };

 view release on metacpan or  search on metacpan

lib/Finance/Dogecoin/API.pm  view on Meta::CPAN

    while (my ($key, $value) = each %params) {
        $uri->query_param( $key => $value );
    }

    my $response = $self->ua->get( $uri );
    my $result   = $self->json->decode( $response->decoded_content );

    Carp::croak( "Bad API call from $method() call" ) if $result eq 'Bad Query';
    Carp::croak( "Invalid API key '" . $self->api_key . "'" )
        if $result eq 'Invalid API Key';

 view release on metacpan or  search on metacpan

lib/Finance/Indodax.pm  view on Meta::CPAN

    log_trace("JSON API request: %s", $url);

    my $res = $self->{_http}->get($url);
    die "Can't retrieve $url: $res->{status} - $res->{reason}"
        unless $res->{success};
    my $decoded;
    eval { $decoded = $self->{_json}->decode($res->{content}) };
    die "Can't decode response from $url: $@" if $@;

    log_trace("JSON API response: %s", $decoded);

    $decoded;
}

sub tapi {
    my ($self, $method, %args) = @_;

lib/Finance/Indodax.pm  view on Meta::CPAN

    my $url = "$url_prefix/tapi/";
    my $res = $self->{_http}->post($url, $options);
    die "Can't retrieve $url: $res->{status} - $res->{reason}"
        unless $res->{success};
    my $decoded;
    eval { $decoded = $self->{_json}->decode($res->{content}) };
    die "Can't decode response from $url: $@" if $@;

    log_trace("TAPI response: %s", $decoded);

    die "API response not a hash: $decoded" unless ref $decoded eq 'HASH';
    die "API response is not success: $decoded->{error}" unless $decoded->{success};
    $decoded;
}

sub _check_pair {
    my $pair = shift;
    $pair =~ /\A(\w{3,5})_(\w{3,5})\z/

 view release on metacpan or  search on metacpan

lib/Finance/PremiumBonds.pm  view on Meta::CPAN

    if (!$resp->is_success) {
        warn "Request failed - " . $resp->status_line;
        return;
    }

    my $resp_data = JSON::from_json($resp->decoded_content);

    if ($resp_data->{holder_number} eq 'is_invalid') {
        carp "Holder number not recognised by NS+I";
        return;
    }

 view release on metacpan or  search on metacpan

devel/Casablanca.pm  view on Meta::CPAN

  foreach my $symbol (@symbol_list) {
    my $url = make_url ($symbol);

    my $req = HTTP::Request->new ('GET', $url);
    $ua->prepare_request ($req);
    $req->accept_decodable; # we know decoded_content() below
    $req->user_agent (__PACKAGE__."/$VERSION " . $req->user_agent);
    ### Request: $req->as_string

    my $resp = $ua->request ($req);
    resp_to_quotes ($fq, $symbol, $resp, \%quotes);

devel/Casablanca.pm  view on Meta::CPAN

  $quotes->{$symbol,'currency'} = 'MAD';
  $quotes->{$symbol,'source'} = __PACKAGE__;
  $quotes->{$symbol,'success'} = 1;

  # defaults to latin1, which is right
  my $content = $resp->decoded_content (raise_error => 1, charset => 'none');
  if (! $resp->is_success) {
    $quotes->{$symbol,'success'}  = 0;
    $quotes->{$symbol,'errormsg'} = $resp->status_line;
    return;
  }