view release on metacpan or  search on metacpan

script/lccnorm  view on Meta::CPAN

If no file is specified, or if the file name C<-> is specified, standard input
will be processed.

Normalization of call number ranges is a special challenge, because ranges are
not normally specified using the exact endpoint.  Consider the range C<B708-B713>; while
C<B708> does indicate the beginning point -- a no call number that comes before B 708 can
fall within the range -- the end point is only a guide, not a strict limit, since the intent
is that call numbers such as C<B 713 .H94> and C<B 713 .W55 L86> B<do> fall within the
range.  Unfortunately, ranges are often specified ambiguously; for example, the call number
C<B 713.14 G92> might or might not be considered to fall within this range.

 view release on metacpan or  search on metacpan

lib/BigIP/iControl.pm  view on Meta::CPAN

=head3 create_subscription_list (%args)

        my $subscription = $ic->create_subscription_list (
                                                name                            => 'my_subscription_name',
                                                url                             => 'http://company.com/my/eventnotification/endpoint,
                                                username                        => 'username',
                                                password                        => 'password',
                                                ttl                             => -1,
                                                min_events_per_timeslice        => 10,
                                                max_timeslice                   => 10

lib/BigIP/iControl.pm  view on Meta::CPAN

A user-friendly name for the subscription.

=item url

The target URL endpoint for the event notification interface to send event notifications.

=item username

The basic authentication username required to access the URL endpoint.

=item password

The basic authentication password required to access the URL endpoint.

=item ttl

The time to live (in seconds) for this subscription. After the ttl is reached, the subscription
will be removed from the system. A value of -1 indicates an infinite life time.

=item min_events_per_timeslice

The minimum number of events needed to trigger a notification. If this value is 50, then this
means that when 50 events are queued up they will be sent to the notification endpoint no matter
what the max_timeslice is set to.

=item max_timeslice

This maximum time to wait (in seconds) before event notifications are sent to the notification
endpoint. If this value is 30, then after 30 seconds a notification will be sent with the events
in the subscription queue.

=back

=cut

 view release on metacpan or  search on metacpan

lib/Binance/API.pm  view on Meta::CPAN

[OPTIONAL] Number of milliseconds the request is valid for. Applies only in
signed requests.

=item baseUrl

[OPTIONAL] Base URL of Binance endpoint.

=item logger

[OPTIONAL] See L<Binance::API::Logger/new>

lib/Binance/API.pm  view on Meta::CPAN

sub log { return $_[0]->{logger}; }

=head2 ua

    $api->ua->get('/binance/endpoint');

B<PARAMETERS>

=over

 view release on metacpan or  search on metacpan

lib/Bio/ConnectDots/SimpleGraph.pm  view on Meta::CPAN

 Note    : The software caches the components once computed, so it's efficient
           to call this repeatedly.

 Title   : shortest_paths
 Usage   : my $paths=$graph->shortest_paths;
           while(my($endpoints,$path)=each %$paths) {
             my($start,$stop)=split($;,$endpoints);
             my @nodes_on_path=@$path;
             print "Path from $start to $stop: @$nodes_on_path\n";
           }
           -- OR --
           my ($paths,$distances)=$graph->shortest_paths(-want_distances=>1);
           while(my($endpoints,$path)=each %$paths) {
             my $distance=$distances->{$endpoints};
             my($start,$stop)=split($;,$endpoints);
             my @nodes_on_path=@$path;
             print "Path from $start to $stop, distance $distance: @$nodes_on_path\n";
           }
 Function: Compute shortest path between each pair of nodes.
 Args    : (optional)

lib/Bio/ConnectDots/SimpleGraph.pm  view on Meta::CPAN

                 Paths longer than this are not found
           -want_distances=>Boolean. If true, distances are also returned
 Returns : HASH whose keys are pairs of nodes (encoded in the standard
           Perl manner as two strings joined by $;) and whose values
           are paths. Each path is an ARRAY ref of nodes starting at
           the first endpoint and ending at the second.

           The first endpoint is always lexically smaller (lt) than
           the second.

           If -want_distances is specified, the result is a pair of
           HASHes, one containing paths and the other containing
           distances.

 Title   : distances
 Usage   : my $distances=$graph->distances;
           while(my($endpoints,$distance)=each %$distances) {
             my($start,$stop)=split($;,$endpoints);
             print "Path from $start to $stop has distance $distance\n";
           }
           -- OR --
           my ($paths,$distances)=$graph->distances(-want_paths=>1);
           while(my($endpoints,$distance)=each %$distances) {
             my $path=$paths->{$endpoints};
             my($start,$stop)=split($;,$endpoints);
             my @nodes_on_path=@$path;
             print "Path from $start to $stop, distance $distance: @$nodes_on_path\n";
           }
 Function: Compute distance between each pair of nodes. This is the
           length of the shortest path

lib/Bio/ConnectDots/SimpleGraph.pm  view on Meta::CPAN

           -want_paths=>Boolean. If true, paths are also returned
 Returns : HASH whose keys are pairs of nodes (encoded in the standard
           Perl manner as two strings joined by $;) and whose values
           are distances.

           The first endpoint is always lexically smaller (lt) than
           the second.

           If -want_paths is specified, the result is a pair of
           HASHes, one containing paths and the other containing
           distances.

 view release on metacpan or  search on metacpan

t/05remote.t  view on Meta::CPAN

Bio::DB::Big->init();

subtest 'Testing opening remote BigWig file' => sub {
  my $httpd = $get_server->();
  my $url_root = $httpd->endpoint;
  my $bw_file = "${url_root}/test.bw";
  note $bw_file;
  {
    my $big = Bio::DB::Big->open($bw_file);
    is($big->type(), 0, 'Type of file should be 0 i.e. a bigwig file');

t/05remote.t  view on Meta::CPAN

  }
};

subtest 'Testing opening remote BigBed file' => sub {
  my $httpd = $get_server->();
  my $url_root = $httpd->endpoint;
  my $bb_file = "${url_root}/test.bb";
  note $bb_file;
  {
    my $big = Bio::DB::Big->open($bb_file);
    is($big->type(), 1, 'Type of file should be 0 i.e. a bigbed file');

t/05remote.t  view on Meta::CPAN

  is($big->type(), 1, 'Type of file should be 0 i.e. a bigbed file');
};

subtest 'Checking that we can influence the CURL opts' => sub {
  my $httpd = $get_server->();
  my $url_root = $httpd->endpoint;
  
  {
    my $bw_file = "${url_root}/test.bw";
  
    Bio::DB::Big->timeout(1);

 view release on metacpan or  search on metacpan

lib/Bio/DB/Das/Chado/Segment/Feature.pm  view on Meta::CPAN

	} else {
	  $self->{start} = $start if !defined($self->{start}) || $start > $self->{start};
	  $self->{stop}  = $stop  if !defined($self->{stop})  || $stop  < $self->{stop};
	}

	# fix up endpoints of targets too (for homologies only)
#	my $h = $feat->group;
#	next unless $h && $h->isa('Bio::DB::GFF::Homol'); # always false (for now)
#	next unless $g && $g->isa('Bio::DB::GFF::Homol');
#	($start,$stop) = ($h->{start},$h->{stop});
#	if ($h->strand >= 0) {

 view release on metacpan or  search on metacpan

lib/Bio/DB/GFF/Feature.pm  view on Meta::CPAN

	    $self->{stop}  = $low
	      if (!defined($self->{stop}))  || $low  < $self->{stop};
	  }
	}

	# fix up endpoints of targets too (for homologies only)
	my $h = $feat->group;
	next unless $h && $h->isa('Bio::DB::GFF::Homol');
	next unless $g && $g->isa('Bio::DB::GFF::Homol');

	($start,$stop) = ($h->{start},$h->{stop});

lib/Bio/DB/GFF/Feature.pm  view on Meta::CPAN

  return $self->gff3_string(@_) if $version == 3;

  my ($start,$stop) = ($self->start,$self->stop);

  # the defined() tests prevent uninitialized variable warnings, when dealing with clone objects
  # whose endpoints may be undefined
  ($start,$stop) = ($stop,$start) if defined($start) && defined($stop) && $start > $stop;

  my ($class,$name) = ('','');
  my $strand = ('-','.','+')[$self->strand+1];

lib/Bio/DB/GFF/Feature.pm  view on Meta::CPAN

  my $self = shift;
  my ($recurse,$parent) = @_;
  my ($start,$stop) = ($self->start,$self->stop);

  # the defined() tests prevent uninitialized variable warnings, when dealing with clone objects
  # whose endpoints may be undefined
  ($start,$stop) = ($stop,$start) if defined($start) && defined($stop) && $start > $stop;

  my $strand = ('-','.','+')[$self->strand+1];
  my $ref = $self->refseq;
  my $n   = ref($ref) ? $ref->name : $ref;

 view release on metacpan or  search on metacpan

eg/subsequence.cgi  view on Meta::CPAN

sub print_form {
  print p("This web page permits you to extract a short subsequence of DNA from a large GenBank entry.  This is especially useful in an era of huge \"contigs\" of genomic DNA, where you only want to extract a few hundred base pairs for subsequent ana...
  
  print p,"This program also illustrates the power of ",a({-href => 'http://www.BioPerl.org/'}, "BioPerl"), ", a powerful set of tools for molecular biology analysis.  The ", a({-href => 'subsequence.pl.txt'}, "source code"), " for this program is le...
  
  print p,"You must specify the GenBank accession number along with a start position.  You may specify either the length of the subsequence you wish to extract or, equivalently, the endpoint.\n";
  
  print "The sequence may be reverse-complemented if you wish, e.g., the reverse complement of <font color=green>ATCGC</font> is <font color=yellow>GCGAT</font>.\n";
  
  print p,"To test this web page, try accession NT_004002, start 50000, length 400.\n";
  

 view release on metacpan or  search on metacpan

lib/Bio/DB/SeqFeature/Store.pm  view on Meta::CPAN

The positional form is as follows:

 $db->get_features_by_location($seqid [[,$start,]$end])

The $seqid is the name of the sequence on which the feature resides,
and start and end are optional endpoints for the match. If the
endpoints are missing then any feature on the indicated seqid is
returned.

Examples:

 get_features_by_location('chr1');      # all features on chromosome 1

lib/Bio/DB/SeqFeature/Store.pm  view on Meta::CPAN

strand of undef is the same as not specifying this argument at all,
and retrieves all features regardless of their strandedness.

The B<-range_type> argument, if present, can be one of "overlaps" (the
default), to find features whose positions overlap the indicated
range, "contains," to find features whose endpoints are completely
contained within the indicated range, and "contained_in" to find
features whose endpoints are both outside the indicated range.

=cut

sub get_features_by_location {
  my $self = shift;

lib/Bio/DB/SeqFeature/Store.pm  view on Meta::CPAN

 Status  : public

This is a convenience method that can be used when you are interested
in the contents of a particular sequence landmark, such as a
contig. Specify the ID of a sequence or other landmark in the database
and optionally a start and endpoint relative to that landmark. The
method will look up the region and return a
Bio::DB::SeqFeature::Segment object that spans it. You can then use
this segment object to make location-restricted queries on the database.

Example:

 view release on metacpan or  search on metacpan

Das/Feature.pm  view on Meta::CPAN

	} else {
	  $self->{start} = $start if !defined($self->{start}) || $start > $self->{start};
	  $self->{stop}  = $stop  if !defined($self->{stop})  || $stop  < $self->{stop};
	}

	# fix up endpoints of targets too
	my $st = $feat->{target};
	next unless $t && $st;
	($start,$stop) = (@{$st}[1,2]);
	if ($start < $stop) {
	  $t->[1] = $start if !defined($t->[1]) || $start < $t->[1];  # start

 view release on metacpan or  search on metacpan

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

This module provides a Perl-based interface to the L<EMBL-EBI|http://www.ebi.ac.uk> L<RNA-seq analysis API|http://www.ebi.ac.uk/fg/rnaseq/api/>.

The RNA-seq Analysis API enables access to analysis results for thousands of
publicly available gene expression datasets. This module provides functions to
access each endpoint provided by the API.

For more information about the API, see its L<documentation|http://www.ebi.ac.uk/fg/rnaseq/api/doc>.

=head1 SYNOPSIS

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=over 2

=item B<get_run>

Accesses the API's C<getRun> JSON endpoint and returns analysis information for
a single run, passed in the arguments.

Arguments should be passed as a hash containing values for "run" and
"minimum_mapped_reads", e.g.:

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=item B<get_runs_by_list>

This function takes an anonymous array of run accessions and sequentially
accesses the API's C<getRun> JSON endpoint to collect the analysis information
for each run in the list provided.

 my $runInfo = $rnaseqAPI->get_runs_by_list(
    runs => [ "ERR030885", "ERR030886" ],
    minimum_mapped_reads => 0

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

}


=item B<get_runs_by_study>

Accesses the API's C<getRunsByStudy> JSON endpoint, and returns an anonymous array
containing an anonymous hash for each run found (see L</get_run> docs for an example).

 my $runInfo = $rnaseqAPI->get_runs_by_study(
    study => "E-MTAB-513",
    minimum_mapped_reads => 0

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

}


=item B<get_runs_by_organism>

Accesses the API's C<getRunsByOrganism> JSON endpoint, and returns an anonymous
array containing an anonymous hash for each run found.

 my $runInfo = $rnaseqAPI->get_runs_by_organism(
    organism => "homo_sapiens",
    minimum_mapped_reads => 70

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

}


=item B<get_runs_by_organism_condition>

Accesses the API's C<getRunsByOrganismCondition> JSON endpoint, and returns an
anonymous array containing an anonymous hash for each run found. An organism
name and a "condition" -- meaning a sample attribute -- are passed in the
arguments. The condition must exist in the L<Experimental Factor Ontology (EFO)|http://www.ebi.ac.uk/efo>; this can
be checked via the EFO website or via the L<Ontology Lookup Service (OLS) API|http://www.ebi.ac.uk/ols/docs/api>.

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=over 2

=item B<get_study>

Accesses the API's C<getStudy> JSON endpoint. Single argument is a study
accession (L<ENA|http://www.ebi.ac.uk/ena>, L<SRA|http://www.ncbi.nlm.nih.gov/sra>, L<DDBJ|http://www.ddbj.nig.ac.jp/> or L<ArrayExpress|http://www.ebi.ac.uk/arrayexpress>). Returns an anonymous hash
containing the results for the matching study. Returns C<undef> (and logs
errors) if errors are encountered. If you try an ArrayExpress accession and it
doesn't work, try the corresponding sequencing archive study accession instead.

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

    }
}

=item B<get_studies_by_organism>

Accesses the API's C<getStudiesByOrganism> JSON endpoint. Single argument is the
name of an organism (see the L</run_organism_list> attribute for allowed names).
Returns an anonymous array containing one anonymous hash per study found. See
L</get_study> docs for an example of an anonymous hash.

 my $studies = $rnaseqAPI->get_studies_by_organism( "arabidopsis_thaliana" );

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=over 2

=item B<get_sample_attributes_by_run>

Accesses the API's C<getSampleAttributesByRun> JSON endpoint. Single argument is
the accession of the run. Returns an anonymous array containing one anonymous
hash per sample attribute found.

 my $sampleAttributes = $rnaseqAPI->get_sample_attributes_by_run( "SRR805786" );

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

    }
}

=item B<get_sample_attributes_per_run_by_study>

Accesses the API's C<getSampleAttributesPerRunByStudy> JSON endpoint. Single
argument is a study accession. Returns an array ref containing one anonymous
hash per sample attribute. See L</get_sample_attributes_by_run> docs for an
example. Returns C<undef> (and logs errors) if errors are encountered.

 my $sampleAttributes = $rnaseqAPI->get_sample_attributes_per_run_by_study( "DRP000391" );

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

    }
}

=item B<get_sample_attributes_coverage_by_study>

Accesses the API's C<getSampleAttributesCoverageByStudy> endpoint. Single argument
is a study accession. Returns an anonymous array containing one anonymous hash
per sample attribute. Returns C<undef> (and logs errors) if errors are
encountered.

 my $sampleAttributeCoverage = $rnaseqAPI->get_sample_attributes_coverage_by_study( "DRP000391" );

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=over 2

=item B<get_expression_by_organism_genesymbol>

Accesses the API's C<getExpression> endpoint. Provide arguments as a hash,
passing an organism name and a gene symbol, as well as a value for the minimum
percentage of mapped reads to allow:

 my $geneExpressionInfo = $rnaseqAPI->get_expression(
    minimum_mapped_reads => 0,

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

=item B<get_expression_by_gene_id>

Accesses the API's C<getExpression> endpoint, but instead of querying by
organism and gene symbol (see L</get_expression_by_organism_genesymbol>), this
function queries by gene identifier. Also expects a value for the minimum
percentage of mapped reads to allow.

 my $geneExpressionInfo = $rnaseqAPI->get_expression(

lib/Bio/EBI/RNAseqAPI.pm  view on Meta::CPAN

    $userAgent->env_proxy;

    return $userAgent;
}

# Run organisms list builder. This is built by accessing the API's endpoints for
# the various genome reference resources it uses. Most of these are the
# divisions of Ensembl (http://www.ensembl.org and http://ensemblgenomes.org)
# -- core, plants, fungi, metazoa, and protists, as well as WormBase ParaSite
# (http://parasite.wormbase.org/). The endpoint for each resource provides
# key-value pairs of sample organism and reference organism, the reference
# organism being the name of the reference genome that was used in the
# alignment of RNA-seq reads, and the sample organism being the species the RNA
# sample was taken from. Here we collect all the sample organisms, add them as
# keys in an anonymous hash (pointing at 1), and return the anonymous hash.

 view release on metacpan or  search on metacpan

lib/Bio/EnsEMBL/Utils/Tree/Interval/Immutable.pm  view on Meta::CPAN

  return sort_by_begin(uniq($result));
}

# This corresponds to the left branch of the range search, once we find a node, whose
# midpoint is contained in the query interval. All intervals in the left subtree of that node
# are guaranteed to intersect with the query, if they have an endpoint greater or equal than
# the start of the query interval. Basically, this means that every time we branch to the left
# in the binary search, we need to add the whole right subtree to the result set.

sub _range_query_left {
  my ($self, $node, $interval, $result) = @_;

lib/Bio/EnsEMBL/Utils/Tree/Interval/Immutable.pm  view on Meta::CPAN

  }
}

# This corresponds to the right branch of the range search, once we find a node, whose
# midpoint is contained in the query interval. All intervals in the right subtree of that node
# are guaranteed to intersect with the query, if they have an endpoint smaller or equal than
# the end of the query interval. Basically, this means that every time we branch to the right
# in the binary search, we need to add the whole left subtree to the result set.

sub _range_query_right {
  my ($self, $node, $interval, $result) = @_;

 view release on metacpan or  search on metacpan

lib/Bio/Graphics/Feature.pm  view on Meta::CPAN

=item add_segment(@segments)

Add one or more segments (a subfeature).  Segments can either be
Feature objects, or [start,stop] arrays, as in the -segments argument
to new().  The feature endpoints are automatically adjusted.

=item my @features = get_SeqFeatures('type1','type2','type3'...)

Get the subfeatures of this feature. If an optional list of types is
provided, then only returns subfeatures with the indicated

 view release on metacpan or  search on metacpan

lib/Bio/MAGETAB/SDRF.pm  view on Meta::CPAN

            push @list_of_rows, @{ $subrow_list };
        }
    }
    else {

        # Recursion endpoint.
        push @list_of_rows, [ $node ];
    }

    return \@list_of_rows;
}

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    * Fixed the padded alignments returned for hard-clipped alignments.

Version 1.10
    * Added a new Bio::DB::Bam method for caching remote files' indices in the
      temp directory. This is used by default by high-level API.
    * Fixed bug in soft and hard clipping code; query endpoints should be
      correct now.
    * Fixed bug in get_all_tags() which was choking on "Z" style tags and giving
      scrambled results.
    * $feature->query now reports the DNA query in canonical (ref)
      coordinates; only $feature->target reverse complements the query

 view release on metacpan or  search on metacpan

scripts/bam2wig.pl  view on Meta::CPAN

	'd|mid!'            => \$use_mid,            # record mid point
	'a|span!'           => \$use_span,           # record span
	'cspan!'            => \$use_cspan,          # record center span
	'e|extend!'         => \$use_extend,         # extend read
	'smartcov!'         => \$use_smartpe,        # smart paired coverage
	'ends!'             => \$use_ends,           # record paired-end endpoints
	'coverage!'         => \$use_coverage,       # calculate coverage
	'position=s'        => \$position,           # legacy option
	'l|splice|split!'   => \$splice,             # split splices
	'p|pe!'             => \$paired,             # paired-end alignments
	'P|fastpe!'         => \$fastpaired,         # fast paired-end alignments

scripts/bam2wig.pl  view on Meta::CPAN

	if ( $shift and $paired ) {
		print " WARNING: disabling shift with paired reads\n";
		undef $shift;
	}
	if ( $use_ends and $shift ) {
		print " WARNING: disabling shift when recording paired endpoints\n";
		undef $shift;
	}
	if ( $use_ends and $splice ) {
		print " WARNING: disabling splices when recording paired endpoints\n";
		undef $splice;
	}

	# check to shift position or not
	if ( $shift or $use_extend ) {

scripts/bam2wig.pl  view on Meta::CPAN

		$callback = \&smart_stranded_pe;
		print " Recording stranded, smart paired-end coverage\n";
	}
	elsif ( $paired and not $do_strand and $use_ends ) {
		$callback = \&pe_ends;
		print " Recording paired-end fragment endpoints\n";
	}
	elsif ( $paired and $do_strand and $use_ends ) {
		$callback = \&pe_strand_ends;
		print " Recording stranded, paired-end fragment endpoints\n";
	}
	else {
		die "programmer error!\n" unless $shift;    # special exception
	}

scripts/bam2wig.pl  view on Meta::CPAN

	# walk through the chromosome in 1 kb increments
	my $chrom_data;
	for ( my $start = 0; $start < $seq_length; $start += $coverage_dump ) {

		# set endpoint
		my $end = $start + $coverage_dump;
		$end = $seq_length if $end > $seq_length;

		# using the low level interface for a little more performance
		my $coverage = low_level_bam_coverage( $sam, $tid, $start, $end );

scripts/bam2wig.pl  view on Meta::CPAN

  -d --mid                      record at midpoint of alignment or pair
  -a --span                     record across entire alignment or pair
  -e --extend                   extend alignment (record predicted fragment)
  --cspan                       record a span centered on midpoint
  --smartcov                    record paired coverage without overlaps, splices
  --ends                        record paired endpoints
  --coverage                    raw alignment coverage
 
 Alignment reporting options:
  -l --splice                   split alignment at N splices
  -t --strand                   record separate strands as two wig files

scripts/bam2wig.pl  view on Meta::CPAN

Smart alignment coverage of paired-end alignments without 
double-counting overlaps or recording gaps (intron splices). 

=item --ends

Record both endpoints of paired-end fragments, i.e. the outermost 
or 5' ends of properly paired fragments. This may be useful with 
ATAC-Seq, Cut&Run-Seq, or other cleavage experiments where you want 
to record the locations of cutting yet retain the ability to filter 
paired-end fragment sizes.

 view release on metacpan or  search on metacpan

lib/Bio/WebService/LANL/SequenceLocator.pm  view on Meta::CPAN

    is      => 'ro',
    lazy    => 1,
    builder => sub { 'https://www.hiv.lanl.gov' },
);

has lanl_endpoint => (
    is      => 'ro',
    lazy    => 1,
    builder => sub { shift->lanl_base . '/cgi-bin/LOCATE/locate.cgi' },
);

lib/Bio/WebService/LANL/SequenceLocator.pm  view on Meta::CPAN

    # LANL only presents the parseable table.txt we want if there's more
    # than a single sequence.  We always add it so we can reliably skip it.
    $fasta .= "\n> " . $self->_bogus_slug . "\n";

    return $self->_request(
        POST $self->lanl_endpoint,
        Content_Type => 'form-data',
        Content      => [
            organism            => 'HIV',
            DoReverseComplement => 0,
            seq_input           => $fasta,

 view release on metacpan or  search on metacpan

lib/Bio/Tools/Run/Analysis/soap.pm  view on Meta::CPAN

=over 4

=item -location

A URL (also called an I<endpoint>) defining where is located a Web Service
representing this analysis tool.

Default is C<http://www.ebi.ac.uk/soaplab/services> (services running
at European Bioinformatics Institute on top of most of EMBOSS
analyses, and few others).

 view release on metacpan or  search on metacpan

Bio/DB/GFF/Feature.pm  view on Meta::CPAN

	    $self->{stop}  = $low
	      if (!defined($self->{stop}))  || $low  < $self->{stop};
	  }
	}

	# fix up endpoints of targets too (for homologies only)
	my $h = $feat->group;
	next unless $h && $h->isa('Bio::DB::GFF::Homol');
	next unless $g && $g->isa('Bio::DB::GFF::Homol');

	($start,$stop) = ($h->{start},$h->{stop});

Bio/DB/GFF/Feature.pm  view on Meta::CPAN

  return $self->gff3_string(@_) if $version == 3;

  my ($start,$stop) = ($self->start,$self->stop);

  # the defined() tests prevent uninitialized variable warnings, when dealing with clone objects
  # whose endpoints may be undefined
  ($start,$stop) = ($stop,$start) if defined($start) && defined($stop) && $start > $stop;

  my ($class,$name) = ('','');
  my $strand = ('-','.','+')[$self->strand+1];

Bio/DB/GFF/Feature.pm  view on Meta::CPAN

  my $self = shift;
  my ($recurse,$parent) = @_;
  my ($start,$stop) = ($self->start,$self->stop);

  # the defined() tests prevent uninitialized variable warnings, when dealing with clone objects
  # whose endpoints may be undefined
  ($start,$stop) = ($stop,$start) if defined($start) && defined($stop) && $start > $stop;

  my $strand = ('-','.','+')[$self->strand+1];
  my $ref = $self->refseq;
  my $n   = ref($ref) ? $ref->name : $ref;

 view release on metacpan or  search on metacpan

lib/Bluesky.pm  view on Meta::CPAN

                ( @captions            ? ( captions    => \@captions )   : () ), ( defined $alt ? ( alt => $alt ) : () ),
                ( defined $aspectRatio ? ( aspectRatio => $aspectRatio ) : () )
            };
            if (0) {

                # You may upload videos as plain blobs but this endpoint allows you to check on processing status
                # Testing because HTTP::Tiny does not support multipart
                # I need to get auth token for new service via 'com.atproto.server.getServiceAuth'
                my $boundary = join '', map { [ 0 .. 9, 'a' .. '4' ]->[ rand 36 ] } 1 .. 5 + rand(10);
                my $job      = $at->post(
                    'https://video.bsky.app/xrpc/app.bsky.video.uploadVideo?did=' . $at->did . '&name=upload.mp4',

 view release on metacpan or  search on metacpan

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

    }
    $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

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

    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/BmltClient/ApiClient.pm  view on Meta::CPAN

           # 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/Mojolicious/Plugin/BoardStreams.pm  view on Meta::CPAN

            },
        });
    });

    $app->hook(around_action => async sub ($next, $c, $action, $last) {
        if ($last and $c->stash->{'boardstreams.endpoint'}) {
            $c->render_later;
            try {
                my $ret = $next->();
                await $ret if $ret->$_can('then');
                return await $c->bs->init_client_p;

 view release on metacpan or  search on metacpan

src/boost/geometry/strategies/agnostic/point_in_poly_oriented_winding.hpp  view on Meta::CPAN

        calculation_type const p = get<D>(point);
        calculation_type const s1 = get<D>(seg1);
        calculation_type const s2 = get<D>(seg2);


        // Check if one of segment endpoints is at same level of point
        bool eq1 = math::equals(s1, p);
        bool eq2 = math::equals(s2, p);

        if (eq1 && eq2)
        {

 view release on metacpan or  search on metacpan

include/boost/regex/v4/basic_regex_creator.hpp  view on Meta::CPAN

   //
   first = char_set.ranges_begin();
   last = char_set.ranges_end();
   while(first != last)
   {
      // first grab the endpoints of the range:
      digraph<charT> c1 = *first;
      c1.first = this->m_traits.translate(c1.first, this->m_icase);
      c1.second = this->m_traits.translate(c1.second, this->m_icase);
      ++first;
      digraph<charT> c2 = *first;

include/boost/regex/v4/basic_regex_creator.hpp  view on Meta::CPAN

   //
   first = char_set.ranges_begin();
   last = char_set.ranges_end();
   while(first != last)
   {
      // first grab the endpoints of the range:
      charT c1 = this->m_traits.translate(first->first, this->m_icase);
      ++first;
      charT c2 = this->m_traits.translate(first->first, this->m_icase);
      ++first;
      // different actions now depending upon whether collation is turned on:

 view release on metacpan or  search on metacpan

lib/Bootylicious/Plugin/Pingback.pm  view on Meta::CPAN

            return unless $c->req->method =~ m/GET|HEAD/;

            return unless $c->res->code && $c->res->code == 200;

            return unless $c->match->endpoint->name eq 'article';

            $c->res->headers->header(
                'X-Pingback' => $c->url_for('pingback', format => undef)->to_abs);
        }
    );

 view release on metacpan or  search on metacpan

lib/Bot/ChatBots/Messenger/Sender.pod  view on Meta::CPAN

=head2 B<< url >>

   my $fb_messenger_url = $obj->url;

The Facebook Messenger API endpoint. Defaults to
L<https://graph.facebook.com/v2.6/me/messages>.

=head1 METHODS

This class consumes the following roles (inheriting all its methods):

 view release on metacpan or  search on metacpan

eg/README.md  view on Meta::CPAN

the command line with the first program:

    $ ./longpoll $TOKEN

The second program needs a place to be installed and run, as well as
exposing an HTTPS type of endpoint, so you need to do an extra mile
to see it at work.

 view release on metacpan or  search on metacpan

examples/pendulum.pl  view on Meta::CPAN

        for (1..$precision){
            $world->Step( $timestep, $vIters, $pIters );
            $world->ClearForces();
        }
        
        my $endpoint = $bobs[$#bobs]{body}->GetPosition();
        my $current_path_pos
            = [ w2s( $endpoint->x ), w2s( s2w($height) - $endpoint->y ) ];

        # trace path on bg
        $bg->draw_line( $prev_path_pos, $current_path_pos, $pathColor )
            if $prev_path_pos;
        $prev_path_pos = $current_path_pos;

 view release on metacpan or  search on metacpan

lib/Brackup/Target/Riak.pm  view on Meta::CPAN

I<(Mandatory.)> Must be "B<Riak>".

=item B<riak_host_url>

URL specifying your riak cluster endpoint. Default: http://127.0.0.1:8098/.

=item B<riak_r> 

riak read quorum - how many replicas need to agree when retrieving an object. 
Default: 2.