Provided by: libbio-das-lite-perl_2.11-6_all bug

NAME

       Bio::Das::Lite - Perl extension for the DAS (HTTP+XML) Protocol (http://biodas.org/)

VERSION

         See $Bio::Das::Lite::VERSION

SYNOPSIS

         use Bio::Das::Lite;
         my $bdl     = Bio::Das::Lite->new_from_registry({'category' => 'GRCh_37,Chromosome,Homo sapiens'});
         my $results = $bdl->features('22');

SUBROUTINES/METHODS

   new : Constructor
         my $das = Bio::Das::Lite->new('http://das.ensembl.org/das/ensembl1834');

         my $das = Bio::Das::Lite->new({
                                      'timeout'    => 60,
                                      'dsn'        => 'http://user:pass@das.ensembl.org/das/ensembl1834',
                                      'http_proxy' => 'http://user:pass@webcache.local.com:3128/',
                                     });

        Options can be: dsn        (optional scalar or array ref, URLs of DAS services)
                        timeout    (optional int,      HTTP fetch timeout in seconds)
                        http_proxy (optional scalar,   web cache or proxy if not set in %ENV)
                        no_proxy   (optional list/ref, non-proxiable domains if not set in %ENV)
                        caching    (optional bool,     primitive caching on/off)
                        callback   (optional code ref, callback for processed XML blocks)
                        registry   (optional array ref containing DAS registry service URLs
                                    defaults to 'http://das.sanger.ac.uk/registry/services/das')
                        proxy_user (optional scalar,   username for authenticating forward-proxy)
                        proxy_pass (optional scalar,   password for authenticating forward-proxy)
                        user_agent (optional scalar,   User-Agent HTTP request header value)

   new_from_registry : Constructor
         Similar to 'new' above but supports 'capability' and 'category'
         in the given hashref, using them to query the DAS registry and
         configuring the DSNs accordingly.

         my $das = Bio::Das::Lite->new_from_registry({
                                                    'capability' => ['features'],
                                                    'category'   => ['Protein Sequence'],
                                                   });

        Options are as above, plus
                        capability OR capabilities   (optional arrayref of capabilities)
                        category                     (optional arrayref of categories)

         For a complete list of capabilities and categories, see:

           http://das.sanger.ac.uk/registry/

         The category can optionally be a full coordinate system name,
         allowing further restriction by authority, version and species.
         For example:
             'Protein Sequence' OR
             'UniProt,Protein Sequence' OR
             'GRCh_37,Chromosome,Homo sapiens'

   http_proxy : Get/Set http_proxy
           $das->http_proxy('http://user:pass@squid.myco.com:3128/');

   proxy_user : Get/Set proxy username for authenticating forward-proxies
         This is only required if the username wasn't specified when setting http_proxy

           $das->proxy_user('myusername');

   proxy_pass : Get/Set proxy password for authenticating forward-proxies
         This is only required if the password wasn't specified when setting http_proxy

           $das->proxy_pass('secretpassword');

   no_proxy : Get/Set domains to not use proxy for
           $das->no_proxy('ebi.ac.uk', 'localhost');
           OR
           $das->no_proxy( ['ebi.ac.uk', 'localhost'] );

           Always returns an arrayref

   user_agent : Get/Set user-agent for request headers
           $das->user_agent('GroovyDAS/1.0');

   timeout : Get/Set timeout
           $das->timeout(30);

   caching : Get/Set caching
           $das->caching(1);

   callback : Get/Set callback code ref
           $das->callback(sub { });

   basename : Get base URL(s) of service
           $das->basename(optional $dsn);

   dsn : Get/Set DSN
         $das->dsn('http://das.ensembl.org/das/ensembl1834/'); # give dsn (scalar or arrayref) here if not specified in new()

         Or, if you want to add to the existing dsn list and you're feeling sneaky...

         push @{$das->dsn}, 'http://my.server/das/additionalsource';

   dsns : Retrieve information about other sources served from this server.
        Note this call is 'dsns', as differentiated from 'dsn' which is the current configured source

         my $src_data = $das->dsns();

   entry_points : Retrieve the list of entry_points for this source
         e.g. chromosomes and associated information (e.g. sequence length and version)

         my $entry_points  = $das->entry_points();

   Types of argument for 'types', 'features', 'sequence' calls:
         Segment Id:
         '1'

         Segment Id with range:
         '1:1,1000'

         Segment Id with range and type:
         {
           'segment' => '1:1,1000',
           'type'    => 'exon',
         }

         Multiple Ids with ranges and types:
         [
           {
             'segment' => '1:1,1000',
             'type'    => 'exon',
           },
           {
             'segment' => '2:1,1000',
             'type'    => 'exon',
           },
         ]

         See DAS specifications for other parameters

   types : Find out about different data types available from this source
         my $types         = $das->types(); # takes optional args - see DAS specs

        Retrieve the types of data available for this source
        e.g. 32k_cloneset, karyotype, swissprot

   features : Retrieve features from a segment
          e.g. clones on a chromosome

         #########
         # Different ways to fetch features -
         #
         my $feature_data1 = $das->features('1:1,100000');
         my $feature_data2 = $das->features(['1:1,100000', '2:20435000,21435000']);
         my $feature_data3 = $das->features({
                                             'segment' => '1:1,1000',
                                             'type'    => 'karyotype',
                                             # optional args - see DAS Spec
                                            });
         my $feature_data4 = $das->features([
                                             {'segment'  => '1:1,1000000','type' => 'karyotype',},
                                             {'segment'  => '2:1,1000000',},
                                             {'group_id' => 'OTTHUMG00000036084',},
                                            ]);

         #########
         # Feature fetch with callback
         #
         my $callback = sub {
                             my $struct = shift;
                             print {*STDERR} Dumper($struct);
                            };
         # then:
         $das->callback($callback);
         $das->features('1:1,1000000');

         # or:
         $das->features('1:1,1000000', $callback);

         # or:
         $das->features(['1:1,1000000', '2:1,1000000', '3:1,1000000'], $callback);

         # or:
         $das->features([{'group_id' => 'OTTHUMG00000036084'}, '2:1,1000000', '3:1,1000000'], $callback);

   alignment : Retrieve protein alignment data for a query.  This can be a multiple sequence
       alignment or pairwise alignment.  Note - this has not been tested for structural
       alignments as there is currently no Das source avialable.
         my $alignment = $das->alignment({query => 'Q01234'});

   structure : Retrieve known structure (i.e. PDB) for a query
         my $structure = $das->structure({ query => 'pdb_id'});

   sources : Retrieves the list of sources form the DAS registry, via a DAS call.
         my $sources = $das->source;

   sequence : Retrieve sequence data for a segment (probably dna or protein)
         my $sequence      = $das->sequence('2:1,1000'); # segment:start,stop (e.g. chromosome 2, bases 1 to 1000)

   stylesheet : Retrieve stylesheet data
         my $style_data    = $das->stylesheet();
         my $style_data2   = $das->stylesheet($callback);

   statuscodes : Retrieve HTTP status codes for request URLs
         my $code         = $das->statuscodes($url);
         my $code_hashref = $das->statuscodes();

   specversions : Retrieve a server's DAS specification version for a request URL
         my $version         = $das->specversions($url);  # e.g. 1.53, 1.6, 1.6E
         my $version_hashref = $das->specversions();

   max_hosts set number of running concurrent host connections
         THIS METHOD IS NOW DEPRECATED AND HAS NO EFFECT

         $das->max_hosts(7);
         print $das->max_hosts();

   max_req set number of running concurrent requests per host
         THIS METHOD IS NOW DEPRECATED AND HAS NO EFFECT

         $das->max_req(5);
         print $das->max_req();

   registry : Get/Set accessor for DAS-Registry service URLs
         $biodaslite->registry('http://www.dasregistry.org/das');

         my $registry_arrayref = $biodaslite->registry();

   registry_sources : Arrayref of dassource objects from the configured registry services
         my $sources_ref = $biodaslite->registry_sources();

         my $sources_ref = $biodaslite->registry_sources({
           'capability' => ['features','stylesheet'],
         });

         my $sources_ref = $biodaslite->registry_sources({
           'category' => ['Protein Sequence'],
         });

   build_queries
       Constructs an arrayref of DAS requests including parameters for each call

   build_requests
       Constructs the WWW::Curl callbacks

   postprocess
       Applies processing to the result set, e.g. removal of whitespace from sequence responses.

DESCRIPTION

       This module is an implementation of a client for the DAS protocol (XML over HTTP primarily
       for biological-data).

DEPENDENCIES

       strict
       warnings
       WWW::Curl
       HTTP::Response
       Carp
       English
       Readonly

DIAGNOSTICS

         Set $Bio::Das::Lite::DEBUG = 1;

CONFIGURATION AND ENVIRONMENT

INCOMPATIBILITIES

BUGS AND LIMITATIONS

         The max_req and max_hosts methods are now deprecated and have no effect.

SEE ALSO

       DAS Specifications at: http://biodas.org/documents/spec.html

       ProServer (A DAS Server implementation also by the author) at:
          http://www.sanger.ac.uk/proserver/

       The venerable Bio::Das suite (CPAN and http://www.biodas.org/download/Bio::Das/).

       The DAS Registry at:
          http://das.sanger.ac.uk/registry/

AUTHOR

       Roger Pettett, <rpettett@cpan.org>

LICENSE AND COPYRIGHT

       Copyright (C) 2007 GRL, by Roger Pettett

       This library is free software; you can redistribute it and/or modify it under the same
       terms as Perl itself, either Perl version 5.8.4 or, at your option, any later version of
       Perl 5 you may have available.