Téléchargement perl Dash - Téléchargement du code source perl Dash

NOM

Dash - Applications Web analytiques à Perl (Port of Plotly's Dash to Perl)

VERSION

Version 0.11

SYNOPSIS

 use Dash;
use aliased ' Dash::Html::Components ' => ' html ' ;
use aliased ' Dash::Core::Components ' => ' dcc ' ;
use aliased ' Dash::Dependencies ' => ' deps ' ;

my $external_stylesheets = [ ' https://codepen.io/chriddyp/pen/bWLwgP.css ' ];

my $app = Dash -> new(
    app_name             => ' Basic Callbacks ' ,
    external_stylesheets => $external_stylesheets
);

$app -> layout(
    html -> Div([
        dcc -> Input( id => ' my-id ' , value => ' initial value ' , type => ' text ' ),
        html -> Div( id => ' my-div ' )
    ])
);

$app -> callback(
    deps -> Output( ' my-div ' , ' children ' ),
    [deps -> Input( ' my-id ' , ' value ' )],
    sub {
        my $input_value = shift ;
        return " You've entered ' $input_value ' " ;
    }
);

$app -> run_server();

use Dash;
use aliased ' Dash::Html::Components ' => ' html ' ;
use aliased ' Dash::Core::Components ' => ' dcc ' ;

my $external_stylesheets = [ ' https://codepen.io/chriddyp/pen/bWLwgP.css ' ];

my $app = Dash -> new(
    app_name             => ' Random chart ' ,
    external_stylesheets => $external_stylesheets
);

my $initial_number_of_values = 20;
$app -> layout(
    html -> Div( children => [
        dcc -> Input( id => ' my-id ' , value => $initial_number_of_values , type => ' number ' ),
        dcc -> Graph( id => ' my-graph ' )
    ])
);

my $serie = [ map { rand (100) } 1 .. $initial_number_of_values ];
$app -> callback(
    Output => { component_id => ' my-graph ' , component_property => ' figure ' },
    Inputs => [{ component_id => ' my-id ' , component_property => ' value ' }],
    callback => sub {
        my $number_of_elements = shift ;
        my $size_of_serie = scalar @$serie ;
        if ( $number_of_elements >= $size_of_serie ) {
            push @$serie , map { rand (100) } $size_of_serie .. $number_of_elements ;
        } else {
            @$serie = @$serie [0 .. $number_of_elements ];
        }
        return { data => [ {
            type => " scatter " ,
            y => $serie
            }]};
    }
);

$app -> run_server();

DESCRIPTION

Ce package est un port de Dash de Plotly vers Perl.

Dash rend les applications Web analytiques de construction très faciles. Aucun javascript requis.

C'est un excellent moyen de mettre une belle interface Web interactive à votre application d'analyse de données sans avoir à faire une interface JavaScript et sans avoir à configurer des serveurs ou des frameworks Web. Le cas d'utilisation typique est que vous avez simplement de nouvelles données dans votre modèle ML / AI et vous souhaitez explorer de différentes façons de formation ou simplement visualiser les résultats de différentes configurations de paramètres.

Bases

Les principales parties d'une application Dash sont:

Mise en page
Partie déclarative de l'application où vous spécifiez la vue. Cette disposition est composée de composants disposés dans une hiérarchie, tout comme HTML. Ces composants sont disponibles sous forme de suites de composants (par exemple: dash :: html :: composants, dash :: core :: composants, ...) et ils peuvent être des éléments HTML simples (par exemple dash :: html :: Components :: H1) ou comme complexe que vous voulez comme Dash :: Core :: Components :: graphique qui est une composante de charte basée sur Plotly: js. La plupart du temps, vous utiliserez des composants Dash déjà construits et prêts à l'emploi.
Rappels
Il s'agit du code Perl qui est exécuté lorsque certains composants changent et le résultat de cette exécution Un autre composant (ou composant) est mis à jour. Chaque rappel déclare un ensemble d'entrées, un ensemble de sorties et éventuellement un ensemble d'entrées "d'état". Toutes les entrées, sorties et les entrées "état" sont appelées dépendances de rappel. Chaque dépendance est liée à certaines propriétés d'un composant, de sorte que les entrées déterminent que si une propriété d'un composant déclaré comme entrée dans un rappel déclenchera ce rappel et que la sortie renvoyée par le rappel mettra à jour la propriété du composant déclaré comme sortie.

Donc, pour créer une application Dash, vous avez juste besoin de configurer la mise en page et les rappels. Le squelette de base sera:

 my $app = Dash -> new( app_name => ' My Perl Dash App ' ); 
$app -> layout(...);
$app -> callback(...);
$app -> run_server();

Dans le synopsis, vous pouvez avoir un avant-goût de la façon dont cela fonctionne et aussi dans le dossier Exemples de la distribution

Mise en page

La disposition est la partie déclarative de l'application et c'est le dom de notre application. L'élément racine peut être n'importe quel composant, et une fois l'élément racine terminé, les autres sont des "enfants" de ce composant racine, c'est-à-dire qu'ils sont la valeur de la propriété des enfants du composant parent et les enfants peuvent être une "chose" (texte, composant, peu importe tant que peut être converti en JSON) ou un arrayref de "choses". Ainsi, les composants peuvent être composés autant que vous le souhaitez. Par exemple:

 $app -> layout(html -> Div( children => [
        html -> H1( children => ' Making Perl Dash Apps ' ),
        html -> Img( src => ' https://raw.githubusercontent.com/kraih/perl-raptor/master/example.png ' )
    ]));

Composants

Ce forfait expédie les suites des composants suivants et est prêt à l'emploi:

Dash Core Composants As Dash :: Core :: Composants. Composants principaux pour les applications Web analytiques interactives: formulaires et cartographie
DASH HTML Composants As Dash :: Html :: Composants. Fondamentalement, les éléments HTML.
Dash DataTable comme Dash :: Table

Le plan est de créer les packages également pour Dash-Bio, Dash-Daq, Dash-Canvas et Dash-Cytoscape.

En utilisant les composants

Chaque composant a sa propre classe. Par exemple, dash-html-composant div a la classe: dash :: html :: composants :: div et vous pouvez l'utiliser la voie standard perl:

 use Dash::Html::Components::Div;
...
$app -> layout(Dash::Html::Components::Div -> new( id => ' my-div ' , children => ' This is a simple div ' ));

Mais avec chaque suite de composants pourrait être beaucoup de composants. Donc, pour soulager la tâche de les importer (un par un est un peu fastidieux), nous pourrions utiliser deux façons:

Méthodes d'usine

Chaque suite de composants a une méthode d'usine pour chaque composant. Et en utilisant cette méthodes d'usine, le mot clé des enfants est facultatif tant que les enfants sont le premier élément. Par exemple, Dash :: Html :: Components a la méthode d'usine Div pour charger et construire un tableau de bord :: html :: Components :: Div Component:

 use Dash::Html::Components;
...
$app -> layout(Dash::Html::Components -> Div( id => ' my-div ' , children => ' This is a simple div ' ));
# same as
$app -> layout(Dash::Html::Components -> Div( ' This is a simple div ' , id => ' my-div ' );

Mais ces méthodes d'usine sont censées être aliasées, donc cela devient moins verbeux:

 use aliased ' Dash::Html::Components ' => ' html ' ;
...
$app -> layout(html -> Div( id => ' my-div ' , children => ' This is a simple div ' ));
# same as
$app -> layout(html -> Div( ' This is a simple div ' , id => ' my-div ' ));

Fonctions

De nombreux modules utilisent l'exportateur et les amis pour réduire la frappe. Si vous aimez de cette façon, chaque suite de composants obtient un package de fonctions pour importer toutes ces fonctions dans votre espace de noms. L'utilisation de ces fonctions permet également d'accueillir le mot-clé des enfants si les enfants sont le premier élément.

Ainsi, par exemple pour Dash :: HTML :: Components Il y a un package Dash :: HTML :: ComponentsFunctions avec une fonction d'usine pour charger et construire le composant avec le même nom:

 use Dash::Html::ComponentsFunctions;
...
$app -> layout(Div( id => ' my-div ' , children => ' This is a simple div ' ));
# same as
$app -> layout(Div( ' This is a simple div ' , id => ' my-div ' ));

Rappels

Les rappels sont la partie réactive de l'application Web. Ils écoutent des changements dans les propriétés des composants et sont licenciés par ces changements. La sortie des rappels peut mettre à jour les propriétés pour d'autres composants (ou différentes propriétés pour les mêmes composants) et potentiellement licencier d'autres rappels. Donc, votre application "réagit" aux changements. Ces propriétés que le feu change et les propriétés qui sont mises à jour sont des dépendances du rappel, ce sont les "liens" entre les composants et les rappels.

Chaque composant qui devrait licencier un rappel doit avoir une propriété ID unique.

Définir un rappel est nécessaire au moins:

Entrées
La propriété des composants (ou les propriétés des composants) qui licencient le rappel à chaque modification. Les valeurs de ces propriétés sont des entrées pour les rappels
Sortir
Le composant (ou les composants) dont la propriété (ou les propriétés) est mise à jour
rappel
Le code qui est exécuté

Un rappel minimun sera:

 $app -> callback(
    Output => { component_id => ' my-div ' , component_property => ' children ' },
    Inputs => [{ component_id => ' my-id ' , component_property => ' value ' }],
    callback => sub {
        my $input_value = shift ;
        return " You've entered ' $input_value ' " ;
    }
);

Dépendances

Dépendances "Link" Composants et rappels. Chaque dépendance de rappel a les attributs suivants:

composant_id
Valeur de la propriété ID pour le composant
Component_Property
Nom de la propriété

Entrées

Un rappel peut avoir une ou plusieurs entrées et pour chaque entrée déclarée pour un rappel, la valeur de la propriété sera un paramètre pour le rappel dans le même ordre que les dépendances d'entrée sont déclarées.

Sorties

Un rappel peut avoir une ou plusieurs dépendances de sortie. Lorsqu'il n'y a qu'une seule sortie, la valeur renvoyée par le rappel met à jour la valeur de la propriété du composant. Dans le deuxième cas, la sortie du rappel doit être une liste dans la liste renvoyée sera mappée par une par une des sorties dans le même ordre que les dépendances de sortie sont déclarées.

État

Outre les entrées, un rappel pourrait nécessiter la valeur des autres propriétés d'autres composants mais sans tirer le rappel. Les dépendances de l'État sont destinées à ce cas. Ainsi, pour chaque dépendance d'état déclarée pour un rappel, la valeur OS, la propriété sera un paramètre pour le rappel dans le même ordre, les dépendances d'état sont déclarées mais après toutes les entrées.

Dépendances à l'aide d'objets

Les dépendances peuvent être déclarées uniquement en utilisant une référence de hachage, mais la manière préférée utilise les classes et les méthodes et fonctions d'usine comme avec les composants.

Utilisation d'objets:

 use Dash::Dependencies::Input;
use Dash::Dependencies::Output;
...
$app -> callback(
    Output => Dash::Dependencies::Output -> new( component_id => ' my-div ' , component_property => ' children ' ),
    Inputs => [Dash::Dependencies::Input -> new( component_id => ' my-id ' , component_property => ' value ' )],
    callback => sub {
        my $input_value = shift ;
        return " You've entered ' $input_value ' " ;
    }
);

L'utilisation d'objets permet d'omettre les arguments de mots clés dans la méthode de rappel:

 use Dash::Dependencies::Input;
use Dash::Dependencies::Output;
...
$app -> callback(
    Dash::Dependencies::Output -> new( component_id => ' my-div ' , component_property => ' children ' ),
    [Dash::Dependencies::Input -> new( component_id => ' my-id ' , component_property => ' value ' )],
    sub {
        my $input_value = shift ;
        return " You've entered ' $input_value ' " ;
    }
);

Il existe également des méthodes d'usine pour utiliser ces dépendances, ce qui permet d'omettre les arguments de mots clés pour les dépendances:

 use Dash::Dependencies;
...
$app -> callback(
    Dash::Dependencies -> Output( ' my-div ' , ' children ' ),
    [Dash::Dependencies -> Input( component_id => ' my-id ' , component_property => ' value ' )],
    sub {
        my $input_value = shift ;
        return " You've entered ' $input_value ' " ;
    }
);

Cela peut être aliasé

 use aliased ' Dash::Dependencies ' => ' deps ' ;
...
$app -> callback(
    deps -> Output( component_id => ' my-div ' , component_property => ' children ' ),
    [deps -> Input( ' my-id ' , ' value ' )],
    sub {
        my $input_value = shift ;
        return " You've entered ' $input_value ' " ;
    }
);

Mais si vous préférez utiliser Just Fonctions dans votre espace de noms:

 use Dash::DependenciesFunctions;
...
$app -> callback(
    Output( ' my-div ' , ' children ' ),
    [Input( component_id => ' my-id ' , component_property => ' value ' )],
    sub {
        my $input_value = shift ;
        return " You've entered ' $input_value ' " ;
    }
);

Application en cours d'exécution

La dernière étape consiste à exécuter l'application. Appelez juste:

 $app->run_server();

Et il démarrera un serveur sur le port 8080 et ouvrira un navigateur pour commencer à utiliser votre application!

Faire de nouveaux composants

Il y a beaucoup de composants ... pour Python. Donc, si vous voulez contribuer, je serai heureux de vous aider.

En attendant, vous pouvez construire votre propre composant. Je vais faire un meilleur guide et un constructeur automatisé, mais en ce moment, vous devriez utiliser https://github.com/plotly/dash-component-boilerplate pour toutes les parties javascript (elle est basée sur la réaction) et après cela, la pièce Perl est très facile (les composants sont principalement javascript, ou typescript)::

Pour chaque composant doit être une classe Perl héritée de Dash :: BasEcomponent, surchargeant le hachage de déréférence% {} avec les accessoires que le composant React a (Vérifiez Dash :: Basecomponent to_json Méthode), et avec ces méthodes:
- Dashnamespace
  Espace de noms du composant
- _JS_DIST
  Dépendances JavaScript pour le composant
- _css_dist
  Dépendances CSS pour le composant

Facultativement, la suite de composants aura le package des fonctions et les méthodes d'usine pour faciliter l'utilisation.

Ensuite, il vous suffit de publier la suite composante en tant que package Perl. Pour les nouvelles suites de composants, vous pouvez utiliser le nom du package que vous aimez, mais si vous souhaitez utiliser Dash :: Namespace, veuillez utiliser Dash :: Components :: pour éviter de futures collisions avec un développement ultérieur. En outre, cela facilitera la recherche de plus de composants.

Comme mentionné tôt, je ferai un constructeur automatisé mais les contributions sont plus que bienvenues !! En attendant, veuillez vérifier la contribution.md

Faire un composant pour Dash qui n'est pas basé sur la réaction est un peu difficile, veuillez donc d'abord obtenir la partie JavaScript basée sur la réaction et après cela, l'intégration de Perl, R ou Python sera facile.

STATUT

En ce moment, cette bibliothèque est expérimentale et toujours en développement actif et l'API va changer!

Le but ultime est bien sûr de soutenir tout ce que les versions Python et R soutiennent.

L'utilisation suivra la version Python de Dash, aussi près que possible, de sorte que le Doc Python peut être utilisé avec des modifications mineures:

Utilisation de -> (opérateur de flèche) au lieu de.
Le package principal et la classe pour les applications est le tableau de bord
Les suites des composants utiliseront la convention de package Perl, je veux dire: dash_html_components sera dash :: html :: composants
Au lieu de décorateurs, nous utiliserons de vieux rappels
Le contexte de rappel est disponible comme le dernier paramètre du rappel mais sans la partie de réponse
Au lieu de Flask, nous utiliserons Mojolicious (peut-être dans le futur danseur2)

Dans le synopsis, vous pouvez avoir un avant-goût de la façon dont cela fonctionne et aussi dans le dossier d'exemples de la distribution ou directement dans le référentiel. Le didacticiel complet de Dash est porté sur Perl dans ce dossier d'exemples.

Parties manquantes

En ce moment, il manque beaucoup de pièces:

Support de préfixe
Mode de débogage et rechargement chaud
Configuration du tableau de bord (variables d'environnement de support)
Vérification de la dépendance au rappel
Fonctions côté client
Prise en charge des propriétés des composants Data- * et Aria- *
Génération de disposition dynamique

Et bien d'autres, mais vous pouvez l'utiliser dès maintenant pour faire de superbes applications! (Si vous avez besoin d'inspiration ... vérifiez simplement https://dash-gallery.plotly.host/portal/)

Sécurité

AVERTISSEMENT : Ce module n'est pas testé pour la sécurité, alors testez-vous si vous allez exécuter le serveur d'applications dans un serveur public.

CLAUSE DE NON-RESPONSABILITÉ

Il s'agit d'un module non officiel de Perl. Actuellement, je ne suis pas affilié à Plotly. Mais je pense que Dash est une excellente bibliothèque et je veux l'utiliser avec Perl.

Si vous aimez Dash, veuillez envisager de les soutenir