Forem: Ismaël Maurice

Similitude par cosinus

Ismaël Maurice — Fri, 16 May 2025 03:47:15 +0000

La similitude par cosinus permet de déterminer le degré de similitude entre deux phrases par calcul du cosinus de l'angle formé par les deux vecteurs de chacune de ces phrases.

Soit les phrases suivantes:

Bonjour John.
Bonjour Doé.

On remarque que les deux phrases sont similaires mais comment le savoir avec un ordinateur.

En raison de la difficulté d'ajout de formule Mathématiques dans dev.to, vous trouverez l'article sur le sujet dans le pdf disponible ici: Similitude par cosinus

Vous trouverez des exemples de codes ici: Calcul de la similitude de différentes manières qui montre diverses méthodes de calcul de manière native avec Python, SpaCy, NLTK.

Cosine similarity

Ismaël Maurice — Fri, 16 May 2025 03:36:49 +0000

Similarity by cosine determines the degree of similarity between two sentences by calculating the cosine of the angle formed by the two vectors in each sentence.

Consider the following sentences:

Bonjour John.
Bonjour Doé.

Note that the two sentences are similar, but how can you tell with a computer?

Due to the difficulty of adding mathematical formulas to dev.to, you will find the article on the subject in the pdf available here: Cosine similarity

Code examples can be found here: Calculating similarity in different ways which shows various calculation methods natively with Python, SpaCy, NLTK.

Comment rendre les logs utiles ?

Ismaël Maurice — Sat, 28 Sep 2024 10:46:41 +0000

Comment rendre les logs utiles ?

En tant que développeurs, les logs constituent la partie expressive de notre application. Ils permettent de capturer l’activité d’une application.

En programmation informatique, un développeur peut décider d’afficher ou non les logs dans son application qui peut être une aide de traçabilité en cas de erreurs.

Le problème qui se pose maintenant est de savoir quoi afficher et où d’où l’objet de cet article.

Logs dans une fonction unique

Par définition, une fonction reçoit en entrée aucun ou plusieurs paramètres, ensuite effectue des opérations et retourne un résultat.

Dans une fonction simple les informations utiles à afficher dans les logs sont :

Le(s) paramètre(s) que la fonction reçoit.
Le résultat après opérations (optionnel utile quand on a une suite d’appel de fonctions).

Par exemple pour une fonction qui ne prend aucun paramètre et retourne le message ‘Hello’ on aurait en Python :

Supposons que la fonction prenne en paramètre un nom et retourne « Hello nom d’utilisateur », on aurait :

Si on veut afficher le résultat de la fonction dans les logs on aurait :

Quand les paramètres contiennent des informations confidentielles comme l’email et mot de passe, il ne faut pas afficher ces informations dans les logs il faut les remplacer par **.

Logs dans une suite de fonctions

Un programme informatique est une suite de fonctions et méthodes qui s’appellent entres elles. Supposons un programme constitué de 3 fonctions fonction A,fonction B et fonction C avec la pile suivante :

Quand on a plusieurs fonctions les logs doivent se présenter comme suit :

La fonction appelante doit afficher ses paramètres lors de son appel.
La fonction appelante après avoir exécuté une autre fonction doit afficher le résultat obtenu.
La fonction appelante peut afficher le résultat renvoyé.

Soit une fonction main qui appelle une fonction obtenirNom et avec le nom saisi par l’utilisateur appelle une fonction hello pour afficher le message ‘Hello nom d’utilisateur’.

Si on veut appliquer les logs dans cette suite de fonctions on aurait :

L’exécution donnerait :

Dans les exemples précédents nous avons utilisé la fonction print pour afficher les logs. Dans vos projets il faut préférer des modules de logs de votre langage. En Python, vous pouvez utiliser Logging.

Les techniques décrites plus haut reste adaptable selon vos besoins.

Quand les paramètres contiennent des informations confidentielles comme l’email et mot de passe, il ne faut pas afficher ces informations dans les logs il faut les remplacer par **.

How to make logs useful?

Ismaël Maurice — Sat, 28 Sep 2024 10:39:54 +0000

How to make logs useful?

As developers, logs are the expressive part of our application. They allow us to capture the activity of an application.

In computer programming, a developer can decide whether to display logs in his application, which can be a traceability aid in the event of errors.

The problem now is to know what to display and where, hence the purpose of this article.

Logs in a single function

By definition, a function receives one or more parameters as input, then performs operations and returns a result.

In a simple function, the useful information's to be displayed in the logs are:

The parameter(s) the function receives.
Result after operations (optional, useful when you have a sequence of function calls).

For example, for a function that takes no parameters and returns the message 'Hello' we would have in Python:

Suppose the function took a name as parameter and returned “Hello username”, we'd have:

If we want to display the result of the function in the logs we would have:

When parameters contain confidential information such as email and password, these should not be displayed in the logs and should be replaced by **.

Logs in a sequence of functions

A computer program is a sequence of functions and methods that call each other. Let's assume a program consisting of 3 functions: function A, function B and function C, with the following stack:

When you have several functions, the logs should look like this:

The calling function must display its parameters when called.
After executing another function, the calling function must display the result obtained.
The calling function can display the returned result.

Let's say a main function calls a getName function and, with the name entered by the user, calls a hello function to display the message 'Hello username'.

If we want to apply the logs in this sequence of functions, we would have:

Execution would give :

In the previous examples, we used the print function to display logs. In your projects, you should use log modules from your own language. In Python, you can use Logging.

The techniques described above can be adapted to suit your needs.

When parameters contain confidential information such as email and password, these should not be displayed in the logs and should be replaced by **.

Quelle est le rôle de la fonction id en Python ?

Ismaël Maurice — Sun, 24 Mar 2024 15:47:20 +0000

Définition

Par définition, les variables sont de façon imagée des cases dans lesquelles Python va stocker des valeurs identifiées par une étiquette appelée nom de variable.

Source Image

Si la mémoire de l'ordinateur était représentée comme une étagère avec plusieurs tiroirs numéroté, la valeur d'une variable serait stockée dans un de ces tiroirs.

Le rôle de id en Python est de renvoyer le numéro de la case mémoire où est stockée la valeur de la variable.

Pour utiliser id on respecte le format suivant: id(nom_variable). Par exemple:

Dans l'exemple précédent on voit que les variables a et b ont un numéro de case mémoire différent ce qui signifie que les valeurs des variables sont stockées dans des cases mémoire différentes.

La fonction id ne renvoie pas tout le temps le même numéro de case mémoire. La valeur obtenue varie d'un ordinateur à l'autre.

Quand on écrit un programme en Python pour les types primitifs comme int(entier), float(nombre à virgule), bool(booléen) et les types str(chaine) lorsque deux variables ont la même valeur, les deux variables partagent la même case mémoire tant que leur valeur est identique. Comme dans les exemples ci-dessous:

Le même résultat est obtenu avec les strings type str.

Ce mécanisme de partage de la même case mémoire n'augmente pas la mémoire occupée par une variable. 100 variables ayant la même valeur et 50 variables ayant la même valeur sont liées à une seule case mémoire.

Cependant cela n'est plus pareil pour les types Objets comme les list(liste), tuple et les dict(dictionnaires). Toute déclaration d'une variable de type objet sera stockée dans une nouvelle case mémoire peu importe qu'une autre variable avec la même valeur existe ou non.

Contrairement aux types primitifs ici on a une augmentation du nombre de cases mémoire occupées. 100 variables de type objet occuperont 100 cases mémoires différentes.

Quand on utilise l'opération = pour assigner une variable à une autre c'est la copie de la case mémoire qui est faite. a=b signifie assigne aux variables a et b la même case mémoire qui est celle de b. Vue que la case mémoire est pareil dans le cas des listes cela revient à manipuler la même liste.

Subtilité avec input

Quand l'utilisateur entre dans le jeu cela change.

Précédemment pour les types primitifs, id renvoyait la même valeur parce les variables contenaient les mêmes valeurs. Quand on utilise la fonction input (qui permet à l'utilisateur de saisir une valeur), la valeur saisie par l'utilisateur est stockée dans une nouvelle case mémoire.

Quand l'utilisateur doit saisir un nombre la saisie est stockée dans une nouvelle case mémoire car on ne sait pas si ce que va fournir l'utilisateur est une valeur déjà stockée ou non.

Après la saisie de l'utilisateur, si on convertit et qu'on a la même valeur qu'une déjà stockée, l'identifiant devient celui de la valeur actuellement stockée on parle de mutation.

Ce mécanisme de mutation ne fonctionne pas avec les chaines de caractères ni avec les types objets.

Quand il s'agit du type str la case mémoire où la valeur de l'utilisateur est stockée ne changera pas même si la même valeur existe déjà c'est pourquoi on dit que les chaine de caractères str sont immuables car leur id ne change plus quand déjà alloué.

Subtilité des comparaisons avec is et is not

Il existe en Python les mots clés is not et is qui sont utilisés par certains programmeurs (moi y compris je suis tombé dans le piège d'où l'objet de l'article) parfois à tort pour vérifier si deux variables ont la même valeur.

Cependant cette méthode ne signifie pas la même chose quand on parle des types complexes comme les string (chaines de caractères).

En réalité les mots clés is et is not font une comparaison des cases mémoire c'est à dire du résultat des valeurs de id pas des valeurs des variables.

Ces mots clés vérifient que deux variables sont stockées dans la même case mémoire. Pour comparer les valeurs on utilisera == et != quand on parle des chaines.

== et != sur les types primitifs sont identiques que is et is not.

Sur les chaines c'est plus pareil.

Pour résumer :

is et is not donne le même résultat que != et == pour les variables de types simples car ces valeurs sont mutables, les identifiants de cases mémoire changent quand les valeurs sont identiques. Plusieurs variables avec la même valeur auront la même case mémoire.
is et is not sont différents de != et == pour les variables de types complexes comme les chaines. Deux chaines de mêmes valeurs n'ont pas forcément les mêmes identifiants de cases mémoire. Pour les chaines de caractères on utilisera == pour vérifier l'égalité des valeurs des variables de types chaine et != pour vérifier la différence entre les valeurs.

What is the Python id function?

Ismaël Maurice — Sun, 24 Mar 2024 15:40:31 +0000

What is the role of the id function in Python?

Definition

By definition, variables are a pictorial representation of boxes in which Python will store values identified by a label called a variable name.

Image Source

If computer memory were represented as a shelf with several numbered drawers, the value of a variable would be stored in one of the drawers.

The role of id in Python is to return the number of the memory cell where the value of the variable is stored.

To use id we use the following format: id(variable_name). For example:

In the previous example, we can see that the variables a and b have different memory location numbers, which means that the values of the variables are stored in different memory locations.

The id function does not always return the same memory cell number. The value obtained varies from one computer to another.

When writing a program in Python for primitive types such as int(integer), float(decimal point), bool(Boolean) and str(string), when two variables have the same value, both variables share the same memory slot as long as the value is identical. As in the examples below:

The same result is obtained with strings type str.

This mechanism of sharing the same memory slot does not increase the memory occupied by a variable. 100 variables with the same value and 50 variables with the same value are linked to a single memory cell.

However, this is no longer the case for Object types such as list, tuple and dict (dictionaries). Any declaration of an object-type variable will be stored in a new memory cell, regardless of whether another variable exists or not.

Unlike primitive types, here we have an increase in the amount of memory occupied. 100 object-type variables will occupy 100 different memory slots.

When the = operation is used to assign one variable to another, the memory location is copied. For example, a=b means assigning the same memory location to the a and b variables, i.e. that of b. As the memory location is the same in the case of lists, this amounts to manipulating the same list.

Ruler with input function

When the user enters the game, things change.

Previously, for primitive types, id returned the same value because the variables contained the same values. When the input function is used to allow the user to enter a value, the value entered by the user is stored in a new memory cell.

When the user is asked to enter a number, the entry is stored in a new memory cell, as we don't know whether what the user is going to provide is a value already stored or not.

After user input, if we convert and have the same value as one already stored, the identifier becomes that of the currently stored value - this is called mutation.

This mutation mechanism does not work with strings or object types.

When it comes to the str type, the memory location where the user's value is stored will not change even if the same value already exists. This is why str strings are said to be immutable, as their id does not change when already allocated.

Comparisons rules with is and is not

In Python, the keywords is not and is, which are used by some programmers (including me, who fell into the trap, hence the purpose of this article), sometimes incorrectly, to check whether two variables have the same value.

However, this method is not at all the same when it comes to complex types such as string.

In reality, the is and is not keywords compare memory cells, i.e. the result of id values, not variable values.

These keywords verify that two variables are stored in the same memory cell. To compare values, we use == and != when talking about strings.

== and != on primitive types are identical to is and is not..

On the channels, it's not the same.

To summarize:

is and is not give the same result as != and == for variables of simple types, since these values are mutable, and memory location identifiers change when the values are identical. Several variables with the same value will have the same memory location.
is and is not are different from != and == for complex variables such as strings. Two strings with the same values do not necessarily have the same memory cell identifiers. For strings, we use == to check the equality of string variable values and != to check the difference between values.

Différence entre height, min-height, max-height, width, min-width, max-width

Ismaël Maurice — Sun, 11 Feb 2024 18:19:27 +0000

Définition de width et height

Les propriétés CSS width et height permettent respectivement de spécifier la largeur et la hauteur d'un élément.

Pour voir la différence entre chacun des élements nous allons utiliser le code de base suivant:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Height Only</title>
</head>
<body>
    <div class="app">
        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    </div>
</body>
</html>
<style>
    .app {
        /* On écrira ici le code de la demo */
        background-color: yellow;
        border: solid 2px black;
    }
</style>

Propriété height

height sans contrainte

La propriété height permet d'appliquer une hauteur à un élément html. La valeur peut être absolue en pixel ou relative en pourcentage.

Si on applique une valeur absolue de 20 pixels à notre div précédente en remplaçant le style par:

<style>
    .app {
        height: 20px;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

On obtient le résultat suivant:

Le texte à l'intérieur de la div déborde car le texte est plus grand que 20 pixels.

Si on veut faire contenir le contenu (le texte) dans le conteneur (la div) on peut utiliser la propriété css overflow: auto. Ce qui donne comme style:

<style>
    .app {
        height: 20px;
        overflow: auto;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

Avec la propriété overflow: auto; le contenant restera à l'intérieur du conteneur avec une barre de défilement verticale.

height avec min

On peut précéder la propriété height de min. Dans ce cas le mode de fonctionnement change:

Si on utilise min-height celà signifie que l'élément ne peut avoir une hauteur plus pétite que celle spécifiée même si la hauteur de l'écran est plus pétite que la hauteur spécifiée.

Si on change le style par:

<style>
    .app {
        min-height: 510px;
        overflow: auto;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

La hauteur de la page web sera au minimum égale à la hauteur spécifiée même si le contenu de la div ne dépasse pas la valeur spécifiée. Par exemple sur un écran de 648 x 530 (largeur x hauteur) aura comme résultat.

Dans l'exemple précédent on voit que la div a gardé sa hauteur minimun de 510 pixels même si le texte à l'intérieur ne dépasse pas les 510 pixels.

Si jamais on applique une valeur min-height à la div et que le contenu de la div a une hauteur plus grande que la valeur spécifiée, la div aura comme hauteur celle de son contenu.

Par exemple si on applique le style suivant:

<style>
    .app {
        min-height: 30px;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

On obtient comme résultat:

Ici la valeur de la div a pris la valeur de son contenu le texte.

Pour résumer les règles d'application:

Style	Condition	Action
min-height: 20px;	Si le contenu de la div peut être affiché sur une hauteur de 50 pixels alors	la hauteur de la div sera de 50 pixels
min-height: 20px;	Si le contenu de la div peut être affiché sur une hauteur de 10 pixels alors	la hauteur de la div sera de 20 pixels

height avec max

Quand on utilise la propriété max-height, celà signifie que l'élément ne peut avoir qu'au maximun la hauteur spécifiée.

Le fonctionnement ici est un peu différent:

Si le contenu de l'élément a une hauteur plus grande que la hauteur maximale spécifiée, on aura un débordement comme ci dessous: css <style> .app { max-height: 50px; background-color: yellow; border: solid 2px black; } </style> Ce qui donne comme résultat:

Pour éviter le débordement on peut appliquer la proprité overflow: auto; pour avoir le résultat:

Si le contenu de l'élément a une hauteur plus pétite que la hauteur maximale spécifiée, le conteneur prend la hauteur du contenu comme ci-dessous: css <style> .app { max-height: 300px; background-color: yellow; border: solid 2px black; } </style> Ce qui donne comme résultat:

Peut importe la valeur du max-height dès l'instant qu'elle est plus grande que la taille du contenu on obtient le même résultat.

    <style>
        .app {
            max-height: 1000px;
            background-color: yellow;
            border: solid 2px black;
        }
    </style>

    <style>
        .app {
            max-height: 1300px;
            background-color: yellow;
            border: solid 2px black;
        }
    </style>

Donnera le même résultat identique à celui affiché plus haut:

Pour résumer les règles d'application:

Style	Condition	Action
max-height: 20px;	Si le contenu de la div peut être affiché sur une hauteur de 50 pixels alors	la hauteur de la div sera de 20 pixels avec débordement du contenu sur 30 pixels
min-height: 20px;	Si le contenu de la div peut être affiché sur une hauteur de 10 pixels alors	la hauteur de la div sera de 10 pixels identique à celle de son contenu

Pour plus d'information sur la propriété consulter height.

Propriété width

La propriété width est identique à la propriété height sauf que la règle s'applique sur la largeur. Ce qui donne les régles suivantes:

Style	Condition	Action
min-width: 20px;	Si le contenu de la div peut être affiché sur une largeur de 50 pixels alors	la largeur de la div sera de 50 pixels
min-width: 20px;	Si le contenu de la div peut être affiché sur une largeur de 10 pixels alors	la largeur de la div sera de 20 pixels
max-width: 20px;	Si le contenu de la div peut être affiché sur une largeur de 50 pixels alors	la largeur de la div sera de 20 pixels avec débordement du contenu sur 30 pixels sur la largeur
min-width: 20px;	Si le contenu de la div peut être affiché sur une largeur de 10 pixels alors	la largeur de la div sera de 10 pixels identique à celle de son contenu

Comme pour la propriété height on peut appliquer la propriété overflow: auto; dans le cas du width le contenu restera à l'intérieur du conteneur avec une barre de défilement verticale.

On peut aussi utiliser les deux propriétés sur un même élément.

Pour plus d'information sur la propriété consulter width.

Difference between height, min-height, max-height, width, min-width, max-width

Ismaël Maurice — Sun, 11 Feb 2024 18:09:33 +0000

Definition of width and height

The CSS properties width and height are used to specify the width and height of an element respectively.

To see the difference between each element, we'll use the following basic code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Height Only</title>
</head>
<body>
    <div class="app">
        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
        Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
        Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
        Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
    </div>
</body>
</html>
<style>
    .app {
        /* We'll write the demo code here */
        background-color: yellow;
        border: solid 2px black;
    }
</style>

Property height

height without constraint

The height property is used to apply a height to a html element. The value can be absolute in pixel or relative in percentage.

If we apply an absolute value of 20 pixels to our previous div by replacing the style with:

<style>
    .app {
        height: 20px;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

We obtain the following result:

The text inside the div overflows the container because the text is larger than 20 pixels.

If you want the content (the text) to be contained within the container (the div), you can use the css property overflow: auto. This gives the following style:

<style>
    .app {
        height: 20px;
        overflow: auto;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

With the property overflow: auto; the container will remain inside the container with a vertical scroll bar.

height with min

The height property can be preceded by min. In this case, the operating mode changes:

If min-height is used, this means that the element height cannot be smaller than the specified height, even if the screen height is smaller than the specified height.

If we change the style to:

<style>
    .app {
        min-height: 510px;
        overflow: auto;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

The height of the web page will be at least equal to the specified height, even if the content of the div does not exceed the specified value. For example, on a 648 x 530 (width x height) screen, the result would be.

In the previous example, we can see that the div has kept its minimum size of 510 pixels, even though the text inside doesn't exceed 510 pixels.

If a min-height value is applied to the div and the contents of the div have a height greater than the specified value, the div will have the height of its contents.

For example, if we apply the following style:

<style>
    .app {
        min-height: 30px;
        background-color: yellow;
        border: solid 2px black;
    }
</style>

The result is:

Here the value of the div has taken the value of its text content.

To summarize the rules of application:

Style	Condition	Action
min-height: 20px;	If the div content can be displayed at a height of 50 pixels, then	the height of the div will be 50 pixels
min-height: 20px;	If the div content can be displayed at a height of 10 pixels, then	the height of the div will be 20 pixels

height with max

When the max-height property is used, this means that the element can only have a maximum of the specified height.

It works a little differently here:

If the element's content is higher than the specified maximum height, an overflow will occur, as shown below: css <style> .app { max-height: 50px; background-color: yellow; border: solid 2px black; } </style> The result is:

To avoid overflow, you can apply the overflow: auto; property to get the result:

If the content of the element has a height greater than the maximum height specified, the container takes the height of the content as shown below: css <style> .app { max-height: 300px; background-color: yellow; border: solid 2px black; } </style> The result is:

It doesn't matter what the max-height value is, as long as it's greater than the content size, you get the same result.

    <style>
        .app {
            max-height: 1000px;
            background-color: yellow;
            border: solid 2px black;
        }
    </style>

    <style>
        .app {
            max-height: 1300px;
            background-color: yellow;
            border: solid 2px black;
        }
    </style>

Will give the same result as above:

To summarize the application rules:

Style	Condition	Action
max-height: 20px;	If the div content can be displayed at a height of 50 pixels, then	the height of the div will be 20 pixels with a 30-pixel content overflow
min-height: 20px;	If the div content can be displayed at a height of 10 pixels, then	the height of the div will be 10 pixels identical to that of its content

For more information on the property, consult height.

Property width

The width property is identical to the height property, except that the rule applies to the width. This gives the following rules:

Style	Condition	Action
min-width: 20px;	If the content of the div can be displayed at a width of 50 pixels, then	the width of the div will be 50 pixels
min-width: 20px;	If the div content can be displayed at a width of 10 pixels, then	the width of the div will be 20 pixels
max-width: 20px;	If the content of the div can be displayed at a width of 50 pixels, then	the width of the div will be 20 pixels, with the content extending 30 pixels over the width
min-width: 20px;	If the div content can be displayed at a width of 10 pixels, then	the width of the div will be 10 pixels identical to that of its content

As with the **height property, you can apply the overflow: auto; in the case of width the content will remain inside the container with a vertical scroll bar.**

You can also use both properties on the same element.

For more information on the property, consult width.

How do I back up all my Github repositories?

Ismaël Maurice — Sat, 21 Oct 2023 09:40:20 +0000

Goal

The goal of this article is to explain how to back up all your Github repositories with a utility script.

I wrote this script in order to be able to:

the personal user repositories private and public,
the user organization repositories,
the ancestor repositories,
the fork repositories.

When the script is run for the first time, it will retrieve all the repositories if the repositories have been previously retrieved it will do an update.

Important:
The repository name with space will be replace in clone folder by -. Example the repository name like repo 1 will be clone with name repo-1.

Installation

Before getting started, you'll need to install Python and Git on your machine:

Python >=3.9

Git

After installation, you can clone the utility script at the following address: Github Clone Repo

Preparation

Token creation

Go to your Github account to generate a token with read-only authorization as below:

If you use the Fine-grained personal access tokens you must provide the following authorizations:

If you use the Personal access token (classic) you must provide the following authorizations:

Important:
If you want to update fork repositories, you need to give workflow authorization to allow repositories to be updated. Activate the option as shown below:

Initializing environment variables

In the clone utility project repository folder, create the file .env with the following contents:

# Clone repo host
DOMAIN = github.com
# Domain protocol type http or https
PROTOCOL = https
# Access Token To Domain
TOKEN = your_generate_token_here
# Storage Folder => Folder where the repositories will be save => example /home/toto or C:\users\toto for windows
FOLDER = folder_path_here

You must enter specific values as shown in the example below:

Information:
During execution, destination folders will be created if they do not exist.

Execution

Run the following command in the project folder (must be run once):
```
    python -m venv env
```
or
```
    python3 -m venv env
```
or for ubuntu
```
    virtualenv venv
```
Information:
If you encounter an error, please check the following link: https://gist.github.com/frfahim/73c0fad6350332cef7a653bcd762f08d
Run the following command to activate the environment:Lancez la commande suivante pour activer l'environnement:
```
source env/bin/activate
```
or on windows
```
    env\Scripts\activate.bat
```
Install the modules from the command:
```
    pip install -r requirements.txt
```
Run the backup script with the command: python main.py or python3 main.py.

At the end you'll have all the repositories in the destination folder.

Information:
Note that for each execution you have the log generated inside utility script folder inside subfolder logs.

For Gitlab version you can visit Gitlab Backup.

Comment sauvegarder tous ses dépôts Github ?

Ismaël Maurice — Sat, 21 Oct 2023 09:40:05 +0000

Objectif

L'objectif de cet article est d'expliquer comment sauvegarder l'ensemble de ses dépôts Github avec un script utilitaire.

J'ai écris cet script dans le but de pouvoir :

récupérer tous mes dépôts Github ainsi que toutes les branches associées,
récupérer tous les dépôts dont j'ai fait un fork ainsi qu'une mise à jour du fork avant récupération,
récupérer tous les dépots de mes organisations,
récupérer tous les dépôts de mes ascendants.

Quand le script est exécuté pour la première fois, il va récupérer tous les dépôts si les dépôts ont été précédemment récupérer il fera une mise à jour.

Important:
Les dépôts avec des espaces dans le nom seront récupérés avec remplacement de l'espace par -. Par exemple le dépôt avec nom repo 1 sera récupérer avec le nom repo-1.

Installation

Avant de commencer, vous devez installer Python et Git sur votre machine :

Python >=3.9

Git

Après installation, vous pouvez cloner le script utilitaire à l'adresse suivante: Github Clone Repo

Préparation

Création des tokens

Allez sur votre compte Github pour générer un token avec l'autorisation de la lecture uniquement comme ci-dessous :

Si vous utilisez l'option Fine-grained personal access tokens vous devez fournir les autorisations suivantes :

Si vous utilisez l'option Personal access token (classic) vous devez fournir les autorisations suivantes :

Important:
Si vous voulez mettre à jour les dépôts fork, vous devez donner l'autorisation workflow pour permettre la mise à jour des dépôts. Activez l'option comme ci-dessous :

Initialisation des variables d'environnement

Dans le dossier du dépôt récupéré, créer le fichier .env avec le contenu suivant :

# Domaine Github
DOMAIN = github.com
# Protocol du domaine par défaut https
PROTOCOL = https
# Copier et coller le token que vous avez généré précédemment ici
TOKEN = le_token_genere_ici
# Dossier là où sera sauvegardé les dépôts mettre le chemin absolu => exemple /home/toto ou C:\users\toto pour windows
FOLDER = chemin_absolu_du_dossier

Vous devez mettre les valeurs spécifiques comme l'exemple ci-dessous :

Information:
Lors de l'exécution, les dossiers de destination seront créés s'ils n'existent pas.

Exécution

Lancez la commande suivante dans le dossier du projet (doit être lancé une fois) :
```
    python -m venv env
```
ou
```
    python3 -m venv env
```
ou pour ubuntu
```
    virtualenv venv
```
Information:
Si vous rencontrer une erreur, veillez vérifier sur le lien suivant: https://gist.github.com/frfahim/73c0fad6350332cef7a653bcd762f08d
Lancez la commande suivante pour activer l'environnement :
```
source env/bin/activate
```
ou sur windows
```
    env\Scripts\activate.bat
```
Installez les modules à partir de la commande :
```
    pip install -r requirements.txt
```
Lancez le script de sauvegarde avec la commande : python main.py or python3 main.py

Et voilà à la fin vous aurez tous les dépôts dans le dossier de destination.

Information:
Notez que pour chaque exécution, vous avez le journal généré dans le dossier du script utilitaire dans le sous-dossier logs.

Pour la version avec Gitlab vous pouvez visiter Sauvegarde Gitlab.

How do I back up all my Gitlab repositories?

Ismaël Maurice — Sat, 21 Oct 2023 09:39:40 +0000

How do I back up all my Gitlab repositories?

Goal

The goal of this article is to explain how to back up all your Gitlab repositories with a utility script.

I wrote this script in order to be able to:

the personal user repositories private and public,
the user organization repositories,
the fork repositories.

When the script is run for the first time, it will retrieve all the repositories if the repositories have been previously retrieved it will do an update.

Important:
The repository name with space will be replace in clone folder by -. Example the repository name like repo 1 will be clone with name repo-1.

Installation

Before getting started, you'll need to install Python and Git on your machine:

Python >=3.9

Git

After installation, you can clone the utility script at the following address: Gitlab Clone Repo

Preparation

Token creation

Go to your Gitlab account to generate a token with read-only authorization as below:

Important:
If you want to update fork repositories, you need to give workflow authorization to allow repositories to be updated. Activate the option as shown below:

Initializing environment variables

In the clone utility project repository folder, create the file .env with the following contents:

# Clone repo host
DOMAIN = gitlab.com
# Domain protocol type http or https
PROTOCOL = https
# Access Token To Domain
TOKEN = your_generate_token_here
# Username gitlab
USERNAME = your_gitlab_username
# Storage Folder => Folder where the repositories will be save => example /home/toto or C:\users\toto for windows
FOLDER = folder_path_here

You must enter specific values as shown in the example below:

Information:
During execution, destination folders will be created if they do not exist.

Execution

Run the following command in the project folder (must be run once):
```
    python -m venv env
```
or
```
    python3 -m venv env
```
or for ubuntu
```
    virtualenv venv
```
Information:
If you encounter an error, please check the following link: https://gist.github.com/frfahim/73c0fad6350332cef7a653bcd762f08d
Run the following command to activate the environment:Lancez la commande suivante pour activer l'environnement:
```
source env/bin/activate
```
or on windows
```
    env\Scripts\activate.bat
```
Install the modules from the command:
```
    pip install -r requirements.txt
```
Run the backup script with the command: python main.py or python3 main.py.

At the end you'll have all the repositories in the destination folder.

Information:
Note that for each execution you have the log generated inside utility script folder inside subfolder logs.

For Github version you can visit Github Backup.

Comment sauvegarder tous ses dépôts Gitlab ?

Ismaël Maurice — Sat, 21 Oct 2023 09:39:07 +0000

Objectif

L'objectif de cet article est d'expliquer comment sauvegarder l'ensemble de ses dépôts Gitlab avec un script utilitaire.

J'ai écris cet script dans le but de pouvoir :

récupérer tous mes dépôts Gitlab ainsi que toutes les branches associées,
récupérer tous les dépôts dont j'ai fait un fork ainsi qu'une mise à jour du fork avant récupération,
récupérer tous les dépots de mes organisations.

Quand le script est exécuté pour la première fois, il va récupérer tous les dépôts si les dépôts ont été précédemment récupérer il fera une mise à jour.

Important:
Les dépôts avec des espaces dans le nom seront récupérés avec remplacement de l'espace par -. Par exemple le dépôt avec nom repo 1 sera récupérer avec le nom repo-1.

Installation

Avant de commencer, vous devez installer Python et Git sur votre machine :

Python >=3.9

Git

Après installation, vous pouvez cloner le script utilitaire à l'adresse suivante: Gitlab Clone Repo

Préparation

Création des tokens

Allez sur votre compte Gitlab pour générer un token avec l'autorisation de la lecture uniquement comme ci-dessous :

Important:
Si vous voulez mettre à jour les dépôts fork, vous devez donner l'autorisation workflow pour permettre la mise à jour des dépôts. Activez l'option comme ci-dessous :

Initialisation des variables d'environnement

Dans le dossier du dépôt récupéré, créer le fichier .env avec le contenu suivant :

# Domaine Gitlab
DOMAIN = gitlab.com
# Protocol du domaine par défaut https
PROTOCOL = https
# Copier et coller le token que vous avez généré précédemment ici
TOKEN = le_token_genere_ici
# Nom d'utiliateur gitlab
USERNAME = nom_d_utilisateur_gitlab
# Dossier là où sera sauvegardé les dépôts mettre le chemin absolu => exemple /home/toto ou C:\users\toto pour windows
FOLDER = chemin_absolu_du_dossier

Vous devez mettre les valeurs spécifiques comme l'exemple ci-dessous :

Information:
Lors de l'exécution, les dossiers de destination seront créés s'ils n'existent pas.

Exécution

Lancez la commande suivante dans le dossier du projet (doit être lancé une fois) :
```
    python -m venv env
```
ou
```
    python3 -m venv env
```
ou pour ubuntu
```
    virtualenv venv
```
Information:
Si vous rencontrer une erreur, veillez vérifier sur le lien suivant: https://gist.github.com/frfahim/73c0fad6350332cef7a653bcd762f08d
Lancez la commande suivante pour activer l'environnement :
```
source env/bin/activate
```
ou sur windows
```
    env\Scripts\activate.bat
```
Installez les modules à partir de la commande :
```
    pip install -r requirements.txt
```
Lancez le script de sauvegarde avec la commande : python main.py or python3 main.py

Et voilà à la fin vous aurez tous les dépôts dans le dossier de destination.

Information:
Notez que pour chaque exécution, vous avez le journal généré dans le dossier du script utilitaire dans le sous-dossier logs.

Pour la version avec Github vous pouvez visiter Sauvegarde Github.