Full Circle Magazine FR

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== 1 ======
**Last month, we discussed using sets to show us missing episode numbers. Now’s the time to put the rough code we presented into practice.

We’ll modify one routine and write one routine. We’ll do the modification first. In the working file that you’ve been using the last few months, find the WalkThePath(filepath) routine. The fourth and fifth lines should be:

efile = open('errors.log',"w")
    
for root, dirs, files in os.walk(filepath,topdown=True):**

Le mois dernier, nous avons parlé de l'utilisation des ensembles pour afficher les épisodes manquants. Voici venu le moment de mettre en pratique le code brut que nous avons présenté.

Nous allons modifier une routine et en écrire une. Nous ferons d'abord la modification. Dans le fichier de travail que vous avez utilisé ces derniers mois, cherchez la routine ParcourirChemin(chemin). Les quatrième et cinquième lignes devraient être :

ficerr = open('erreurs.log',"w")

for racine, reps, fichiers in os.walk(chemin,topdown=True):

====== 2 ======
**In between these two lines, we will insert the following code:
<nowiki>
lastroot = ''
    
elist = []
    
currentshow = ''
    
currentseason = ''
</nowiki>

By now, you should recognize that all we’re doing here is initializing variables. There are three string variables and one list. We will use the list to hold the episode numbers (hence the elist name).**

Entre ces deux lignes, nous allons insérer le code suivant :
<nowiki>
  derniere_racine = ''
    
  ep_liste = []
    
  emission_courante = ''
    
  saison_courante = ''
</nowiki>
A présent, vous devriez reconnaître que tout ce que nous faisons ici est l'initialisation de variables. Il y a trois variables de chaîne et une liste. Nous allons utiliser la liste pour contenir les numéros d'épisodes (d'où le nom ep_liste).

====== 3 ======
**Let’s take a quick look and freshen our memory (above) about what we’re doing in the existing routine before we modify any further.

The first two lines here set things up for the walk-the-path routine where we start at a given folder in the file system and recursively visit each folder below, and check for files that have the file extension of .avi, .mkv, .mp4 or .m4v. If there are any, we then iterate through the list of those filenames.

In the line above right, we call the GetSeasonEpisode routine to pull the series name, season number and episode number from the filename. If everything parses correctly, the variable isok is set to true, and the data we are looking for is placed into a list and then returned to us.**

Jetons un coup d’œil rapide et rafraîchissons notre mémoire (ci-dessus) sur ce que nous faisons dans la routine existante avant de la modifier.

Les deux premières lignes ici initialisent les choses pour la routine ParcourirChemin, dans laquelle nous commençons dans un dossier donné dans le système de fichiers et visitons de manière récursive chaque dossier en-dessous et vérifions l'existence des fichiers qui ont l'extension .avi, .mkv, .mp4 ou .m4v. S'il y en a, nous parcourons ensuite la liste de ces noms de fichiers.

Dans la ligne en haut à droite, nous appelons la routine RecupereSaisonEpisode pour récupérer le nom de la série et les numéros de la saison et de l'épisode à partir du nom de fichier. Si tout est analysé correctement, la variable estok est réglée à vrai (true) et les données que nous cherchons sont placées dans une liste qui nous est retournée.

====== 4 ======
**Here (below) we are simply assigning the data passed back from GetSeasonEpisode and putting them into separate variables that we can play with. Now that we know where we were, let’s talk about where we are going.

We want to get the episode number of each file and put it into the elist list. Once we are done with all the files within the folder we are currently in, we can then make the assumption that we have been pretty much keeping up with the files and the highest numbered episode is the latest one available. As we discussed last month, we can then create a set that is numbered from 1 to the last episode, and convert the list to a set and pull a difference. While that is great in theory, there is a bit of a “hitch in our git-a-long” when it comes down to actual practice. We don’t actually get a nice and neat indication as to when we are done with any particular folder. What we do have though, is the knowledge that when we get done with each file, the code right after the “for file in [...” gets run. If we know the name of the last folder visited, and the current folder name, we can compare the two and, if they are different, we have finished a folder and our episode list should be complete. That’s what the ‘lastroot’ variable is for.**

Ensuite (ci-dessous), nous affectons simplement les données retournées par RecupereSaisonEpisode et les mettons dans des variables distinctes avec lesquelles nous pourrons jouer. Maintenant que nous savons où nous en sommes, parlons de ce qui va se passer.

Nous voulons obtenir le numéro d'épisode pour chaque fichier et le placer dans la liste ep_liste. Une fois que nous avons terminé avec tous les fichiers du dossier dans lequel nous sommes, nous pouvons faire l'hypothèse que nous avons à peu près correctement traité les fichiers et que le numéro d'épisode le plus élevé est le plus récent disponible. Comme nous l'avons vu le mois dernier, nous pouvons alors créer un ensemble contenant les numéros de 1 au dernier épisode, convertir la liste en ensemble et calculer la différence. C'est très bien en théorie, mais il y a un petit grain de sable dans notre mécanique quand on la met en pratique. Nous n'avons pas vraiment d'indication claire et nette quand nous avons fini avec un dossier particulier. Ce que nous savons cependant, c'est que, lorsque nous aurons fini avec chaque fichier, le code juste après « for fic in [... » est exécuté. Si nous connaissons le nom du dernier dossier visité et le nom du dossier en cours, nous pouvons comparer les deux et s'ils sont différents, c'est que nous venons de terminer un dossier et que notre liste d'épisodes devrait être complète. C'est pour cela que la variable « derniere_racine » est là.

====== 5 ======
**Just after the ‘for file in[‘ line is where we’ll put the majority of our new code. It’s only seven lines. Here are the seven lines. (The black lines are the existing lines for your convenience.)

Line by line of the new code, here is the logic:

First, we check to see if the variable lastroot has the same value as root (the current folder name). If so, we are in the same folder, so we don’t run any of the code. If not, we then assign the current folder name to the lastroot variable. Next, we check to see if the episode list (elist) has any entries (len(elist) > 0). This is to make sure we weren’t in an empty directory. If we have items in the list, then we call the Missing routine. We pass the episode list, the highest episode number, the current season number, and the name of the season, so we can print that out later on. The last three lines clear the list, the current show name, and the current season, and we move on as we did before.**

Nous allons mettre la majorité de notre nouveau code juste après la ligne « for fic in [… ». Cela ne représente que sept lignes, que voici (j'ai mis en noir les lignes existantes pour plus de clarté).

Voici la logique du nouveau code, ligne par ligne :

Tout d'abord, nous vérifions si la variable derniere_racine a la même valeur que racine (le nom du dossier en cours). Si c'est le cas, nous sommes dans le même dossier et nous n'exécutons pas le code. Sinon, nous attribuons le nom de dossier actuel à la variable derniere_racine. Ensuite, nous vérifions si la liste des épisodes (ep_liste) a des entrées (len(ep_liste)> 0). C'est pour s'assurer que nous ne sommes pas dans un répertoire vide. Si nous avons des éléments dans la liste, alors nous appelons la routine Manquant. Nous lui passons la liste des épisodes, le numéro de l'épisode le plus élevé, le numéro de la saison en cours, et le nom de la saison, pour pouvoir les afficher plus tard. Les trois dernières lignes effacent la liste, le nom de l'émission en cours, et la saison en cours, et nous continuons comme nous le faisions avant.

====== 6 ======
**Next we have to change two lines and add one line of code into the if isok: code, a few lines down. Again, right, the black lines are the existing code:

Here, we have just come back from the GetSeasonEpisode routine. If we had a parsable file name, we want to get the show name and season number, and add the current episode into the list. Notice, we are converting the episode number to an integer before we add it to the list.

We are done with this portion of the code. Now, all we have to do is add the Missing routine. Just after the WalkThePath routine, we’ll add the following code.**

Ensuite, nous devons changer deux lignes et ajouter une ligne de code dans le morceau de code « if estok » quelques lignes plus bas. Encore une fois, les lignes noires sont le code existant :

Ici, nous venons de revenir de la routine RecupereSaisonEpisode. Si nous avions un nom de fichier analysable, nous voulons obtenir le nom de l'émission et le numéro de la saison, et ajouter l'épisode actuel dans la liste. Remarquez que nous convertissons en nombre entier le numéro de l'épisode avant de l'ajouter à la liste.

Nous en avons fini avec cette partie du code. Maintenant, tout ce qui nous reste à faire est d'ajouter la routine Manquant. Juste après la routine ParcourirChemin, nous allons ajouter le code suivant.

====== 7 ======
**Again, it is a very simple set of code and we pretty much went over it last month, but we’ll walk through it just in case you missed it.

We define the function and set up four parameters. We will be passing the episode list (eplist), the number of episodes we should expect (shouldhave) which is the highest episode number in the episode list, the season number (season), and the show name (showname).

Next, we create a set that contains a list of numbers using the range built-in function, starting with 1 and going to the value in shouldhave + 1. We then call the difference function – on this set and a converted set from the episode list (temp-set(eplist)) – and convert it back to a list. We then check to see if there is anything in the list – so we don’t print a line with an empty list, and if there’s anything there, we print it out.**

Encore une fois, c'est du code très simple et nous l'avons quasiment déjà vu le mois dernier, mais nous allons le parcourir juste au cas où vous l'auriez manqué.

Nous définissons la fonction et mettons en place quatre paramètres. Nous passerons la liste des épisodes (episode_liste), le nombre d'épisodes que nous devrions avoir (nombre_therorique) qui est le numéro d'épisode le plus élevé dans la liste des épisodes, le numéro de la saison (saison), et le nom de l'émission (nom_emission).

Ensuite, nous créons un ensemble qui contient une liste de numéros en utilisant la fonction intégrée « range », en allant de 1 à la valeur nombre_therorique + 1. Nous appelons ensuite la fonction de différence - sur cet ensemble et un ensemble converti depuis la liste des épisodes (temp - set(episode_liste)) - et le reconvertissons en liste. Nous vérifions ensuite s'il y a quelque chose dans la liste - afin de ne pas afficher une ligne avec une liste vide, et s'il y a quelque chose, nous l'affichons.

====== 8 ======
**That’s it. The one flaw in this logic is that by doing things this way, we don’t know if there are any new episodes that we don’t have.

I’ve put the two routines up on pastebin for you if you just want to do a quick replace into your working code. You can find it at http://pastebin.com/XHTRv2dQ.

Have a good month and we’ll see you soon.**

C'est tout. La seule faille dans cette logique est qu'avec cette façon de faire, nous ne savons pas s'il y a de nouveaux épisodes que nous n'avons pas.

J'ai mis les deux routines sur pastebin au cas où vous voudriez juste faire un remplacement rapide dans votre code. Vous pouvez les consulter ici : http://pastebin.com/CnHK8xxf.

Passez un bon mois et nous vous reverrons bientôt.

====== Morceaux de code dans les encadrés ======

==== page 7 en haut ====

    for racine, reps, fichiers in os.walk(chemin,topdown=True):
        for fic in [f for f in fichiers if f.endswith (('.avi','mkv','mp4','m4v'))]:

==== page 7 juste en dessous ====

    # Combine chemin et nom de fichier pour creer une seule variable
    fn = join(racine,fic)  
    NomFicOriginal,ext = os.path.splitext(fic)
    fl = fic
    estok,donnees = RecupereSaisonEpisode(fl)

==== page 7 en bas ====

    if estok:
        nomEmission = data[0]
        saison = data[1]
        episode = data[2]
        print("Saison {0} Episode {1}".format(saison,episode)

==== page 8 en haut ====

    for fic in [f for f in fichiers if f.endswith (('.avi','mkv','mp4','m4v'))]:
        # Combine chemin et nom de fichier pour creer une seule variable
        if derniere_racine != racine:
            derniere_racine = racine
            if len(ep_liste) > 0:
                Manquants(ep_liste,max(ep_liste),saison_courante,emission_courante)
            ep_liste = []
            emission_courante = ''
            saison_courante = ''
        fn = join(racine,fic)  

==== page 8 juste en dessous ====

    estok,donnees = RecupereSaisonEpisode(fl)
    if estok:
        emission_courante = nomEmission = data[0]
        saison_courante = saison = data[1]
        episode = data[2]
        ep_liste.append(int(episode))
    else:

==== page 8 en bas ====

    #----------------------------------
    def Manquants(episode_liste,nombre_theorique,saison,nom_emission):
        temp = set(range(1,nombre_theorique+1))
        ret = list(temp-set(episode_liste))
        if len(ret) > 0:
            print('Episodes manquants pour {0} saison {1} - {2}'.format(nom_emission,saison,ret))