Trier les libellés lignes par ordre alphabétique dans Slidie

Objectif : Trier les libellés lignes de mon tableau dans Slidie

Méthodologie :
Il n'existe pas d'options automatique de tri des libellés lignes (ou colonnes) dans Slidie. L'astuce consiste à transférer les textes lignes dans le corps du tableau et ensuite d'utiliser le tri standard de Slidie

Étapes :
1 - Script de transfert des libellés lignes dans le corps du tableau :

t = ARG1
#Création d'une colonne vide pour recevoir l'information
t = t.Columns[0, Range(1, t.Rows.Size)]

for  i in Range(1, t.Columns.Size):
 parts = GetRowText(t, i)
 t.Rows[i].Columns[1].Values = Enumerate(parts)

RESULT = t

 2 - Trier la colonne crée en mode "littéral"

3 - Supprimer la colonne crée.

Script d'extraction avec conservation de la dimension.

Objectif : Extraire une liste de lignes / colonnes en conservant de la dimension d'extraction. Les éléments absents générant une ligne / colonne vide.

Script :

Exemple d'extraction des colonnes.

t = ARG1

def  GetIndex(x):
 if x in t.Columns.Texts:
  return '"' + x + '"'
 else:
  return 0


marques = ( "Ensemble","Marque 1","Marque 2" [...] "Marque N" )
t = t.Columns[[GetIndex(x) for x in marques]]

for  i in Range(1, len(marques)):
 SetColumnText(t, i, marques[i - 1].Trim('"'))

RESULT = t

Apparier à partir d'une table de correspondance

Objectif : Concaténer des informations provenant de deux tableaux distincts (magasins / régions) à l'aide d'un tableau de correspondances.

Tableaux en entrée :

1) Un tableau contenant les informations régions.



2) Un tableau contenant les informations magasins.



Attention, les tableaux magasins et régions doivent avoir le même nombre de lignes.

3) Un tableau de correspondance.



Transformation :



Elle consiste à produire un tableau par magasin associé à sa région de référence.

Le tableau final aura pour structure :
- La première colonne correspondant au magasin
- La seconde colonne correspondant à sa région de référence

Script :

01:#Arguments
02:# 1 - Tableau des magasins
03:t1 = ARG1
04:# 2 - Tableau des régions
05:t2 = ARG2
06:# 3 - Tableau des correspondances
07:lk = ARG3
08:#Initialisation de la liste
09:lst = []
10:for i in Range(1, (t1.Columns.Size)):
11:#Reprise du magasin
12: nom_etab = GetColumnText(t1 ,i)
13:#Reprise de la région
14: nom_reg = GetColumnText(t2 ,i)
15:#Recherche de la région concernée dans la table de correspondances
16: codes = ['"' + x + '" ' for x in lk.Rows['"' + nom_etab + '"'].Texts]
17:#Concaténation du magasin et de sa région associée
18: c = MergeColumns(t1.Columns[i],t2.Columns[codes])
19:#Reprise des annotations
20: c.Annotations["NOMMAG"] = nom_etab
21: c.Annotations["NOMREG"] = FirstOf (lk.Rows['"' + nom_etab + '"'].Texts)
22:#Stockage des tableaux
23: lst.Add(c)
25:
26:RESULT = lst

Résultats :

Cette transformation produit autant de tableaux que de magasins présents.
Dans notre cas, elle produira donc 5 tableaux.

Les méthodes d'extractions dans Slidie

Les différentes méthodes d'extractions de modalités dans Slidie :

• 1 2 -> Extrait les deux premières lignes / colonnes / calculs / pages
• "Marque" -> Extrait la ligne / colonne / calcul / page ayant pour texte "Marque"
• -1 -> Extrait le dernier item
• $"Le*" -> Extrait les items débutants par le texte "Le"
• $"*le*" -> Extrait les items contenant le texte "Le". "Elle", "épeler", "lettre" seront conservés.
  
• $"*le" -> Extrait les items finissant par le texte "Le"
• 3..5 -> Extrait les items de 3 à 5
• "Marque".2 -> Extrait le second item du sous-titres "Marque"

Pour tous les extractions textuelles, la casse n'a pas d'importance.

Mise en forme conditionnelle d'un tableau par rapport à une colonne de référence

Objectif : Appliquer des couleurs de fonds de cellules d'un tableau selon un calcul de différence de pourcentages par rapport à une colonne de référence.

Tableau en entrée :



La colonne de référence est la colonne "Ensemble".
L'objectif est de coloriser les fonds de cellules en rouge / vert quand la différence est inférieure / supérieure de 15% à la colonne ensemble.

Première étape : Script de calcul

# Récupération du tableau
t = ARG1

# Seuil de comparaison par rapport (0.15 car les nombres sont au format pourcentage)
SEUILCOMP = 0.15

# Récupération de la première colonne de référence
Base = t.Columns[1].Calculations["CALC1"]

# Récupération des autres colonnes à tester contre la colonne de référence
Crit = t.Columns.Remove(1).Calculations["CALC1"]

# Calcul de la différence entre le critère et la base
delta = Crit - Base

#Fonction de transformation du delta
def ApplyThreshold(x, s):
if x >= s:
return "Pos"
elif x <= -s:
return "Neg"
return ""

#Application de la fonction valeurs par valeurs
delta.ChangeValues(lambda x: ApplyThreshold(x, SEUILCOMP))

# Résultat final avec stockage d'un nouveau calcul résultat : "DELTA"
t = MergeCalculations (t.Calculations["CALC1"],MergeColumns (Base,delta))
SetCalculationText (t, 2, "DELTA")

RESULT = t

Seconde étape : Mise en forme



Cette étape se décompose en 3 blocs :

• Mise en forme des calculs (%)


• Mise en forme des valeurs


• Suppression du calcul "DELTA"

Détails de la mise en forme des valeurs :



Résultat :

Trier un tableau avec deux clés de tris

Objectif : Trier un tableau selon le "total ++" et, en cas d'égalité, sur le "total ++"

Tableau d'entrée :




Script de transformation :

# Récupération du tableau
t = ARG1

# Liste des valeurs de la première colonne de tri
col1 = list(t.Columns[1].Values)

# Liste des valeurs de la seconde colonne de tri
col2 = list(t.Columns[2].Values)

# Liste des positions de 1 au nombre de lignes
positions = list(Range(1, t.Rows.Size))

# Tri de la liste des positions selon les deux clés de tri
positions.sort(key = lambda x: (col1[x-1], col2[x-1]), reverse = True)

# Récapitulatif du nouvelle ordre des postions
log.Info(positions)

# Extraction du tableau selon le vecteur de positions ordonnées par le tri.
RESULT = t.Rows[positions]

Résultat :

Mise en forme du mini / maxi dans une colonne de tableau

Objectif : Mise en couleur du minimum (rouge) et du maximum (vert) des colonnes d'un tableau.

Par exemple, le tableau suivant en entrée :



Etape 1 : Calcul du mini / maxi de chaque colonne dans un nouveau calcul via un script Python.

# Reprise du tableau
t = ARG1

# Consolidation du premier calcul
# Cette étape permet de fixer le premier calcul tel quel
n = t.Calculations[1].Consolidate()

# Calcul du mini et du maxi par ligne
mini = n.Rows.Min
maxi = n.Rows.Max

# Localisation du minimum et du maximum dans le tableau initial
mini = (n <= mini) * -1
maxi = (n >= maxi) * 1

# Concaténation des minimums et des maximums
# -1 pour la ou les valeur(s) minimum
# 1 pour la ou les valeur(s) maximum
# 0 pour les autres valeurs
n = mini + maxi

# Rajout du nouveau calcul au tableau initial
SetCalculationText(n, 1, "BORNES")

# Stockage du tableau
RESULT = MergeCalculations(t, n)

Etape 2 : Mise en forme des valeurs minimum et maximum:

• Les valeurs minimum en rouge


• Les valeurs maximum en vert

La propagation est nécessaire sur l'ensemble des calculs.
Les minimums seront identifiés en rouge et gras.
Les maximums seront identifiés en vert et gras.

Etape 3 : Suppression du calcul de minimums et maximums nommé '2' ou "BORNES".

Résultat :

Reprise d'un annotation textuelle

Objectif : Reprise d'information en provenance d'un tableau dans une zone textuelle.


Etape 1 : Indiquer des tags dans la zone de texte Powerpoint

1 - Dans le menu Format de Powerpoint 2007, sélectionner la rubrique Taille.
2 - Dans la boîte de dialogue qui s'affiche, sélectionner l'onglet 'Texte de remplacement'
3 - Indiquer les informations suivantes :



Le Tag peut être le mot clé de votre choix mais il doit être entouré de crochets [].

Etape 2 : Définir la zone graphique transparente à côté de la zone de texte qui sera associé au tableau issu de Slidie qui calculera les parts de marché des marques.

Etape 3 : Dans Slidie, création de la transformation permettant de remplir les annotations.

Soit le tableau suivant en entrée dans Slidie

	Part de Marché
Marque 1	25,5
Marque 2	9,8
Marque 3	7,9
Marque Autres	56,8

1 - Création des annotations.

La récupération des annotations se fait par l'intermédiaire d'un script Python :

# Récupération du tableau
t = ARG1

# Récupération du tableau
# FirstOf prend la première valeur d'une énumération
# ToString("0.0'%'") permet de fixer le format de l'annotation
# Règles d'extractions :
# Extraction des colonnes : t.Columns[i]
# Extraction des lignes : t.Rows[i]
# Extraction des calculs : t.Calculations[i]

t.Annotations["TAG1"] = FirstOf((t.Columns[1].Rows[1].Calculations[1].Values)).ToString("0.0'%'")
t.Annotations["TAG2"] = FirstOf((t.Columns[1].Rows[2].Calculations[1].Values)).ToString("0.0'%'")
t.Annotations["TAG3"] = FirstOf((t.Columns[1].Rows[3].Calculations[1].Values)).ToString("0.0'%'")
t.Annotations["TAG4"] = FirstOf((t.Columns[1].Rows[4].Calculations[1].Values)).ToString("0.0'%'")

# Stockage du tableau
RESULT = t

2 - Vidage du tableau

Ici également, il faut utiliser un script PYTHON pour vider complétement le tableau.

# Récupération du tableau
t = ARG1

# Extraction d'une seule cellule du tableau
t = t.Columns[1].Rows[1].Calculations[1]
# Suppression des textes colonnes
t.Columns.Texts = Enumerate("")
# Suppression des textes lignes
t.Rows.Texts = Enumerate("")
# Mis à blanc des valeurs
t.Values = Enumerate("")

# Stockage du tableau
RESULT = t

3 - Le tableau ainsi généré peut maintenant être associé au graphique Powerpoint "à blanc" dans l'assistant rapport. Le résultat des annotations est le suivant :

Mise en forme d'une échelle d'accord en 4 points avec reprise des sous-totaux dans le même graphique

Objectif : Automatisation du graphique ci dessous dans Slidie.




A partir des données suivantes :



Pas à pas : la transformation dans Slidie

L'objectif dans Slidie sera de créer un tableau de données pour mettre à jour le graphique dans Powerpoint.

Les données devront avoir la forme suivante :

ST Positif

Série cachée (1 - Somme des positifs)

Positif 1

Positif 2

Négatif 2

Négatif 1

Série cachée (1 - Somme des négatifs)

ST Négatif

Pour cette réalisation, il faudra créer un second calcul caché qui permettra de remplir correctement les étiquettes de données des sous-totaux.





1 - Transposition
La première étape consiste à transposer le tableau afin d'obtenir les données dans le sens souhaité.

2 - Script permettant de calculer les séries cachées nécessaires au centrage du graphisme
Il faut ensuite calculer les compléments à 100% pour les séries cachées qui permettront de centrer le graphique.
Un script Python est nécessaire.

# Récupération du tableau
t = ARG1

# Calcul des compléments positif / négatif
STPos = 1 - (t.Columns[1] + t.Columns[2])
STNeg = 1 - (t.Columns[3] + t.Columns[4])

# Rajout des deux séries calculées au tableau initial
r = MergeColumns(t, STPos, STNeg )

# Stockage des modifications
RESULT = r

3 - Mise en forme du tableau via des extractions
Cette étape permet de réorganiser les colonnes dans l'ordre voulu (5 7 1 2 3 4 8 6) et de créer un nouveau calcul vide (1, 0).

4 - Gestion des valeurs des Sous-Totaux
Afin de gérer les sous-totaux dans le graphique, Slidie a besoin :

- de valeurs fixe à 10% dans le premier calcul pour conserver une largeur unitaire dans le graphique pour les Sous-Totaux
- des valeurs réelles qui iront remplir les étiquettes de données dans le second calcul

Pour cette opération, un nouveau script est nécessaire :

# Récupération du tableau
t = ARG1

# Récupération des valeurs réelles pour les étiquettes de données dans le second calcul.
t.Calculations[2].Columns[1].Values = t.Calculations[1].Columns[7].Values
t.Calculations[2].Columns[8].Values = t.Calculations[1].Columns[8].Values

# Fixation des valeurs à 10% pour les Sous-Totaux dans le premier calcul.
t.Calculations[1].Columns[1].Values = Enumerate(0.10)
t.Calculations[1].Columns[8].Values = Enumerate(0.10)

# Stockage des modifications
RESULT = t

5 - Mise en forme des calculs
Mise en forme des valeurs au format %

6 - Mise en forme des valeurs
Cette étape permet de masquer les valeurs des Sous-Totaux dans le premier calcul afin d'éviter un conflit lors de la reprise des étiquettes de données.



Il suffit ensuite d'indiquer comme format de masque numérique, la valeur " "

Le tableau ainsi généré peut maintenant être associé au graphique Powerpoint dans l'assistant rapport. Le résultat généré est le suivant :

Transformation permettant de créer un histogramme comparatif de deux années avec plusieurs items.

Information en entrée.

Tableau avec deux colonnes représentant les années et n lignes représentant les items avec une base « Ensemble » en première ligne.


Résultat à obtenir.

Un histogramme comparatif entre les deux années des dix marques les plus représentées en 2009 triées de manière décroissante. Une annotation concernant la population de 2009 est présente dans le PPT final.

Une précision sur le calcul affiché (%) doit être présent dans la légende.
Base n=119 (en % du nombre de citations au premier rang)

Transformations.
Récupération de la base.

Cette opération permet de récupérer une information du tableau qui sera transmise à une forme du rapport lors de la génération du document PPT. Dans notre cas, nous récupérons la base de l’année en cours pour remplir un champs Base n=[base] (en % du nombre de citations).

Pour cette opération, il faut créer un script spécifique sous Slidie :
# Affectation du nom à remplacer dans le PPT associé.
NAME = "BASE"
# Récupération du tableau
t = ARG1 #(ARG1 dans notre cas est TAB1)

#Récupération de la dernière base (2009)
value = GetCubeValue(t, 1, -1)
#GetCubeValue([tableau],[numéro(s) de ligne(s)], [numéro(s) de colonne(s)])

t.SafeAnnotations[NAME] = value

# Affectation du résultat
RESULT = t

Suppression d’une partie du tableau.

La ligne ensemble devient maintenant inutile. Il faut purger le tableau en vue de la mise en graphique.


Dans chaque bloc, l’icône en forme de clé donne l’accès aux propriétés du blog. Dans notre cas, il suffit d’indiquer que la première ligne est à supprimer.


Tri du tableau sur l’année de référence.

Afin de faciliter l’extraction des 10 marques les plus représentées et de respecter la contrainte des valeurs décroissante sur 2009, nous allons trier le tableau.


Comme pour la suppression, l’opération de paramétrage est très simple. Il suffit d’indiquer la clé, le calcul et l’ordre du tri


Dans notre cas, le tableau possède un seul calcul (encadré en rouge sur l’impression d’écran). Le tri effectué porte donc sur les % verticaux.

Extraction d’une partie du tableau.

L’extraction ressemble trait pour trait à la suppression. La fenêtre de paramétrage utilisée pour les deux opérations est identique. Dans notre cas, nous prendrons les lignes 1 à 10.

Convention d’écriture :
1 2 3 4 5 6 7 8 9 10 est équivalent à 1..10

Mise en forme des textes de la légende (ajout de l’information %).

Les textes de la légende correspondent aux libellés des colonnes auquel, il faut rajouter une information : (%). Cette opération est un peu plus complexe


L’opération peut porter sur l’une des modalités en colonne, sur une sélection ou sur l’ensemble des modalités. Dans notre cas, la formule $«*» permet d’appliquer la transformation à l’ensemble des colonnes.


Dans notre cas, nous voulons appliquer une information sur le libellé. En cliquant sur le bouton « Texte », nous avons accès à l’ensemble des propriétés de stylistiques de l’ensemble des libellés colonnes.


Dans notre cas, nous voulons faire figurer l’information (%) derrière les libellés années situés en colonnes d’où l’écriture : [PREVIOUS] (%)

Liste des mots clés disponibles pour la reprise des textes :
[PREVIOUS]

Inversion des colonnes.

Afin de respecter l’autre d’affichage, la dernière étape consiste à inverser les deux colonnes 2008 et 2009. Cette transformation n’a pas besoin de paramétrage particulier.


Association du graphique.

La dernière étape de la transformation consiste à associer le graphique voulu préalablement défini dans les templates Excel.


Le paramétrage consiste simplement à sélectionner le graphique souhaité dans la liste disponible en cliquant sur le bouton « Sélection… » du modèle de graphique.


La transformation est maintenant achevée. Le bouton « Sauver » permettra d’archiver la vue fabriqué selon le masque défini dans l’onglet « propriété » de la transformation.


La vue est ensuite stockée dans le projet sous le nom de V_SLIDE_9_001. Elle est directement exportable au format Excel et peut s’intégrer telle quel dans une présentation PPT.