I have made these tools for my own sake, but thought I'd share them, if
anyone is interested. The purpose is to work with large family trees.

What I do is the following. I have created the tree in MyHeritage,
but its output doesn't work for large trees, and it can't find
paths between relatives more than 20 generations apart.
Therefore I export the tree as a GEDCOM-file, and read it into GRAMPS.
However, there are several things in the GEDCOM-file that need to be
removed for this to work. Furthermore, I have written a better tool
for finding paths in large trees.

This is ongoing work, and I give no guarantees. The codes are not perfect.
I am improving them regularly. However, I don't overwrite any files, so I
don't expect that there should be any risk for your data.

My codes are applied to GEDCOM-files. The codes work with the GEDCOM-files
exported by MyHeritage. I don't know if other sites have differences in
the GEDCOM-format. (I wouldn't be surprised if that was the case.)
If you have any problems with a specific GEDCOM-file, please let me know
and mail the GEDCOM-file. Then I might have a look at it (if I have time).

Since the codes are supplied as python-files, it is possible for you to do
changes in them. I would appreciate very much information about any
(successful) changes you do, and a copy of the code.

In any case, below follows a description how one could work with the codes.
(This is what works for me. By the way, I use Linux.)

1. Export your family tree as a GEDCOM-file. 
(Let's assume with the name 'my_fam.ged'.)

2. Clean up by running in a terminal:
  python cleanged.py my_fam.ged
This produces the file 'my_fam_c.ged', where many comments are removed,
html-commands are removed and other things are done.
See the code cleanged.py for details.
You probably want to change it.
(It is based on swedish output in the ged-file.)

Much of the cleaning is done to make GRAMPS happy, since I read the
resulting file in it. The main reason for this is that the output of
MyHeritage doesn't work for large family trees. In GRAMPS it does.

3. Find the GEDCOM-identifiers for the relevant persons. The command:
  python find_name_in_ged.py my_fam_c.ged Kaj
lists the identifiers for all persons whos name includes Kaj.
With 
  python find_name_in_ged.py my_fam_c.ged Kaj Holmberg
you find all persons whos name includes both Kaj and Holmberg.
With 
  python find_name_in_ged.py my_fam_c.ged 'Kaj Holmberg'
you find all persons whos name includes precisely Kaj Holmberg
(but not those that have some other name between).

(I often have to go back to MyHeritage to find the exact names of some.)

4. Find the path from person I123 to persons I456 and I789 with
  python traceged1.py my_fam_c.ged 0 I123 I456 I789
There should be only one origin person, but there could be many target persons.
The parameter before the identifiers guides the search as follows:
  0: only up, ancestors to the origin person, not via marriage
  1: only down, descendants to the origin person, not via marriage
  2: up and down, but not via marriage
  3: all directions, including via marriage
  4: costs (presently not working)
  5: only up from the origin-person and each target person, find the
  first common ancestor

If you have many target persons, you could put their identifiers in a file,
for example 'targets.txt', and run:
  python traceged1.py my_fam_c.ged 0 I123 targets.txt
(This function is decided by the extension .txt.)

This produces the following output files:

my_fam-c+0-I123-gen1.txt: All generations from origin person I123.
my_fam-c+0-I123-dist1.txt: All distances from origin person I123.
my_fam-c+0-I123-dist2.txt: All distances from origin person I123.
my_fam-c+0-I123-dist3.txt: All distances from origin person I123.
my_fam-c+0-I123-unreach.txt: All persons unreachable from origin person I123.
my_fam-c+0-I123-I456-path1.txt: The path from person I123 to person I456.
my_fam-c+0-I123-I789-path1.txt: The path from person I123 to person I789.

For other parameter values than 0, '+0' is replaced by '+1' etc.

For parameter value 5 two paths are written on file
my_fam-c+5-I123-I456-path13.txt
one from each person up to the common ancestor.

The code traceged.py uses GedcomReader from ged4py.parser to parse the ged-file.
It also uses numpy and shortest path routines from scipy to find the paths.

Sites like MyHeritage don't seem to be able to find relations longer than
20 generations. My codes don't have such restrictions. I have found paths
longer than 100 generations in files with more than 30 000 persons.
(That means shortest paths in graphs with more than 30 000 nodes.)
However, it takes some time. So don't be in a hurry.

For parameter values 0-3, only one shortest path search is made.
Then the resulting paths from the target persons are found backwards.
For parameter value 5, one additional shortest path search is made for
each target person.

Kaj Holmberg
kaj.holmberg at allt2.se