<code langage="python" autoinsert="F:\\DEV\\python\\remplace-code-dans-xml.py::signet-dvp-1">
	--- le code sera inséré ici ---
</code>

# Pour fonctionner sur des fichiers contenants des caractères accentués,
# ce script nécessite la présence des lignes
#   import sys
#   sys.setdefaultencoding('latin-1')
# dans le fichier Python/Lib/site-packages/sitecustomize.py
# reference : http://personalpages.tds.net/~kent37/blog/stories/14.html

from __future__ import with_statement
import os
import sys
import shutil
import xml.etree.ElementTree
from xml.etree.ElementTree import ElementTree

def traitementArticle(fichier):
    shutil.copyfile(fichier, nomFichierUnique(fichier))
    tree = ElementTree(None,fichier)
    map(insertionCodeDansBalisesXML,tree.getiterator('code'))
    tree.write(fichier,'iso-8859-1')
    remplacementChr160DansFichier(fichier)

def insertionCodeDansBalisesXML(element):
    try:
        (fichier,signet)=element.attrib['autoinsert'].split('::')
        element.text = extractionLignesEntreSignets(fichier,signet)
    except:
        print "erreur en traitant: ", element.attrib
        print sys.exc_info()

def extractionLignesEntreSignets(fichier,signet):
    resultat=""
    with open(fichier) as f:
        for ligne in f:
            if ligne.find(signet)>=0:
                if resultat != "":
                    break
                else:
                    resultat = "\n"
                    continue
            if resultat != "":
                resultat += ligne
    if resultat == "":
        resultat = "signet " + signet + "non trouvé"
    return resultat

def fabriqueNomFichier(nom,index):
    return nom + "." + str(index)

def nomFichierUnique(fichier):
    index = 1
    while (os.path.exists(fabriqueNomFichier(fichier,index))):
        index += 1
    return fabriqueNomFichier(fichier,index)


# J'ai constaté que la représentation " " du caractére "espace insécable"
# de l'éditeur XML était remplacée par le caractère de code 160 durant la
# transformation. Pour l'instant je n'ai pas trouvé d'autre solution que de réouvrir
# le fichier pour remplacer le caractère 160 par la bonne représentation.
def remplacementChr160DansFichier(fichier):
    with open(fichier) as f:
        s = f.read().replace(chr(160)," ")
    with open(fichier,'w') as f:
        f.write(s)
        
if __name__ == "__main__":
    traitementArticle('C:\\Article_Dvp\\documents\\principe_dry\\principe_dry.xml')

<code langage="python">
autoinsert="F:\\DEV\\python\\remplace-code-dans-xml.py::signet-dvp-1"
</code>

public class Afficheur
{
    private Donnees donnees;
    private Graphique graphique = new Graphique();
    
    public Afficheur(Donnees donnees)
    {
        this.donnees = donnees;
    }

    public void Affiche()
    {
        double pasX = 0 ;
        foreach (double donnee in donnees)
        {
            double valeur_normalisee = 100.0 * (donnee - donnees.Minimum) / (donnees.Maximum - donnees.Minimum);
            pasX += 0.1;
            graphique.AddXY(pasX, valeur_normalisee);
        }
    }

public class Graphique
{
    public void AddXY(double x, double y)
    {
        // ...
    }
}

public class Donnees : IEnumerable 
{
    double minimum ;
    double maximum ;
    private ArrayList donneesInternes = new ArrayList();

    public Donnees (ArrayList donnees)
    {
        minimum = Double.MaxValue;
        maximum = - Double.MaxValue;
        foreach (double d in donnees)
        {
            minimum = Math.Min(minimum, d);
            maximum = Math.Max(maximum, d);
            donneesInternes.Add(d);
        }
    }
   
    public double this[int pos]
    {
        get { return (double)donneesInternes[pos]; }
    }
    public IEnumerator GetEnumerator()
    {
        return donneesInternes.GetEnumerator();
    }
    public double Maximum
    {
        get { return maximum;}
    }
    public double Minimum
    {
        get { return minimum;}
    }
}

[TestFixture]
public class TestNormalisation
{
    [Test]
    public void VerificationValeursAttendues()
    {
        ArrayList donnees_test = new ArrayList();
        donnees_test.Add(1.0);
        donnees_test.Add(2.0);

        Donnees donnees = new Donnees(donnees_test);
        
        Normalisateur norm = new Normalisateur(donnees); 

        Assert.AreEqual(0.0, norm[0], 0.0001);
        Assert.AreEqual(1.0, norm[1], 0.0001);
    }
}

public class Normalisateur : IEnumerable
{
    private Donnees donnees;

    public Normalisateur(Donnees donnees)
    {
        this.donnees = donnees;
    }

    public double this[int pos]
    {
        get { return 100.0 * (donnees[pos]-donnees.Minimum)/(donnees.Maximum - donnees.Minimum); }
    }

    public IEnumerator GetEnumerator()
    {
        return donnees.GetEnumerator(); 
    }
}

public class AfficheurTDD
{
    private IEnumerable donnees;
    private Graphique graphique = new Graphique();

    public AfficheurTDD(IEnumerable donnees)
    {
        this.donnees = donnees;
    }

    public void Affiche()
    {
        double pasX = 0;
        foreach (double donnee in donnees)
        {
            pasX += 0.1;
            graphique.AddXY(pasX, donnee);
        }
    }
}

Function GetTempDir : String;
Var
  Buffer : Array[0..1023] Of Char;
Begin
  SetString(Result, Buffer, GetTempPath(SizeOf(Buffer), Buffer));
End;

function GetTempDir: string;
var
  Buffer: array [0..MAX_PATH] of Char;
begin
  SetString(Result, Buffer, GetTempPath(SizeOf(Buffer), Buffer));
end;

function GetPTempDirectory: string;
var
  pcRepertoire: PChar;
begin
  pcRepertoire := StrAlloc(255);
  try
    GetTempPath(254, pcRepertoire);
    Result := StrPas(pcRepertoire);
    if (Result[Length(Result)] <> '\') then
      Result := Result + '\';
  finally
    StrDispose(pcRepertoire);
  end;
end;

Function DirectoryTemp : String;
Var
  tempdir : PChar;
Begin
  tempdir := Stralloc(255);
  Try
    If (GetTempPath(255, tempdir) > 0) Then
      result := String(tempdir)
    Else
      result := '';
  Finally
    StrDispose(tempdir);
  End;
End;

GetTempPath Function

Retrieves the path of the directory designated for temporary files.


DWORD WINAPI GetTempPath(
  __in   DWORD nBufferLength,
  __out  LPTSTR lpBuffer
);
Parameters
nBufferLength 
The size of the string buffer identified by lpBuffer, in TCHARs.

lpBuffer 
A pointer to a string buffer that receives the null-terminated string specifying 
the temporary file path. The returned string ends with a backslash, 
for example, C:\TEMP\.

Return Value
If the function succeeds, the return value is the length, in TCHARs, of the 
string copied to lpBuffer, not including the terminating null character. 
If the return value is greater than nBufferLength, the return value is the length, 
in TCHARs, of the buffer required to hold the path.

  //Get the temp folder
  TempStrLength := 0;
  repeat
    TempStrLength := TempStrLength + 10;
    tempstr := StrAlloc(TempStrLength);
    try
      ret := GetTempPath(TempStrLength, tempstr);
      TempPath := tempstr;
    finally
      StrDispose(tempstr);
    end;
  until (ret < TempStrLength);

function GetWindowsTempFolder: string;
var
  Required: Cardinal;
begin
  Result := '';
  Required := GetTempPath(0, nil);
  if Required <> 0 then
  begin
    SetLength(Result, Required);
    GetTempPath(Required, PChar(Result));
    StrResetLength(Result);
    Result := PathRemoveSeparator(Result);
  end;
end;

procedure TrouverLeFichierLePlusAncien(const nomDossier: string);
var
  search_record: TSearchRec;
  chemin_de_recherche: string;

  plus_ancienne_date: _FILETIME;
  plus_ancien_fichier: string;
  resultat_recherche: Integer;
  fichier_courant: string;
begin
  plus_ancienne_date.dwLowDateTime := MaxLongInt;
  plus_ancienne_date.dwHighDateTime := MaxLongInt;

  fichier_courant := '';
  plus_ancien_fichier := '';

  chemin_de_recherche := IncludeTrailingPathDelimiter(nomDossier) + '*.xml';

  resultat_recherche := sysutils.FindFirst(chemin_de_recherche, faAnyFile, search_record);
  while (resultat_recherche = 0) do
  begin
    if VerifierFichierNonReadOnly(search_record) then
    begin
      fichier_courant := IncludeTrailingPathDelimiter(nomDossier) + search_record.Name;

      if not VerifierFichierDejaOuvert(fichier_courant) then
        CalculerFichierPlusAncien(search_record.FindData.ftCreationTime, fichier_courant, plus_ancienne_date, plus_ancien_fichier);
    end;
    resultat_recherche := sysutils.FindNext(search_record);
  end;

  sysutils.FindClose(search_record);

  fichier_courant := plus_ancien_fichier;
  if (fichier_courant <> '')
  //signet-refaire-la-vérification
  and not VerifierFichierDejaOuvert(fichier_courant) and VerifierFichierNonReadOnly(search_record)
  //signet-refaire-la-vérification
  then begin
    // ... traitement du fichier
  end;
end;

  and not VerifierFichierDejaOuvert(fichier_courant) and VerifierFichierNonReadOnly(search_record)