Free google software for linux

Ruby/Google offers a higher-level abstraction of Googles SOAP-driven Web API. Ruby/Google module allows the user to programatically query the Google search engine from Ruby.

The aim of the library is to shield the programmer from the details of the raw data structures returned by the Web API, and in the process make the API more accessible for everyday use.

WWW::Google::SiteMap::Robot is a Perl extension for creating Google SiteMaps by spidering a site.

SYNOPSIS

use WWW::Google::SiteMap::Robot;

my $robot = WWW::Google::SiteMap::Robot->new(
domain => www.jasonkohles.com,
restrict => qr{^http://www.jasonkohles.com/},
starting_url => [/index.html,/google-me.html],
delay => 1, # delay in minutes
sitemap_file => /var/www/html/sitemap.gz,
sitemap_url => http://www.jasonkohles.com/sitemap.gz,
user_agent => MyOwnSpider/1.0,
);
$robot->run();

This is a simple robot class which subclasses LWP::RobotUA to create a web-crawling spider. By giving it the URL to your home page, it will crawl all the pages it can find and create a sitemap for them.

WWW::Google::SiteMap::URL is URL Helper class for WWW::Google::SiteMap.

This is a helper class that supports WWW::Google::SiteMap and WWW::Google::SiteMap::Index.

METHODS

new()

loc()

Change the URL associated with this object. For a WWW::Google::SiteMap this specifies the URL to add to the sitemap, for a WWW::Google::SiteMap::Index, this is the URL to the sitemap.

changefreq()

Set the change frequency of the object. This field is not used in sitemap indexes, only in sitemaps.

lastmod()

Set the last modified time. You have to provide this as one of the following:

a complete ISO8601 time string

A complete time string will be accepted in exactly this format:

YYYY-MM-DDTHH:MM:SS+TZ:TZ
YYYY - 4-digit year
MM - 2-digit month (zero padded)
DD - 2-digit year (zero padded)
T - literal character T
HH - 2-digit hour (24-hour, zero padded)
SS - 2-digit second (zero padded)
+TZ:TZ - Timezone offset (hours and minutes from GMT, 2-digit, zero padded)

epoch time

Seconds since the epoch, such as would be returned from time(). If you provide an epoch time, then an appropriate ISO8601 time will be constructed with gmtime() (which means the timezone offset will be +00:00). If anyone knows of a way to determine the timezone offset of the current host that is cross-platform and doesnt add dozens of dependencies then I might change this.
an ISO8601 date (YYYY-MM-DD)

A simple date in YYYY-MM-DD format. The time will be set to 00:00:00+00:00.

a DateTime object.

If a DateTime object is provided, then an appropriate timestamp will be constructed from it.

a HTTP::Response object.

If given an HTTP::Response object, the last modified time will be calculated from whatever time information is available in the response headers. Currently this means either the Last-Modified header, or tue current time - the current_age() calculated by the response object. This is useful for building web crawlers.

Note that in order to conserve memory, any of these items that you provide will be converted to a complete ISO8601 time string when they are stored. This means that if you pass an object to lastmod(), you cant get it back out. If anyone actually has a need to get the objects back out, then I might make a configuration option to store the objects internally.

If you have suggestions for other types of date/time objects or formats that would be usefule, let me know and Ill consider them.

priority()

Set the priority. This field is not used in sitemap indexes, only in sitemaps.

delete()

Delete this object from the sitemap or the sitemap index.

lenient()

If lenient contains a true value, then errors will not be fatal.

Geo::Coder::Google is a Perl module for Google Maps Geocoding API.

SYNOPSIS

use Geo::Coder::Google;

my $geocoder = Geo::Coder::Google->new(apikey => Your API Key);
my $location = $geocoder->geocode( location => Hollywood and Highland, Los Angeles, CA );

Geo::Coder::Google provides a geocoding functionality using Google Maps API.

METHODS

new

$geocoder = Geo::Coder::Google->new(apikey => Your API Key);
$geocoder = Geo::Coder::Google->new(apikey => Your API Key, host => maps.google.co.jp);

Creates a new geocoding object. You should pass a valid Google Maps API Key as apikey parameter.

When youd like to query Japanese address, you might want to set host parameter, which should point to maps.google.co.jp. I think this also applies to other countries like UK (maps.google.co.uk), but so far I only tested with .com and .co.jp.

geocode

$location = $geocoder->geocode(location => $location);
@location = $geocoder->geocode(location => $location);

Queries $location to Google Maps geocoding API and returns hash refernece returned back from API server. When you cann the method in an array context, it returns all the candidates got back, while it returns the 1st one in a scalar context.
When youd like to pass non-ascii string as a location, you should pass it as either UTF-8 bytes or Unicode flagged string.

Returned data structure is as follows:

{
AddressDetails => {
Country => {
AdministrativeArea => {
SubAdministrativeArea => {
SubAdministrativeAreaName => San Francisco,
Locality => {
PostalCode => {
PostalCodeNumber => 94107
},
LocalityName => San Francisco,
Thoroughfare => {
ThoroughfareName => 548 4th St
}
}
},
AdministrativeAreaName => CA
},
CountryNameCode => US
}
},
address => 548 4th St, San Francisco, CA 94107, USA,
Point => {
coordinates => [
-122.397323,
37.778993,
0
]
}
}

WWW::Cache::Google is Perl module URI class for Google cache.

SYNOPSIS

use WWW::Cache::Google;

$cache = WWW::Cache::Google->new(http://www.yahoo.com/);

$url = $cache->as_string; # cache URL
$html = $cache->fetch; # fetches via LWP::Simple

Oops, 404 Not Found. But wait ... there might be a google cache!
WWW::Cache::Google provides an easy way conversion from an URL to Google cache URL.

If all you want is only to get cache content, consider using Google Web APIs at http://www.google.com/apis/index.html

$html = SOAP::Lite
->uri(urn:GoogleSearch)
->proxy(http://api.google.com/search/beta2) # may change
->doGetCachedPage($GoogleKey, http://cpan.org/)
->result;

Google::Adwords::AccountService is a Perl module to interact with the Google Adwords AccountService API calls.

SYNOPSIS

use Google::Adwords::AccountService;
use Google::Adwords::AccountInfo;
use Google::Adwords::CoverageType;
use Google::Adwords::EmailPromotionsPreferences;
use Google::Adwords::CreditCard;
use Google::Adwords::Address;

my $service = Google::Adwords::AccountService->new();

# login to the Adwords server
$service->email($email)
->password($password)
->clientEmail($cemail)
->applicationToken($app_token)
->developerToken($dev_token);

# getAccountInfo
my $account = $service->getAccountInfo();
print "currencyCode : " . $account->currencyCode . "n";
print "descriptiveName : " . $account->descriptiveName . "n";

# getClientAccounts
my @emailaccounts = $service->getClientAccounts();
print "getClientAccounts : " . join(|, @emailaccounts) . "n";

# getCreditCard
my $creditcard = $service->getCreditCard();

# setLoginInfo
my $ret_setlogininfo= $service->setLoginInfo(email@example.com, toto);

# setLocalTimezone to brrr ...
my $ret_setlocaltimezone = $service->setLocalTimezone(America/Anchorage);

# setCreditCard
my $cc = Google::Adwords::CreditCard->new
->cardNumber(12345678912346)
->cardType(VISA)
->cardVerificationNumber(123)
->expirationMonth(1)
->expirationYear(2008);

my $addr = Google::Adwords::Address->new
->addressLine1(down the street)
->city(Paris)
->companyName(Up there)
->countryCode(FR)
->emailAddress(me@example.com)
->name(Up there)
->phoneNumber(+33112345678)
->postalCode(75020);

my $ret_setcreditcard = $service->setCreditCard($cc, $addr);

# createAdWordsAccount
my $emailPrefs = Google::Adwords::EmailPromotionsPreferences->new
->marketResearchEnabled(1)
->newsletterEnabled(1)
->promotionsEnabled(0);

my $covType = Google::Adwords::CoverageType->new
->optInContentNetwork(0)
->optInSearchNetwork(1);

my $ret = $service->createAdWordsAccount({
loginEmail => $loginEmail,
password => $password,
languagePreference => $lgPref,
emailPrefs => $emailPrefs,
currencyCode => $curCode,
cardInfo => $creditcard,
contactInfo => $address,
defaultAdsCoverage => $covType,
timeZoneId => $timeZoneId
});

# updateAccountInfo
$account->primaryBusinessCategory(Advertising, Marketing, SEO);
my $ret_updateaccountinfo = $service->updateAccountInfo($account);

This module provides an interface to the Google Adword AccountService API calls.

Net::Google is a simple OOP-ish interface to the Google SOAP API.

SYNOPSIS

use Net::Google;
use constant LOCAL_GOOGLE_KEY => "********************************";

my $google = Net::Google->new(key=>LOCAL_GOOGLE_KEY);
my $search = $google->search();

# Search interface

$search->query(qw(aaron straup cope));
$search->lr(qw(en fr));
$search->starts_at(5);
$search->max_results(15);

map { print $_->title()."n"; } @{$search->results()};

# or...

foreach my $r (@{$search->response()}) {
print "Search time :".$r->searchTime()."n";

# returns an array ref of Result objects
# the same as the $search->results() method
map { print $_->URL()."n"; } @{$r->resultElements()};
}

# Spelling interface

print $google->spelling(phrase=>"muntreal qwebec")->suggest(),"n";

# Cache interface

my $cache = $google->cache(url=>"http://search.cpan.org/recent");
print $cache->get();

Provides a simple OOP-ish interface to the Google SOAP API