System.bot: export from /home/www-data/landscapefor/atlas/beta/cli/wikidata-import-export.php

2022-06-06T11:32:01Z

export from /home/www-data/landscapefor/atlas/beta/cli/wikidata-import-export.php

Nuova pagina

This is the [[atlas:|AtlasFor]]'s '''Wikidata import-export''' command line interface script.

It's designed to:

* list all [[atlas:|AtlasFor]] point of interests, by last import date first
* chunk them 50 at time, to then do a single HTTP call to the [https://www.wikidata.org/w/api.php?action=help&modules=wbgetentities Wikidata <code>wbgetentities</code> API]
** this is done using the [https://gitpull.it/w/first_steps_with_boz-mw/ boz-mw] framework using <code>Wikidata::instance()->fetch()</code>
* update our local Wikidata identifiers with any upstream Wikidata redirect (fixing merges)
* export our label in Wikidata, only if one is missing
* export our short description in Wikidata, only if one is missing
* export our geolocation in Wikidata, only if one is missing and if it's not an area
** if the preferred geolocation is NOT the one from AtlasFor, investigate why
*** allow to push or pull a better geolocation from/in Wikidata
* import Wikipedia editions (in some languages)
* import Wikimedia Commons link
* import official website (keeping language), and other identifiers
* export our street address, only if one is missing and if it's not an area
** import it, if we have not it
* export our local identifier (https://www.wikidata.org/wiki/Property:P7004) if we saved at least 1 thing, or if our POI is important

/home/www-data/landscapefor/atlas/beta/cli/wikidata-import-export.php

<pre>
#!/usr/bin/php
<?php
# Landscapefor-map - The "Landscapefor" map management system
# Copyright (C) 2018, 2019, 2020, 2021, 2022 Valerio Bozzolan
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

// allowed only from command line interface
if( !isset( $argv[ 0 ] ) ) {
exit( 1 );
}

// autoload suckless-php
require __DIR__ . '/../load.php';

// autoload boz-php
require BOZ_MW;

// declare usage of useful classes
use \wm\Wikidata;
use \wb\StatementExternalID;
use \wb\StatementGlobeCoordinate;
use \wb\StatementMonolingualText;
use \wb\Label;
use \wb\Reference;
use \wb\SnakURL;
use \wb\SnakTime;
use \wb\SnakItem;

// command line arguments
$opts = getopt( '', [
'poiid:',
'no-export',
'no-import-messages',
'no-just-identifiers',
'upgrade-coordinates',
] );

$LANGUAGE_PREFERENCES = [
'it',
'en',
];

// export option
$POIID = $opts['poiid'] ?? null;
$EXPORT = !isset( $opts['no-export'] );
$NO_IMPORT = isset( $opts['no-import-messages'] );
$NO_JUST_ID = isset( $opts['no-just-identifiers'] );
$UP_COORDS = isset( $opts['upgrade-coordinates'] );

// when a single POI is selected, try to upgrade the coordinates
if( $POIID ) {
$UP_COORDS = true;
}

echo "--poiid specified: " . ( $POIID ? $POIID : 'no' ) . "\n";
echo "--no-export specified: " . ( $EXPORT ? 'no' : 'yes' ) . "\n";
echo "--upgrade-coordinates specified: " . ( $UP_COORDS ? 'yes' : 'no' ) . "\n";
echo "--no-import-messages specified: " . ( $NO_IMPORT ? 'yes' : 'no' ) . "\n";
echo "--no-just-identifiers specified: " . ( $NO_JUST_ID ? 'yes' : 'no' ) . "\n";

// to avoid to save addresses like 'Torino' or other shitty stuff
$MIN_LENGTH_ADDRESS = 14;

$WIKIDATA_LANGUAGES = [
'Q1860' => 'en',
'Q652' => 'it',
'Q150' => 'fr',
'Q7850' => 'zh',
'Q8798' => 'uk',
];

// properties to be queried from Wikidata APIs
$ENTITY_PROPS = [
'labels',
'descriptions',
'claims',
];

// get the externalsites that can be extracted from a Wikidata property
$importable_identifiers =
( new ExternalsiteApi() )
->joinExternalsitecategory()
->whereWikidataPropertyIsNotNULL()
->queryResults();

$POI_FIELDS = [
POI::ID,
POI::NAME,
POI::LAT,
POI::LNG,
POI::WIKIDATA,
POI::ADDRESS,
POI::CAPTION,
POI::EXTERNAL_URLS,
POI::COMUNE_,
Comune::NAME,
];

$only_published_medias = function( $query ) {
$query->joinMedia();
$query->whereMediaIsPublished();
};

$pois = new QueryPOI();
$pois->defaultClass( POIFull::class );
$pois->joinComune( 'LEFT') ;
$pois->select( $POI_FIELDS );
$pois->selectPOIMediaCount( $only_published_medias );

if( $POIID ) {
$pois->wherePOIID( $POIID );
} else {
$pois->whereStr( POI::STATUS, 'published' );
}

$pois->compare( POI::WIKIDATA, 'IS NOT', 'NULL' );

// first POIs that was never marked as imported
$pois->orderBy( 'poi_lastwikidataimport', 'ASC' );

$wikidata = Wikidata::instance()
->login( WIKIMEDIA_BOT_USERNAME, WIKIMEDIA_BOT_PASSWORD );

$poi_generator = $pois->queryGenerator();

// process 50 at time
foreach( chunk_generator( $poi_generator, 50 ) as $poi_chunk ) {

// process few of them
$poi_by_wikidata_id = [];
foreach( $poi_chunk as $poi ) {
// note that Wikidata codes can be empty
if( $poi->get( POI::WIKIDATA ) ) {
$poi_by_wikidata_id[ $poi->get( POI::WIKIDATA ) ] = $poi;
}
}

$entities = [];
try {
$entities = $wikidata->fetch( [
'action' => 'wbgetentities',
'ids' => array_keys( $poi_by_wikidata_id ),
'props' => $ENTITY_PROPS,
] );
} catch( mw\API\NoSuchEntityException $e ) {
\cli\Log::error( $e->getMessage() );
sleep( 5 );
}

// it should be just one
foreach( $entities->entities ?? [] as $entity ) {

$entity_id = $entity->id;
$new_entity_id = null;
if( isset( $entity->redirects ) ) {
$entity_id = $entity->redirects->from;
$new_entity_id = $entity->redirects->to;
}
$poi = $poi_by_wikidata_id[ $entity_id ];

if( !$poi ) {
var_dump( $entity );
die( "not found entity\n" );
}

$need_to_refresh_poi = false;

$entity_data = $wikidata->createDataModelFromObject( $entity );

// allow to refresh the POI later
do {

$poi_ID = $poi->getPOIID();

echo "Analyzing POI {$poi_ID}\n";

// check if this POI need to be refreshed (maybe this is the second loop)
if( $need_to_refresh_poi ) {

// pull data from AtlasFor
$poi = ( new QueryPOI() )
->select( $POI_FIELDS )
->selectPOIMediaCount( $only_published_medias )
->joinComune( 'LEFT' )
->wherePOI( $poi )
->defaultClass( POIFull::class )
->queryRow();

// pull most recent Wikidata ID
$entity_id = $poi->get( POI::WIKIDATA );

// pull data from Wikidata
$entity_data = $wikidata->fetchSingleEntity( $entity_id, [
'props' => $ENTITY_PROPS,
] );

$need_to_refresh_poi = false;
}

// empty container for information to be saved
$new_data = $entity_data->cloneEmpty();

// wikidata standard reference
$reference = new Reference( [
// reference URL: AtlasFor
new SnakURL( 'P854', "https://atlasf.eu/poi/$poi_ID" ),

// retrieved point in time: now
new SnakTime( 'P813' ),
] );

// update redirected Wikidata ID
if( $poi && $new_entity_id ) {
update_poi( $poi, [
new DBCol( POI::WIKIDATA, $new_entity_id, 's' ),
] );
}

$summary = [];
$imports = [];

// export italian label
if( !$entity_data->hasLabelInLanguage( 'it' ) ) {
$label = new Label( 'it', $poi->getPOIName() );
$new_data->setLabel( $label );
$summary[] = "add label it: " . $poi->getPOIName();
}

// export English label
if( !$entity_data->hasLabelInLanguage( 'en' ) ) {
$label = new Label( 'en', $poi->getPOIName() );
$new_data->setLabel( $label );
$summary[] = "add label en: " . $poi->getPOIName();
}

// for each importable identifier (from a Wikidata property like Official website)
foreach( $importable_identifiers as $importable_identifier ) {

// this may be official website, Facebook, etc.
$wikidata_property = $importable_identifier->getWikidataProperty();
$identifier_name = $importable_identifier->getExternalsitecategoryName();

// import official website or whatever official external URL (take all claims)
foreach( $entity_data->getClaimsInProperty( $wikidata_property ) as $claim ) {

// index the websites by the language
$sites_by_lang = [];

// try to associate to a language
$site = $claim->getMainsnak()->getDataValue()->getValue();
if( $site ) {

// read 'language of work or name' to identify the language
foreach( $claim->getQualifiersInProperty( 'P407' ) as $qualifier ) {
$lang = $qualifier->getDataValue()->getValue()[ 'id' ];
if( $lang ) {
if( isset( $WIKIDATA_LANGUAGES[ $lang ] ) ) {
$sites_by_lang[ $WIKIDATA_LANGUAGES[ $lang ] ] = $site;
}
}
}

// case for no language specified
if( !$sites_by_lang ) {
$sites_by_lang['none'] = $site;
}
}

// save official website
foreach( $sites_by_lang as $lang => $site ) {

// query the externalsite (in that language)
$externalsite_query = new ExternalsiteApi();
$externalsite_query->whereExternalsitecategory( $importable_identifier );
if( $lang === 'none' ) {
$externalsite_query->whereExternalsiteLangIsNULL();
} else {
$externalsite_query->whereExternalsiteLang( $lang );
}
$externalsite = $externalsite_query->queryRow();

if( !$externalsite ) {
error_die( "missing site for {$identifier_name}[lang:$lang]" );
}

/*
* If the italian language is found, delete the website without language that is less precise
* This is useful when:
* - Today I import an official website without language
* - Tomorrow I import that official website in Italian (someone specified the language of name or work)
*/
if( $lang === 'it' ) {

// check if it exists a version of this identifier without language
$neutral_externalsite = ( new ExternalsiteApi() )
->whereExternalsiteCategory( $importable_identifier )
->whereExternalsiteLangIsNULL()
->queryRow();

// delete the neutral entries (if any)
if( $neutral_externalsite ) {
$neutral_externalsitepage_query =
( new ExternalsitepageApi() )
->whereExternalsite( $neutral_externalsite )
->wherePOI( $poi );

if( $neutral_externalsitepage_query->queryRow() ) {
$imports[] = "delete imprecise version of $identifier_name\n";
$neutral_externalsitepage_query->delete();
}
}
} else {
$externalsite_query->whereExternalsiteLang( $lang );
}

// find existing external site page
$externalsitepage = ( new ExternalsitepageApi() )
->whereExternalsite( $externalsite )
->wherePOI( $poi )
->queryRow();

// append a new one
if( $externalsitepage ) {
if( $claim->isDeprecated() ) {
// if is deprecated, drop
( new ExternalsitepageApi() )
->whereExternalsitepage( $externalsitepage )
->delete();

$imports[] = "deleted now deprecated {$identifier_name}[lang:$lang]";
}
} else {
// import only if it's not deprecated
if( !$claim->isDeprecated() ) {
( new ExternalsitepageApi() )
->insertRow( [
new DBCol( 'externalsite_ID', $externalsite->getExternalsiteID(), 'd' ),
new DBCol( 'externalsitepage_uid', $site, 's' ),
new DBCol( 'poi_ID', $poi_ID, 'd' ),
new DBCOl( 'externalsitepage_lastedit_date', 'NOW()', '-' ),
new DBCol( 'externalsitepage_lastedit_user', 1, 'd' ),
] );

$imports[] = "import {$identifier_name}[lang:$lang]: '$site'";
}
}
}
}
}

$is_area =
$entity_data->hasClaimsInProperty( 'P159' ) // headquarters location
||
$entity_data->hasClaimsInProperty( 'P1332' ) // coordinates of northernmost point
||
$entity_data->hasClaimsInProperty( 'P1333' ) // coordinates of southernmost point
||
$entity_data->hasClaimsInProperty( 'P1334' ) // coordinates of easternmost point
||
$entity_data->hasClaimsInProperty( 'P1335' ) // coordinates of westernmost point
||
$entity_data->hasClaimsInProperty( 'P1376' ) // capital of
||
$entity_data->hasClaimsInProperty( 'P1082' ) // population
||
$entity_data->hasClaimsInProperty( 'P2046' ) // area (km)
;

// eventually add coordinates
if( !$is_area ) {

$all_coordinates = $entity_data->getClaimsInProperty( 'P625' );

// at the moment we assume that we have better coordinates ONLY if there are not
$we_have_better_coordinates = false;
if( !count( $all_coordinates ) ) {
$we_have_better_coordinates = true;
}

// check if we already saved some coordinates
foreach( $entity_data->getClaimsInProperty( 'P625' ) as $claim_coordinates ) {

$found_our_claim_reference = find_claim_reference_url( $claim_coordinates, 'https://atlasf.eu/' );

// check if we can upgrade coordinates (since they differs, on AtlasFor are probably more recent)
if( $found_our_claim_reference && $UP_COORDS ) {

// TODO: do something to understand if:
// this is our: automatic
$upstream_coordinates_raw = $claim_coordinates->getMainsnak()->getDataValue()->getValue();
$upstream_coordinates_raw_lat = $upstream_coordinates_raw['latitude'];
$upstream_coordinates_raw_lng = $upstream_coordinates_raw['longitude'];

if( has_poi_different_coordinates( $poi, $upstream_coordinates_raw_lat, $upstream_coordinates_raw_lng ) ) {

// show this coordinates
echo "Upstream coordinates with rank " . $claim_coordinates->getRank() . "\n";
echo GeoTools::geohackURL( [
'lat' => $upstream_coordinates_raw_lat,
'lng' => $upstream_coordinates_raw_lng,
] );

echo "\n\n";
echo "Current coordinates:\n";
echo $poi->getPOIGeohackURL() . "\n";

echo "\n";
$we_have_better_coordinates_input = readline( "Is the new better? [Y/n]\n" );
$we_have_better_coordinates_input = strtolower( $we_have_better_coordinates_input );
if( $we_have_better_coordinates_input !== 'n' ) {
$we_have_better_coordinates = true;

if( true ) {
// mark for removal
$claim_coordinates->markForRemoval();
$new_data->addClaim( $claim_coordinates );

$summary[] = "remove obsolete [[Property:P625|coordinate location]]";
} else {
// set this as obsolete
$claim_coordinates->setRankDeprecated();
$claim_coordinates->addQualifier( new SnakItem( 'P2241', 'Q107356532' ) );
$new_data->addClaim( $claim_coordinates );

$summary[] = "obsolete [[Property:P625|coordinate location]]";
}
}

} else {
echo "Upstream up to date\n";
}
}
}

if( $we_have_better_coordinates ) {

// coordinate location
$statement = new StatementGlobeCoordinate( 'P625',
$poi->getPOILatitude(),
$poi->getPOILongitude(),
0.01
);

// append coordinates
$new_data->addClaim( $statement->addReference( $reference ) );

$summary[] = "add [[Property:P625|coordinate location]]";

echo "Our location:\n";
echo $poi->getPOIGeohackURL() . "\n";
}

}

// address import-export
$address = $poi->get( POI::ADDRESS );
if( $address ) {
if( !$is_area ) {
// export address
if( strlen( $address ) > $MIN_LENGTH_ADDRESS && !$entity_data->hasClaimsInProperty( 'P6375' ) ) {
$statement = new StatementMonolingualText( 'P6375', 'it', $address );
$new_data->addClaim( $statement->addReference( $reference ) );
$summary[] = "add [[Property:P6375|address]]: $address";
}
}
} else {
$new_address = null;

// import address from Wikidata
foreach( $entity_data->getBestClaimsInProperty( 'P6375' ) as $claim ) {
$value = $claim->getMainSnak()->getDataValue()->getValue();
if( $value['language'] === 'it' ) {
$new_address = $value['text'];
}
}
if( $new_address ) {
$imports[] = "import address: $new_address";
update_poi( $poi, [
new DBCol( POI::ADDRESS, $new_address, 's' ),
] );
}
}

// reset for each POI
$add_identifier = null;

// check if we already have a local identifier
foreach( $entity_data->getBestClaimsInProperty( WIKIDATA_PROPERTY ) as $claim ) {

$identifier_upstream = $claim->getMainSnak()->getDataValue()->getValue();

$to =
( new QueryPOIRedirect() )
->select( POIFull::fieldsForPermalink() )
->wherePOIRedirectFromID( $identifier_upstream )
->joinPOIRedirectTo()
->joinCategory()
->queryRow();

// redirect found?
if( $to ) {

$claim->setRankDeprecated();

// reason for deprecated rank: withdrawn identifier value
$claim->addQualifier( new SnakItem( 'P2241', 'Q21441764' ) );

// prepare for saving
$new_data->addClaim( $claim );

$summary[] = "deprecate [[Property:" . WIKIDATA_PROPERTY. "|AtlasFor ID]]: $identifier_upstream";
} else {

// check if already present
if( $identifier_upstream == $poi_ID ) {
$add_identifier = false;
}

}
}

// check if it has sense to save the identifier
if( $add_identifier !== false ) {

// if we have more changes
if( $new_data->getClaims() ) {

// this is not the only change, save the identifier
$add_identifier = true;

} else {

// this is the only change

// check if it still has sense
$poi_medias = $poi->count_medias ?? 0;
if( !$NO_JUST_ID && $poi_medias > 2 ) {
$add_identifier = true;
}
}
}

// add the AtlasFor identifier to Wikidata
if( $add_identifier ) {
$statement = new StatementExternalID( WIKIDATA_PROPERTY, (string) $poi_ID );
$new_data->addClaim( $statement );
$summary[] = "add [[Property:" . WIKIDATA_PROPERTY. "|AtlasFor ID]]: $poi_ID";
}

// show some imported informations
if( $imports && !$NO_IMPORT ) {
echo "Import\n\t";
echo implode( "\n\t", $imports );
echo "\n";
}

// have we any change to be saved?
if( $summary ) {

// is this export mode?
if( $EXPORT ) {

// edit summary
$summary_raw = implode( "; ", $summary );
// $summary_raw .= " from [[Q65769786|AtlasFor]] {$poi->getPOIPermalinkShort()}";

// show some info
echo "\n";
echo "\n";
echo "POI {$poi->getPOIPermalinkShort()}\n";
echo " " . $poi->getPOIName() . "\n";
echo " " . $poi->get( Comune::NAME ) . "\n";
echo " " . $poi->get( POI::CAPTION ) . "\n";
echo "WIKIDATA https://www.wikidata.org/wiki/{$entity->id}\n";
echo " " . $entity_data->getWhateverLabelValue( $LANGUAGE_PREFERENCES ) . "\n";
echo " " . $entity_data->getWhateverDescriptionValue( $LANGUAGE_PREFERENCES ) . "\n";
echo "SUMMARY:\n";
foreach( $summary as $summary_line ) {
echo " $summary_line\n";
}

// show something interesting
// TODO: the DataValue are not specific, so the getPrintableWikitext() does not work
// $new_data->printChanges();
//print_r( $new_data->get() );

// user interaction
$interaction = readline( "Save? [Y/n/r/d] (Yes/no/refresh/dropID from DB)" );
$interaction = strtolower( $interaction );
if( $interaction === 'r' ) {

$need_to_refresh_poi = true;

} elseif( $interaction == 'd' ) {

echo "Dropping Wikidata ID from our POI...\n";

// drop Wikidata ID
( new QueryPOI() )
->wherePOIID( $poi_ID )
->update( [
POI::WIKIDATA => null,
] );

} elseif( $interaction !== 'n' ) {

echo "Saving...\n";
try {
$new_data->editEntity( [
'summary' => $summary_raw,
'bot' => 1,
] );

} catch( \wb\API\ModificationFailedException $e ) {
\cli\Log::warn( $e->getMessage() );
sleep( 2 );
} catch( \mw\API\PermissionDeniedException $e ) {
\cli\Log::error( $e->getMessage() );
sleep( 2 );
}

} else {

echo "Skipped manually...\n";

}
} else {
echo "Skipped (not in export mode)...\n";
}
}

} while( $need_to_refresh_poi );

// mark this POI as just seen
( new QueryPOI() )
->wherePOIID( $poi_ID )
->update( [
new DBCol( 'poi_lastwikidataimport', 'NOW()', '-' ),
] );
}
}

/**
* A small shortcut to update a single POI
*
* @param POI $poi
* @param array $data
*/
function update_poi( $poi, $data ) {

$data[] = new DBCol( POI::LASTEDIT_USER, 1, 'd' );
$data[] = new DBCol( POI::LASTEDIT_DATE, 'NOW()', '-' );

( new QueryPOI() )
->wherePOI( $poi )
->update( $data );
}

/**
* Given lot of results, split them in small chunks
*
* @param array $entries
* @param int $n
* @generator
*/
function chunk_generator( $entries, $n ) {

$chunk = [];
foreach( $entries as $entry ) {
$chunk[] = $entry;

if( count( $chunk ) > $n ) {
yield $chunk;
$chunk = [];
}
}

if( $chunk ) {
yield $chunk;
}
}

/**
* Check if a Claim contains a reference URL
*
* @param Claim $claim
* @param string $url_part
* @return Snak|false
*/
function find_claim_reference_url( $claim, $url_part ) {

$references = $claim->getReferences();
foreach( $references as $reference ) {

// reference URLs
$snaks = $reference->getSnaksInProperty( 'P854' );
foreach( $snaks as $snak ) {
$snak_datavalue = $snak->getDataValue();
$snak_value = $snak_datavalue->getValue();

if( strpos( $snak_value, $url_part ) !== -1 ) {
return $reference;
}
}

}

return false;
}

/**
* Compare POI's coordinates with some others
*
* @param POI $poi
* @param float $lat2
* @param float $lng2
*/
function has_poi_different_coordinates( $poi, $lat2, $lng2 ) {
$lat1 = $poi->getPOILatitude();
$lng1 = $poi->getPOILongitude();
return are_different_coordinates( $lat1, $lng1, $lat2, $lng2 );
}

/**
* Check if two coordinates are very very similar
*
* NOTE: The numbers are considered the same if their truncation is the same.
*
* @param float $lat1 Latitude (or longitude)
* @param float $lat2 Latitude (or longitude)
* @return boolean
*/
function are_same_coordinates( $lat1, $lat2 ) {

$minlen = min( strlen( $lat1 ), strlen( $lat2 ) );

$lat1 = substr( $lat1, 0, $minlen );
$lat2 = substr( $lat2, 0, $minlen );

return "$lat1" === "$lat2";
}

/**
* Check if two pairs of coordinates are different
*
* @param float $lat1 Latitude (1)
* @param float $lng1 Longitude (1)
* @param float $lat2 Latitude (2)
* @param float $lng2 Longitude (2)
* @return boolean
*/
function are_different_coordinates( $lat1, $lng1, $lat2, $lng2 ) {
return !are_same_coordinates( $lat1, $lat2 )
|| !are_same_coordinates( $lng1, $lng2 );
}
</pre>

Sostegno/2022/Microgrant WMI/Relazione conclusiva/script-import-export.php - Cronologia

System.bot: export from /home/www-data/landscapefor/atlas/beta/cli/wikidata-import-export.php