view release on metacpan or  search on metacpan

lib/AsposeThreeDCloud/ApiClient.pm  view on Meta::CPAN

148
149
150
151
152
153
154
155
156
157
158
    $self->{get_access_token_time} = time();
    return $_response_object;
}
 
# make the HTTP request
# @param string $resourcePath path to method endpoint
# @param string $method method to call
# @param array $queryParams parameters to be place in query URL
# @param array $postData parameters to be placed in POST body
# @param array $headerParams parameters to be place in request header
# @return mixed

lib/AsposeThreeDCloud/ApiClient.pm  view on Meta::CPAN

403
404
405
406
407
408
409
410
411
412
413
my ($self, $header_params, $query_params, $auth_settings) = @_;
 
return $self->_global_auth_setup($header_params, $query_params) 
    unless $auth_settings && @$auth_settings;
 
# one endpoint can have more than 1 auth settings
foreach my $auth (@$auth_settings) {
    # determine which one to use
    if (!defined($auth)) {
        # TODO show warning about auth setting not defined
    }

lib/AsposeThreeDCloud/ApiClient.pm  view on Meta::CPAN

421
422
423
424
425
426
427
428
429
430
431
432
433
434
            # TODO show warning about security definition not found
        }
    }
}
 
# The endpoint API class has not found any settings for auth. This may be deliberate, 
# in which case update_params_for_auth() will be a no-op. But it may also be that the 
# OpenAPI Spec does not describe the intended authorization. So we check in the config for any 
# auth tokens and if we find any, we use them for all endpoints; 
sub _global_auth_setup {
        my ($self, $header_params, $query_params) = @_; 
         
        my $tokens = $self->{config}->get_tokens;
        return unless keys %$tokens;

 view release on metacpan or  search on metacpan

lib/AsposeWordsCloud/ApiClient.pm  view on Meta::CPAN

63
64
65
66
67
68
69
70
71
72
73
    }
    $self->{http_timeout} = $seconds;
}
 
# make the HTTP request
# @param string $resourcePath path to method endpoint
# @param string $method method to call
# @param array $queryParams parameters to be place in query URL
# @param array $postData parameters to be placed in POST body
# @param array $headerParams parameters to be place in request header
# @return mixed

 view release on metacpan or  search on metacpan

lib/Astro/ADS/Search.pm  view on Meta::CPAN

1
2
3
4
5
6
package Astro::ADS::Search;
# ABSTRACT: Queries the ADS Search endpoint and collects the results
$Astro::ADS::Search::VERSION = '1.90';
use Moo;
extends 'https://metacpan.org/pod/Astro::ADS">Astro::ADS';
with 'https://metacpan.org/pod/Astro::ADS::Role::ResultMapper">Astro::ADS::Role::ResultMapper';

lib/Astro/ADS/Search.pm  view on Meta::CPAN

166
167
168
169
170
171
172
173
174
175
 
=encoding UTF-8
 
=head1 NAME
 
Astro::ADS::Search - Queries the ADS Search endpoint and collects the results
 
=head1 VERSION
 
version 1.90

 view release on metacpan or  search on metacpan

lib/Astro/Catalog/Query/Sesame.pm  view on Meta::CPAN

58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
my $self = shift;
 
# clean out buffer
$self->_set_raw("");
 
my $endpoint = $self->endpoint();
my %options = $self->_translate_options();
 
# return unless we haev a target, set it otherwise
return undef unless $self->query_options("object");
 
# make sesame query
my $service = SOAP::Lite->service($self->endpoint());
 
my $ident = $self->query_options("object");
$ident =~ s/\+/ /g;
 
my $buffer;

lib/Astro/Catalog/Query/Sesame.pm  view on Meta::CPAN

94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
These methods are for internal use only.
 
=over 4
 
=item B<_default_endpoint>
 
=cut
 
sub _default_endpoint {
    return "http://cdsws.u-strasbg.fr/axis/services/Sesame?wsdl";
}
 
=item B<_default_urn>

 view release on metacpan or  search on metacpan

lib/Astro/DSS/JPEG.pm  view on Meta::CPAN

67
68
69
70
71
72
73
74
75
76
77
        ua         => $ua                                                          # Optional
    );
   
All parameters are optional. The constructor by default creates an L<LWP::UserAgent>,
but you can pass your own with C<ua>, while the URL to the L<STScI|https://archive.stsci.edu/dss/copyright.html>
JPEG endpoint and the L<SIMBAD|http://simbad.u-strasbg.fr/simbad/> simple identifier query
interface can be redefined (e.g. if they change in the future) from the above shown defaults.
 
=head1 METHODS
 
=head2 C<get_image>

lib/Astro/DSS/JPEG.pm  view on Meta::CPAN

144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
=back
 
=head1 NOTES
 
Some artifacts can be seen at the borders of separate "stripes" of the survey and
also the particular JPEG endpoint used sometimes can leave the corners as plain black
squares (depending on the selected frame size, as it is to do with the way it does
segmentation), so if you want to make sure you have a frame with no corner gaps,
request some more angular size than you want and crop. 
 
Note that the module test suite won't actually fetch data from either DSS or SIMBAD.
This is mainly to ensure it will not fail even if the DSS & SIMBAD endpoints change,
as you can still use the module by passing the updated urls to the constructor. It
also avoids unneeded strain to those free services.
 
=cut

 view release on metacpan or  search on metacpan

lib/Astro/SIMBAD/Client/WSQueryInterfaceService.pm  view on Meta::CPAN

12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
our $VERSION = '0.047';
## TRW ^^^^
 
my %methods = (
queryObjectById => {
##    endpoint => 'http://simweb.u-strasbg.fr:8080/axis/services/WSQuery',
    endpoint => 'axis/services/WSQuery',
    soapaction => '',
    namespace => 'http://uif.simbad.cds',
    parameters => [
      SOAP::Data->new(name => 'in0', type => 'soapenc:string', attr => {}),
      SOAP::Data->new(name => 'in1', type => 'soapenc:string', attr => {}),
      SOAP::Data->new(name => 'in2', type => 'soapenc:string', attr => {}),
    ], # end parameters
  }, # end queryObjectById
queryObjectByBib => {
##    endpoint => 'http://simweb.u-strasbg.fr:8080/axis/services/WSQuery',
    endpoint => 'axis/services/WSQuery',
    soapaction => '',
    namespace => 'http://uif.simbad.cds',
    parameters => [
      SOAP::Data->new(name => 'in0', type => 'soapenc:string', attr => {}),
      SOAP::Data->new(name => 'in1', type => 'soapenc:string', attr => {}),
      SOAP::Data->new(name => 'in2', type => 'soapenc:string', attr => {}),
    ], # end parameters
  }, # end queryObjectByBib
queryObjectByCoord => {
##    endpoint => 'http://simweb.u-strasbg.fr:8080/axis/services/WSQuery',
    endpoint => 'axis/services/WSQuery',
    soapaction => '',
    namespace => 'http://uif.simbad.cds',
    parameters => [
      SOAP::Data->new(name => 'in0', type => 'soapenc:string', attr => {}),
      SOAP::Data->new(name => 'in1', type => 'soapenc:string', attr => {}),

lib/Astro/SIMBAD/Client/WSQueryInterfaceService.pm  view on Meta::CPAN

67
68
69
70
71
72
73
74
75
76
77
78
79
80
  ## my $name = UNIVERSAL::isa($method => 'SOAP::Data') ? $method->name : $method;
  my $name = eval {$method->isa('SOAP::Data')} ? $method->name : $method;
  ## TRW ^^^^
  my %method = %{$methods{$name}};
  ## TRW vvvv
  $method{endpoint} or Carp::croak "No server address (proxy) specified";
  my $endpoint = $simbad->__build_url( $method{endpoint} );
  ## $self->proxy($method{endpoint} || Carp::croak "No server address (proxy) specified") 
  $self->proxy( $endpoint )
    unless $self->proxy;
  ## TRW ^^^^
  my @templates = @{$method{parameters}};
  my @parameters = ();
## TRW  foreach my $param (@_) {

lib/Astro/SIMBAD/Client/WSQueryInterfaceService.pm  view on Meta::CPAN

90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
    } else {
      push(@parameters, $param);
    }
  }
 
## TRW  $self->endpoint($method{endpoint})
## TRW       ->ns($method{namespace})
## TRW      ->on_action(sub{qq!"$method{soapaction}"!});
 
## vvv TRW
 
if ($self->can ('ns')) {
    $self->endpoint($endpoint)
        ->ns($method{namespace})
        ->on_action (sub{$method{soapaction}});
} else {
    $self->endpoint($endpoint)
        ->envprefix ('soap')
        ->uri($method{namespace})
        ->on_action (sub{$method{soapaction}});
}

 view release on metacpan or  search on metacpan

lib/Async/Template.pm  view on Meta::CPAN

222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
tt $vars, << 'END',
   USE timeout = Second;
   AWAIT timeout.start(10)
 
   r = AWAIT api.call('endpoint', {param = 'val'});
   error = ERROR(r);
   result = RESULT(r);
   RETURN IF ERROR(r);
 
   p2 = ASYNC some_async_fn('param');
   p1 = ASYNC api.call('endpoint', {});
   AWAIT p1;
   AWAIT p2;
   RETURN IF RESULT(r);
 END
 sub{

 view release on metacpan or  search on metacpan

lib/At.pm  view on Meta::CPAN

687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
 
=over
 
=item C<identifier> - required
 
Lexicon endpoint.
 
=item C<content>
 
This will be passed along to the endpoint as query parameters.
 
=back
 
On success, the content is returned. If the lexicon is known, the returned data is coerced into simple (blessed)
objects.

lib/At.pm  view on Meta::CPAN

720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
 
=over
 
=item C<identifier> - required
 
Lexicon endpoint.
 
=item C<content>
 
This will be passed along to the endpoint as encoded JSON.
 
=back
 
On success, the content is returned. If the lexicon is known, the returned data is coerced into simple (blessed)
objects.

 view release on metacpan or  search on metacpan

lib/Attean/Algebra.pm  view on Meta::CPAN

743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
use Types::Standard qw(ConsumerOf Bool);
use namespace::clean;
 
with 'https://metacpan.org/pod/Attean::API::Algebra">Attean::API::Algebra', 'Attean::API::UnaryQueryTree', 'Attean::API::UnionScopeVariables';
 
has 'endpoint' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariable'], required => 1);
has 'silent' => (is => 'ro', isa => Bool, default => 0);
 
sub algebra_as_string {
        my $self        = shift;
        my $endpoint    = $self->endpoint->as_sparql;
        chomp($endpoint);
        return sprintf('Service %s', $endpoint);
}
 
sub tree_attributes { return qw(endpoint) };
 
sub sparql_tokens {
        my $self        = shift;
        my $service     = AtteanX::SPARQL::Token->keyword('SERVICE');
        my $l           = AtteanX::SPARQL::Token->lbrace;

lib/Attean/Algebra.pm  view on Meta::CPAN

767
768
769
770
771
772
773
774
775
776
777
        my @tokens;
        push(@tokens, $service);
        if ($self->silent) {
                push(@tokens, AtteanX::SPARQL::Token->keyword('SILENT'));
        }
        push(@tokens, $self->endpoint->sparql_tokens->elements);
        push(@tokens, $l);
        push(@tokens, $child->sparql_subtokens->elements);
        push(@tokens, $r);
        return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}

 view release on metacpan or  search on metacpan

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

57
58
59
60
61
62
63
64
65
66
}
 
sub prepare_app {
        my $self = shift;
        my $config = $self->{config};
        $self->{endpoint} = eval { AtteanX::Endpoint->new( $config ) };
        if ($@) {
                warn $@;
        }
}

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

70
71
72
73
74
75
76
77
78
79
                my $req = Plack::Request->new($env);
                unless ($req->method =~ /^(GET|HEAD|POST)$/) {
                        return [ 405, [ 'Content-type', 'text/plain' ], [ 'Method not allowed' ] ];
                }
 
                my $ep          = $self->{endpoint};
                my $resp        = $ep->run( $req );
                return $resp->finalize;
        }
}

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

91
92
93
94
95
96
97
98
99
100
  use v5.14;
  use Attean;
 
=head1 DESCRIPTION
 
The AtteanX::Endpoint class implements a PSGI SPARQL Protocol endpoint.
 
=head1 ATTRIBUTES
 
=over 4

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
=item C<< model >>
 
=item C<< conf >>
 
A hash reference containing configuration data for the endpoint. For example:
 
  {
    endpoint  => {
      service_description => {
        named_graphs => 1,
        default => 1,
      },
      html => {

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
sub _run {
        my $self        = shift;
        my $req         = shift;
         
        my $config      = $self->{conf};
        my $endpoint_path = $config->{endpoint}{endpoint_path} || '/sparql';
        my $model       = $self->{model};
         
        my $response    = Plack::Response->new;
 
        our $VERSION;
        my $server = "AtteanX::Endpoint/$VERSION";
        $server .= " " . $response->headers->header('Server') if defined($response->headers->header('Server'));
        $response->headers->header('Server' => $server);
 
        unless ($req->path eq $endpoint_path) {
                my $content;
                my $path        = $req->path_info;
                $path           =~ s#^/##;
                my $dir         = $ENV{ATTEAN_ENDPOINT_SHAREDIR} || File::Spec->catdir((eval { dist_dir('AtteanX-Endpoint') } || 'share'), 'endpoint');
                my $abs         = File::Spec->rel2abs($dir);
                my $file        = File::Spec->catfile($abs, 'www', $path);
                if (-r $file) {
                        open( my $fh, '<', $file ) or croak $!;
                        $response->status(200);

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
if ($req->method !~ /^(GET|POST)$/i) {
        my $method      = uc($req->method);
        $content        = "Unexpected method $method (expecting GET or POST)";
        $self->log_error( $req, $content );
        $response->header('Allow' => 'GET, POST');
        die AtteanX::Endpoint::ClientError->new(code => 405, message => 'Method not allowed', uri => 'http://id.kasei.us/rdf-endpoint/error/bad_http_method');
} elsif (defined($ct) and $ct eq 'application/sparql-query') {
        $sparql = $req->content;
} elsif (defined($ct) and $ct eq 'application/sparql-update') {
        if ($config->{endpoint}{update} and $req->method eq 'POST') {
                $sparql = $req->content;
        }
} elsif ($req->param('query')) {
        my @sparql      = $req->param('query');
        if (scalar(@sparql) > 1) {
                $content        = "More than one query string submitted";
                $self->log_error( $req, $content );
                die AtteanX::Endpoint::ClientError->new(code => 400, message => 'Multiple query strings not allowed', uri => 'http://id.kasei.us/rdf-endpoint/error/multiple_queries');
        } else {
                $sparql = $sparql[0];
        }
} elsif ($req->param('update')) {
        my @sparql      = $req->param('update');
        if (scalar(@sparql) > 1) {
                $content        = "More than one update string submitted";
                $self->log_error( $req, $content );
                die AtteanX::Endpoint::ClientError->new(code => 400, message => 'Multiple update strings not allowed', uri => 'http://id.kasei.us/rdf-endpoint/error/multiple_updates');
        }
 
        if ($config->{endpoint}{update} and $req->method eq 'POST') {
                $sparql = $sparql[0];
        } elsif ($req->method ne 'POST') {
                my $method      = $req->method;
                $content        = "Update operations must use POST";
                $self->log_error( $req, $content );
                $response->header('Allow' => 'POST');
                die AtteanX::Endpoint::ClientError->new(code => 405, message => "$method Not Allowed for Update Operation", uri => 'http://id.kasei.us/rdf-endpoint/error/bad_http_method_update');
        }
}
 
if ($sparql) {
        my %args;
        $args{ update }         = 1 if ($config->{endpoint}{update} and $req->method eq 'POST');
        $args{ load_data }      = 1 if ($config->{endpoint}{load_data});
 
        my $protocol_specifies_update_dataset   = 0;
        {
                my @default     = $req->param('default-graph-uri');
                my @named       = $req->param('named-graph-uri');

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
                                my $error       = $@ || 'Internal error';
                                $self->log_error( $req, $error );
                                my $eclass      = ($error =~ /Syntax/) ? 'AtteanX::Endpoint::ClientError' : 'AtteanX::Endpoint::ServerError';
                                if ($req->method ne 'POST' and $error =~ /read-only queries/sm) {
                                        $error  = 'Updates must use a HTTP POST request.';
                                        die $eclass->new(message => 'Updates must use a HTTP POST request', uri => 'http://id.kasei.us/rdf-endpoint/error/bad_http_method_update');
                                } else {
                                        die $eclass->new(message => 'SPARQL query/update parse error', uri => 'http://id.kasei.us/rdf-endpoint/error/parse_error', details => { error => $error, sparql => $sparql });
                                }
                        } else {
                                $self->log_query( $req, $sparql );
                                # TODO: handle case where query specifies update dataset
#                               if ($protocol_specifies_update_dataset and $query->specifies_update_dataset) {
#                                       my $method      = $req->method;
#                                       $content        = "Update operations cannot specify a dataset in both the query and with protocol parameters";
#                                       $self->log_error( $req, $content );
#                                       die AtteanX::Endpoint::ClientError->new(code => 400, message => 'Multiple datasets specified for update', uri => 'http://id.kasei.us/rdf-endpoint/error/update_specifies_multiple_datasets');
#                               }
                                if ($self->log->is_trace) {
                                        $self->log->trace("Algebra:\n" . $algebra->as_string);
                                }
                                my $graph       = $self->graph;

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
                                        $response->headers->content_type($stype);
                                };
                                if ($@) {
                                        my $error       = $@;
                                        $self->log->fatal($error);
                                        die AtteanX::Endpoint::ServerError->new(code => 500, message => 'SPARQL query/update execution error', uri => 'http://id.kasei.us/rdf-endpoint/error/execution_error', details => { error => $@, sparql => $sparql });
                                }
                        }
                } elsif ($req->method eq 'POST') {
                        $content        = "POST without recognized query or update";
                        $self->log_error( $req, $content );
                        die AtteanX::Endpoint::ClientError->new(message => 'Missing SPARQL Query/Update String', uri => 'http://id.kasei.us/rdf-endpoint/error/missing_sparql_string');
                } else {
                        my $stype               = 'text/html';
                        my $dir                 = $ENV{ATTEAN_ENDPOINT_SHAREDIR} || File::Spec->catdir((eval { dist_dir('AtteanX-Endpoint') } || 'share'), 'endpoint');
                        my $template    = File::Spec->catfile($dir, 'index.html');
                        my $parser              = XML::LibXML->new(validation => 0, suppress_errors => 1, no_network => 1, recover => 2);
                        my $doc                 = $parser->parse_file( $template );
#                       my $gen                 = RDF::RDFa::Generator->new( style => 'HTML::Head');
#                       $gen->inject_document($doc, $sdmodel);

lib/AtteanX/Endpoint.pm  view on Meta::CPAN

568
569
570
571
572
573
574
575
576
577
=back
 
=head1 BUGS
 
Please report any bugs or feature requests to through the GitHub web interface
at L<https://github.com/kasei/atteanx-endpoint/issues>.
 
=head1 SEE ALSO
 
L<http://www.perlrdf.org/>

 view release on metacpan or  search on metacpan

lib/AtteanX/Query/AccessPlan/Cache.pm  view on Meta::CPAN

21
22
23
24
25
26
27
28
29
30
31
my $model = shift;
my $active_graphs       = shift;
my $pattern     = shift;
 
# First, add any plans coming from the original planner (which will
# include queries to the remote SPARQL endpoint
my @plans = $orig->(@params);
my @vars        = $pattern->values_consuming_role('Attean::API::Variable');
my @varstrings = map { $_->value } @vars;
 
# Start checking the cache

 view release on metacpan or  search on metacpan

lib/AtteanX/RDFQueryTranslator.pm  view on Meta::CPAN

173
174
175
176
177
178
179
180
181
182
183
184
185
        my $s           = $self->translate($a->start);
        my $o           = $self->translate($a->end);
        my $path        = $self->translate_path($a->path);
        return Attean::Algebra::Path->new( subject => $s, path => $path, object => $o );
} elsif ($a->isa('RDF::Query::Algebra::Service')) {
        my $endpoint    = $self->translate($a->endpoint);
        my $p                   = $self->translate($a->pattern);
        return Attean::Algebra::Service->new( children => [$p], endpoint => $endpoint );
} elsif ($a->isa('RDF::Query::Algebra::NamedGraph')) {
        my $graph       = $self->translate($a->graph);
        my $p           = $self->translate($a->pattern);
        return Attean::Algebra::Graph->new( children => [$p], graph => $graph );
} elsif ($a->isa('RDF::Query::Algebra::Filter')) {

 view release on metacpan or  search on metacpan

lib/AtteanX/Query/AccessPlan/LDF.pm  view on Meta::CPAN

22
23
24
25
26
27
28
29
30
31
32
my $model = shift;
my $active_graphs       = shift;
my $pattern     = shift;
 
# First, add any plans coming from the original planner (which will
# include queries to the remote SPARQL endpoint
my @plans = $orig->(@params);
# Add my plans
push(@plans, AtteanX::Plan::LDF::Triple->new(subject => $pattern->subject,
                                                                                                                                         predicate => $pattern->predicate,
                                                                                                                                         object => $pattern->object,

 view release on metacpan or  search on metacpan

lib/AtteanX/Model/SPARQL.pm  view on Meta::CPAN

60
61
62
63
64
65
66
67
68
69
70
 
AtteanX::Model::SPARQL - Attean SPARQL Model
 
=head1 SYNOPSIS
 
  my $store = Attean->get_store('SPARQL')->new(endpoint_url => $url);
  my $model = AtteanX::Model::SPARQL->new( store => $store );
 
=head1 DESCRIPTION
 
This model is in practice a thin wrapper around the underlying SPARQL

 view release on metacpan or  search on metacpan

t/30-utf8.t  view on Meta::CPAN

22
23
24
25
26
27
28
29
30
31
 
my $test = Plack::Test->create($app);
my $json = JSON::MaybeXS->new->utf8->allow_nonref;
 
my $res = $test->request(POST "/faces");
ok $res->is_success, "request to endpoint succeeded";
 
is $json->decode($res->content), $faces, "request returned expected response";
 
done_testing;

 view release on metacpan or  search on metacpan

lib/Audio/Nama.pm  view on Meta::CPAN

2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
add_mark: _add_mark ident { Audio::Nama::drop_mark $item{ident}; 1}
add_mark: _add_mark {  Audio::Nama::drop_mark(); 1}
next_mark: _next_mark { Audio::Nama::next_mark(); 1}
previous_mark: _previous_mark { Audio::Nama::previous_mark(); 1}
loop: _loop someval(s) {
        my @new_endpoints = @{ $item{"someval(s)"}}; 
        $Audio::Nama::mode->{loop_enable} = 1;
        @{$Audio::Nama::setup->{loop_endpoints}} = (@new_endpoints, @{$Audio::Nama::setup->{loop_endpoints}}); 
        @{$Audio::Nama::setup->{loop_endpoints}} = @{$Audio::Nama::setup->{loop_endpoints}}[0,1];
        1;}
noloop: _noloop { $Audio::Nama::mode->{loop_enable} = 0; 1}
name_mark: _name_mark ident {$Audio::Nama::this_mark->set_name( $item{ident}); 1}
list_marks: _list_marks { 
        my $i = 0;

 view release on metacpan or  search on metacpan

Basic.pm  view on Meta::CPAN

1
2
3
4
5
6
7
8
9
10
11
12
13
#
# Authen::Challenge::Basic: Provides a trivial challenge/response protocol
#       to assist in authentication tasks. It provides for time-window
#       challenge/response sessions. 
#
# Using this module, it's possible to autenticate both endpoints of
# a transaction provided that a shared-secret was exchanged prior to
# the session among the endpoints. As timestamps are part of the
# protocol, some restrictions can be applied to the timing, to help
# prevent hijacked connections.
#
# This is free software. You can use at will provided that proper
# credit is given to the author(s). This module requires MD5.

Basic.pm  view on Meta::CPAN

72
73
74
75
76
77
78
79
80
81
82
 
The following functions are provided by this class.
 
new()
 
Creates a new instance of a challenge/response endpoint. It has three
parameters that influence its behavior. Those can be seen next
 
        $server = Authen::Challenge::Basic->new ('Secret' => 'known2us',
                                                 'Timeout' => 30,
                                                 'Sync' => 10);

 view release on metacpan or  search on metacpan

t/10-metadata.t  view on Meta::CPAN

105
106
107
108
109
110
111
112
113
# Extract a bit of iCMS metadata
 
my $method = eval { $sp->_icms_method_data('Validate'); } || {};
is($@, '', "parsed iCMS config without error");
is($method->{url}, 'https://ws.test.logon.fakeme.govt.nz/icms/Validate_v1_1',
    'got iCMS endpoint for FLT resolution');
 
 
done_testing();

 view release on metacpan or  search on metacpan

lib/Authen/Tcpdmatch/Tcpdmatch.pm  view on Meta::CPAN

66
67
68
69
70
71
72
73
74
75
 
=back
 
=head2 LIMITATIONS
 
It does not support shell commands,  client lookups, endpoint patterns, spoofing attacks,
and expansions. If these features are important to you,
perhaps you should be using libwarp.so with Authen::Libwrap .
 
=head2 EXPORT

 view release on metacpan or  search on metacpan

lib/Autodia/Diagram.pm  view on Meta::CPAN

1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
[% FOREACH inheritance = inheritances %]
 [%- IF inheritance.Parent >0 AND inheritance.Child >0 -%]
 <assocwidget totalcounta="2" indexa="1" totalcountb="2" indexb="1" widgetbid="[% inheritance.Parent %]" widgetaid="[% inheritance.Child %]" xmi.id="[% inheritance.Id %]" >
  <linepath>
   <startpoint startx="[% inheritance.left_x %]" starty="[% inheritance.top_y %]" />
   <endpoint endx="[% inheritance.right_x %]" endy="[% inheritance.bottom_y %]" />
  </linepath>
 </assocwidget>
 [%- END %]
[% END %]
[% SET dependencies = diagram.Dependancies %]
[% FOREACH dependency = dependencies %]
  [%- IF dependency.Parent >0 AND dependency.Child >0 -%]
 <assocwidget totalcounta="2" indexa="1" totalcountb="2" indexb="1" widgetbid="[% dependency.Parent %]" widgetaid="[% dependency.Child %]" xmi.id="[% dependency.Id %]" >
  <linepath>
   <startpoint startx="[% dependency.left_x %]" starty="[% dependency.top_y %]" />
   <endpoint endx="[% dependency.right_x %]" endy="[% dependency.bottom_y %]" />
  </linepath>
 </assocwidget>
 [%- END %]
[% END %]
</associations>

 view release on metacpan or  search on metacpan

lib/Avatica/Client.pm  view on Meta::CPAN

1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
// Generic metadata for the server to return with each response.
message RpcMetadata {
  string server_address = 1; // The host:port of the server
}
 
// Message which encapsulates another message to support a single RPC endpoint
message WireMessage {
  string name = 1;
  bytes wrapped_message = 2;
}

 view release on metacpan or  search on metacpan

lib/Azure/AD/ClientCredentials.pm  view on Meta::CPAN

60
61
62
63
64
65
66
67
68
69
70
  default => sub {
    'https://login.microsoftonline.com'
  },
);
 
has token_endpoint => (
  is => 'ro',
  isa => Str,
  lazy => 1,
  default => sub {
    my $self = shift;

lib/Azure/AD/ClientCredentials.pm  view on Meta::CPAN

107
108
109
110
111
112
113
114
115
116
117
}
 
return if $self->expiration >= time;
 
my $auth_response = $self->ua->post_form(
  $self->token_endpoint,
  {
    grant_type    => 'client_credentials',
    client_id     => $self->client_id,
    client_secret => $self->secret_id,
    resource      => $self->resource_id,

lib/Azure/AD/ClientCredentials.pm  view on Meta::CPAN

180
181
182
183
184
185
186
187
188
189
A Key assigned to the Client Id.
 
=head2 ad_url
 
This defaults to C<https://login.microsoftonline.com>, and generally doesn't need to
be specified. Azure AD has more endpoints for some clouds: 
 
C<https://login.chinacloudapi.cn> China Cloud
 
C<https://login.microsoftonline.us> US Gov Cloud

 view release on metacpan or  search on metacpan

lib/Azure/Storage/Blob/Client/Call.pm  view on Meta::CPAN

1
2
3
4
5
6
7
8
9
package Azure::Storage::Blob::Client::Call;
use Moose::Role;
 
requires 'endpoint';
requires 'method';
requires 'operation';
 
sub serialize_uri_parameters {
  my $self = shift;

 view release on metacpan or  search on metacpan

etc/bgp_monitor_2_00.xsd  view on Meta::CPAN

10
11
12
13
14
15
16
17
18
19
20
21
22
23
<xsd:element name="BGP_MONITOR_MESSAGE" type="bgpm:bgp_monitor_message_type" />
 
<xsd:complexType name="bgp_monitor_message_type">
  <xsd:sequence>
    <xsd:element name="SOURCE" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="DEST" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1" />
    <xsd:element name="MONITOR" type="bgpm:endpoint_type" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="RELAY" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="OBSERVED_TIME" type="bgpm:observed_time_type" minOccurs="1" maxOccurs="1" />
    <xsd:element name="SEQUENCE_NUMBER" type="xsd:unsignedLong" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="COLLECTION" type="xsd:string" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="PARSE_ERROR"  type="xfb:parse_error_type" maxOccurs="1" minOccurs="0" />
    <xsd:choice minOccurs="1" maxOccurs="1">

etc/bgp_monitor_2_00.xsd  view on Meta::CPAN

37
38
39
40
41
42
43
44
45
46
47
<xsd:element minOccurs="1" maxOccurs="1" name="NODE_PATH" type="xsd:string"/>
<xsd:element minOccurs="1" maxOccurs="1" name="ANNOTATION" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
 
<xsd:complexType name="endpoint_type">
  <xsd:sequence>
    <xsd:element name="ADDRESS" type="ne:network_address_type" />
    <xsd:element name="PORT" type="ne:port_type" />
    <xsd:choice minOccurs="1" maxOccurs="1">
    <xsd:element name="ASN2" type="ne:asn2_type" />

 view release on metacpan or  search on metacpan

etc/bgp_monitor_2_00.xsd  view on Meta::CPAN

10
11
12
13
14
15
16
17
18
19
20
21
22
23
<xsd:element name="BGP_MONITOR_MESSAGE" type="bgpm:bgp_monitor_message_type" />
 
<xsd:complexType name="bgp_monitor_message_type">
  <xsd:sequence>
    <xsd:element name="SOURCE" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="DEST" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1" />
    <xsd:element name="MONITOR" type="bgpm:endpoint_type" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="RELAY" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="OBSERVED_TIME" type="bgpm:observed_time_type" minOccurs="1" maxOccurs="1" />
    <xsd:element name="SEQUENCE_NUMBER" type="xsd:unsignedLong" minOccurs="1" maxOccurs="1"/>
    <xsd:element name="COLLECTION" type="xsd:string" minOccurs="0" maxOccurs="1"/>
    <xsd:element name="PARSE_ERROR"  type="xfb:parse_error_type" maxOccurs="1" minOccurs="0" />
    <xsd:choice minOccurs="1" maxOccurs="1">

etc/bgp_monitor_2_00.xsd  view on Meta::CPAN

37
38
39
40
41
42
43
44
45
46
47
<xsd:element minOccurs="1" maxOccurs="1" name="NODE_PATH" type="xsd:string"/>
<xsd:element minOccurs="1" maxOccurs="1" name="ANNOTATION" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
 
<xsd:complexType name="endpoint_type">
  <xsd:sequence>
    <xsd:element name="ADDRESS" type="ne:network_address_type" />
    <xsd:element name="PORT" type="ne:port_type" />
    <xsd:choice minOccurs="1" maxOccurs="1">
    <xsd:element name="ASN2" type="ne:asn2_type" />

 view release on metacpan or  search on metacpan

lib/Backblaze/B2/v1/AnyEvent.pm  view on Meta::CPAN

144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
my( $self, %options) = @_;
 
$options{ method } ||= 'GET';
#my $completed = delete $options{ cb };
my $method    = delete $options{ method };
my $endpoint  = delete $options{ api_endpoint };
my $headers = delete $options{ headers } || {};
$headers = { $self->get_headers, %$headers };
my $body = delete $options{ _body };
     
my $url;
if( ! $options{url} ) {
    croak "Don't know the api_endpoint for the request"
        unless $endpoint;
    $url = URI->new( join( "/b2api/v1/",
        $self->apiUrl,
        $endpoint)
    );
} else {
    $url = delete $options{ url };
    $url = URI->new( $url )
        if( ! ref $url );

lib/Backblaze/B2/v1/AnyEvent.pm  view on Meta::CPAN

264
265
266
267
268
269
270
271
272
273
274
croak "Need a bucket name"
    unless defined $options{ bucketName };
$options{ accountId } ||= $self->accountId;
$options{ bucketType } ||= 'allPrivate'; # let's be defensive here...
 
$self->json_request(api_endpoint => 'b2_create_bucket',
    accountId => $options{ accountId },
    bucketName => $options{ bucketName },
    bucketType => $options{ bucketType },
    %options
)

lib/Backblaze/B2/v1/AnyEvent.pm  view on Meta::CPAN

294
295
296
297
298
299
300
301
302
303
304
    croak "Need a bucketId"
        unless defined $options{ bucketId };
    $options{ accountId } ||= $self->accountId;
     
    my $res = AnyEvent->condvar;
    $self->json_request(api_endpoint => 'b2_delete_bucket',
        accountId => $options{ accountId },
        bucketId => $options{ bucketId },
        %options
    );
}

lib/Backblaze/B2/v1/AnyEvent.pm  view on Meta::CPAN

316
317
318
319
320
321
322
323
324
325
sub list_buckets {
    my( $self, %options ) = @_;
     
    $options{ accountId } ||= $self->accountId;
     
    $self->json_request(api_endpoint => 'b2_list_buckets',
        accountId => $options{ accountId },
        %options
    )
}

lib/Backblaze/B2/v1/AnyEvent.pm  view on Meta::CPAN

337
338
339
340
341
342
343
344
345
346
347
    my( $self, %options ) = @_;
     
    croak "Need a bucketId"
        unless defined $options{ bucketId };
 
    $self->json_request(api_endpoint => 'b2_get_upload_url',
        %options
    )
}
 
=head2 C<< $b2->upload_file >>

lib/Backblaze/B2/v1/AnyEvent.pm  view on Meta::CPAN

433
434
435
436
437
438
439
440
441
442
443
      
    croak "Need a bucket id"
        unless defined $options{ bucketId };
 
    $self->json_request(
        api_endpoint => 'b2_list_file_names',
        %options
    );
}
 
=head2 C<< $b2->list_all_file_names >>

lib/Backblaze/B2/v1/AnyEvent.pm  view on Meta::CPAN

553
554
555
556
557
558
559
560
561
        unless defined $options{ fileNamePrefix };
    croak "Need a duration for the token"
        unless defined $options{ validDurationInSeconds };
 
    $self->json_request(
        api_endpoint => 'b2_get_download_authorization',
        %options
    );
}

 view release on metacpan or  search on metacpan

lib/Backblaze/B2V2Client.pm  view on Meta::CPAN

245
246
247
248
249
250
251
252
253
254
255
        return $self->{current_status};
}
 
# no need to proceed if we already have done for this bucket this during this session
# return if $self->{bucket_info}{$bucket_name}{upload_url};
# COMMENTED OUT:  It seems like B2 wants a new upload_url endpoint for each upload,
# and we may want to upload multiple files into each bucket...so this won't work
 
# if we don't have the info for the bucket name, retrieve the bucket's ID
if (ref($self->{buckets}{$bucket_name}) ne 'HASH') {
        $self->b2_list_buckets($bucket_name);

lib/Backblaze/B2V2Client.pm  view on Meta::CPAN

640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
 
# generic method to handle communication to B2
sub b2_talker {
        my $self = shift;
 
        # args hash must include 'url' for the target API endpoint URL
        # most other requests will also include a 'post_params' hashref, and 'authorization' value for the header
        # for the b2_upload_file function, there will be several other headers + a file_contents arg
        my (%args) = @_;
 
        if (!$args{url}) {
                $self->error_tracker('Can not use b2_talker() without an endpoint URL.');
        }
 
        # if they sent an Authorization header, set that value
        if ($args{authorization}) {
                $self->{mech}->delete_header( 'Authorization' );

 view release on metacpan or  search on metacpan

lib/BankDetails/India.pm  view on Meta::CPAN

150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
    print $fh $xml;
    close($fh);
}
 
sub get_response {
    my ($self, $endpoint, $ifsc) = @_;
    return if ( !$self->ping_api || !defined $endpoint || length $endpoint <= 0);
 
    $ifsc = uc($ifsc);
    my $request_url = $endpoint.$ifsc;
    my $cache_key = md5_hex(encode_sereal($ifsc));
    my $response_data;
    my $cache_response_data = $self->cache_data->get($cache_key);
    if (defined $cache_response_data) {
        $response_data = decode_sereal($cache_response_data);

lib/BankDetails/India.pm  view on Meta::CPAN

235
236
237
238
239
240
241
242
243
244
245
 
=head3 api_url
 
The URL of the API resource is read only attribute.
 
    # get the API endpoint.
    $api->api_url;
 
=head3 cache_data
 
The cache engine used to cache the web service API calls. By default, it uses

lib/BankDetails/India.pm  view on Meta::CPAN

264
265
266
267
268
269
270
271
272
273
274
    # get cache engine.
    $api->cache_data
 
=head2 ping_api()
 
Checks whether the API endpoint is currently up.
 
    # Returns 1 if up or 0 if not.
    $api->ping_api();
 
=head2 get_all_data_by_ifsc

 view release on metacpan or  search on metacpan

lib/Bb/Collaborate/V3/Connection.pm  view on Meta::CPAN

17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
use Elive;
use Elive::Util;
 
=head1 NAME
 
Bb::Collaborate::V3::Connection -  Manage Collaborate SOAP V3 endpoint connections.
 
=head1 DESCRIPTION
 
This module handles logical connections to the C<.../webservice.event> endpoint
on the Collaborate server. This endpoint implements the Standard Bridge API.
 
=cut
 
our %KnownCommands = (

 view release on metacpan or  search on metacpan

share/SpamAssassin/easy_ham/00606.9733a34d34069bbc9671b0292068449d  view on Meta::CPAN

102
103
104
105
106
107
108
109
    very visible.
 
[1] That is to say, rates will
    be exponential in the free
    energy differences between
    endpoints and a transition
    state.  We can ignore that
    complication in this model.