Suite

Comment convertir l'heure unix en type d'heure qt?


Comment puis-je convertir l'horodatage unix en type d'heure qt à l'aide du calculateur de champ qgis ? Je voudrais éviter d'importer ma table dans Excel et convertir l'horodatage en type de temps qt.


C'est assez facile à faire en utilisant la calculatrice de champ et une fonction personnalisée simple. Le résultat est une chaîne, que vous pouvez contraindre à une classe heure/date appropriée plus tard (par exemple pour certains calculs date/heure appropriés), ou étendre le script pour le faire pour vous.

OuvertCalculateur de champet cliquez sur leÉditeur de fonctionslanguette. Vous pouvez créer un nouveauNouveau fichierou étendre un existant avec les quelques lignes de code (Python) suivantes :

""" Définissez de nouvelles fonctions à l'aide de @qgsfunction. feature et parent doivent toujours être les derniers arguments. Utilisez args=-1 pour passer une liste de valeurs en tant qu'arguments """ de qgis.core import * de qgis.gui import * import time @qgsfunction(args='auto', group="Custom") def fromSecToDate(value1, feature, parent): outtime = time.gmtime(value1) outtime = time.strftime("%d-%m-%Y", temps mort) retour temps mort

Cela devrait ressembler à ceci dans 2.18.3.

Une fois que vous avez terminé, n'oubliez pas d'appuyer sur leChargebouton. Passez maintenant àExpressiononglet et trouverFromSecToDatefonctionner sous lePersonnaliségroupe (tel que défini dans le script, n'hésitez pas à le modifier). N'oubliez pas de nommer correctement vos variables et de définir le type de champ de sortie surTexte (chaîne).

Pour être en mesure de contraindre à unDateformat, vous devrez modifier le script ci-dessus en changeant l'ordre des unités : année-mois-jour

time.strftime("%d-%m-%Y", temps mort)

puis dans leOnglet Expressioncréation d'un nouveau champ de type Date à l'aide

to_date(fromSecToDate("votrevariable"))

s'il n'est pas disponible, vous pouvez toujours créer votre propre fonction de conversion :

http://nathanw.net/2012/11/10/user-defined-expression-functions-for-qgis/

et devrait être bon de le partager à un endroit ou de proposer de l'insérer dans la bibliothèque d'expressions


À partir de QGIS 3.12, il est possible d'utiliser la méthode intégrée du calculateur de champdatetime_from_epoch()qui convertit l'horodatage Unix en valeur de date et d'heure QGIS.

https://www.qgis.org/en/site/forusers/visualchangelog312/index.html#feature-add-datetime-from-epoch-msec-from-epoch-expression-function


Comment convertir l'heure unix en type d'heure qt? - Systèmes d'information géographique

Obtenez l'heure actuelle du calendrier en tant que valeur de type time_t .

La fonction renvoie cette valeur, et si l'argument n'est pas un pointeur nul, il définit également cette valeur sur l'objet pointé par timer .

La valeur renvoyée représente généralement le nombre de secondes depuis 00:00 heures, le 1er janvier 1970 UTC (c'est-à-dire, la valeur actuelle horodatage unix). Bien que les bibliothèques puissent utiliser une représentation différente du temps : les programmes portables ne doivent pas utiliser la valeur renvoyée par cette fonction directement, mais s'appuient toujours sur des appels à d'autres éléments de la bibliothèque standard pour les traduire en types portables (tels que localtime , gmtime ou difftime ) .

Paramètres

Valeur de retour

L'heure actuelle du calendrier en tant qu'objet time_t.

Si l'argument n'est pas un pointeur nul, la valeur de retour est la même que celle stockée à l'emplacement pointé par l'argument timer .

Si la fonction n'a pas pu récupérer l'heure du calendrier, elle renvoie une valeur de -1 .

time_t est un alias d'un fondamental type arithmétique capable de représenter les temps.


Internationalisation avec Qt

le internationalisation et localisation d'une application sont les processus d'adaptation de l'application aux différentes langues, aux différences régionales et aux exigences techniques d'un marché cible. L'internationalisation signifie concevoir une application logicielle de manière à ce qu'elle puisse être adaptée à différentes langues et régions sans modifications techniques. La localisation signifie adapter un logiciel internationalisé pour une région ou une langue spécifique en ajoutant des composants spécifiques aux paramètres régionaux (tels que les formats de date, d'heure et de nombre) et en traduisant le texte.

Classes Qt et API pertinentes

Ces classes prennent en charge l'internationalisation des applications Qt.

Compare les chaînes selon un algorithme de classement localisé

Peut être utilisé pour accélérer le classement des chaînes

Convertit entre les nombres et leurs représentations sous forme de chaîne dans différentes langues

Conversions entre les encodages de texte

Prise en charge de l'internationalisation pour la sortie de texte

Langues et systèmes d'écriture

Dans certains cas, l'internationalisation est simple, par exemple, rendre une application américaine accessible aux utilisateurs australiens ou britanniques peut nécessiter un peu plus que quelques corrections orthographiques. Mais pour rendre une application américaine utilisable par les utilisateurs japonais, ou une application coréenne utilisable par les utilisateurs allemands, il faudra que le logiciel fonctionne non seulement dans différentes langues, mais qu'il utilise des techniques de saisie, des codages de caractères et des conventions de présentation différents.

Qt essaie de rendre l'internationalisation aussi simple que possible pour les développeurs. Tous les contrôles de saisie et les méthodes de dessin de texte dans Qt offrent une prise en charge intégrée de toutes les langues prises en charge. Le moteur de polices intégré est capable de restituer correctement et de manière attrayante du texte contenant des caractères de différents systèmes d'écriture en même temps.

Qt prend en charge la plupart des langages utilisés aujourd'hui, en particulier :

  • Toutes les langues d'Asie de l'Est (chinois, japonais et coréen)
  • Toutes les langues occidentales (utilisant l'écriture latine)
  • arabe
  • Langues cyrilliques (russe, ukrainien, etc.)
  • grec
  • hébreu
  • Thaï et Lao
  • Tous les scripts en Unicode 6.2 qui ne nécessitent pas de traitement spécial
  • bengali
  • Birman (Myanmar)
  • Devanagari
  • gujarati
  • Gurmukhi
  • Kannada
  • Khmer
  • malayalam
  • Tamil
  • Telugu
  • Tibétain

La liste ci-dessus est prise en charge et fonctionnera sur toutes les plates-formes tant que le système dispose de polices pour rendre ces systèmes d'écriture installés.

Sous Windows, Linux et Unix avec FontConfig (prise en charge des polices côté client), les langues suivantes sont également prises en charge :

Sur macOS, les langues suivantes sont également prises en charge :

Beaucoup de ces systèmes d'écriture présentent des caractéristiques spéciales :

  • Comportement spécial de rupture de ligne. Certaines langues asiatiques sont écrites sans espaces entre les mots. Le saut de ligne peut se produire soit après chaque caractère (à quelques exceptions près) comme en chinois, japonais et coréen, soit après les limites logiques des mots comme en thaï.
  • Ecriture bidirectionnelle. L'arabe et l'hébreu s'écrivent de droite à gauche, à l'exception des nombres et du texte anglais incorporé qui s'écrit de gauche à droite. Le comportement exact est défini dans l'annexe technique Unicode #9.
  • Marques sans espacement ou diacritiques (accents ou trémas dans les langues européennes). Certaines langues telles que le vietnamien font un usage intensif de ces marques et certains caractères peuvent avoir plus d'une marque à la fois pour clarifier la prononciation.
  • Ligatures. Dans des contextes particuliers, certaines paires de caractères sont remplacées par un glyphe combiné formant une ligature. Des exemples courants sont les ligatures fl et fi utilisées dans la composition de livres américains et européens.

Qt essaie de prendre en charge toutes les fonctionnalités spéciales énumérées ci-dessus. Vous n'avez généralement pas à vous soucier de ces fonctionnalités tant que vous utilisez les contrôles d'entrée de Qt (par exemple, QLineEdit, QTextEdit et les classes dérivées ou l'élément Quick TextInput) et les contrôles d'affichage de Qt (par exemple, QLabel et l'élément de texte de Qt Quick).

La prise en charge de ces systèmes d'écriture est transparente pour le programmeur et complètement encapsulée dans le moteur de texte de Qt. Cela signifie que vous n'avez généralement pas besoin de connaître le système d'écriture utilisé dans une langue particulière, à moins que vous ne vouliez écrire vos propres contrôles de saisie de texte. Dans certaines langues, comme l'arabe ou les langues du sous-continent indien, la largeur et la forme d'un glyphe changent en fonction des caractères environnants. Pour prendre cela en compte, utilisez QTextLayout. L'écriture de contrôles d'entrée nécessite également une certaine connaissance des scripts dans lesquels ils vont être utilisés. Habituellement, le moyen le plus simple est de sous-classer QLineEdit ou QTextEdit.

Produire des traductions

Qt fournit un excellent support pour la traduction des applications Qt C++ et Qt Quick dans les langues locales. Les gestionnaires de versions, les traducteurs et les développeurs peuvent utiliser les outils de traduction Qt pour accomplir leurs tâches.

Les outils de traduction Qt, Qt Linguist, lupdate et lrelease sont installés dans le sous-répertoire bin du répertoire de base dans lequel Qt est installé. Pour plus d'informations sur leur utilisation, consultez le manuel Qt Linguist.

Qt lui-même contient plusieurs milliers de chaînes qui devront également être traduites dans les langues que vous ciblez. Vous trouverez un certain nombre de fichiers de traduction dans le référentiel qttranslations. Avant de commencer à traduire Qt, lisez la page wiki Traduire Qt dans d'autres langues.

Activation de la traduction

En règle générale, la fonction main() de votre application ressemblera à ceci :

Pour une application prenant en charge la traduction, un objet QTranslator est créé, puis une traduction est chargée en fonction des paramètres régionaux d'affichage de l'interface utilisateur préférés de l'utilisateur au moment de l'exécution, et enfin, l'objet traducteur est installé dans l'application.

Localiser les traductions de Qt

Vous pouvez également utiliser QLibraryInfo::location() pour localiser les traductions des modules Qt utilisés. Vous pouvez demander le chemin d'accès aux traductions au moment de l'exécution en passant QLibraryInfo::TranslationsPath à cette fonction.

Catalogues disponibles

Les catalogues de traduction Qt sont situés dans le référentiel qttranslations.

Avertissement: Les traductions de Qt sont fournies par la communauté Qt et fournies sans aucune garantie. Les traductions peuvent être manquantes, obsolètes ou entièrement incorrectes, au point d'être malveillantes. Il est recommandé de vérifier toutes les traductions que vous expédiez.

Le méta-catalogue qt_ contient les traductions Qt encore existantes qui ont été incluses dans le catalogue qt_ dans Qt 4. Il a été créé pour faciliter le portage des applications de Qt 4 à Qt 5. Le méta-catalogue dépend de traductions qui peuvent être absentes, car elles appartiennent à des modules inutiles ou obsolètes, ce qui peut entraîner l'échec du chargement des traductions. Si vous utilisez des modules nouveaux dans Qt 5 dans votre application, vous devez spécifier les noms des catalogues pour ces modules même si vous utilisez le méta-catalogue.

Le tableau suivant répertorie les catalogues de traduction disponibles pour les modules et outils Qt dans Qt.

Module ou outil QtCatalogue
Assistant Qt assistant_
Qt Bluetooth qtconnectivity_
Qt simultané qtbase_
Qt Core qtbase_
Qt D-Bus qtbase_
Concepteur Qt designer_
Qt GUI qtbase_
Aide Qt qt_help_
Qt Linguiste linguiste_
Emplacement Qt qtlocation_
Qt Multimédia qtmultimédia_
Widgets multimédia Qt qtmultimédia_
Qt NFC qtconnectivity_
Réseau Qt qtbase_
Positionnement Qt qtlocation_
Support d'impression Qt qtbase_
Qt QML qtdeclarative_
Qt rapide qtdeclarative_
Contrôles rapides Qt qtcontrôlesquick2_
Qt Quick Widgets qtdeclarative_
Port série Qt qtserialport_
Qt SQL qtbase_
Qt WebEngine qtwebengine_
Qt WebSockets qtwebsockets_
Qt Widgets qtbase_
Exemple : modules Qt de base

Par exemple, pour localiser les traductions des modules Qt de base, tels que Qt Core, Qt GUI, Qt Network et Qt Widgets, ajoutez le code suivant à la fonction main() :

Prise en charge des encodages

La classe QTextCodec et les fonctionnalités de QTextStream facilitent la prise en charge de nombreux codages d'entrée et de sortie hérités pour les données de vos utilisateurs. Lorsqu'une application démarre, les paramètres régionaux de la machine détermineront l'encodage 8 bits utilisé lors du traitement des données externes 8 bits. QTextCodec::codecForLocale() renvoie un codec qui peut être utilisé pour convertir entre cet encodage local et Unicode.

L'application peut parfois nécessiter des codages autres que le codage local 8 bits par défaut. Par exemple, une application dans une locale cyrillique KOI8-R (la locale standard de facto en Russie) peut avoir besoin de sortir le cyrillique dans le codage ISO 8859-5. Le code pour cela serait :

Pour convertir Unicode en encodages 8 bits locaux, un raccourci est disponible : la fonction QString::toLocal8Bit() renvoie ces données 8 bits. Un autre raccourci utile est QString::toUtf8(), qui renvoie le texte dans l'encodage UTF-8 8 bits : cela préserve parfaitement les informations Unicode tout en ressemblant à de l'ASCII simple si le texte est entièrement ASCII.

Pour convertir dans l'autre sens, il existe les fonctions de commodité QString::fromUtf8() et QString::fromLocal8Bit(), ou le code général, illustré par cette conversion de la conversion ISO 8859-5 cyrillique en Unicode :

Les E/S Unicode doivent être utilisées car cela maximise la portabilité des documents entre les utilisateurs du monde entier. Dans de nombreux cas, il est cependant toujours nécessaire de prendre en charge d'autres encodages car vos utilisateurs devront traiter des documents existants. L'encodage supplémentaire le plus important à prendre en charge est celui renvoyé par QTextCodec::codecForLocale(), car c'est celui dont l'utilisateur est le plus susceptible d'avoir besoin pour communiquer avec d'autres personnes et applications (c'est le codec utilisé par local8Bit()).

Qt prend en charge nativement la plupart des encodages les plus fréquemment utilisés. Pour une liste complète des encodages pris en charge, consultez la documentation QTextCodec.

Dans certains cas et pour des encodages moins fréquemment utilisés, il peut être nécessaire d'écrire votre propre sous-classe QTextCodec. En fonction de l'urgence, il peut être utile de contacter l'équipe de support technique de Qt ou de demander sur la liste de diffusion qt-interest pour voir si quelqu'un d'autre travaille déjà sur le support de l'encodage.

Localisation des numéros, des dates, des heures et des devises

La localisation est le processus d'adaptation aux conventions locales, par exemple en présentant les dates et les heures en utilisant les formats localement préférés. Pour les nombres, dates, heures et chaînes de devise localisés, utilisez la classe QLocale.

La localisation des images n'est pas recommandée. Choisissez des icônes claires qui conviennent à toutes les localités, plutôt que de vous fier à des jeux de mots locaux ou à des métaphores étirées. L'exception concerne les images de flèches pointant vers la gauche et la droite qui peuvent devoir être inversées pour les paramètres régionaux arabes et hébreux.

Traduction dynamique

Certaines applications, telles que Qt Linguist, doivent être capables de prendre en charge les modifications des paramètres de langue de l'utilisateur pendant qu'elles sont toujours en cours d'exécution. Pour informer les widgets des modifications apportées aux objets QTranslator installés, réimplémentez la fonction changeEvent() du widget pour vérifier si l'événement est un événement LanguageChange, et mettez à jour le texte affiché par les widgets en utilisant la fonction tr() de la manière habituelle. Par example:

Tous les autres événements de modification doivent être transmis en appelant l'implémentation par défaut de la fonction.

La liste des traducteurs installés peut changer en réaction à un événement LocaleChange, ou l'application peut fournir une interface utilisateur qui permet à l'utilisateur de changer la langue actuelle de l'application.

Le gestionnaire d'événements par défaut pour les sous-classes QWidget répond à l'événement QEvent::LanguageChange et appellera cette fonction si nécessaire.

Les événements LanguageChange sont publiés lorsqu'une nouvelle traduction est installée à l'aide de la fonction QCoreApplication::installTranslator(). De plus, d'autres composants d'application peuvent également forcer les widgets à se mettre à jour en leur publiant des événements LanguageChange.

Prise en charge du système

Certains des systèmes d'exploitation et des systèmes de fenêtrage sur lesquels Qt s'exécute n'ont qu'une prise en charge limitée d'Unicode. Le niveau de support disponible dans le système sous-jacent a une certaine influence sur le support que Qt peut fournir sur ces plates-formes, bien qu'en général les applications Qt n'aient pas à se préoccuper trop des limitations spécifiques à la plate-forme.

Unix/X11
  • Polices et méthodes de saisie adaptées aux paramètres régionaux. Qt les masque et fournit une entrée et une sortie Unicode.
  • Les conventions de système de fichiers telles que UTF-8 sont aujourd'hui utilisées par défaut dans la plupart des variantes d'Unix. Toutes les fonctions de fichiers Qt autorisent l'Unicode, mais convertissent les noms de fichiers en codage local 8 bits, car c'est la convention Unix (voir QFile::setEncodingFunction() pour explorer des codages alternatifs).
  • Les E/S de fichiers sont par défaut l'encodage local 8 bits, avec des options Unicode dans QTextStream.
  • Certaines anciennes distributions Unix ne contiennent qu'une prise en charge partielle de certaines locales. Par exemple, si vous avez un répertoire /usr/share/locale/ja_JP.EUC, cela ne signifie pas nécessairement que vous pouvez afficher du texte japonais, vous devez également avoir installé des polices japonaises et le /usr/share/locale/ja_JP.EUC le répertoire doit être complet. Pour de meilleurs résultats, utilisez les paramètres régionaux complets de votre fournisseur de système.
Linux
  • Qt fournit une prise en charge complète d'Unicode, y compris les méthodes de saisie, les polices, le presse-papiers, le glisser-déposer.
  • Le système de fichiers est généralement codé en UTF-8 sur toutes les distributions Linux modernes et ne devrait pas poser de problème. Les E/S de fichiers sont par défaut UTF-8.
Les fenêtres
  • Qt fournit une prise en charge complète d'Unicode, y compris les méthodes de saisie, les polices, le presse-papiers, le glisser-déposer et les noms de fichiers.
  • Les E/S de fichiers sont par défaut Latin1, avec des options Unicode dans QTextStream. Notez que certains programmes Windows ne comprennent pas les fichiers texte Unicode big-endian même si c'est l'ordre prescrit par la norme Unicode en l'absence de protocoles de niveau supérieur.
MacOS

Pour plus de détails sur la traduction spécifique à macOS, reportez-vous au document sur les problèmes de Qt pour macOS ici.


Type de membre Documentation

Enum QTimeZone :: NameType

Le type de nom de fuseau horaire.

ConstantValeurLa description
QTimeZone::DefaultName 0 La forme par défaut du nom du fuseau horaire, par ex. LongName, ShortName ou OffsetName
QTimeZone::LongName 1 La forme longue du nom du fuseau horaire, par ex. "Heure d'Europe centrale"
QTimeZone::ShortName 2 La forme abrégée du nom du fuseau horaire, généralement une abréviation, par ex. "HEC"
QTimeZone::OffsetName 3 La forme de décalage ISO standard du nom du fuseau horaire, par ex. "UTC + 00:00"

Typedef QTimeZone :: OffsetDataList

Enum QTimeZone :: TimeType

Le type de fuseau horaire, par exemple lors de la demande du nom. Dans les fuseaux horaires qui n'appliquent pas l'heure d'été, les trois valeurs peuvent renvoyer le même résultat.

ConstantValeurLa description
QTimeZone::StandardTime 0 L'heure standard d'un fuseau horaire, c'est-à-dire lorsque l'heure d'été n'est pas en vigueur. Par exemple, lors du formatage d'un nom d'affichage, cela affichera quelque chose comme "Heure normale du Pacifique".
QTimeZone::DaylightTime 1 Un moment où l'heure d'été est en vigueur. Par exemple, lors du formatage d'un nom d'affichage, cela affichera quelque chose comme "Heure d'été du Pacifique".
QTimeZone::GenericTime 2 Une heure qui n'est pas spécifiquement l'heure standard ou l'heure d'été, soit une heure inconnue, soit une forme neutre. Par exemple, lors du formatage d'un nom d'affichage, cela affichera quelque chose comme "Heure du Pacifique".

Enum QTimeZone :: anonyme

Les décalages UTC de Sane vont de -14 à +14 heures. Aucune zone connue > 12 h à l'ouest de Greenwich (Baker Island, USA). Aucune zone connue > 14 h à l'est de Greenwich (Kiritimati, Christmas Island, Kiribati).

ConstantValeurLa description
QTimeZone::MinUtcOffsetSecs -14 * 3600 -14 * 3600,
QTimeZone::MaxUtcOffsetSecs +14 * 3600 +14 * 3600

Contenu

Deux couches d'encodage composent le temps Unix. La première couche code un point dans le temps sous la forme d'un nombre réel scalaire qui représente le nombre de secondes écoulées depuis le jeudi 1er janvier 1970 à 00:00:00 UTC. [5] La deuxième couche code ce nombre sous la forme d'une séquence de bits ou chiffres décimaux.

Comme c'est la norme avec l'UTC, cet article étiquette les jours à l'aide du calendrier grégorien et compte les heures de chaque jour en heures, minutes et secondes. Certains des exemples montrent également l'heure atomique internationale (TAI), un autre schéma horaire qui utilise les mêmes secondes et est affiché dans le même format que l'UTC, mais dans lequel chaque jour dure exactement 86 400 secondes, perdant progressivement la synchronisation avec la rotation de la Terre. à un rythme d'environ une seconde par an.

Encodage du temps sous forme de nombre Modifier

L'heure Unix est un nombre signé unique qui s'incrémente chaque seconde, ce qui facilite le stockage et la manipulation des ordinateurs par rapport aux systèmes de date conventionnels. Les programmes d'interprétation peuvent ensuite le convertir en un format lisible par l'homme.

le Epoque Unix est l'heure 00:00:00 UTC le 1er janvier 1970. [2] Il y a un problème avec cette définition, en ce que UTC n'existait pas dans sa forme actuelle jusqu'en 1972, cette question est discutée ci-dessous. Par souci de concision, le reste de cette section utilise le format de date et d'heure ISO 8601, dans lequel l'époque Unix est 1970-01-01T00:00:00Z.

Le nombre de temps Unix est nul à l'époque Unix, et augmente d'exactement 86 400 par jour depuis l'époque. Ainsi 2004-09-16T00:00:00Z, 12 677 jours après l'époque, est représenté par le nombre de temps Unix 12 677 × 86 400 = 1 095 292 800 . Cela peut également être étendu vers l'arrière à partir de l'époque, en utilisant des nombres négatifs, ainsi 1957-10-04T00:00:00Z, 4472 jours avant l'époque, est représenté par le nombre de temps Unix -4472 × 86 400 = -386 380 800 . Cela s'applique dans les jours ainsi que le nombre de temps à un moment donné d'une journée est le nombre de secondes qui se sont écoulées depuis le début de minuit ce jour ajouté au nombre de temps de ce minuit.

Le temps Unix est parfois, à tort, appelé Temps d'époque, parce que l'époque Unix est basée sur une époque, et à cause d'un malentendu courant selon lequel l'époque Unix est la seule époque (souvent appelée "l'époque" [2] ). [6] [7] [8]

Secondes intercalaires Modifier

Le schéma ci-dessus signifie que lors d'un jour UTC normal, qui a une durée de 86 400 secondes, le nombre de temps Unix change de manière continue jusqu'à minuit. Par exemple, à la fin de la journée utilisée dans les exemples ci-dessus, les représentations temporelles progressent comme suit :

Temps Unix jusqu'à minuit jusqu'au 17 septembre 2004 (pas de seconde intercalaire)
TAI (17 septembre 2004) UTC (16 au 17 septembre 2004) Temps Unix
2004-09-17T00:00:30.75 2004-09-16T23:59:58.75 1 095 379 198 .75
2004-09-17T00:00:31.00 2004-09-16T23:59:59.00 1 095 379 199 .00
2004-09-17T00:00:31.25 2004-09-16T23:59:59.25 1 095 379 199 .25
2004-09-17T00:00:31.50 2004-09-16T23:59:59.50 1 095 379 199 .50
2004-09-17T00:00:31.75 2004-09-16T23:59:59.75 1 095 379 199 .75
2004-09-17T00:00:32.00 2004-09-17T00:00:00.00 1 095 379 200 .00
2004-09-17T00:00:32.25 2004-09-17T00:00:00.25 1 095 379 200 .25
2004-09-17T00:00:32.50 2004-09-17T00:00:00.50 1 095 379 200 .50
2004-09-17T00:00:32.75 2004-09-17T00:00:00.75 1 095 379 200 .75
2004-09-17T00:00:33.00 2004-09-17T00:00:01.00 1 095 379 201 .00
2004-09-17T00:00:33.25 2004-09-17T00:00:01.25 1 095 379 201 .25

Lorsqu'une seconde intercalaire se produit, le jour UTC ne dure pas exactement 86 400 secondes et le nombre de temps Unix (qui augmente toujours d'exactement 86 400 chaque jour) connaît une discontinuité. Les secondes intercalaires peuvent être positives ou négatives. Aucune seconde intercalaire négative n'a jamais été déclarée, mais si c'était le cas, à la fin d'une journée avec une seconde intercalaire négative, le nombre de temps Unix augmenterait de 1 jusqu'au début du jour suivant. Pendant une seconde intercalaire positive à la fin d'une journée, qui se produit environ tous les ans et demi en moyenne, le nombre de temps Unix augmente continuellement jusqu'au jour suivant pendant la seconde intercalaire, puis à la fin de la seconde intercalaire recule de 1 (retour au début du lendemain). Par exemple, c'est ce qui s'est passé sur les systèmes POSIX.1 strictement conformes à la fin de 1998 :

Heure Unix jusqu'à minuit jusqu'au 1er janvier 1999 (seconde intercalaire positive)
TAI (1er janvier 1999) UTC (31 décembre 1998 au 1er janvier 1999) Temps Unix
1999-01-01T00:00:29.75 1998-12-31T23:59:58.75 915 148 798 .75
1999-01-01T00:00:30.00 1998-12-31T23:59:59.00 915 148 799 .00
1999-01-01T00:00:30.25 1998-12-31T23:59:59.25 915 148 799 .25
1999-01-01T00:00:30.50 1998-12-31T23:59:59.50 915 148 799 .50
1999-01-01T00:00:30.75 1998-12-31T23:59:59.75 915 148 799 .75
1999-01-01T00:00:31.00 1998-12-31T23:59:60.00 915 148 800 .00
1999-01-01T00:00:31.25 1998-12-31T23:59:60.25 915 148 800 .25
1999-01-01T00:00:31.50 1998-12-31T23:59:60.50 915 148 800 .50
1999-01-01T00:00:31.75 1998-12-31T23:59:60.75 915 148 800 .75
1999-01-01T00:00:32.00 1999-01-01T00:00:00.00 915 148 800 .00
1999-01-01T00:00:32.25 1999-01-01T00:00:00.25 915 148 800 .25
1999-01-01T00:00:32.50 1999-01-01T00:00:00.50 915 148 800 .50
1999-01-01T00:00:32.75 1999-01-01T00:00:00.75 915 148 800 .75
1999-01-01T00:00:33.00 1999-01-01T00:00:01.00 915 148 801 .00
1999-01-01T00:00:33.25 1999-01-01T00:00:01.25 915 148 801 .25

Les numéros de temps Unix sont répétés dans la seconde immédiatement après une seconde intercalaire positive. Le nombre de temps Unix 1 483 142 400 est donc ambigu : il peut faire référence soit au début de la seconde intercalaire (2016-12-31 23:59:60) soit à la fin de celle-ci, une seconde plus tard (2017-01-01 00 :00:00). Dans le cas théorique où une seconde intercalaire négative se produit, aucune ambiguïté n'est causée, mais à la place, il existe une plage de numéros de temps Unix qui ne se réfèrent à aucun moment de l'heure UTC.

Une horloge Unix est souvent implémentée avec un type différent de traitement de seconde intercalaire positive associé au Network Time Protocol (NTP). Cela donne un système qui n'est pas conforme à la norme POSIX. Voir la section ci-dessous concernant NTP pour plus de détails.

Lorsqu'il s'agit de périodes qui n'englobent pas une seconde intercalaire UTC, la différence entre deux nombres de temps Unix est égale à la durée en secondes de la période entre les points correspondants dans le temps. Il s'agit d'une technique de calcul courante. Cependant, lorsque des secondes intercalaires se produisent, de tels calculs donnent une mauvaise réponse. Dans les applications où ce niveau de précision est requis, il est nécessaire de consulter un tableau des secondes intercalaires lorsqu'il s'agit d'heures Unix, et il est souvent préférable d'utiliser un codage temporel différent qui ne souffre pas de ce problème.

Un nombre de temps Unix est facilement reconverti en temps UTC en prenant le quotient et le module du nombre de temps Unix, modulo 86 400 . Le quotient est le nombre de jours depuis l'époque, et le module est le nombre de secondes depuis minuit UTC ce jour-là. Si un nombre de temps Unix est ambigu en raison d'une seconde intercalaire positive, cet algorithme l'interprète comme l'heure juste après minuit. Il ne génère jamais un temps qui se situe pendant une seconde intercalaire. Si un numéro de temps Unix n'est pas valide en raison d'une seconde intercalaire négative, il génère un temps UTC tout aussi invalide. Si ces conditions sont significatives, il est nécessaire de consulter un tableau des secondes intercalaires pour les détecter.

Variante basée sur le protocole de temps réseau non synchrone Modifier

Généralement, une horloge Unix de style Mills est implémentée avec une gestion des secondes intercalaires non synchrone avec le changement du numéro de temps Unix. Le nombre de temps diminue initialement là où un saut aurait dû se produire, puis il saute à l'heure correcte 1 seconde après le saut. Cela facilite la mise en œuvre et est décrit par l'article de Mills. [9] Voici ce qui se passe au cours d'une seconde intercalaire positive :

Horloge Unix non synchrone de style Mills
à minuit jusqu'au 1er janvier 1999 (seconde intercalaire positive)
TAI (1er janvier 1999) UTC (31 décembre 1998 au 1er janvier 1999) État Horloge Unix
1999-01-01T00:00:29.75 1998-12-31T23:59:58.75 TIME_INS 915 148 798 .75
1999-01-01T00:00:30.00 1998-12-31T23:59:59.00 TIME_INS 915 148 799 .00
1999-01-01T00:00:30.25 1998-12-31T23:59:59.25 TIME_INS 915 148 799 .25
1999-01-01T00:00:30.50 1998-12-31T23:59:59.50 TIME_INS 915 148 799 .50
1999-01-01T00:00:30.75 1998-12-31T23:59:59.75 TIME_INS 915 148 799 .75
1999-01-01T00:00:31.00 1998-12-31T23:59:60.00 TIME_INS 915 148 800 .00
1999-01-01T00:00:31.25 1998-12-31T23:59:60.25 TIME_OOP 915 148 799 .25
1999-01-01T00:00:31.50 1998-12-31T23:59:60.50 TIME_OOP 915 148 799 .50
1999-01-01T00:00:31.75 1998-12-31T23:59:60.75 TIME_OOP 915 148 799 .75
1999-01-01T00:00:32.00 1999-01-01T00:00:00.00 TIME_OOP 915 148 800 .00
1999-01-01T00:00:32.25 1999-01-01T00:00:00.25 TEMPS D'ATTENTE 915 148 800 .25
1999-01-01T00:00:32.50 1999-01-01T00:00:00.50 TEMPS D'ATTENTE 915 148 800 .50
1999-01-01T00:00:32.75 1999-01-01T00:00:00.75 TEMPS D'ATTENTE 915 148 800 .75
1999-01-01T00:00:33.00 1999-01-01T00:00:01.00 TEMPS D'ATTENTE 915 148 801 .00
1999-01-01T00:00:33.25 1999-01-01T00:00:01.25 TEMPS D'ATTENTE 915 148 801 .25

Cela peut être décodé correctement en prêtant attention à la variable d'état du second saut, qui indique sans ambiguïté si le saut a déjà été effectué. Le changement de variable d'état est synchrone avec le saut.

Une situation similaire se produit avec une seconde intercalaire négative, où la seconde qui est sautée est légèrement trop tardive. Très brièvement, le système affiche un nombre de temps nominalement impossible, mais cela peut être détecté par le TIME_DEL état et corrigé.

Dans ce type de système, le nombre de temps Unix viole POSIX autour des deux types de seconde intercalaire. La collecte de la variable d'état de seconde intercalaire avec le numéro de temps permet un décodage sans ambiguïté, de sorte que le numéro de temps POSIX correct peut être généré si vous le souhaitez, ou l'heure UTC complète peut être stockée dans un format plus approprié.

La logique de décodage requise pour faire face à ce style d'horloge Unix décoderait également correctement une horloge hypothétique conforme à POSIX en utilisant la même interface. Ceci serait réalisé en indiquant le TIME_INS pendant la totalité d'une seconde intercalaire insérée, puis indiquant TEMPS D'ATTENTE pendant toute la seconde suivante en répétant le décompte des secondes. Cela nécessite une gestion synchrone des secondes intercalaires. C'est probablement la meilleure façon d'exprimer l'heure UTC sous forme d'horloge Unix, via une interface Unix, lorsque l'horloge sous-jacente n'est fondamentalement pas perturbée par les secondes intercalaires.

Variante basée sur le TAI Modifier

Une autre variante non conforme, beaucoup plus rare, du chronométrage Unix consiste à coder le TAI plutôt que l'UTC. Certains systèmes Linux sont configurés de cette façon. [10] Parce que TAI n'a pas de seconde intercalaire et que chaque jour TAI dure exactement 86400 secondes, cet encodage est en fait un décompte linéaire pur de secondes écoulées depuis 1970-01-01T00:00:00 TAI. Cela rend l'arithmétique des intervalles de temps beaucoup plus facile. Les valeurs temporelles de ces systèmes ne souffrent pas de l'ambiguïté des systèmes POSIX strictement conformes ou des systèmes pilotés par NTP.

Dans ces systèmes, il est nécessaire de consulter une table de secondes intercalaires pour convertir correctement entre l'UTC et la représentation en temps pseudo-Unix. Cela ressemble à la manière dont les tables de fuseaux horaires doivent être consultées pour convertir vers et depuis l'heure civile. heure locale. La conversion se heurte également à des problèmes de définition avant le début en 1972 de la forme actuelle d'UTC (voir la section Base UTC ci-dessous).

Ce système basé sur TAI, malgré sa ressemblance superficielle, n'est pas du temps Unix. Il code des temps avec des valeurs qui diffèrent de plusieurs secondes des valeurs de temps POSIX. Une version de ce système a été proposée pour inclusion dans le time.h de l'ISO C, mais seule la partie UTC a été acceptée en 2011. [11] Un tai_clock existe cependant en C++20.

Représenter le nombre Modifier

Un nombre de temps Unix peut être représenté sous n'importe quelle forme capable de représenter des nombres. Dans certaines applications, le nombre est simplement représenté textuellement sous la forme d'une chaîne de chiffres décimaux, ne soulevant que des problèmes supplémentaires triviaux. Cependant, certaines représentations binaires de l'époque Unix sont particulièrement significatives.

Le type de données Unix time_t qui représente un point dans le temps est, sur de nombreuses plateformes, un entier signé, traditionnellement de 32 bits (mais voir ci-dessous), encodant directement le nombre de temps Unix comme décrit dans la section précédente. Être 32 bits signifie qu'il couvre une plage d'environ 136 ans au total. La date représentable minimum est le vendredi 1901-12-13, et la date représentable maximum est le mardi 2038-01-19. Une seconde après 03:14:07 UTC 2038-01-19 cette représentation débordera. Cette étape importante est anticipée avec un mélange d'amusement et d'effroi - voir le problème de l'année 2038.

Dans certains systèmes d'exploitation plus récents, time_t a été élargi à 64 bits. Cela étend les temps représentables d'environ 293 milliards d'années dans les deux directions, ce qui représente plus de vingt fois l'âge actuel de l'univers par direction.

Il y avait à l'origine une certaine controverse sur la question de savoir si le time_t Unix devait être signé ou non. S'il n'était pas signé, sa portée serait doublée à l'avenir, repoussant le débordement de 32 bits (de 68 ans). Cependant, il serait alors incapable de représenter les temps antérieurs à l'époque. Le consensus est que time_t soit signé, et c'est la pratique habituelle. La plate-forme de développement logiciel pour la version 6 du système d'exploitation QNX a un time_t 32 bits non signé, bien que les versions plus anciennes utilisaient un type signé.

Les spécifications POSIX et Open Group Unix incluent la bibliothèque standard C, qui inclut les types de temps et les fonctions définis dans le fichier d'en-tête <time.h>. La norme ISO C stipule que time_t doit être un type arithmétique, mais n'impose aucun type ou codage spécifique pour celui-ci. POSIX exige que time_t soit un type entier, mais n'exige pas qu'il soit signé ou non signé.

Unix n'a pas pour tradition de représenter directement les nombres temporels Unix non entiers sous forme de fractions binaires. Instead, times with sub-second precision are represented using composite data types that consist of two integers, the first being a time_t (the integral part of the Unix time), and the second being the fractional part of the time number in millionths (in struct timeval ) or billionths (in struct timespec ). [12] [13] These structures provide a decimal-based fixed-point data format, which is useful for some applications, and trivial to convert for others.

UTC basis Edit

The present form of UTC, with leap seconds, is defined only starting from 1 January 1972. Prior to that, since 1 January 1961 there was an older form of UTC in which not only were there occasional time steps, which were by non-integer numbers of seconds, but also the UTC second was slightly longer than the SI second, and periodically changed to continuously approximate the Earth's rotation. Prior to 1961 there was no UTC, and prior to 1958 there was no widespread atomic timekeeping in these eras, some approximation of GMT (based directly on the Earth's rotation) was used instead of an atomic timescale. [ citation requise ]

The precise definition of Unix time as an encoding of UTC is only uncontroversial when applied to the present form of UTC. The Unix epoch predating the start of this form of UTC does not affect its use in this era: the number of days from 1 January 1970 (the Unix epoch) to 1 January 1972 (the start of UTC) is not in question, and the number of days is all that is significant to Unix time.

The meaning of Unix time values below +63 072 000 (i.e., prior to 1 January 1972) is not precisely defined. The basis of such Unix times is best understood to be an unspecified approximation of UTC. Computers of that era rarely had clocks set sufficiently accurately to provide meaningful sub-second timestamps in any case. Unix time is not a suitable way to represent times prior to 1972 in applications requiring sub-second precision such applications must, at least, define which form of UT or GMT they use.

As of 2009 [update] , the possibility of ending the use of leap seconds in civil time is being considered. [14] A likely means to execute this change is to define a new time scale, called International Time, that initially matches UTC but thereafter has no leap seconds, thus remaining at a constant offset from TAI. If this happens, it is likely that Unix time will be prospectively defined in terms of this new time scale, instead of UTC. Uncertainty about whether this will occur makes prospective Unix time no less predictable than it already is: if UTC were simply to have no further leap seconds the result would be the same.

The earliest versions of Unix time had a 32-bit integer incrementing at a rate of 60 Hz, which was the rate of the system clock on the hardware of the early Unix systems. The value 60 Hz still appears in some software interfaces as a result. The epoch also differed from the current value. The first edition Unix Programmer's Manual dated 3 November 1971 defines the Unix time as "the time since 00:00:00, 1 January 1971, measured in sixtieths of a second". [15]

The User Manual also commented that "the chronologically-minded user will note that 2**32 sixtieths of a second is only about 2.5 years". Because of this limited range, the epoch was redefined more than once, before the rate was changed to 1 Hz and the epoch was set to its present value of 1 January 1970 00:00:00 UTC. This yielded a range of about 136 years, half of it before 1970 and half of it afterwards.

As indicated by the definition quoted above, the Unix time scale was originally intended to be a simple linear representation of time elapsed since an epoch. However, there was no consideration of the details of time scales, and it was implicitly assumed that there was a simple linear time scale already available and agreed upon. The first edition manual's definition does not even specify which time zone is used. Several later problems, including the complexity of the present definition, result from Unix time having been defined gradually by usage rather than fully defined from the outset.

When POSIX.1 was written, the question arose of how to precisely define time_t in the face of leap seconds. The POSIX committee considered whether Unix time should remain, as intended, a linear count of seconds since the epoch, at the expense of complexity in conversions with civil time or a representation of civil time, at the expense of inconsistency around leap seconds. Computer clocks of the era were not sufficiently precisely set to form a precedent one way or the other.

The POSIX committee was swayed by arguments against complexity in the library functions, [ citation requise ] and firmly defined the Unix time in a simple manner in terms of the elements of UTC time. This definition was so simple that it did not even encompass the entire leap year rule of the Gregorian calendar, and would make 2100 a leap year.

The 2001 edition of POSIX.1 rectified the faulty leap year rule in the definition of Unix time, but retained the essential definition of Unix time as an encoding of UTC rather than a linear time scale. Since the mid-1990s, computer clocks have been routinely set with sufficient precision for this to matter, and they have most commonly been set using the UTC-based definition of Unix time. This has resulted in considerable complexity in Unix implementations, and in the Network Time Protocol, to execute steps in the Unix time number whenever leap seconds occur. [ citation requise ]

Unix enthusiasts have a history of holding "time_t parties" (pronounced "time tea parties") to celebrate significant values of the Unix time number. [16] [17] These are directly analogous to the new year celebrations that occur at the change of year in many calendars. As the use of Unix time has spread, so has the practice of celebrating its milestones. Usually it is time values that are round numbers in decimal that are celebrated, following the Unix convention of viewing time_t values in decimal. Among some groups round binary numbers are also celebrated, such as +2 30 which occurred at 13:37:04 UTC on Saturday, 10 January 2004. [ citation requise ]

The events that these celebrate are typically described as "N seconds since the Unix epoch", but this is inaccurate as discussed above, due to the handling of leap seconds in Unix time the number of seconds elapsed since the Unix epoch is slightly greater than the Unix time number for times later than the epoch.

  • At 18:36:57 UTC on Wednesday, 17 October 1973, the first appearance of the date in ISO 8601 format [a] (1973-10-17) within the digits of Unix time (119731017) took place.
  • At 01:46:40 UTC on Sunday, 9 September 2001, the Unix billennium (Unix time number 1 000 000 000 ) was celebrated. [18] The name billennium is a portmanteau of milliard et millennium. [19][20] Some programs which stored timestamps using a text representation encountered sorting errors, as in a text sort times after the turnover, starting with a 1 digit, erroneously sorted before earlier times starting with a 9 digit. Affected programs included the popular Usenet reader KNode and e-mail client KMail, part of the KDE desktop environment. Such bugs were generally cosmetic in nature and quickly fixed once problems became apparent. The problem also affected many Filtrix document-format filters provided with Linux versions of WordPerfect a patch was created by the user community to solve this problem, since Corel no longer sold or supported that version of the program. [21]
  • At 23:31:30 UTC on Friday, 13 February 2009, the decimal representation of Unix time reached 1 234 567 890 seconds. [22]Google celebrated this with a Google doodle. [23] Parties and other celebrations were held around the world, among various technical subcultures, to celebrate the 1 234 567 890 th second. [16][24]
  • At 03:33:20 UTC on Wednesday, 18 May 2033, the Unix time value will equal 2 000 000 000 seconds.
  • At 06:28:16 UTC on Thursday, 7 February 2036, Network Time Protocol will loop over to the next epoch, as the 32-bit time stamp value used in NTP (unsigned, but based on 1 January 1900) will overflow. This date is close to the following date because the 136-year range of a 32-bit integer number of seconds is close to twice the 70-year offset between the two epochs.
  • At 03:14:08 UTC on Tuesday, 19 January 2038, 32-bit versions of the Unix timestamp will cease to work, as it will overflow the largest value that can be held in a signed 32-bit number ( 7FFFFFFF 16 or 2 147 483 647 ). Before this moment, software using 32-bit time stamps will need to adopt a new convention for time stamps, [25] and file formats using 32-bit time stamps will need to be changed to support larger time stamps or a different epoch. If unchanged, the next second will be incorrectly interpreted as 20:45:52 Friday 13 December 1901 UTC . This is referred to as the Year 2038 problem.
  • At 05:20:00 UTC on Saturday, 24 January 2065, the Unix time value will equal 3 000 000 000 seconds.
  • At 06:28:15 UTC on Sunday, 7 February 2106, the Unix time will reach FFFFFFFF 16 or 4 294 967 295 seconds, which, for systems that hold the time on 32-bit unsigned integers, is the maximum attainable. For some of these systems, the next second will be incorrectly interpreted as 00:00:00 Thursday 1 January 1970 UTC . Other systems may experience an overflow error with unpredictable outcomes. [citation requise]
  • At 15:30:08 UTC on Sunday, 4 December 292 277 026 596 , [26][27] 64-bit versions of the Unix time stamp cease to work, as it will overflow the largest value that can be held in a signed 64-bit number. This is nearly 22 times the estimated current age of the universe, which is 1.37 × 10 10 years (13.7 billion).

Vernor Vinge's novel A Deepness in the Sky describes a spacefaring trading civilization thousands of years in the future that still uses the Unix epoch. The "programmer-archaeologist" responsible for finding and maintaining usable code in mature computer systems first believes that the epoch refers to the time when man first walked on the Moon, but then realizes that it is "the 0-second of one of Humankind's first computer operating systems". [28]


Related Non-Members

QDataStream & operator<< ( QDataStream &out, const QDateTime &dateTime)

Writes dateTime to the out stream.

QDataStream & operator>> ( QDataStream &dans, QDateTime &dateTime)

Reads a datetime from the stream dans into dateTime.

© 2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.


How to convert unix time to qt time type? - Systèmes d'information géographique

IMGKit: Python library of HTML to IMG wrapper

Python 2 and 3 wrapper for wkhtmltoimage utility to convert HTML to IMG using Webkit.

Warning! Version in debian/ubuntu repos have reduced functionality (because it compiled without the wkhtmltopdf QT patches), such as adding outlines, headers, footers, TOC etc. To use this options you should install static binary from wkhtmltopdf site or you can use this script.

Windows and other options:

Check wkhtmltopdf homepage for binary installers or wiki page.

Also you can pass an opened file:

If you wish to further process generated IMG, you can read it to a variable:

You can find all wkhtmltoimage options by type wkhtmltoimage command or visit this Manual. You can drop '--' in option name. If option without value, use None, False ou alors '' for dict value:. For repeatable options (incl. allow, cookie, custom-header, post, postfile, run-script, replace) you may use a list or a tuple. With option that need multiple values (e.g. --custom-header Authorization secret) we may use a 2-tuple (see example below).

At some headless servers, perhaps you need to install xvfb:

Then use IMGKit with option xvfb: <"xvfb": "">.

By default, IMGKit will show all wkhtmltoimage output. If you don't want it, you need to pass quiet option:

Due to wkhtmltoimage command syntax, TOC et Cover options must be specified separately. If you need cover before TOC, use cover_first option:

You can specify external CSS files when converting files or strings using css option.

You can also pass any options through meta tags in your HTML:

Each API call takes an optional config paramater. This should be an instance of imgkit.config() API call. It takes the config options as initial paramaters. The available options are:

  • wkhtmltoimage - the location of the wkhtmltoimage binary. By default imgkit will attempt to locate this using which (on UNIX type systems) or where (on Windows).
  • xvfb - the location of the xvfb-run binary. By default imgkit will attempt to locate this using which (on UNIX type systems) or where (on Windows).
  • meta_tag_prefix - the prefix for imgkit specific meta tags - by default this is imgkit-

Example - for when wkhtmltopdf or xvfb is not in $PATH :

IOError: 'No wkhtmltopdf executable found' :

Make sure that you have wkhtmltoimage in your $PATH or set via custom configuration (see preceding section). where wkhtmltoimage in Windows or which wkhtmltoimage on Linux should return actual path to binary.

IOError: 'No xvfb executable found' :

Make sure that you have xvfb-run in your $PATH or set via custom configuration (see preceding section). where xvfb in Windows or which xvfb-run ou alors which Xvfb on Linux should return actual path to binary.

This error means that IMGKit was unable to process an input. You can try to directly run a command from error message and see what error caused failure (on some wkhtmltoimage versions this can be cause by segmentation faults)


Exemples

Let’s assume the program you want to execute is called “cal,” and you get a “Command not found” error message from Unix or Linux system. First, type the following command to see if you get a pathname:
$ whereis cal
Sample outputs:

If you do, you can invoke it using a full path name (e.g. /usr/bin/cal):
$ /usr/bin/cal
Sample outputs:

Or you can add the path to your PATH variable in your shell start-up file $HOME/.cshrc (csh/tcsh) or $HOME/.bashrc (bash) file, then “source” the file:
$ vi $HOME/.bashrc
Add the path as follows:

Save and close the file. Run the following source command:
$ source

/.bashrc
$ echo "$PATH"
$ cal
Finally, you can use the following find command to search for cal command get a hit about its location.
$ find / -name cal -print
Another faster option is to use the locate command:
$ locate cal
Then, invoke it using a full path name or add it to your PATH variable in your shell startup file.


Search permission is denied for one of the directories in the path prefix of path. (See also path_resolution(7).)

Too many symbolic links encountered while traversing the path. ENAMETOOLONG path is too long. ENOENT

A component of path does not exist, or path is an empty string.

Out of memory (i.e., kernel memory). ENOTDIR A component of the path prefix of path is not a directory. EOVERFLOW path ou alors fd refers to a file whose size, inode number, or number of blocks cannot be represented in, respectively, the types off_t, ino_t, ou alors blkcnt_t. This error can occur when, for example, an application compiled on a 32-bit platform without -D_FILE_OFFSET_BITS=64 calls stat() on a file whose size exceeds (1<<31)-1 octets.


There are mainly two approaches to do that:

  • If you have to run a script, you don't convert it but rather run the script via a systemd service.

Therefore you need two files: the script and the .service file (unit configuration file).
Make sure your script is executable and the first line (the shebang) is #!/bin/sh . Then create the .service file in /etc/systemd/system (a plain text file, let's call it vgaoff.service ).
Par example:

Now, edit the unit file. Its content depends on how your script works:

If vgaoff just powers off the gpu, e.g.:

then the content of vgaoff.service should be:

If vgaoff is used to power off the GPU and also to power it back on, e.g.:

then the content of vgaoff.service should be:

  • For the most trivial cases, you can do without the script and execute a certain command directly:

Once you're done with the files, enable the service:

It will start automatically on next boot. You could even enable and start the service in one go with