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.