latest blogs

The aim of this 2-parts blog post is to show some useful, yet not very complicated, features of the Pandas Python library that are not found in most (numeric oriented) tutorials.

We will illustrate these techniques with Geonames data : extract useful data from the Geonames dump, transform it, and load it into another file. There is no numeric computation involved here, nor statictics. We will prove that pandas can be used in a wide range of cases beyond numerical analysis.

While the first part was an introduction to Geonames data, this second part contains the real work with Pandas. Please read part 1 if you are not familiar with Geonames data.

The project

The goal is to read Geonames data, from allCountries.txt and alternateNames.txt files, combine them, and produce a new CSV file with the following columns:

  • gid, the Geonames id,
  • frname, French name when available,
  • gname, Geonames main name,
  • fclass, feature class,
  • fcode, feature code,
  • parent_gid, Geonames id of the parent location,
  • lat, latitude,
  • lng, longitude.

Also we don't want to use too much RAM during the process. 1 GB is a maximum.

You may think that this new CSV file is a low-level objective, not very interesting. But it can be a step into a larger process. For example one can build a local Geonames database that can then be used by tools like Elastic Search or Solr to provide easy searching and auto-completion in French.

Another interesting feature is provided by the parent_gid column. One can use this column to build a tree of locations, or a SKOS thesaurus of concepts.

The method

Before diving into technical details, let us first look at the big picture, the overall process to achieve the aforementioned goal.

Considering the wanted columns, we can see the following differences with allCountries.txt:

  • we are not interested in some original columns (population, elevation, ...),
  • the column frname is new and will come from alternateNames.txt, thanks to the Geonames id,
  • the column parent_gid is new too. We must derive this information from the adminX_code (X=1, 2, 3, 4) columns in allCountries.txt.

This column deserves an example. Look at Arrondissement de toulouse.

feature_code: ADM3, country_code: FR, admin1_code: 76, admin2_code: 31, admin3_code: 313

To find its parent, we must look at a place with the following properties,

feature_code: ADM2, country_code: FR, admin1_code: 76, admin2_code: 31

and there is only one place with such properties, Geonames id 3,013,767, namely Département de la Haute-Garonne. Thus we must find a way to derive the Geonames id from the feature_code, country_code and adminX_code columns. Pandas will make this easy for us.


Let's get to work. And of course, we must first import the Pandas library to make it available. We also import the csv module because we will need it to perform basic operations on CSV files.

>>> import pandas as pd
>>> import csv

The French names step

Loading file

We begin by loading data from the alternateNames.txt file.

And indeed, that's a big file. To save memory we won't load the whole file. Recall from previous part, that the alternateNames.txt file provides the following columns in order.

alternateNameId   : the id of this alternate name, int
geonameid         : geonameId referring to id in table 'geoname', int
isolanguage       : iso 639 language code 2- or 3-characters; (...)
alternate name    : alternate name or name variant, varchar(400)
isPreferredName   : '1', if this alternate name is an official/preferred name
isShortName       : '1', if this is a short name like 'California' for 'State of California'
isColloquial      : '1', if this alternate name is a colloquial or slang term
isHistoric        : '1', if this alternate name is historic and was used in the pastq

For our purpose we are only interested in columns geonameid (so that we can find corresponding place in allCountries.txt file), isolanguage (so that we can keep only French names), alternate name (of course), and isPreferredName (because we want to keep preferred names when possible).

Another way to save memory is to filter the file before loading it. Indeed, it's a better practice to load a smaller dataset (filter before loading) than to load a big one and then filter it after loading. It's important to keep those things in mind when you are working with large datasets. So in our case, it is cleaner (but slower) to prepare the CSV file before, keeping only French names.

>>> # After restarting Python
>>> with open('alternateNames.txt') as f:
...     reader = csv.reader(f, delimiter='\t', quoting=csv.QUOTE_NONE)
...     with open('frAltNames.txt', 'w') as g:
...         writer = csv.writer(g, delimiter='\t', quoting=csv.QUOTE_NONE,
...                             escapechar='\\')
...         for row in reader:
...             if row[2] == u'fr':
...                 writer.writerow(row)

To load a CSV file, Pandas provides the read_csv function. It returns a dataframe populated with data from a CSV file.

>>> with open('frAltNames.txt') as altf:
...     frnames = pd.read_csv(
...         altf, encoding='utf-8',
...         sep='\t', quoting=csv.QUOTE_NONE,
...         header=None, usecols=(1, 3, 4), index_col=0,
...         names=('gid', 'frname', 'pref'),
...         dtype={'gid': 'uint32', 'frname': str, 'pref': 'bool_'},
...         true_values=['1'], false_values=[u''], na_filter=False,
...         skipinitialspace=True, error_bad_lines=False
...     )
...

The read_csv function is quite complex and it takes some time to use it rightly. In our cases, the first few parameters are self-explanatory: encoding for the file encoding, sep for the CSV separator, quoting for the quoting protocol (here there is none), and header for lines to be considered as label lines (here there is none).

usecols tells pandas to load only the specified columns. Beware that indices start at 0, so column 1 is the second column in the file (geonameid in this case).

index_col says to use one of the columns as a row index (instead of creating a new index from scratch). Note that the number for index_col is relative to usecols. In other words, 0 means the first column of usecols, not the first column of the file.

names gives labels for columns (instead of using integers from 0). Hence we can extract the last column with frnames['pref'] (instead of frnames[3]). Please note, that this parameter is not compatible with headers=0 for example (in that case, the first line is used to label columns).

The dtype parameter is interesting. It allows you to specify one type per column. When possible, prefer to use NumPy types to save memory (eg np.uint32, np.bool_).

Since we want boolean values for the pref column, we can tell Pandas to convert '1' strings to True and empty strings ('') to False. That is the point of using parameters true_values and false_values.

But, by default, Pandas detect empty strings and affect them np.nan (NaN means not a number). To prevent this behavior, setting na_filter to False will leave empty strings as empty strings. Thus, empty strings in the pref column will be converted to False (thanks to the false_values parameter and to the 'bool_' data type).

Finally, skipinitialspace tells Pandas to left-strip strings to remove leading spaces. Without it, a line like a, b (commas-separated) would give values 'a' and ' b' (note leading space before b).

And lastly, error_bad_lines make pandas ignore lines he cannot understand (eg. wrong number of columns). The default behavior is to raise an exception.

There are many more parameters to this function, which is much more powerful than the simple reader object from the csv module. Please, refer to the documentation at http://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_csv.html for a full list of options. For example, the header parameter can accept a list of integers, like [1, 3, 4], saying that lines at position 1, 3 and 4 are label lines.

>>> frnames.info(memory_usage='deep')
<class 'pandas.core.frame.DataFrame'>
Int64Index: 55684 entries, 18918 to 11441793
Data columns (total 2 columns):
frname     55684 non-null object
pref       55684 non-null bool
dtypes: bool(1), object(1)
memory usage: 6.6 MB

We can see here that our dataframe contains 55,684 entries and that it takes about 6.6 MB in memory.

Let's look at entry number 3,013,767 for the Haute-Garonne department.

>>> frnames.loc[3013767]
                                 frname    pref
gid
3013767  Département de la Haute-Garonne  False
3013767                    Haute-Garonne   True

Removing duplicated indices

There is one last thing to do with the frnames dataframe: make its row indices uniques. Indeed, we can see from the previous example that there are two entries for the Haute-Garonne department. We need to keep only one, and, when possible, the preferred form (when the pref column is True).

This is not always possible: we can see at the beginning of the dataframe (use the head method) that there is no preferred French name for Rwanda.

>>> frnames.head()
                     frname   pref
gid
18918              Protaras   True
49518  République du Rwanda  False
49518                Rwanda  False
50360       Woqooyi Galbeed  False
51230              Togdheer  False

In such a case, we will take one of the two lines at random. Maybe a clever rule to decide which one to keep would be useful (like involving other columns), but for the purpose of this tutorial it does not matter which one is kept.

Back to our problem, how to make indices uniques ? Pandas provides the duplicated method on Index objects. This method returns a boolean NumPy 1d-array (a vector), the size of which is the number of entries. So, since our dataframe has 55,684 entries, the length of the returned vector is 55,684.

>>> dups_idx = frnames.index.duplicated()
>>> dups_idx
array([False, False,  True, ..., False, False, False], dtype=bool)
>>> len(dups_idx)
55684

The meaning is simple: when you encounter True, it means that the index at this position is a duplicate of a previously encountered index. For example, we can see that the third value in dups_idx is True. And indeed, the third line of frnames has an index (49,518) which is a duplicate of the second line.

So duplicated is meant to mark as True duplicated indices and to keep only the first one (there is an optional parameter to change this: read the doc). How do we make sure that the first entry is the preferred entry ? Sorting the dataframe of course! We can sort a table by a column (or by a list of columns), using the sort_values method. We give ascending=False because True > False (that's a philosophical question!), and inplace=True to sort the dataframe in place, thus we do not create a copy (still thinking about memory usage).

>>> frnames.sort_values('pref', ascending=False, inplace=True)
>>> frnames.head()
                               frname  pref
gid
18918                        Protaras  True
8029850  Hôtel de ville de Copenhague  True
8127417                        Kalmar  True
8127361                     Sundsvall  True
8127291                        Örebro  True
>>> frnames.loc[3013767]
                                  frname   pref
gid
3013767                    Haute-Garonne   True
3013767  Département de la Haute-Garonne  False

Great! All preferred names are now first in the dataframe. We can then use the duplicated index method to filter out duplicated entries.

>>> frnames = frnames[~(frnames.index.duplicated())]
>>> frnames.loc[3013767]
frname     Haute-Garonne
pref                True
Name: 3013767, dtype: object
>>> frnames.loc[49518]
frname     Rwanda
pref        False
Name: 49518, dtype: object
>>> frnames.info(memory_usage='deep')
<class 'pandas.core.frame.DataFrame'>
Int64Index: 49047 entries, 18918 to 11441793
Data columns (total 2 columns):
frname     49047 non-null object
pref       49047 non-null bool
dtypes: bool(1), object(1)
memory usage: 5.7 MB

We end up with 49,047 French names. Notice the ~ in the filter expression ? That's because we want to keep the first entry for each duplicated index, and the first entry is False in the vector returned by duplicated.

Summary for the french names step

One last thing to do is to remove the pref column which won't be used anymore. We already know how to do it.

>>> frnames.drop('pref', axis=1, inplace=True)

There has been a lot of talking until now. But if we summarize, very few commands where needed to obtain this table with only two columns (gid and frname):

  1. Prepare a smaller file so there is less data to load (keep only french names).

    with open('alternateNames.txt') as f:
        reader = csv.reader(f, delimiter='\t', quoting=csv.QUOTE_NONE)
        with open('frAltNames.txt', 'w') as g:
            writer = csv.writer(g, delimiter='\t', quoting=csv.QUOTE_NONE,
                                escapechar='\\')
            for row in reader:
                if row[2] == u'fr':
                    writer.writerow(row)
    
  2. Load the file into Pandas.

    with open('frAltNames.txt') as altf:
        frnames = pd.read_csv(
            altf, encoding='utf-8',
            sep='\t', quoting=csv.QUOTE_NONE,
            header=None, usecols=(1, 3, 4), index_col=0,
            names=('gid', 'frname', 'pref'),
            dtype={'gid': 'uint32', 'frname': str, 'pref': 'bool_'},
            true_values=['1'], false_values=[u''], na_filter=False,
            skipinitialspace=True, error_bad_lines=False
        )
    
  3. Sort on the pref column and remove duplicated indices.

    frnames.sort_values('pref', ascending=False, inplace=True)
    frnames = frnames[~(frnames.index.duplicated())]
    
  4. Remove the pref column.

    frnames.drop('pref', axis=1, inplace=True)
    

Simple, isn't it ? We'll keep this dataframe for later use. Pandas will make it a breeze to merge it with the main dataframe coming from allCountries.txt to create the new frname column.

The administrative tree step

But for now, let's look at the second problem: how to derive a gid from a feature_code, a country_code, and a bunch of adminX_code (X=1, 2, 3, 4).

Loading file

First we need the administrative part of the file allCountries.txt, that is all places with the A feature class.

Of course we can load the whole file into Pandas and then filter to keep only A-class entries, but now you know that this is memory intensive (and this file is much bigger than alternateNames.txt). So we'll be more clever and first prepare a smaller file.

>>> with open('allCountries.txt') as f:
...     reader = csv.reader(f, delimiter='\t', quoting=csv.QUOTE_NONE)
...     with open('adm_geonames.txt', 'w') as g:
...         writer = csv.writer(g, delimiter='\t', quoting=csv.QUOTE_NONE, escapechar='\\')
...         for row in reader:
...             if row[6] == 'A':
...                 writer.writerow(row)

Now we load this file into pandas. Remembering our goal, the resulting dataframe will only be used to compute gid from the code columns. So all columns we need are geonameid, feature_code, country_code, admin1_code, admin2_code, admin3_code, and admin4_code.

What about data types. All these columns are strings except for geonameid which is an integer. Since it will be painful to type <colname>: str for the dtype parameter dictionary, let's use the fromkeys constructor instead.

>>> d_types = dict.fromkeys(['fcode', 'code0', 'code1', 'code2', 'code3',
...                          'code4'], str)
>>> d_types['gid'] = 'uint32'  # Shorter geonameid in gid

We can now load the file.

>>> with open('adm_geonames.txt') as admf:
...     admgids = pd.read_csv(
...         admf, encoding='utf-8',
...         sep='\t', quoting=csv.QUOTE_NONE,
...         header=None, usecols=(0, 7, 8, 10, 11, 12, 13),
...         names=('gid', 'fcode', 'code0', 'code1', 'code2', 'code3', 'code4'),
...         dtype=d_types, na_values='', keep_default_na=False,
...         error_bad_lines=False
...     )

We recognize most parameters in this instruction. Notice that we didn't use index_col=0: gid is now a normal column, not an index, and Pandas will generate automatically a row index with integers starting at 0.

Two new parameters are na_values and keep_default_na. The first one gives Pandas additional strings to be considerer as NaN (Not a Number). The astute reader would say that empty strings ('') are already considered by Pandas as NaN, and he would be right.

But here comes the second parameter which, if set to False, tells Pandas to forget about its default list of strings recognized as NaN. The default list contains a bunch of strings like 'N/A' or '#NA' or, this is interesting, simply 'NA'. But 'NA' is used in allCountries.txt as country code for Namibia. If we keep the default list, this whole country will be ignored. So the combination of these two parameters tells Pandas to:

  • reset its default list of NaN strings,
  • use '' as a NaN string, which, consequently, will be the only one.

That's it for NaN. What can Pandas tells us about our dataframe ?

>>> admgids.info(memory_usage='deep')
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 369277 entries, 0 to 369276
Data columns (total 7 columns):
gid      369277 non-null uint32
fcode    369273 non-null object
code0    369272 non-null object
code1    369197 non-null object
code2    288494 non-null object
code3    215908 non-null object
code4    164899 non-null object
dtypes: object(6), uint32(1)
memory usage: 128.8 MB

Note the RangeIndex which Pandas has created for us. The dataframe takes about 130 MB of memory because it has a lots of object columns. Apart from that, everything looks good.

Replacing values

One thing we want to do before going on, is to replace all 'PCL<X>' values in the fcode column with just PCL. This will make our life easier later when searching in this dataframe.

>>> pd.unique(admgids.fcode)
array([u'ADMD', u'ADM1', u'PCLI', u'ADM2', u'ADM3', u'ADM2H', u'PCLD',
       u'ADM4', u'ZN', u'ADM1H', u'PCLH', u'TERR', u'ADM3H', u'PRSH',
       u'PCLIX', u'ADM5', u'ADMDH', nan, u'PCLS', u'LTER', u'ADM4H',
       u'ZNB', u'PCLF', u'PCL'], dtype=object)

Pandas provides the replace method for that.

>>> admgids.replace({'fcode': {r'PCL[A-Z]{1,2}': 'PCL'}}, regex=True, inplace=True)
>>> pd.unique(admgids.fcode)
array([u'ADMD', u'ADM1', u'PCL', u'ADM2', u'ADM3', u'ADM2H', u'ADM4',
       u'ZN', u'ADM1H', u'TERR', u'ADM3H', u'PRSH', u'ADM5', u'ADMDH', nan,
       u'LTER', u'ADM4H', u'ZNB'], dtype=object)

The replace method has lot of different signatures, refer to the Pandas documentation for a comprehensive description. Here, with the dictionary, we hare saying to look only in column fcode, and in this column, replace strings matching the regular expression with the given value. Since we are using regular expressions, the regex parameter must be set to True.

And as usual, the inplace parameter avoids creation of a copy.

Multi-indexing

Remember the goal: we want to be able to get the gid from the others columns. Well, dear reader, you'll be happy to know that Pandas allows an index to be composite, to be composed of multiple columns, what Pandas calls a MultiIndex.

To put it simply, a multi-index is useful when you have hierarchical indices Consider for example the following table.

lvl1 lvl2 N S
A AA 11 1x1
A AB 12 1x2
B BA 21 2x1
B BB 22 2x2
B BC 33 3x3

If we were to load such a table in a Pandas dataframe df (exercise: do it), we would be able to use it as follows.

>>> df.loc['A']
     N    S
AA  11  1x1
AB  12  1x2
>>> df.loc['B']
     N    S
BA  21  2x1
BB  22  2x2
BC  23  2x3
>>> df.loc[('A',), 'S']
AA    1x1
AB    1x2
Name: S, dtype: object
>>> df.loc[('A', 'AB'), 'S']
'1x2'
>>> df.loc['B', 'BB']
N     22
S    2x2
Name: (B, BB), dtype: object
>>> df.loc[('B', 'BB')]
N     22
S    2x2
Name: (B, BB), dtype: object

So, basically, we can query the multi-index using tuples (and we can omit tuples if column indexing is not involved). But must importantly we can query a multi-index partially: df.loc['A'] returns a sub-dataframe with one level of index gone.

Back to our subject, we clearly have hierarchical information in our code columns: the country code, then the admin1 code, then the admin2 code, and so on. Moreover, we can put the feature code at the top. But how to do that ?

It can't be more simpler. The main issue is to find the correct method: set_index.

>>> admgids.set_index(['fcode', 'code0', 'code1', 'code2', 'code3', 'code4'],
...                    inplace=True)
>>> admgids.info(memory_usage='deep')
<class 'pandas.core.frame.DataFrame'>
MultiIndex: 369277 entries, (ADMD, AD, 00, nan, nan, nan) to (PCLH, nan, nan, nan, nan, nan)
Data columns (total 1 columns):
gid      369277 non-null uint32
dtypes: uint32(1)
memory usage: 21.9 MB
>>> admgids.head()
                                         gid
fcode code0 code1 code2 code3 code4
ADMD  AD    00    NaN   NaN   NaN    3038817
                              NaN    3039039
ADM1  AD    06    NaN   NaN   NaN    3039162
            05    NaN   NaN   NaN    3039676
            04    NaN   NaN   NaN    3040131

That's not really it, because Pandas has kept the original dataframe order, so multi-index is all messed up. No problem, there is the sort_index method.

>>> admgids.sort_index(inplace=True)
>>> admgids.info(memory_usage='deep')
<class 'pandas.core.frame.DataFrame'>
MultiIndex: 369277 entries, (nan, CA, 10, 02, 94235, nan) to (ZNB, SY, 00, nan, nan, nan)
Data columns (total 1 columns):
gid      369277 non-null uint32
dtypes: uint32(1)
memory usage: 21.9 MB
>>> admgids.head()
                                         gid
fcode code0 code1 code2 code3 code4
NaN   CA    10    02    94235 NaN    6544163
      CN    NaN   NaN   NaN   NaN    6255000
      CY    04    NaN   NaN   NaN    6640324
      MX    16    NaN   NaN   NaN    6618819
ADM1  AD    02    NaN   NaN   NaN    3041203

Much better. We can even see that there are three entries without a feature code.

Let's see if all this effort was worth it. Can we fulfill our goal ? Can we get a gid from a bunch of codes ? Can we get the Haute-Garonne gid ?

>>> admgids.loc['ADM2', 'FR', '76', '31']
                 gid
code3 code4
NaN   NaN    3013767

And for the Toulouse ADM4 ?

>>> admgids.loc['ADM4', 'FR', '76', '31', '313', '31555']
                                         gid
fcode code0 code1 code2 code3 code4
ADM4  FR    76    31    313   31555  6453974

Cheers! You've deserved a glass of wine!

Summary for the administrative data step

Before moving on four our grand finale, let's summarize what have been done to prepare administrative data.

  1. We've prepared a smaller file with only administrative data.

    with open('allCountries.txt') as f:
        reader = csv.reader(f, delimiter='\t', quoting=csv.QUOTE_NONE)
        with open('adm_geonames.txt', 'w') as g:
            writer = csv.writer(g, delimiter='\t', quoting=csv.QUOTE_NONE,
                                escapechar='\\')
            for row in reader:
                if row[6] == 'A':
                    writer.writerow(row)
    
  2. We've loaded the file into Pandas.

    d_types = dict.fromkeys(['fcode', 'code0', 'code1', 'code2', 'code3',
                             'code4'], str)
    d_types['gid'] = 'uint32'
    with open('adm_geonames.txt') as admf:
        admgids = pd.read_csv(
            admf, encoding='utf-8',
            sep='\t', quoting=csv.QUOTE_NONE,
            header=None, usecols=(0, 7, 8, 10, 11, 12, 13),
            names=('gid', 'fcode', 'code0', 'code1', 'code2', 'code3', 'code4'),
            dtype=d_types, na_values='', keep_default_na=False,
            error_bad_lines=False
        )
    
  3. We've replaced all 'PCL<XX>' values with just 'PCL' in the fcode column.

    admgids.replace({'fcode': {r'PCL[A-Z]{1,2}': 'PCL'}}, regex=True,
                    inplace=True)
    
  4. Then we've created a multi-index with columns fcode, code0, code1, code2, code3, code4.

    admgids.set_index(['fcode', 'code0', 'code1', 'code2', 'code3', 'code4'],
                       inplace=True)
    admgids.sort_index(inplace=True)
    

Putting it all together

Time has finally come to load the main file now: allCountries.txt. On one hand, we will then be able to use the frnames dataframe to get French name for each entry and populate the frname column, and on the other hand we will use the admgids dataframe to compute parent gid for each line too.

Loading file

On my computer, loading the whole allCountries.txt at once takes 5.5 GB of memory, clearly too much! And in this case, there is no trick to reduce the size of the file first: we want all the data.

Pandas can help us with the chunk_size parameter to the read_csv function. It allows us to read the file chunk by chunk (it returns an iterator). The idea is to first create an empty CSV file for our final data, then read each chunk, perform data manipulation (that is add frname and parent_gid) of this chunk, and append the data to the file.

So we load data into Pandas the usual way. The only difference is that we add a new parameter chunksize with value 1,000,000. You can choose a smaller or a larger number of rows depending of your memory limit.

>>> d_types = dict.fromkeys(['fclass', 'fcode', 'code0', 'code1',
...                          'code2', 'code3', 'code4'], str)
>>> d_types['gid'] = 'uint32'
>>> d_types['lat'] = 'float16'
>>> d_types['lng'] = 'float16'
>>> with open('allCountries.txt') as geof:
...     reader = pd.read_csv(
...         geof, encoding='utf-8',
...         sep='\t', quoting=csv.QUOTE_NONE,
...         header=None, usecols=(0, 1, 4, 5, 6, 7, 8, 10, 11, 12, 13),
...         names=('gid', 'name', 'lat', 'lng', 'fclass', 'fcode',
...                'code0', 'code1', 'code2', 'code3', 'code4'),
...         dtype=d_types, index_col=0,
...         na_values='', keep_default_na=False,
...         chunksize=1000000, error_bad_lines=False
...     )
...     for chunk in reader:
...         pass  # We will put here code to work on each chunk

Joining tables

Pandas can perform a JOIN on two dataframes, much like in SQL. The function to do so is merge.

...     for chunk in reader:
...         chunk = pd.merge(chunk, frnames, how='left',
...                          left_index=True, right_index=True)

merge expects first the two dataframes to be joined. The how parameter tells what type of JOIN to perform (it can be left, right, inner, ...). Here we wants to keep all lines in chunk, which is the first parameter, so it is 'left' (if chunk was the second parameter, it would have been 'right').

left_index=True and right_index=True tell Pandas that the pivot column is the index on each table. Indeed, in our case the gid index will be use in both tables to compute the merge. If in one table, for example the right one, the pivot column is not the index, one can set right_index=False and add parameter right_on='<column_name>' (same parameter exists for left table).

Additionally, If there are name clashes (same column name in both tables), one can also use the suffixes parameter. For example suffixes=('_first', '_second').

And that's all we need to add the frname column. Simple isn't it ?

Computing parent gid

The parent_gid column is trickier. We'll delegate computation of the gid from administrative codes to a separate function. But first let's define two reverse dictionaries linking the fcode column to a level number

>>> level_fcode = {0: 'PCL', 1: 'ADM1', 2: 'ADM2', 3: 'ADM3', 4: 'ADM4'}
>>> fcode_level = dict((v, k) for k, v in level_fcode.items())

And here is the function computing the Geonames id from administrative codes.

>>> def geonameid_from_codes(level, **codes):
...     """Return the Geoname id of the *administrative* place with the
...     given information.
...
...     Return ``None`` if there is no match.
...
...     ``level`` is an integer from 0 to 4. 0 means we are looking for a
...     political entity (``PCL<X>`` feature code), 1 for a first-level
...     administrative division (``ADM1``), and so on until fourth-level
...     (``ADM4``).
...
...     Then user must provide at least one of the ``code0``, ...,
...     ``code4`` keyword parameters, depending on ``level``.
...
...     Examples::
...
...         >>> geonameid_from_codes(level=0, code0='RE')
...         935317
...         >>> geonameid_from_codes(level=3, code0='RE', code1='RE',
...         ...                      code2='974', code3='9742')
...         935213
...         >>> geonameid_from_codes(level=0, code0='AB')  # None
...
...     """
...     try:
...         idx = tuple(codes['code{0}'.format(i)] for i in range(level+1))
...     except KeyError:
...         raise ValueError('Not enough codeX parameters for level {0}'.format(level))
...     idx = (level_fcode[level],) + idx
...     try:
...         return admgids.loc[idx, 'gid'].values[0]
...     except (KeyError, TypeError):
...         return None
...

A few comments about this function: the first part builds a tuple idx with the given codes. Then this idx is used as an index value in the admgids dataframe to find the matching gid.

We also need another function which will compute the parent gid for a Pandas row.

>>> from six import string_types
>>> def parent_geonameid(row):
...     """Return the Geoname id of the parent of the given Pandas row.
...
...     Return ``None`` if we can't find the parent's gid.
...     """
...     # Get the parent's administrative level (PCL or ADM1, ..., ADM4)
...     level = fcode_level.get(row.fcode)
...     if (level is None and isinstance(fcode, string_types)
...             and len(fcode) >= 3):
...         fcode_level.get(row.fcode[:3], 5)
...     level = level or 5
...     level -= 1
...     if level < 0:  # We were on a country, no parent
...         return None
...     # Compute available codes
...     l = list(range(5))
...     while l and pd.isnull(row['code{0}'.format(l[-1])]):
...         l.pop()  # Remove NaN values backwards from code4
...     codes = {}
...     for i in l:
...         if i > level:
...             break
...         code_label = 'code{0}'.format(i)
...         codes[code_label] = row[code_label]
...     try:
...         return geonameid_from_codes(level, **codes)
...     except ValueError:
...         return None
...

In this function, we first look at the row fcode to get the row administrative level. If the fcode is ADMX we get the level directly. If it is PCL<X>, we get level 0 from PCL. Else we set it to level 5 to say that it is below level 4. So the parent's level is the found level minus one. And if it is -1, we know that we were on a country and there is no parent.

Then we compute all available administrative codes, removing codes with NaN values from the end.

With the level and the codes, we can search for the parent's gid using the previous function.

Now, how do we use this function. No need for a for loop, Pandas gives us the apply method.

...     for chunk in reader:
...         # (...) pd.merge as before
...         parent_gids = chunk.apply(parent_geonameid, axis=1)

This will apply the parent_geonameid to each row and return a new Pandas series whose head looks like this.

gid
2986043     nan
2993838     nan
2994701     nan
3007683     nan
3017832     nan
...
3039162     3041565.0

None values have been converted to NaN. Thus, integer values have been converted to float (you cannot have NaN within an integer column), and this is not what we want. As a compromise, we are going to convert this into str and suppress the decimal part.

...         parent_gids = parent_gid.astype(str)  # no inplace=True here
...         parent_gids.replace(r'\.0', '', regex=True, inplace=True)

We also add a label to the column. That's the name the column in our future dataframe.

...         parent_gids = parent_gids.rename('parent_gid')

And we can now append this new column to our chunk dataframe.

...         chunk = pd.concat([chunk, parent_gids], axis=1)

We're almost there. Before we can save the chunk in a CSV file, we must reorganize its columns to the expected order. For now, the frname and parent_gid columns have been appended at the end of the dataframe.

...         chunk = chunk.reindex(columns=['frname', 'name', 'fclass',
...                                        'fcode', 'parent_gid', 'lat',
...                                        'lng'])

At last, we save the chunk to the file opened in append mode.

...         chunk.to_csv('final.txt', mode='a', encoding='utf-8',
...                      quoting=csv.QUOTE_NONE, sep='\t', header=None)

Caching to speed up

Currently, creating the new CSV file from Geonames takes hours, and this is not acceptable. There are multiple ways to make thing go faster. One of the most significant change is to cache results of the parent_geonameid function. Indeed, many places in Geonames have the same parent ; computing the parent gid once and caching it sounds like a good idea.

If you are using Python3, you can simply use the @functools.lru_cache decorator on the parent_geonameid function. But let us try to define our own custom cache.

>>> from six import string_types
>>> gid_cache = {}
>>> def parent_geonameid(row):
...     """Return the Geoname id of the parent of the given Pandas row.
...
...     Return ``None`` if we can't find the parent's gid.
...     """
...     # Get the parent's administrative level (PCL or ADM1, ..., ADM4)
...     level = fcode_level.get(row.fcode)
...     if (level is None and isinstance(fcode, string_types)
...             and len(fcode) >= 3):
...         fcode_level.get(row.fcode[:3], 5)
...     level = level or 5
...     level -= 1
...     if level < 0:  # We were on a country, no parent
...         return None
...     # Compute available codes
...     l = list(range(5))
...     while l and pd.isnull(row['code{0}'.format(l[-1])]):
...         l.pop()  # Remove NaN values backwards from code4
...     codes = {}
...     code_tuple = [level]
...     for i in l:
...         if i > level:
...             break
...         code_label = 'code{0}'.format(i)
...         code = row[code_label]
...         codes[code_label] = code
...         code_tuple.append(code)
...     code_tuple = tuple(code_tuple)
...     try:
...         parent_gid = (gid_cache.get(code_tuple)
...                       or geonameid_from_codes(level, **codes))
...     except ValueError:
...         parent_gid = None
...     # Put value in cache if not already to speed up future lookup
...     if code_tuple not in gid_cache:
...         gid_cache[code_tuple] = parent_gid
...     return parent_gid

The only difference with the previous version is the use of a gid_cache dictionary. Keys for this dictionary are tuples (<level>, <code0>, [[<code1>], ..., <code4>]) (stored in the code_tuple variable), and the corresponding value is the parent gid for this combination of level and codes. Then the returned parent_gid is first looked in this dictionary for a previous cached result, else is computed from the geonameid_from_codes function like before, and the result is cached.

Summary for the final step

Let's review what we have done.

  1. We have defined three useful dictionaries. Two to get a level number from a feature code and conversely, and one to cache computation results.

    level_fcode = {0: 'PCL', 1: 'ADM1', 2: 'ADM2', 3: 'ADM3', 4: 'ADM4'}
    fcode_level = dict((v, k) for k, v in level_fcode.items())
    gid_cache = {}
    
  2. We have defined a function computing a Geoname id from administrative codes.

    def geonameid_from_codes(level, **codes):
        """Return the Geoname id of the *administrative* place with the
        given information.
    
        Return ``None`` if there is no match.
    
        ``level`` is an integer from 0 to 4. 0 means we are looking for a
        political entity (``PCL<X>`` feature code), 1 for a first-level
        administrative division (``ADM1``), and so on until fourth-level
        (``ADM4``).
    
        Then user must provide at least one of the ``code0``, ...,
        ``code4`` keyword parameters, depending on ``level``.
    
        Examples::
    
            >>> geonameid_from_codes(level=0, code0='RE')
            935317
            >>> geonameid_from_codes(level=3, code0='RE', code1='RE',
            ...                      code2='974', code3='9742')
            935213
            >>> geonameid_from_codes(level=0, code0='AB')  # None
            >>>
    
        """
        try:
            idx = tuple(codes['code{0}'.format(i)] for i in range(level+1))
        except KeyError:
            raise ValueError('Not enough codeX parameters for level {0}'.format(level))
        idx = (level_fcode[level],) + idx
        try:
            return admgids.loc[idx, 'gid'].values[0]
        except (KeyError, TypeError):
            return None
    
  3. We have defined a function computing the parent's gid of a Pandas row.

    def parent_geonameid(row):
        """Return the Geoname id of the parent of the given Pandas row.
    
        Return ``None`` if we can't find the parent's gid.
        """
        # Get the parent's administrative level (PCL or ADM1, ..., ADM4)
        level = fcode_level.get(row.fcode)
        if (level is None and isinstance(fcode, string_types)
                and len(fcode) >= 3):
            fcode_level.get(row.fcode[:3], 5)
        level = level or 5
        level -= 1
        if level < 0:  # We were on a country, no parent
            return None
        # Compute available codes
        l = list(range(5))
        while l and pd.isnull(row['code{0}'.format(l[-1])]):
            l.pop()  # Remove NaN values backwards from code4
        codes = {}
        code_tuple = [level]
        for i in l:
            if i > level:
                break
            code_label = 'code{0}'.format(i)
            code = row[code_label]
            codes[code_label] = code
            code_tuple.append(code)
        code_tuple = tuple(code_tuple)
        try:
            parent_gid = (gid_cache.get(code_tuple)
                          or geonameid_from_codes(level, **codes))
        except ValueError:
            parent_gid = None
        # Put value in cache if not already to speed up future lookup
        if code_tuple not in gid_cache:
            gid_cache[code_tuple] = parent_gid
        return parent_gid
    
  4. And finally we have loaded the file allCountries.txt into Pandas using chunks of 1,000,000 rows to save memory. For each chunk, we have merged it with the frnames table to add the frname column, and we applied the parent_geonameid function to add the parent_gid column. We then reordered the columns and append the chunk to the final CSV file.

    d_types = dict.fromkeys(['fclass', 'fcode', 'code0', 'code1',
                             'code2', 'code3', 'code4'], str)
    d_types['gid'] = 'uint32'
    d_types['lat'] = 'float16'
    d_types['lng'] = 'float16'
    with open('allCountries.txt') as geof:
        reader = pd.read_csv(
            geof, encoding='utf-8',
            sep='\t', quoting=csv.QUOTE_NONE,
            header=None, usecols=(0, 1, 4, 5, 6, 7, 8, 10, 11, 12, 13),
            names=('gid', 'name', 'lat', 'lng', 'fclass', 'fcode',
                   'code0', 'code1', 'code2', 'code3', 'code4'),
            dtype=d_types, index_col=0,
            na_values='', keep_default_na=False,
            chunksize=1000000, error_bad_lines=False
        )
        for chunk in reader:
            chunk = pd.merge(chunk, frnames, how='left',
                             left_index=True, right_index=True)
            parent_gids = chunk.apply(parent_geonameid, axis=1)
            parent_gids = parent_gids.astype(str)  # no inplace=True here
            parent_gids.replace(r'\.0', '', regex=True, inplace=True)
            parent_gids = parent_gids.rename('parent_gid')
            chunk = pd.concat([chunk, parent_gids], axis=1)
            chunk = chunk.reindex(columns=['frname', 'name', 'fclass',
                                           'fcode', 'parent_gid', 'lat',
                                           'lng'])
            chunk.to_csv('final.txt', mode='a', encoding='utf-8',
                         quoting=csv.QUOTE_NONE, sep='\t', header=None)
    

This final part is the longest, because the parent_geonameid function takes some time on each chunk to compute all parents gids. But at the end of the process we'll proudly see a final.txt file with data the way we want it, and without using too much memory... High five!

What can be improved

Congratulations! This ends our journey into the Pandas world.

Regarding Geonames, to be honest, we've only scratch the surface of its complexity. There's so much to be done.

If you look at the file we've just produced, you'll see plenty of empty values in the parent_gid column. May be our method to get the Geonames id of the parent needs to be improved. May be all those orphan places should be moved inside their countries.

Another problem lies within Geonames data. France has overseas territories, for example Reunion Island, Geoname id 935,317. This place has feature code PCLD, which means "dependent political entity". And indeed, Reunion Island is not a country and should not appear at the top level of the tree, at the same level as France. So some work should be done here to have Reunion Island linked to France in some way, may be using the until now ignored cc2 column (for "alternate country codes").

Still another improvement, easier this one, is to have yet another parent level for continents. For this, one can use the file countryInfo.txt, downloadable from the same page.

Considering speed this time, there is also room for improvements. First, the code itself might be better designed to avoid some tests and for loops. Another possibility is tu use multiprocessing, since each chunk in allCountries.txt isindependent. Processes can put their finished chunk on a queue that a writer process will read to write data in the output file. Another way to go is Cython (see: http://pandas.pydata.org/pandas-docs/stable/enhancingperf.html).

blog entry of

The aim of this 2-parts blog post is to show some useful, yet not very complicated, features of the Pandas Python library that are not found in most (numeric oriented) tutorials.

We will illustrate these techniques with Geonames data : extract useful data from the Geonames dump, transform it, and load it into another file. There is no numeric computation involved here, nor statictics. We will prove that pandas can be used in a wide range of cases beyond numerical analysis.

This first part is an introduction to Geonames data. The real work with Pandas will be shown on the second part You can skip this part and go directly to part 2 if you are already familiar with Geonames.

Main data

Geonames data can be downloaded from http://download.geonames.org/export/dump/ The main file to download is allCountries.zip. Once extracted, you'll get a CSV file named allCountries.txt which contains nearly all Geonames data. In this file, CSV data are separated by tabulation.

A sample Geonames entry

Let's look in Geonames data for the city of Toulouse in France.

$ grep -P '\tToulouse\t' allCountries.txt

You'll find multiple results (including one in the United States of America), and among them the following line.

2972315     Toulouse        Toulouse        Gorad Tuluza,Lapangan Terbang Blagnac,TLS,Tolosa,(...)  43.60426        1.44367 P       PPLA    FR              76      31      313     31555   433055          150     Europe/Paris    2016-02-18

What is the meaning of each column ? There is no header line at the top of the file... Go back to the web page from where you downloaded the file. Below download links, you'll find some documentation. In particular, consider the following excerpt.

The main 'geoname' table has the following fields :
---------------------------------------------------
geonameid         : integer id of record in geonames database
name              : name of geographical point (utf8) varchar(200)
asciiname         : name of geographical point in plain ascii characters, varchar(200)
alternatenames    : alternatenames, comma separated, ascii names automatically transliterated, convenience attribute from alternatename table, varchar(10000)
latitude          : latitude in decimal degrees (wgs84)
longitude         : longitude in decimal degrees (wgs84)
feature class     : see http://www.geonames.org/export/codes.html, char(1)
feature code      : see http://www.geonames.org/export/codes.html, varchar(10)
country code      : ISO-3166 2-letter country code, 2 characters
cc2               : alternate country codes, comma separated, ISO-3166 2-letter country code, 200 characters
admin1 code       : fipscode (subject to change to iso code), see exceptions below, see file admin1Codes.txt for display names of this code; varchar(20)
admin2 code       : code for the second administrative division, a county in the US, see file admin2Codes.txt; varchar(80)
admin3 code       : code for third level administrative division, varchar(20)
admin4 code       : code for fourth level administrative division, varchar(20)
population        : bigint (8 byte int)
elevation         : in meters, integer
dem               : digital elevation model, srtm3 or gtopo30, average elevation of 3''x3'' (ca 90mx90m) or 30''x30'' (ca 900mx900m) area in meters, integer. srtm processed by cgiar/ciat.
timezone          : the iana timezone id (see file timeZone.txt) varchar(40)
modification date : date of last modification in yyyy-MM-dd format

So we see that entry 2,972,315 represents a place named Toulouse, for which latitude is 43.60 and longitude is 1.44. The place is located in France (FR country code), its population is estimated to 433,055, elevation is 150 m, and timezone is the same than Paris.

To understand the meaning of P and PPLA, as feature class and feature code respectively, the indicated web page at http://www.geonames.org/export/codes.html provides us with the following information.

P city, village,...
PPLA        seat of a first-order administrative division

Thus line 2,972,315 is about a city which is the seat of a first-order administrative division in France. And indeed, Toulouse is the seat of the Occitanie region in France.

Geonames administrative divisions

So let's look for Occitanie.

$ grep -P '\tOccitanie\t' allCountries.txt

You'll end up with the following line.

11071623    Occitanie       Occitanie       Languedoc-Roussillon-Midi-Pyrenees,(...)        44.02722        1.63559 A       ADM1    FR              76              5626858         188     Europe/Paris    2016-11-16

This is entry number 11,071,623, and we have latitude, longitude, population, elevation and timezone as usual. The place's class is A and its code is ADM1. Information about these codes can be found in the same previous page.

A country, state, region,...
ADM1        first-order administrative division

This confirms that Occitanie is a first-order administrative division of France.

Now look at the adminX_code part of the Occitanie line (X=1, 2, 3, 4).

76

Only column admin1_code is filled with value 76. Compare this with the same part from the Toulouse line.

76  31      313     31555

Here all columns admin1_code, admin2_code, admin3_code and admin4_code are given a value, respectively 76, 31 313, and 31555.

Furthermore, we see that column admin1_code matches for Occitanie and Toulouse (value 76). This let us deduce that Toulouse is actually a city located in Occitanie.

So, following the same logic, we can infer that Toulouse is also located in a second-order administrative division of France (feature code ADM2) with admin1_code of 76 and admin2_code equals to 31. Let's look for such a line in allCountries.txt.

$ grep -P '\tADM2\t' allCountries.txt | grep -P '\tFR\t' | grep -P '\t76\t' \
> | grep -P '\t31\t'

We get the following line.

3013767     Département de la Haute-Garonne Departement de la Haute-Garonne Alta Garonna,Alto Garona,(...)  43.41667        1.5     A       ADM2    FR              76      31                      1254347         181     Europe/Paris    2016-02-18

Success! Toulouse is actually in the Haute-Garonne department, which is a department in Occitanie region.

Is this going to work for third-level administrative division ? Let's look for an ADM3 line, with admin1_code=76, admin2_code=31, and admin3_code=313.

$ grep -P '\tADM3\t' allCountries.txt | grep -P '\tFR\t' | grep -P '\t76\t' \
> | grep -P '\t31\t' | grep -P '\t313\t'

Here is the result.

2972314     Arrondissement de Toulouse      Arrondissement de Toulouse      Arrondissement de Toulouse      43.58333        1.5     A       ADM3    FR              76      31      313             972098          139     Europe/Paris    2016-12-05

Still works! Finally, let's find out the fourth-order administrative division which contains the city of Toulouse.

$ grep -P '\tADM4\t' allCountries.txt | grep -P '\tFR\t' | grep -P '\t76\t' \
> | grep -P '\t31\t' | grep -P '\t313\t' | grep -P '\t31555\t'

We get a place also named Toulouse.

6453974     Toulouse        Toulouse        Toulouse        43.60444        1.44194 A       ADM4    FR              76      31      313     31555   440204          153     Europe/Paris    2016-02-18

That's a surprise. That's because in France, an arrondissement is the smallest administrative division above a city. So for Geonames, city of Toulouse is both an administrative place (feature class A with feature code ADM4) and a populated place (feature class P with feature code PPLA), so there is two different entries with the same name (beware that this may be different for other countries).

And that's it! We have found the whole hierarchy of administrative divisions above city of Toulouse, thanks to the adminX_code columns: Occitanie, Département de la Haute-Garonne, Arrondissement de Toulouse, Toulouse (ADM4), and Toulouse (PPL).

That's it, really ? What about the top-most administrative level, the country ? This may not be intuitive: feature codes for countries start with PCL (for political entity).

$ grep -P '\tPCL' allCountries.txt | grep -P '\tFR\t'

Among the result, there's only one PCLI, which means independant political entity.

3017382     Republic of France      Republic of France      An Fhrainc,An Fhraing,(...)     46      2       A       PCLI    FR              00      64768389                543     Europe/Paris    2015-01-08

Now we have the whole hierarchy, summarized in the following table.

level name id fclass fcode ccode adm1_code adm2_code adm3_code adm4_code
country Republic of France 3017382 A PCLI FR        
level 1 Occitanie 11071623 A ADM1 FR 76      
level 2 Département de la Haute-Garonne 3013767 A ADM2 FR 76 31    
level 3 Arrondissement de Toulouse 2972314 A ADM3 FR 76 31 313  
level 4 Toulouse 6453974 A ADM4 FR 76 31 313 31555
city Toulouse 2972315 P PPL FR 76 31 313 31555

Alternate names

In the previous example, "Republic of France" is the main name for Geonames. But this is not the name in French ("République française"), and even the name in French is not the most commonly used name which is "France".

In the same way, "Département de la Haute-Garonne" is not the most commonly used name for the department, which is just "Haute-Garonne".

The fourth column in allCountries.txt provides a comma-separated list of alternate names for a place, in other languages and in other forms. But this is not very useful because we can't decide which form in the list is in which language.

For this, the Geonames project provides another file to download: alternateNames.zip. Go back to the download page, download it, and extract it. You'll get another tabulation-separeted CSV file named alternateNames.txt.

Let's look at alternate names for the Haute-Garonne department.

$ grep -P '\t3013767\t' alternateNames.txt

Multiple names are printed.

2080345     3013767 fr      Département de la Haute-Garonne
2080346     3013767 es      Alto Garona     1       1
2187116     3013767 fr      Haute-Garonne   1       1
2431178     3013767 it      Alta Garonna    1       1
2703076     3013767 en      Upper Garonne   1       1
2703077     3013767 de      Haute-Garonne   1       1
3047130     3013767 link    http://en.wikipedia.org/wiki/Haute-Garonne
3074362     3013767 en      Haute Garonne
4288095     3013767         Département de la Haute-Garonne
10273497    3013767 link    http://id.loc.gov/authorities/names/n80009763

To understand these columns, let's look again at the documentation.

The table 'alternate names' :
-----------------------------
alternateNameId   : the id of this alternate name, int
geonameid         : geonameId referring to id in table 'geoname', int
isolanguage       : iso 639 language code 2- or 3-characters; (...)
alternate name    : alternate name or name variant, varchar(400)
isPreferredName   : '1', if this alternate name is an official/preferred name
isShortName       : '1', if this is a short name like 'California' for 'State of California'
isColloquial      : '1', if this alternate name is a colloquial or slang term
isHistoric        : '1', if this alternate name is historic and was used in the pastq

We can see that "Haute-Garonne" is a short version of "Département de la Haute-Garonne" and is the preferred form in French. As an exercise, the reader can confirm in the same way that "France" is the preferred shorter form for "Republic of France" in French.


And that's it for our introductory journey into Geonames. You are now familiar enough with this data to begin working with it using Pandas in Python. In fact, what we have done until now, namely working with grep commands, is not very useful... See you in part 2!

blog entry of

Cet article résume le retour d'expérience d'Arthur Lutz (Logilab) sur la gestion d'entrepôts et de paquets Debian non officiels présenté lors des rencontres Debian Nantes en février 2017. Il a été complété en direct-live par Cyril Brulebois.

https://www.logilab.org/file/2269692/raw/debian_nantes.png

Objectifs

  • distribuer du logiciel qu'il n'est pas nécessaire de faire rentrer dans Debian
  • livrer ses clients (via https protégé par mot de passe)
  • préparer des backports
  • changer des options de compilation
  • activer des modules/plugins
  • compiler pour une version précise de debian (type wheezy-backports construit sur jessie)
  • diminuer les opérations manuelles
  • flexibilité de l'automatisation (pouvoir passer en manuel à tout moment, rejouer une étape, etc.)
  • progressivement corriger les erreurs signalées par lintian

Récuperer les sources et le packaging

  • dget
  • debcheckout (utilise VCS-, bzr, git, etc.)
  • apt-get source

Construire sur place

  • dpkg-buildpackage
  • pdebuild (wrapper pour les suivants)
  • pbuilder (dans un chroot)
  • sbuild (official) sur buildd
  • cowbuilder
  • logilab-packaging (lgp)

Gestion des dépôts

Entrepôts d'autres technologies

Futur

blog entry of

J'ai eu la chance de participer au premier hackathon BnF qui s'est déroulé les samedi 19 et dimanche 20 novembre. Alors, c'est quoi un hackathon BnF ?

C'est d'abord un lieu ! Un lieu insiprant qui a été ma deuxième maison mon deuxième lieu de travail pendant ces 5 dernières années où j'ai travaillé sur data.bnf.fr.

https://upload.wikimedia.org/wikipedia/commons/thumb/0/0b/BNF_FM_Hall_Est.jpg/512px-BNF_FM_Hall_Est.jpg

Et puis une thématique : mettre en avant le patrimoine de la BnF et inventer de nouveaux usages numériques autour de ses ressources. Pas beaucoup de contraintes si ce n'est de rendre le code disponible sous une licence libre.

Je ne connais pas bien toutes les applications de la BnF et en particulier je ne maîtrise pas tous les services de Gallica (honte à moi !) mais je commence à avoir une certaine idée de ce que sont les données à la BnF, de comment elles sont rangées (je finis même par connaître les zones intermarc et pouvoir comprendre des 100$blagues). Au-delà du projet data.bnf.fr lui-même, la connaissance de ces données, de leur récupération et de leur usage s'est affinée avec mes travaux sur les projets OpenCat, reliures, bp16, et tous les autres passés ou en cours où on a relié des bases de données extérieures aux notices d'autorité de la BnF comme human-music , andrebreton, les registres de la Comédie-Française, libretheatre, prototype biblissima, bientôt des morceaux d'Archives départementales et nationales et j'en oublie certainement. Je partais donc avec l'idée qu'à défaut de réaliser quelque chose, je saurai a minima servir de facilitateur dans la récupération et le traitement des données.

Le hackathon, c'est aussi une ambiance conviviale portée par les quelques 70 participants qui sont venus, la dizaine d'équipes ainsi constituées et tous les agents BnF qui se sont relayés pendant plus de 24h pour répondre à nos questions, nous guider ou redonner un petit coup de boost lorsque la fatigue ou la frustration commençaient à gagner du terrain. Oui parce qu'en fait, on était quand même là pour tenter de produire quelque chose… Pour ma part, j'ai rejoint en début de hackathon le projet porté par Carmen Brando et Francesca Frontini dont le but était de pouvoir extraire de Gallica les tables des matières et les textes OCRisés et procéder à de la reconnaissance d'entités nommées. Plus précisément, il s'agissait de pouvoir retrouver les lieux et personnes cités dans les textes numérisés pour les aligner vers les données de data.bnf.fr. À la différence d'autres projets, nous voulions donc créer de la nouvelle donnée et l'exploiter plutôt que de réutiliser des relations ou indexations déjà présentes dans les catalogues. Si ce chantier aboutissait, les intérêts pourraient être multiples puisqu'on pourrait imaginer une navigation enrichie de cartes ou de nouveaux rebonds, de nouvelles visualisations à partir de statistiques et possiblement soulever de nouvelles questions de recherche sur les textes eux-mêmes.

Relations entre auteurs / visualisation créée par Marine Riguet

Relations entre auteurs / visualisation créée par Marine Riguet

Nous nous sommes plus ou moins répartis en sous-groupes de travail (je simplifie car chacun a en réalité participé de près ou de loin à tout) :

  • Paule, Delphine et Marc qui étaient nos experts littéraires et nous ont aidé à déterminer des corpus de travail pertinents pour tester nos outils,
  • Frédéric, qui avait développé l'outil de traitement linguistique Alix, et qui s'est donc occupé du traitement initial et des annotations linguistiques des textes,
  • Carmen et Francesca, qui avaient écrit le moteur de reconnaissance d'entités nommées REDEN, se sont occupées d'améliorer l'outil pour permettre le traitement du texte annoté et retrouver les concepts databnf et dbpedia de personnes et de lieux,
  • Gaétan, Mehdi (issus de l'équipe Prevu), Jean-Baptiste se sont plus concentrés sur le développement d'une appli JS pour naviguer et visualiser les résultats obtenus,
  • Bruno et moi-même voguions de sous-groupe en sous-groupe pour faciliter la récupération de données, réaliser les divers pré/post-traitements et aussi taper un peu sur la visu.

Le résultat ? Je crois que nous avons été un peu trop ambitieux et il n'est malheureusement pas encore consultable en ligne mais on va tenter d'y travailler dans les jours qui viennent et de rendre le code accessible. Même si ce n'est encore qu'une preuve de concept, on a malgré tout obtenu quelques jolis résultats comme l'affichage d'une carte des lieux mentionnés dans une œuvre avec rebonds interactifs vers les pages correspondantes dans Gallica ou encore des pages de statistiques sur les personnes citées. Tout ça est encore loin d'être industrialisé et il y a évidemment plein de problèmes comme la résilience face à un mauvais OCR (on s'est concentrés sur les textes dont la qualité d'OCRisation était supérieure à 80% d'après Gallica), à l'ancien français ou encore à la gestion propre des personnes ou lieux fictifs vs. réels.

Exemple d'écran de navigation obtenu qui fait le lien entre une carte et un texte OCRisé de Gallica

En tout cas, j'ai eu la chance de tomber sur des co-équipiers de luxe et je garderai un excellent souvenir de ces 24h. Pour conclure, j'adresse un grand bravo à gallicarte qui a remporté le prix du jury et à diderotbot qui a trouvé de belles perles dans Gallica qui résonnaient particulièrement bien avec l'actualité.

À l'année prochaine pour la suite j'espère !

blog entry of

J'ai eu l'occasion de participer une nouvelle fois à un forum ouvert lors de la rencontre autour de l'entreprise libérée organisée par l'APAP et NOÏO (la dernière, c'était à l'Agile Tour Toulouse) . J'en ai fait un petit compte-rendu mais ce n'est pas l'objet de ce billet.

Comme je trouve que le forum ouvert est vraiment un format super pour tirer le meilleur parti d'un groupe de gens indépendamment de la taille du groupe, je vais ici faire un petit rappel des bases (telles qu'elles nous ont été rappellées lors de cette rencontre), qu'on peut ensuite adapter en fonction de ses propres contraintes.

Les principes du forum ouvert (ou Open Space) sont inspirés du fait que dans les conférences, la plupart des choses intéressantes sont dites en off : en discutant entre les conférences, pendant le café, devant la porte, etc. L'idée est donc de transformer la conférence en une grande pause avec des discussions libres, en petit groupe, autour d'un thème donné et avec les quatre principes suivants pour mettre tout le monde à l'aise :

  • toutes les personnes présentes sont les bonnes personnes,
  • ce qui arrive est ce qui pouvait arriver,
  • quelque soit le moment où ça commence, c'est le bon moment,
  • et quand c'est fini, c'est fini.
https://www.logilab.org/file/9306538/raw/20161121_194647.jpg

Partant de ces bases, un forum ouvert se déroule en quatre phases :

  1. introduction du sujet et des principes du forum ouvert énoncés ici,
  2. proposition et éventuellement sélection des sujets,
  3. plusieurs rounds de discussions sur les sujets choisis,
  4. choix d'actions et clôture.

Une fois le sujet introduit, voici le détail du déroulement des étapes suivantes...

L'émergence des sujets

Dans cette première phase, chacun est invité à proposer un sujet qu'il va écrire en gros sur une feuille en y indiquant également son nom. Cette feuille sera affichée sur un tableau qu'on nomme la place du marché, accompagnée d'une indication de l'heure et du lieu où aura lieu cette discussion.

Pour cette indication, l'organisateur aura au préalable préparé une grille d'emploi du temps déduite :

  • du nombre de discussions en parallèle (en fonction de l'espace ou des tables disponibles ainsi que du nombre de personnes présentes - compter entre 5 et 10 personnes max par groupe),
  • de la durée et le nombre de créneaux successifs (au moins 40 minutes pour un créneau, le temps passe vite !).

À partir de ces informations on obtient une grille horaire dans laquelle les propositions pourront être placées, ainsi accompagnée d'un lieu (en général un numéro de table) et d'un créneau horaire.

https://www.logilab.org/file/9306522/raw/20161121_194729.jpg

On peut apparemment tabler sur une proposition de sujet pour deux personnes en moyenne. Si plusieurs propositions sont similaires, il est possible de les recouper si les porteurs du sujet le souhaitent. Enfin s'il est nécessaire de faire une sélection, on peut demander aux participants de "s'inscrire" sur les sujets afin de voir lesquels sont les moins suivis.

Le temps des discussions

Et c'est parti pour le premier round de discussion ! Chaque porteur de sujet s'installe à sa table, y indique clairement le sujet discuté (on laisse l'affichage général en place pour les retardataires et promeneurs) et attend d'être rejoint par d'autres personnes également intéressées par ce sujet. Il a deux responsabilités :

  • introduire le sujet,
  • s'assurer qu'un compte-rendu sera écrit (mais pas forcément par lui).

Animer la discussion n'en fait pas parti.

Pendant les discussions, on peut ajouter :

  • la loi des deux pieds : chacun est libre s'il en ressent l'envie pour une raison ou pour une autre de quitter sa table pour aller s'installer sur une autre,
  • les abeilles qui butinent de tables en tables, sans jamais vraiment s'installer mais en permettant d'essaimer l'information d'une table à l'autre,
  • les papillons qui papillonnent un peu en marge du processus, mais il n'est pas rare d'en voir émerger des choses.
https://www.logilab.org/file/9306530/raw/20161121_194658.jpg

Une dizaine de minutes avant la fin du créneau, l'organisateur indique qu'il est temps de s'assurer que le compte-rendu de la discussion sera fait. Enfin à la fin du temps imparti, chaque table va afficher son compte-rendu sur le grand journal.

https://www.logilab.org/file/9306515/raw/20161121_212456.jpg

Je trouve qu'il est intéressant de réserver un créneau à ce moment là pour qu'une personne par table présente ce compte-rendu en quelques minutes, car il est parfois difficile de se contenter de ce qui est écrit ou dessiné.

Après on enchaîne rapidement sur le round suivant, et ainsi de suite.

La clôture

À ce moment là, tout le monde commence à être bien détendu, en confiance, et à connaître au moins une partie des participants. Afin de faire avancer la cause discutée, on va effectuer une dernier round de propositions / discussions dont l'objectif est de dégager des actions réalistes à court terme. Sur le modèle des étapes précédente, les participants sont invités à proposer une action qu'ils ont envie de tirer (ou de voir tirer) avec d'autres. Ils l'énoncent et l'affichent sur le marché aux actions.

Une fois toutes les actions proposées, les personnes intéressées par une action donnée se regroupent et structurent une action qui sera énoncée devant l'assistance une fois le temps imparti écoulé. Si possible, l'organisateur effectuera un suivi de ces actions après l'évènement.

https://www.logilab.org/file/9306297/raw/20161121_214833.jpg

Il est ensuite temps de se féliciter, de se remercier, d'annoncer la suite ou toute autre chose utile avant de se quitter.

Les photos sont tirées de l'évènement sus-cité, merci aux organisateurs et en particulier ici aux facilitateurs graphiques !

blog entry of

J'ai eu l'occasion de participer à une rencontre autour de l'entreprise libérée organisée par l'APAP et NOÏO sur Toulouse. Voici quelques notes pour la postérité.

https://www.logilab.org/file/9306297/raw/20161121_214833.jpg

La première partie de cette rencontre était la diffusion du documentaire E 3.0, Une entreprise humaniste qui présente les 6 premiers mois de la "libération" d'Averia, une entreprise de miroiterie d'ile de france. Le réalisateur était présent et nous a annoncé en amont de la projection son parti pris volontaire pour l'entreprise libérée (ce qui n'est pas pour me déplaire). J'ai trouvé ce documentaire intéressant de par l'aspect "témoignage sur le vif" et par le suivi sur quelques mois de cette phase critique de transformation. Ça donne envie de savoir où il en sont maintenant (la période filmée est le second semestre 2015).

La seconde partie s'est déroulée sous la forme d'un forum ouvert. Au delà des sujets de départ que j'avais choisi, cela m'a surtout permis d'échanger avec d'autres personnes dont l'entreprise est plus ou moins avancée sur le chemin de la libération (j'ai du mal avec ce terme que je trouve un peu galvaudé mais bon). J'y ai notamment rencontré une dirigeante d'une société de pose de parquets (Erah), en voie de "libération" depuis 5 ans. Celle-ci a pour le moins étonné tout le monde lorsqu'elle nous a appris que ses salariés avaient décidés ensemble d'être tous payés pareils, indépendamment de leur expérience (mais légèrement au dessus des prix du marché même pour les expérimentés), ou encore que la société finançait à ses salariés des stages sur leur temps de travail, indépendamment de l'intérêt du sujet pour elle. J'ai également discuté avec la dirigeante de Fun and fly qui gère son entreprise d'une dizaine de personnes dans la veine de l'entreprise libérée sans le savoir jusqu'ici. Non sans similitude avec Logilab, où nous avons grandi depuis 2000 avec bon nombre de principes aujourd'hui regroupés sous la bannière de l'entreprise libérée.

https://www.logilab.org/file/9306355/raw/20161121_222142.jpg

La soirée s'est conclut pour moi avec le directeur de Web-Atrio qui devrait prochainement inviter le petit groupe que nous avons formé à un déjeuner ou diner afin d'aller plus loin dans les échanges autour de nos avancées et expérimentations respectives, élément qui est apparu essentiel à chacun, même si nous n'espérons pas y trouver de recettes miracles s'appliquant à tout le monde.

Pour aller plus loin, le lecteur intéressé pourra :

  • regarder cette conférence d'Isaac Getz qui m'a été recommandée pendant la soirée (à Logilab Toulouse nous en avons regardé une de Frédéric Laloux que je recommende également si vous n'avez pas lu son livre),
  • lire une bande dessinée à ce sujet,
  • suivre ce qu'il se passe du côté de l'association MOM21, qui devrait notamment créer une antenne Sud-Ouest et organiser une journée à ce sujet le 18 janvier prochain (mais je n'ai pas trouvé plus d'info à ce sujet sur leur site).

Merci à tous les organisateurs pour ce moment rondement mené et qui a permis de se rendre compte qu'on n'est pas seul sur le chemin !

blog entry of

SciviJS

2016/10/10 by Martin Renou

Introduction

The goal of my work at Logilab is to create tools to visualize scientific 3D volumic-mesh-based data (mechanical data, electromagnetic...) in a standard web browser. It's a part of the european OpenDreamKit project. Franck Wang has been working on this subject last year. I based my work on his results and tried to improve them.

Our goal is to create widgets to be used in Jupyter Notebook (formerly IPython) for easy 3D visualization and analysis. We also want to create a graphical user interface in order to enable users to intuitively compute multiple effects on their meshes.

As Franck Wang worked with X3DOM, which is an open source JavaScript framework that makes it possible to display 3D scenes using HTML nodes, we first thought it was a good idea to keep on working with this framework. But X3DOM is not very well maintained these days, as can be seen on their GitHub repository.

As a consequence, we decided to take a look at another 3D framework. Our best candidates were:

  • ThreeJS
  • BabylonJS

ThreeJS and BabylonJS are two well-known Open Source frameworks for 3D web visualization. They are well maintained by hundreds of contributors since several years. Even if BabylonJS was first thought for video games, these two engines are interesting for our project. Some advantages of ThreeJS are:

Finally, the choice of using ThreeJS was quite obvious because of its Nodes feature, contributed by Sunag Entertainment. It allows users to compose multiple effects like isocolor, threshold, clip plane, etc. As ThreeJS is an Open Source framework, it is quite easy to propose new features and contributors are very helpful.

ThreeJS

As we want to compose multiple effects like isocolor and threshold (the pixel color correspond to a pressure but if this pressure is under a certain threshold we don't want to display it), it seems a good idea to compose shaders instead of creating a big shader with all the features we want to implement. The problem is that WebGL is still limited (as of the 1.x version) and it's not possible for shaders to exchange data with other shaders. Only the vertex shader can send data to the fragment shader through varyings.

So it's not really possible to compose shaders, but the good news is we can use the new node system of ThreeJS to easily compute and compose a complex material for a mesh.

alternate text

It's the graphical view of what you can do in your code, but you can see that it's really simple to implement effects in order to visualize your data.

SciviJS

With this great tools as a solid basis, I designed a first version of a javascript library, SciviJS, that aims at loading, displaying and analyzing mesh data in a standard web browser (i.e. without any plugin).

You can define your visualization in a .yml file containing urls to your mesh and data and a hierarchy of effects (called block structures).

See https://demo.logilab.fr/SciviJS/ for an online demo.

You can see the block structure like following:

https://www.logilab.org/file/8719790/raw

Data blocks are instantiated to load the mesh and define basic parameters like color, position etc. Blocks are connected together to form a tree that helps building a visual analysis of your mesh data. Each block receives data (like mesh variables, color and position) from its parent and can modify them independently.

Following parameters must be set on dataBlocks:

  • coordURL: URL to the binary file containing coordinate values of vertices.
  • facesURL: URL to the binary file containing indices of faces defining the skin of the mesh.
  • tetrasURL: URL to the binary file containing indices of tetrahedrons. Default is ''.
  • dataURL: URL to the binary file containing data that you want to visualize for each vertices.

Following parameters can be set on dataBlocks or plugInBlocks:

  • type: type of the block, which is dataBlock or the name of the plugInBlock that you want.
  • colored: define whether or not the 3D object is colored. Default is false, object is rendered gray.
  • colorMap: color map used for coloration, available values are rainbow and gray. Default is rainbow.
  • colorMapMin and colorMapMax: bounds for coloration scaled in [0, 1]. Default is (0, 1).
  • visualizedData: data used as input for coloration. If data are 3D vectors available values are magnitude, X, Y, Z, and default is magnitude. If data are scalar values you don't need to set this parameter.
  • position, rotation, scale: 3D vectors representing position, rotation and scale of the object. Default are [0., 0., 0.], [0., 0., 0.] and [1., 1., 1.].
  • visible: define whether or not the object is visible. Default is true if there's no childrenBlock, false otherwise.
  • childrenBlocks: array of children blocks. Default is empty.

As of today, there are 6 types of plug-in blocks:

  • Threshold: hide areas of your mesh based on a variable's value and bound parameters

    • lowerBound: lower bound used for threshold. Default is 0 (representing dataMin). If inputData is under lowerBound, then it's not displayed.
    • upperBound: upper bound used for threshold. Default is 1 (representing dataMax). If inputData is above upperBound, then it's not displayed.
    • inputData: data used for threshold effect. Default is visualizedData, but you can set it to magnitude, X, Y or Z.
  • ClipPlane: hide a part of the mesh by cutting it with a plane

    • planeNormal: 3D array representing the normal of the plane used for section. Default is [1., 0., 0.].
    • planePosition: position of the plane for the section. It's a scalar scaled bewteen -1 and 1. Default is 0.
  • Slice: make a slice of your mesh

    • sliceNormal
    • slicePosition
  • Warp: deform the mesh along the direction of an input vector data

    • warpFactor: deformation factor. Default is 1, can be negative.
    • inputData: vector data used for warp effect. Default is data, but you can set it to X, Y or Z to use only one vector component.
  • VectorField: represent the input vector data with arrow glyphs

    • lengthFactor: factor of length of vectors. Default is 1, can be negative.
    • inputData
    • nbVectors: max number of vectors. Default is the number of vertices of the mesh (which is the maximum value).
    • mode: mode of distribution. Default is volume, you can set it to surface.
    • distribution: type of distribution. Default is regular, you can set it to random.
  • Points: represent the data with points

    • pointsSize: size of points in pixels. Default is 3.
    • nbPoints
    • mode
    • distribution

Using those blocks you can easily render interesting 3D scenes like this:

https://www.logilab.org/file/8571787/raw https://www.logilab.org/file/8572007/raw

Future works

  • Integration to Jupyter Notebook
  • As of today you only can define a .yml file defining the tree of blocks, we plan to develop a Graphical User Interface to enable users to define this tree interactively with drag and drop
  • Support of most file types (for now it only supports binary files)
blog entry of

La semaine dernière, je suis allé au meetup docker sur "Containers' Jungle. Docker, Rocket, RunC, LXD ... WTF ?".

À Logilab, nous sommes parfois un poil déçus par docker (mais utilisateurs comme vous pouvez le voir sur notre blog Developing salt formulas with docker, Running a local salt-master to orchestrate docker containers, Building Docker containers using Salt, Retour sur la journée conteneurs dans le cadre de Open Source Innovation Spring). Du coup nous étions curieux d'aller creuser la piste de rocket et autres technologies de conteneurs.

https://www.logilab.org/file/8445845/raw/global_361217852.jpeg

Nicolas De Loof nous a présentés quelques concepts sous-jacents à docker, mais aussi quelques alternatives et retours d’expérience sur l'utilisateur de docker et de son écosystème. La présentation sera rejouée au devfest Nantes pour ceux qui l'auraient ratée.

Voici quelques liens collectés lors du meetup qui nécessiteraient un peu plus de lecture et d'explications, mais je pose cela tel quel au cas où ce serait utile à d'autres :

Un meetup recommandé pour explorer docker (et ses alternatives?) à Nantes.

blog entry of

blog entry of

ngReact is an Angular module that allows React components to be used in AngularJS applications.

I had to work on enhancing an Angular-based application and wanted to provide the additionnal functionnality as an isolated component that I could develop and test without messing with a large Angular controller that several other people were working on.

Here is my Angular+React "Hello World", with a couple gotchas that were not underlined in the documentation and took me some time to figure out.

To set things up, just run:

$ mkdir angulareacthello && cd angulareacthello
$ npm init && npm install --save angular ngreact react react-dom

Then write into index.html:

<!doctype html>
<html>
     <head>
             <title>my angular react demo</title>
     </head>
     <body ng-app="app" ng-controller="helloController">
             <div>
                     <label>Name:</label>
                     <input type="text" ng-model="person.name" placeholder="Enter a name here">
                     <hr>
                     <h1><react-component name="HelloComponent" props="person" /></h1>
             </div>
     </body>
     <script src="node_modules/angular/angular.js"></script>
     <script src="node_modules/react/dist/react.js"></script>
     <script src="node_modules/react-dom/dist/react-dom.js"></script>
     <script src="node_modules/ngreact/ngReact.js"></script>
     <script>
     // include the ngReact module as a dependency for this Angular app
     var app = angular.module('app', ['react']);

     // define a controller that has the name attribute
     app.controller('helloController', function($scope) {
             $scope.person = { name: 'you' };
     });

     // define a React component that displays "Hello {name}"
     var HelloComponent = React.createClass({
             render: function() {
                     return React.DOM.span(null, "Hello "+this.props.name);
             }
     });

     // tell Angular about this React component
     app.value('HelloComponent', HelloComponent);

     </script>
</html>

I took me time to get a couple things clear in my mind.

<react-component> is not a React component, but an Angular directive that delegates to a React component. Therefore, you should not expect the interface of this tag to be the same as the one of a React component. More precisely, you can only use the props attribute and can not set your react properties by adding more attributes to this tag. If you want to be able to write something like <react-component firstname="person.firstname" lastname="person.lastname"> you will have to use reactDirective to create a specific Angular directive.

You have to set an object as the props attribute of the react-component tag, because it will be used as the value of this.props in the code of your React class. For example if you set the props attribute to a string (person.name instead of person in the above example) , you will have trouble using it on the React side because you will get an object built from the enumeration of the string. Therefore, the above example can not be made simpler. If we had written $scope.name = 'you' we could not have passed it correctly to the react component.

The above was tested with angular@1.5.8, ngreact@0.3.0, react@15.3.0 and react-dom@15.3.0.

All in all, it worked well. Thank you to all the developers and contributors of these projects.

blog entry of

In a previous post we talked about an environment to develop salt formulas. To add some spicy requirements, the formula must now handle multiple target OS (Debian and Centos), have tests and a continuous integration (CI) server setup.

http://testinfra.readthedocs.io/en/latest/_static/logo.png

I started a year ago to write a framework to this purpose, it's called testinfra and is used to execute commands on remote systems and make assertions on the state and the behavior of the system. The modules API provides a pythonic way to inspect the system. It has a smooth integration with pytest that adds some useful features out of the box like parametrization to run tests against multiple systems.

Writing useful tests is not an easy task, my advice is to test code that triggers implicit actions, code that has caused issues in the past or simply test the application is working correctly like you would do in the shell.

For instance this is one of the tests I wrote for the saemref formula

def test_saemref_running(Process, Service, Socket, Command):
    assert Service("supervisord").is_enabled

    supervisord = Process.get(comm="supervisord")
    # Supervisor run as root
    assert supervisord.user == "root"
    assert supervisord.group == "root"

    cubicweb = Process.get(ppid=supervisord.pid)
    # Cubicweb should run as saemref user
    assert cubicweb.user == "saemref"
    assert cubicweb.group == "saemref"
    assert cubicweb.comm == "uwsgi"
    # Should have 2 worker process with 8 thread each and 1 http proccess with one thread
    child_threads = sorted([c.nlwp for c in Process.filter(ppid=cubicweb.pid)])
    assert child_threads == [1, 8, 8]

    # uwsgi should bind on all ipv4 adresses
    assert Socket("tcp://0.0.0.0:8080").is_listening

    html = Command.check_output("curl http://localhost:8080")
    assert "<title>accueil (Référentiel SAEM)</title>" in html

Now we can run tests against a running container by giving its name or docker id to testinfra:

% testinfra --hosts=docker://1a8ddedf8164 test_saemref.py
[...]
test/test_saemref.py::test_saemref_running[docker:/1a8ddedf8164] PASSED

The immediate advantage of writing such test is that you can reuse it for monitoring purpose, testinfra can behave like a nagios plugin:

% testinfra -qq --nagios --hosts=ssh://prod test_saemref.py
TESTINFRA OK - 1 passed, 0 failed, 0 skipped in 2.31 seconds
.

We can now integrate the test suite in our run-tests.py by adding some code to build and run a provisioned docker image and add a test command that runs testinfra tests against it.

provision_option = click.option('--provision', is_flag=True, help="Provision the container")

@cli.command(help="Build an image")
@image_choice
@provision_option
def build(image, provision=False):
    dockerfile = "test/{0}.Dockerfile".format(image)
    tag = "{0}-formula:{1}".format(formula, image)
    if provision:
        dockerfile_content = open(dockerfile).read()
        dockerfile_content += "\n" + "\n".join([
            "ADD test/minion.conf /etc/salt/minion.d/minion.conf",
            "ADD {0} /srv/formula/{0}".format(formula),
            "RUN salt-call --retcode-passthrough state.sls {0}".format(formula),
        ]) + "\n"
        dockerfile = "test/{0}_provisioned.Dockerfile".format(image)
        with open(dockerfile, "w") as f:
            f.write(dockerfile_content)
        tag += "-provisioned"
    subprocess.check_call(["docker", "build", "-t", tag, "-f", dockerfile, "."])
    return tag


@cli.command(help="Spawn an interactive shell in a new container")
@image_choice
@provision_option
@click.pass_context
def dev(ctx, image, provision=False):
    tag = ctx.invoke(build, image=image, provision=provision)
    subprocess.call([
        "docker", "run", "-i", "-t", "--rm", "--hostname", image,
        "-v", "{0}/test/minion.conf:/etc/salt/minion.d/minion.conf".format(BASEDIR),
        "-v", "{0}/{1}:/srv/formula/{1}".format(BASEDIR, formula),
        tag, "/bin/bash",
    ])


@cli.command(help="Run tests against a provisioned container",
             context_settings={"allow_extra_args": True})
@click.pass_context
@image_choice
def test(ctx, image):
    import pytest
    tag = ctx.invoke(build, image=image, provision=True)
    docker_id = subprocess.check_output([
        "docker", "run", "-d", "--hostname", image,
        "-v", "{0}/test/minion.conf:/etc/salt/minion.d/minion.conf".format(BASEDIR),
        "-v", "{0}/{1}:/srv/formula/{1}".format(BASEDIR, formula),
        tag, "tail", "-f", "/dev/null",
    ]).strip()
    try:
        ctx.exit(pytest.main(["--hosts=docker://" + docker_id] + ctx.args))
    finally:
        subprocess.check_call(["docker", "rm", "-f", docker_id])

Tests can be run on a local CI server or on travis, they "just" require a docker server, here is an example of .travis.yml

sudo: required
services:
  - docker
language: python
python:
  - "2.7"
env:
  matrix:
    - IMAGE=centos7
    - IMAGE=jessie
install:
  - pip install testinfra
script:
  - python run-tests.py test $IMAGE -- -v

I wrote a dummy formula with the above code, feel free to use it as a template for your own formula or open pull requests and break some tests.

There is a highly enhanced version of this code in the saemref formula repository, including:

  • Building a provisioned docker image with custom pillars, we use it to run an online demo
  • Destructive tests where each test is run in a dedicated "fresh" container
  • Run Systemd in the containers to get a system close to the production one (this enables the use of Salt service module)
  • Run a postgresql container linked to the tested container for specific tests like upgrading a Cubicweb instance.

Destructive tests rely on advanced pytest features that may produce weird bugs when mixed together, too much magic involved here. Also, handling Systemd in docker is really painful and adds a lot of complexity, for instance some systemctl commands require a running systemd as PID 1 and this is not the case during the docker build phase. So the trade-off between complexity and these features may not be worth.

There is also a lot of quite new tools to develop and test infrastructure code that you could include in your stack like test-kitchen, serverspec, and goss. Choose your weapon and go test your infrastructure code.

blog entry of

https://www.logilab.org/file/248336/raw/Salt-Logo.png

While developing salt formulas I was looking for a simple and reproducible environment to allow faster development, less bugs and more fun. The formula must handle multiple target OS (Debian and Centos).

The first barrier is the master/minion installation of Salt, but fortunately Salt has a masterless mode. The idea is quite simple, bring up a virtual machine, install a Salt minion on it, expose the code inside the VM and call Salt states.

https://www.logilab.org/file/7159870/raw/docker.png

At Logilab we like to work with docker, a lightweight OS-level virtualization solution. One of the key features is docker volumes to share local files inside the container. So I started to write a simple Python script to build a container with a Salt minion installed and run it with formula states and a few config files shared inside the VM.

The formula I was working on is used to deploy the saemref project, which is a Cubicweb based application:

% cat test/centos7.Dockerfile
FROM centos:7
RUN yum -y install epel-release && \
    yum -y install https://repo.saltstack.com/yum/redhat/salt-repo-latest-1.el7.noarch.rpm && \
    yum clean expire-cache && \
    yum -y install salt-minion

% cat test/jessie.Dockerfile
FROM debian:jessie
RUN apt-get update && apt-get -y install wget
RUN wget -O - https://repo.saltstack.com/apt/debian/8/amd64/latest/SALTSTACK-GPG-KEY.pub | apt-key add -
RUN echo "deb http://repo.saltstack.com/apt/debian/8/amd64/latest jessie main" > /etc/apt/sources.list.d/saltstack.list
RUN apt-get update && apt-get -y install salt-minion

% cat test/minion.conf
file_client: local
file_roots:
  base:
    - /srv/salt
    - /srv/formula

And finally the run-tests.py file, using the beautiful click module

#!/usr/bin/env python
import os
import subprocess

import click

@click.group()
def cli():
    pass

formula = "saemref"
BASEDIR = os.path.abspath(os.path.dirname(__file__))

image_choice = click.argument("image", type=click.Choice(["centos7", "jessie"]))


@cli.command(help="Build an image")
@image_choice
def build(image):
    dockerfile = "test/{0}.Dockerfile".format(image)
    tag = "{0}-formula:{1}".format(formula, image)
    subprocess.check_call(["docker", "build", "-t", tag, "-f", dockerfile, "."])
    return tag


@cli.command(help="Spawn an interactive shell in a new container")
@image_choice
@click.pass_context
def dev(ctx, image):
    tag = ctx.invoke(build, image=image)
    subprocess.call([
        "docker", "run", "-i", "-t", "--rm", "--hostname", image,
        "-v", "{0}/test/minion.conf:/etc/salt/minion.d/minion.conf".format(BASEDIR),
        "-v", "{0}/{1}:/srv/formula/{1}".format(BASEDIR, formula),
        tag, "/bin/bash",
    ])


if __name__ == "__main__":
    cli()

Now I can run quickly multiple containers and test my Salt states inside the containers while editing the code locally:

% ./run-tests.py dev centos7
[root@centos7 /]# salt-call state.sls saemref

[ ... ]

[root@centos7 /]# ^D
% # The container is destroyed when it exits

Notice that we could add some custom pillars and state files simply by adding specific docker shared volumes.

With a few lines we created a lightweight vagrant like, but faster, with docker instead of virtualbox and it remain fully customizable for future needs.

blog entry of

Nous avons assisté à la conférence Agile France qui a eu lieu les 16 et 17 juin au Chalet de la Porte Jaune, à Paris.

La grande conférence agile francophone, de la communauté pour la communauté, réalisée dans un lieu exceptionnel proposait d'aborder différents sujets, tels que les méthodes agiles, l'intelligence collective et la facilitation, le développement de logiciels, l'expérience utilisateur d'innovation, les organisations et leur management, etc.

Dans un cadre très agréable permettant de s'échapper de l'ambiance urbaine, notre équipe a pu assister à quelques conférences qui ont attirées notre attention :

Facilitation graphique

Jean-Pierre Bonnafous, qui a participé aux 15 ans de Logilab, a invité les participants à réagir tout au long de ces deux jours et a mis en image leurs retours.

https://www.logilab.org/file/6729471/raw

Toutes les sessions d'Agile France étaient présentées sur une fresque. Nous, nous sommes fans !

https://www.logilab.org/file/6831358/raw

Utilisateur, fais moi mal : la ditacture du test

Emilie-Anne Gerch et Nicolas Moreau ont parlé de l'importance du test utilisateur d'une façon dynamique et ont partagé leur expérience concernant le site d'AXA Assurances avec une approche assez drôle : les designers viennent de Vénus et les développeurs de Mars, les utilisateurs sont, quant à eux, de bons Terriens. Comment ramener sur Terre un designer un peu trop perché ou sortir de sa grotte un développeur pour qui un texte blanc sur fond noir est la norme ?

Grande leçon pour les designers, les développeurs et les chefs de projet, car ceux qui apportent la bonne réponse ce sont les utilisateurs. Selon eux, c'est le jury le plus juste, car ce sont eux qui utilisent le produit final. Les utilisateurs finaux constituent le jury le plus sévère mais le plus juste qui soit. Ils ont des mots parfois crus et des doigts qui cliquent partout sauf là où on avait pensé. :-)

Les tests utilisateur permettent de tester un produit en conditions réelles. Grâce à ceux-ci, il est possible de recueillir des informations utiles pour améliorer le produit. Ils permettent de donner une priorité à différentes fonctionnalités ou idées. Ils permettent de reconnaître les fonctionnalités à conserver (les plus utilisées, les plus demandées...) et celles à supprimer (celles que personne ne voit ou n'utilise). Ils constituent aussi un moyen d'intégrer efficacement l'utilisateur dans la conception.

Quelques points permettant de mieux comprendre la psychologie de l'utilisateur :

L'être humain utilise rarement un outil pour sa fonction primaire. Il est partisan du moindre effort, il bricole et modifie les outils de manière à les adapter à son besoin.

L'utilisateur souhaite avant tout aller à l'essentiel.

Il ne veut pas avoir la sensation de devoir apprendre. Il ne lit pas les manuels, il pioche les informations dont il a besoin lorsque la nécessité se fait sentir.

Il est influencé par l'extérieur (le bruit, un interlocuteur), par son état émotionnel (le stress, la somnolence...) et par son vécu (il calque ses actions sur ce qu'il a déjà pratiqué ailleurs). Son expérience s'étend au delà du numérique.

Il est "techno-aveugle" : il veut avant tout que ça marche, la technique utilisée ne l'intéresse pas.

Il est bienveillant : il aura tendance à se blâmer au lieu de remettre en cause le produit et donne des retours d'expérience très facilement.

Présentation

Un iceberg pour explorer ce qui ne va pas

Certains d'entre-nous ont assisté à la conférence Un iceberg pour explorer ce qui ne va pas, animée par Emmanuel Gaillot et Raphaël Pierquin. La session portait sur la découverte de nos réactions face à un évènement donné.

Cette conférence a démarré par une démonstration pratique basée sur la métaphore de l'iceberg créée par Virginia Satir. Il arrive qu'on agisse et qu'on réagisse d'une manière qui nous surprend ou nous dépasse. Pendant cette session, nous avons exploré ces situations à l'aide d'un exercice inventé par Virginia Satir, basé sur la métaphore de l'iceberg (ce qui est émergé est observable, ce qui est immergé se passe au-dedans). Les participant·e·s ont pu ainsi s'approprier un format de réflexion simple à suivre pour apprendre à mieux se connaître — et possiblement apprendre à mieux s'apprécier.

Raphaël Pierquin a choisi un évènement qu'il a contextualisé en décrivant les comportements de chaque personne impliquée dans son récit, puis a présenté sa stratégie par rapport à cet évènement. Guidé par Emmanuel Gaillot, qui avait au préalable disposé des feuilles de papier au sol sur lesquelles étaient écrits les intitulés de chaque "case" de l'iceberg, il a ensuite déroulé devant l'assemblée toutes les étapes présentes sous le niveau de l'eau de l'iceberg. À chaque changement de "case" dans son récit, Raphaël se déplaçait vers la feuille idoine, établissant ainsi son propre cheminement physique et mental. Nous avons ensuite eu l'occasion de pratiquer par trinôme puis de discuter de cette méthode avec Emmanuel et Raphaël.

https://www.logilab.org/file/6832314/raw

DDD : et si on reprenait l'histoire par le bon bout ? Tout simplement.

La conférence sur le DDD (Domain Driven Design), par Thomas Pierrainet Jérémie Grodziski a été une synthèse intéressante sur une approche de conception et de développement permettant de se concentrer sur la valeur métier. Cette approche permet notamment de communiquer efficacement et de collaborer avec les experts métier (qui doivent être capables de lire et comprendre notre code !). Les conférenciers ont su extraire certains principes et patrons de conception du fameux "blue book" à l'origine de cette expression, et les rendre accessibles : les "values objects", la couche anti-corruption, l'architecture hexagonale, etc.

Forum Ouvert

À cette occasion plus d'une trentaine d'orateurs ont proposé un sujet qui leur tenait à coeur. Les personnes intéressées pouvaient débattre sur chaque sujet en groupes spontanés répartis dans tout l'espace de la conférence pendant 45 minutes.

Dans ce type d'activité, les groupes sont petits et donc la répartition du temps de parole est assez homogène.

Juliette de notre équipe a animé le forum "le bonheur au travail" avec une vingtaine de personnes, elle a pu recueillir beaucoup d'idées intéressantes.

Voici quelques idées qui se sont dégagées de la reflexion :

https://www.logilab.org/file/6831796/raw

Mindfulness & Agile

Dov Tsal Sela nous a présenté "Comprendre tes équipes, pour comprendre à toi-même". La pleine conscience est l'art de regarder le moment présent avec clarté. En nous conseillant de faire un voyage à travers le Taoïsme, les neurosciences et le royaume animal pour comprendre comment sont prises les décisions personnelles et en groupes (et qui les prend…)

Au cours de cet atelier, nous avons pu visionner des vidéos, et même méditer un peu.

Comment j'ai recruté mon pair ?

Juliette a assisté à une conférence animée par Houssam Fakih et Jonathan Salmona centrée sur le recrutement. Partant du principe que les profils trop semblables feront les mêmes erreurs et souhaitant recruter les bonnes personnes pour leur société, ils ont développé leur propre méthode d'évaluation. L'entretien est, pour eux, une des nombreuses vitrines de l'entreprise, aussi souhaitent-ils que cette expérience se déroule de la manière la plus professionnelle possible. Ils ont établi un modèle d'entretien, ce qui assure l'équitabilité des chances pour tous les candidats. Ils ont présenté leur grille d'évaluation, les différentes difficultés rencontrées, les pièges à éviter, les retours de leurs candidats, le suivi des nouvelles recrues ...

Mais aussi...

Laura a participé à une discussion intéressante sur le travail agile réparti sur plusieurs sites. De nombreux participants ont fait des retours sur leur expérience, qui parfois impliquait une équipe de développement répartie dans plusieurs pays. À la distance peuvent donc s'ajouter des difficultés liées aux différences culturelles. En laissant de côté ce dernier aspect qui nous concerne moins à Logilab, plusieurs éléments sont applicables sur nos développements répartis entre Paris et Toulouse :

Des obstacles à garder en tête :

Il est difficile de capter le ressenti à distance.

À distance, on ne bénéficie pas de l'"info café" : ces conversations informelles dans le couloir ou la salle café, qui souvent contiennent des informations utiles pour le projet en cours.

Certaines pratiques sont plus compliquées à distance : rétrospective, planning poker... Mais il existe des applications en ligne pour ça.

Il est important de :

Se rencontrer régulièrement, pour partager la même vision et souder les équipes.

En début de projet, se mettre d'accord sur un "contrat de développement", avec entre autres les bonnes pratiques et le processus de revue et d'intégration.

Que tout le monde ait accès à la même information : idéalement, le product owner devrait être sur un troisième site distant, pour ne "favoriser" personne. Si il n'y a pas de PO, faire en sorte que des développeurs de chaque site puissent assister régulièrement aux réunions client.

Et enfin, pourquoi pas...

Mettre des webcams en salle de pause.

Faire du pair-programming réparti.

blog entry of

Vous êtes passionné(e) d'informatique et souhaitez comprendre et maîtriser le fonctionnement de toute la pile applicative, de la base de données à la feuille de style, pour concevoir et développer des produits avec agilité ?

Nous aussi !

https://www.logilab.org/file/6817931/raw

Consultez notre offre "CDI - développement web (client)" et postulez chez nous !

blog entry of

Recently, I've faced the problem to import the European Union thesaurus, Eurovoc, into cubicweb using the SKOS cube. Eurovoc doesn't follow the SKOS data model and I'll show here how I managed to adapt Eurovoc to fit in SKOS.

This article is in two parts:

  • this is the first part where I introduce what a thesaurus is and what SKOS is,
  • the second part will show how to convert Eurovoc to plain SKOS.

The whole text assumes familiarity with RDF, as describing RDF would require more than a blog entry and is out of scope.

What is a thesaurus ?

A common need in our digital lives is to attach keywords to documents, web pages, pictures, and so on, so that search is easier. For example, you may want to add two keywords:

  • lily,
  • lilium

in a picture's metadata about this flower. If you have a large collection of flower pictures, this will make your life easier when you want to search for a particular species later on.

free-text keywords on a picture

In this example, keywords are free: you can choose whatever keyword you want, very general or very specific. For example you may just use the keyword:

  • flower

if you don't care about species. You are also free to use lowercase or uppercase letters, and to make typos...

free-text keyword on a picture

On the other side, sometimes you have to select keywords from a list. Such a constrained list is called a controlled vocabulary. For instance, a very simple controlled vocabulary with only two keywords is the one about a person's gender:

  • male (or man),
  • female (or woman).
a simple controlled vocabulary

But there are more complex examples: think about how a library organizes books by themes: there are very general themes (eg. Science), then more and more specific ones (eg. Computer science -> Software -> Operating systems). There may also be synonyms (eg. Computing for Computer science) or referrals (eg. there may be a "see also" link between keywords Algebra and Geometry). Such a controlled vocabulary where keywords are organized in a tree structure, and with relations like synonym and referral, is called a thesaurus.

an example thesaurus with a tree of keywords

For the sake of simplicity, in the following we will call thesaurus any controlled vocabulary, even a simple one with two keywords like male/female.

SKOS

SKOS, from the World Wide Web Consortium (W3C), is an ontology for the semantic web describing thesauri. To make it simple, it is a common data model for thesauri that can be used on the web. If you have a thesaurus and publish it on the web using SKOS, then anyone can understand how your thesaurus is organized.

SKOS is very versatile. You can use it to produce very simple thesauri (like male/female) and very complex ones, with a tree of keywords, even in multiple languages.

To cope with this complexity, SKOS data model splits each keyword into two entities: a concept and its labels. For example, the concept of a male person have multiple labels: male and man in English, homme and masculin in French. The concept of a lily flower also has multiple labels: lily in English, lilium in Latin, lys in French.

Among all labels for a given concept, some can be preferred, while others are alternative. There may be only one preferred label per language. In the person's gender example, man may be the preferred label in English and male an alternative one, while in French homme would be the preferred label and masculin and alternative one. In the flower example, lily (resp. lys) is the preferred label in English (resp. French), and lilium is an alternative label in Latin (no preferred label in Latin).

SKOS concepts and labels

And of course, in SKOS, it is possible to say that a concept is broader than another one (just like topic Science is broader than topic Computer science).

So to summarize, in SKOS, a thesaurus is a tree of concepts, and each concept have one or more labels, preferred or alternative. A thesaurus is also called a concept scheme in SKOS.

Also, please note that SKOS data model is slightly more complicated than what we've shown here, but this will be sufficient for our purpose.

RDF URIs defined by SKOS

In order to publish a thesaurus in RDF using SKOS ontology, SKOS introduces the "skos:" namespace associated to the following URI: http://www.w3.org/2004/02/skos/core#.

Within that namespace, SKOS defines some classes and predicates corresponding to what has been described above. For example:

  • the triple (<uri>, rdf:type, skos:ConceptScheme) says that <uri> belongs to class skos:ConceptScheme (that is, is a concept scheme),
  • the triple (<uri>, rdf:type, skos:Concept) says that <uri> belongs to class skos:Concept (that is, is a concept),
  • the triple (<uri>, skos:prefLabel, <literal>) says that <literal> is a preferred label for concept <uri>,
  • the triple (<uri>, skos:altLabel, <literal>) says that <literal> is an alternative label for concept <uri>,
  • the triple (<uri1>, skos:broader, <uri2>) says that concept <uri2> is a broder concept of <uri1>.
blog entry of