Group
Extension

Matches 35359

IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/MrzRequest.pm ( view source; MetaCPAN )
oPerl::Client::Object::MrzRequest;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/MrzResponse.pm ( view source; MetaCPAN )
Perl::Client::Object::MrzResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/ImageListResponse.pm ( view source; MetaCPAN )
Client::Object::ImageListResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/ExtractedImage.pm ( view source; MetaCPAN )
l::Client::Object::ExtractedImage;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
Dancer-SearchApp ( C/CO/CORION/Dancer-SearchApp-0.06.tar.gz, CORION, 2016; MetaCPAN )
Dancer-SearchApp/bin/index-imap.pl ( view source; MetaCPAN )
ndex %indices %analyzers );
use Dancer::SearchApp::Utils qw(await);

use JSON::MaybeXS;
my $true = JSON->true;
my $false = JSON->false;

GetOptions(
    'force|f' => \my $force_rebuild,
    'config|c:
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/ImageRequest.pm ( view source; MetaCPAN )
erl::Client::Object::ImageRequest;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/ReportResponse.pm ( view source; MetaCPAN )
l::Client::Object::ReportResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/UserResponse.pm ( view source; MetaCPAN )
erl::Client::Object::UserResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/AnalysisApi.pm ( view source; MetaCPAN )
_resource_path = '/v0/pdfreport/{analysisRefUid}';
    $_resource_path =~ s/{format}/json/; # default format to json

    my $_method = 'GET';
    my $query_params = {};
    my $header_params = {};
  
tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json; charset=utf-8');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept
y $_resource_path = '/v0/result/{analysisRefUid}';
    $_resource_path =~ s/{format}/json/; # default format to json

    my $_method = 'GET';
    my $query_params = {};
    my $header_params = {};
  
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/AdministrationApi.pm ( view source; MetaCPAN )
nputs
    my $_resource_path = '/v0/admin/health';
    $_resource_path =~ s/{format}/json/; # default format to json

    my $_method = 'GET';
    my $query_params = {};
    my $header_params = {};
  
tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json; charset=utf-8');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept
 inputs
    my $_resource_path = '/v0/admin/user';
    $_resource_path =~ s/{format}/json/; # default format to json

    my $_method = 'GET';
    my $query_params = {};
    my $header_params = {};
  
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/TaskResponse.pm ( view source; MetaCPAN )
erl::Client::Object::TaskResponse;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/SandboxApi.pm ( view source; MetaCPAN )
 $_resource_path = '/v0/sandbox/image/{imageUid}';
    $_resource_path =~ s/{format}/json/; # default format to json

    my $_method = 'GET';
    my $query_params = {};
    my $header_params = {};
  

    my $_resource_path = '/v0/sandbox/imagelist';
    $_resource_path =~ s/{format}/json/; # default format to json

    my $_method = 'GET';
    my $query_params = {};
    my $header_params = {};
  
tent-Type' header
    my $_header_accept = $self->{api_client}->select_header_accept('application/json; charset=utf-8');
    if ($_header_accept) {
        $header_params->{'Accept'} = $_header_accept
IdcheckioPerl-Client ( D/DJ/DJAGOUDEL/IdcheckioPerl-Client-1.0.3.1.tar.gz, DJAGOUDEL, 2016; MetaCPAN )
IdcheckioPerl-Client/lib/IdcheckioPerl/Client/Object/Image.pm ( view source; MetaCPAN )
heckioPerl::Client::Object::Image;

require 5.6.0;
use strict;
use warnings;
use utf8;
use JSON qw(decode_json);
use Data::Dumper;
use Module::Runtime qw(use_module);
use Log::Any qw($log);
use Date::
# return perl hash
sub to_hash {
    return decode_json(JSON->new->convert_blessed->encode( shift ));
}

# used by JSON for serialization
sub TO_JSON { 
    my $self = shift;
    my $_data = {};
    f
 deserialize the data
    while ( my ($_key, $_type) = each %{$self->swagger_types} ) {
    	my $_json_attribute = $self->attribute_map->{$_key}; 
        if ($_type =~ /^array\[/i) { # array
        
Device-WallyHome ( C/CJ/CJHAMIL/Device-WallyHome-0.21.3.tar.gz, CJHAMIL, 2016; MetaCPAN )
Device-WallyHome/lib/Device/WallyHome/Role/REST.pm ( view source; MetaCPAN )
seX::AttributeShortcuts;

use Data::Dumper;
use HTTP::Headers;
use HTTP::Request;
use JSON::MaybeXS qw(decode_json);
use LWP::UserAgent;

use Device::WallyHome::Test::Data;

our $VERSION = '0.21.3';

se->content();
    }

    my $decodedResponse = {};

    eval {
        $decodedResponse = decode_json($responseContent);
    };

    if ($@) {
        $self->_lastApiError($@);

        return undef;
Algorithm-LDA ( B/BT/BTMCINNES/Algorithm-LDA-0.03.tar.gz, BTMCINNES, 2016; MetaCPAN )
Algorithm-LDA/bin/lda.pl ( view source; MetaCPAN )
rations - Maximum Iterations
# $updateCorpus - 1 = Force update documents, 0 = allow loading from JSON
# $wordThreshold - Minimum number of documents a word must appear in
# $alpha - Default Alpha val
SilverGoldBull-API ( D/DB/DBOYS/SilverGoldBull-API-0.08.tar.gz, DBOYS, 2016; MetaCPAN )
SilverGoldBull-API/lib/SilverGoldBull/API.pm ( view source; MetaCPAN )
aders;
use URI;
use JSON::XS;

use SilverGoldBull::API::Response;

use constant {
  API_URL           => 'https://api.silvergoldbull.com/',
  JSON_CONTENT_TYPE => 'application/json',
  TIMEOUT        
 return LWP::UserAgent->new();
  }
);

has 'json' => (
  is       => 'ro',
  init_arg => undef,
  isa      => 'JSON::XS',
  default  => sub {
    return JSON::XS->new();
  }
);

has 'api_url' => ( is 
f->api_key,
    %{$args->{params} || {}},
  );
  
  my $head = HTTP::Headers->new(Content_Type => JSON_CONTENT_TYPE);
  $head->header(%params);
  my $req  = HTTP::Request->new($args->{method},$args->{
Algorithm-LDA ( B/BT/BTMCINNES/Algorithm-LDA-0.03.tar.gz, BTMCINNES, 2016; MetaCPAN )
Algorithm-LDA/lib/Algorithm/LDA.pm ( view source; MetaCPAN )
ccessor::Fast/;
use List::Util qw(shuffle sum max);
use List::MoreUtils qw(uniq first_index);
use JSON::XS;


use vars qw($VERSION);

$VERSION = '0.03';


#Used for accessing $self->documents
__PACKAG
rations - Maximum Iterations
# $updateCorpus - 1 = Force update documents, 0 = allow loading from JSON
# $threshold - Minimum number of documents a word must appear in
# $numWords - Number of words pe
<- hash containing data

output:

 1

example:

 while (my $line = <$fh2>) {
    my $obj = decode_json($line);
    add(%$obj);
 }

=cut

#Used to add to array of documents ($self->documents)
#Adds a w
Monitor-MetricsAPI ( J/JS/JSIME/Monitor-MetricsAPI-0.900.tar.gz, JSIME, 2016; MetaCPAN )
Monitor-MetricsAPI/lib/Monitor/MetricsAPI/Tutorial.pm ( view source; MetaCPAN )
on.

From the operator's perspective, Monitor::MetricsAPI provides an HTTP API which
can spit out JSON showing some or all of the values the application developer
has decided to track. "There are 5,61

are omitted from the examples above for brevity.]

And because you can get these metrics back in JSON at any time you wish simply
by calling the API, instead of having to consume logs or wait for you
Monitor-MetricsAPI ( J/JS/JSIME/Monitor-MetricsAPI-0.900.tar.gz, JSIME, 2016; MetaCPAN )
Monitor-MetricsAPI/lib/Monitor/MetricsAPI/Server/Routes.pm ( view source; MetaCPAN )
Routes;
$Monitor::MetricsAPI::Server::Routes::VERSION = '0.900';
use Dancer2;

set serializer => 'JSON';

=head1 NAME

Monitor::MetricsAPI::Server::Routes

=head1 SYNOPSIS

You should not interact wit
s are provided by this server for viewing the collected
metrics.

=cut

=head2 /

Returns a small JSON structure with metadata about the metrics collector. May
be used as a heartbeat for the service, 
Mojolicious-Plugin-FormTamperingProtector ( J/JA/JAMADAM/Mojolicious-Plugin-FormTamperingProtector-0.03.tar.gz, JAMADAM, 2016; MetaCPAN )
Mojolicious-Plugin-FormTamperingProtector/README.pod ( view source; MetaCPAN )
Mojo::Base 'Mojolicious::Plugin';
our $VERSION = '0.03';
use Data::Dumper;
use Mojo::JSON qw(decode_json encode_json);
use Mojo::Util qw{encode decode xml_escape hmac_sha1_sum secure_compare
         
charset, $html);
}

sub serialize {
    return b64_encode(encode_json(shift // return), '');
}

sub deserialize {
    return decode_json(b64_decode(shift // return));
}

sub sign {
    my ($value, $se

Powered by Groonga
Maintained by Kenichi Ishigaki <ishigaki@cpan.org>. If you find anything, submit it on GitHub.