CPAN::Groonga

ed to distribution metadata under the custom
C<x_contributors> key.  (e.g. in C<META.yml>, C<META.json>, etc)

If you have duplicate contributors because of differences in committer name
or email you 

se. See https://github.com/plicease/AnyEvent-WebSocket-Client/issues/30
use AnyEvent::HTTP;
use JSON;

=head1 NAME

Centrifugo::Client

=head1 SYNOPSIS

 use Centrifugo::Client;
 use AnyEve

infoRef->{version};		
	}) -> on('message', sub{
		my ($infoRef)=@_;
		print "MESSAGE: ".encode_json $infoRef->{data};

	}) -> connect(
		user => $USER_ID,
		timestamp => $TIMESTAMP,
		token =>

my ($this, $body) = @_;
	$this->_debug( "Centrifugo::Client : Connected to Centrifugo : ".encode_json $body );	
	# on Connect, the client_id must be read (if available)
	if ($body && ref($body) eq 

use strict;
use warnings;
package App::bovespa;

use LWP::UserAgent;
use JSON;

my $agent_string = "Mozilla/5.0 (Windows NT 6.3; rv:36.0) Gecko/20100101 Firefox/36.0";

sub new {
    my ( $class ) = @

:single = 1;

    my %url_params = (
        q           => $yahoo_query,
        format      => "json",
        env         => "store://datatables.org/alltableswithkeys", 
        callback    => unde

     $raw_html = $response->decoded_content;
    }else{
        die;
    }

    my $data = decode_json $raw_html;
    return $data->{ query }{ results }{ quote }{ Bid };

}

=head1 NAME

App::bovespa 

# ABSTRACT: JsonSQL distribution. A collection of modules for generating safe SQL from JSON strings.






use strict;
use warnings;
use 5.014;

package JsonSQL;

our $VERSION = '0.41'; # VERSION


1;

AME

JsonSQL - JsonSQL distribution. A collection of modules for generating safe SQL from JSON strings.

=head1 VERSION

version 0.41

=head1 SYNOPSIS

This is a set of modules used to turn a JSON str

esenting an SQL query into an appropriate SQL statement.

For example,

    use JsonSQL::Query::Select;
    
    my $jsonString = '{
        "fields": [
            {"column": "*"}
        ],
        

 be nothing more than a light wrapper around Physics::Ballistics.

use strict;
use warnings;

use JSON;
use File::Slurp;
use IPC::Open3;
use lib "/home/ttk/modules";
use lib "./lib";  # For running fr

 my $got_errors = 0;
    while(defined(my $js = <STDIN>)) {
      chomp($js);
      my $hr = JSON::from_json($js);
      $self->reset_the_blanks();
      $self->{cartridge_name}     = $hr->{cartridge_

in_achtung();
    die(join("\n",($filenames_ar, @errs))) unless ($ok eq 'OK');
  }

  # print JSON::to_json({filenames_ar => $filenames_ar})."\n";
  print join("\n",@{$filenames_ar})."\n" if (defined(

# ABSTRACT: JSON query base class. Provides the quote_identifier method for escaping table and column identifiers.


use strict;
use warnings;
use 5.014;

package JsonSQL::Query::Query;

our $VERSION 

= '0.41'; # VERSION

use JsonSQL::Validator;



sub new {
    my ( $class, $query_rulesets, $json_schema, $quote_char ) = @_;
    
    ## DB specific values can be used in the future, but for now we a

> $quoteChar
    };
    
    # Get a JsonSQL::Validator object with the provided $json_schema and $query_rulesets.
    my $validator = JsonSQL::Validator->new($json_schema, $query_rulesets);
    if ( 

::Validate::IP qw/is_ipv4 is_ipv6 is_public_ipv4/;
use SimpleR::Reshape;
use Data::Dumper;
use JSON;
use File::Spec;
use Net::CIDR qw/cidr2range/;
use Socket qw/inet_aton inet_ntoa/;
use Memoiz

package WebService::BR::AceitaFacil;

use strict;
use MIME::Base64;
use JSON::XS;
use utf8;

# Configura as URLs de destino baseado na tag raiz
$WebService::BR::AceitaFacil::Target = {
 sandbox => {
 

ss->{ua}->env_proxy;

 # JSON helper
 $class->{json} = JSON::XS->new->allow_nonref->utf8;


 bless( $class, $self );
}


sub ua      { shift->{ua} }
sub json    { shift->{json} }
sub app     { shift->

s dados (será convertido em JSON string).
# @param $Endpoint    Tipo da Requisição (equivalente à tag raiz, exemplo: "requisicao-transacao")
#        $Params      JSON string a enviar com os dados

#!/usr/bin/perl
use JSON;
use Encode;
use Data::Validate::IP;
use FindBin;
$|=1;

our $DATA_DIR='data';

our $PRIVATE = { 
    country => '局域网',
    region => '局域网',
    isp => '局域网'

        my $c = `/usr/bin/curl -s "$url"`;
        my $r;
        eval {
            $r = decode_json($c);
        };
        unless($r){
            print "retry $ip\n";
            sleep 3;
       

e MooseX::MarkAsMethods ( autoclean => 1 );
use MooseX::Types::Moose qw(Str Maybe);

use URI;
use JSON;
use HTTP::Request::Common;

use Pinto::Result;
use Pinto::Constants qw(:protocol);
use Pinto::Ut

->chrome->palette,
        quiet    => $self->chrome->quiet
    };

    return ( chrome => encode_json($chrome_args) );

}

#---------------------------------------------------------------------------

$self->username,
        time_offset => current_time_offset,
    };

    return ( pinto => encode_json($pinto_args) );
}

#-----------------------------------------------------------------------------

use MooseX::StrictConstructor;
use MooseX::MarkAsMethods ( autoclean => 1 );

use URI;
use JSON qw(decode_json);
use HTTP::Request::Common qw(GET);

use Pinto::Util qw(whine);
use Pinto::Constants qw(

_line;
		whine "Stratopan is not responding: $status";
		return;
	}

	my $structs = eval { decode_json($response->content) };
	whine "Invalid response from Stratopan: $@" and return if $@;

	return un

sponder for action requests

package Pinto::Server::Responder::Action;

use Moose;

use Carp;
use JSON;
use IO::Pipe;
use IO::Select;
use Try::Tiny;
use File::Temp;
use File::Copy;
use Proc::Fork;
use

ams{chrome} ? decode_json( $params{chrome} ) : {};
    my $pinto_args  = $params{pinto}  ? decode_json( $params{pinto} )  : {};
    my $action_args = $params{action} ? decode_json( $params{action} ) :

ion 1.11

=head1 SYNOPSIS

Zabbix check for disk

=cut
use strict;
use warnings;
use v5.10.1;
use JSON;
use Lazy::Utils;

use Zabbix::Check;


BEGIN
{
	require Exporter;
	our $VERSION     = '1.11';
	o

					eval { $stats = from_json($tmp) } if $tmp;
				}
				next;
			}
			if (not $old_stats)
			{
				my $tmp = file_get_contents($tmp_path);
				eval { $old_stats = from_json($tmp) } if $tmp;
				next

		}
		unlink($tmp_path);
	}
	unless ($stats)
	{
		$stats = stats();
		my $tmp;
		eval { $tmp = to_json($stats, {pretty => 1}) };
		file_put_contents("$tmp_prefix$now.$$", $tmp) if $tmp;
	}
	return unl

ackage Pinto::Remote::Action::Add;

use Moose;
use MooseX::MarkAsMethods ( autoclean => 1 );

use JSON;

use Pinto::Util qw(throw);

#------------------------------------------------------------------

MooseX::Types::Moose qw(Bool Str Undef);

use String::Format;
use File::Copy ();
use JSON qw(encode_json decode_json);

use Pinto::Util qw(:all);
use Pinto::Types qw(Dir File Version);

use version;
u

inflate_column(
    'properties' => {
        inflate => sub { decode_json( $_[0] || '{}' ) },
        deflate => sub { encode_json( $_[0] || {} ) }
    }
);

#----------------------------------------

-----

__PACKAGE__->inflate_column(
    'metadata' => {
        inflate => sub { CPAN::Meta->load_json_string( $_[0] ) },
        deflate => sub { $_[0]->as_string( { version => "2" } ) }
    }
);

#-

package HBase::JSONRest;

use strict;
use warnings;

use Carp;
use HTTP::Tiny;
use URI::Escape;
use MIME::Base64;
use JSON::XS qw(decode_json encode_json);
use Time::HiRes qw(gettimeofday time);
use D

ers => {
             'Accept' => 'application/json',
         }
    });

    return if $self->_handle_error( $uri, $rs );

    my $response = decode_json($rs->{content});

    my @tables = ();
    fo

ers => {
             'Accept' => 'application/json',
         }
    });

    return if $self->_handle_error( $uri, $rs );

    my $response = decode_json($rs->{content});

    return $response;
}

# 

ThreatStack;

use 5.10.0;
use strict;
use warnings;
use feature 'switch';
use feature 'say';

use JSON;
use REST::Client;

use Moose;
use Moose::Util::TypeConstraints;
use MooseX::Params::Validate;

POST') {
      my $json_args = JSON->new->allow_nonref->utf8->encode($params{args}{data});
      say "[_call]: Making call POST $url" if $self->debug;
      $client->POST($url, $json_args, $headers)
 

rom Redis

$1: I<bind, by defaut 127.0.0.1:6379>

=cut
use strict;
use warnings;
use v5.10.1;
use JSON;
use Net::NTP;
use Lazy::Utils;


BEGIN
{
	require Exporter;
	our $VERSION     = '1.12';
	our @IS

		$newkey => $newval;
				} keys(%$item));
				\%newitem;
			} @items),
		],
	};
	my $result = to_json($discovery, {pretty => 1});
	print $result;
	return $result;
}

sub _version
{
	my $result = "";

ck

=head1 DEPENDENCIES

This module requires these other modules and libraries:

=over

=item *

JSON

=item *

Net::NTP

=item *

Lazy::Utils

=back

=head1 REPOSITORY

B<GitHub> L<https://github.co

use strict;
use warnings;
use 5.12.0;

use REST::Client;
use JSON;

use vars qw($VERSION);
$VERSION = '1.001';

=head1 NAME

WebService::IFConfig::Client - Client for Martin Polden's https://ifconfig.

                      0 means do not run until a request is made.
  server    https://ifconfig.co/json    IPD Server, but you can run your own and provide it here.

=cut

# Whether to run immediately 

nfig.co/json',
    reader  => 'get_server',
    writer  => 'set_server'
);

has '_json' => (
    is      => 'ro',
    isa     => 'HashRef',
    default => sub { {} },
    reader  => '_get_json',
    w