text:
/* global describe it */

var fs = require('fs');
var yaml = require('js-yaml');
var assert = require('chai').assert;
var formatFileName = require('../lib/format-file-name');

var testData = yaml.safeLoad(fs.readFileSync('./test/fixtures/format-file-test-cases.yml', 'utf8'));

describe('formatFileName', function () {
	it('should be `Object`', function () {
		assert.isObject(formatFileName);
	});

	describe('#format', function () {
		it('should format file names object', function () {
			testData.forEach(function (data) {
				assert.deepEqual(
					formatFileName.format(data.input),
					{
						block: {
							file: {
								name: data.output.block.file.name
							}
						},
						bmod: {
							file: {
								name: data.output.bmod.file.name
							}
						},
						elem: {
							file: {
								name: data.output.elem.file.name
							}
						},
						emod: {
							file: {
								name: data.output.emod.file.name
							}
						}
					}
				);
			});
		});
	});
});


text:
/**
 * Spending Widget
 */
Humble( function () {

    var C_SPENDING  = 'humble-dvc-spending',
        T_SPENDING  = '

',
        T_TITLE     = '
Spending:
',
        T_PIE       = '

',
        T_LEGEND    = '

';

    var Spending = function (node, model) {

        this.parentNode = node;
        this.node = $(T_SPENDING);
        this.model = model;

        this.render();
    }

    Spending.prototype = {

        render : function () {

            var node = this.node,
                spendingColors = Humble.Config.DVC.spendingColors;

            this.parentNode.append(node);

            var title = $(T_TITLE);
            this.pieNode    = $(T_PIE);
            this.legendNode = $(T_LEGEND);

            this.legendNode.html(this._getLegendHTML());

            // Do legend colors
            _.each(spendingColors, function (color, key) {
                var c = '.'+C_SPENDING+'-'+key+' .'+C_SPENDING+'-legend-block';
                this.legendNode.find(c).css({'background' : color});
            }, this);

            node.append(title);
            node.append(this.pieNode);
            node.append(this.legendNode);
        },

        _renderPaper : function () {

            var node    = this.pieNode,
                domNode = node.get(0),
                width   = node.width(),
                height  = node.height(),
                paper   = Raphael(domNode, width, height);

            this.pieConfig = {
                x : width / 2,
                y : height / 2,
                r : width / 2 - 2
            }

            return paper;
        },

        update : function (key) {
            this.drawPie(key);
        },

        drawPie : function (key) {

            if (!this.paper) this.paper = this._renderPaper();

            this.deletePie();

            var paper   = this.paper,
                data    = this._getData(key),
                config  = this.pieConfig,
                colors0 = this._getRaphaelColors(),
                colors  = [],
                spendingColors = Humble.Config.DVC.spendingColors;

            colors.push(spendingColors.deficit);
            colors.push(spendingColors.income);
            colors.push(spendingColors.other);

            this._setRaphaelColors(colors);
            this.pie = paper.g.piechart(config.x, config.y, config.r, data);
            this._setRaphaelColors(colors0);
        },

        deletePie : function () {

            if (this.pie) {
                this.pie.remove();
                delete this.pie;
            }
        },

        _getLegendHTML : function () {

            var html = '';

            html += '
';
            html += '

';
            html += '
Deficit Spending
';
            html += '
';
            html += '
';
            html += '

';
            html += '
Income Taxes
';
            html += '
';
            html += '
';
            html += '

';
            html += '
Other Taxes
';
            html += '
';

            return html;
        },
        _getData : function (key) {

            var model   = this.model,
                deficit = model.getDeficitSpending(key),
                other   = model.getOtherTaxSpending(key),
                total   = model.get(key, 'amounti'),
                income  = total - other - deficit,
                data;

            data = [
                deficit,
                income,
                other
            ]

            return data;
        },
        _setRaphaelColors : function (colors) {
            this.paper.g.colors = colors;
        },
        _getRaphaelColors : function (colors) {
            return _.clone(this.paper.g.colors);
        }
    }

    Humble.DVC.Spending = Spending;
});

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="UTF-8"?>
<objects serializationModel="Studio.01.08.00">
    <object class="AudioFile" id="{6ad98d52-c80a-495d-9f79-293eaf3f6ec1}">
        <property name="assetPath">
            <value>Collisions/objects/object - ping pong paddle/object - ping pong paddle 3.wav</value>
        </property>
        <property name="frequencyInKHz">
            <value>44.0999985</value>
        </property>
        <property name="channelCount">
            <value>1</value>
        </property>
        <property name="length">
            <value>0.21945578231292517</value>
        </property>
        <relationship name="masterAssetFolder">
            <destination>{df5bdea7-351b-4ee0-bbd3-53a4a8d8ac13}</destination>
        </relationship>
    </object>
</objects>


text:
package com.mohit;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.system.ApplicationPidFileWriter;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
	public static void main(String[] args) {
		SpringApplication eurekaServer = new SpringApplication(EurekaServerApplication.class);
		eurekaServer.addListeners(new ApplicationPidFileWriter("eureka-server.pid"));
		eurekaServer.run(args);
	}
}


text:
namespace _08.Military_Elite.Entities
{
    using _08.Military_Elite.Interfaces;

    public class Repair : IRepair
    {
        private string partName;
        private int workedHours;

        public Repair(string partName, int workedHours)
        {
            this.partName = partName;
            this.workedHours = workedHours;
        }

        public string PartName
        {
            get { return partName; }
        }

        public int WorkedHours
        {
            get { return workedHours; }
        }

        public override string ToString()
        {
            return $"Part Name: {this.PartName} Hours Worked: {this.WorkedHours}";
        }
    }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
in Bi, Li & Zheng, Guihaia 7(1): 24 (1987)

#### Original name
Psathyrella subincerta Z.S. Bi

### Remarks
null


text:
use libc::{c_char, c_int};

use crate::object::*;
use crate::pyport::Py_ssize_t;

ignore! {
    #[repr(C)]
    pub struct PyDictObject { /* representation hidden */ }
}

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    pub static mut PyDict_Type: PyTypeObject;
    pub static mut PyDictIterKey_Type: PyTypeObject;
    pub static mut PyDictIterValue_Type: PyTypeObject;
    pub static mut PyDictIterItem_Type: PyTypeObject;
    pub static mut PyDictKeys_Type: PyTypeObject;
    pub static mut PyDictItems_Type: PyTypeObject;
    pub static mut PyDictValues_Type: PyTypeObject;
}

#[inline(always)]
pub unsafe fn PyDict_Check(op: *mut PyObject) -> c_int {
    PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS)
}

#[inline(always)]
pub unsafe fn PyDict_CheckExact(op: *mut PyObject) -> c_int {
    let u: *mut PyTypeObject = &mut PyDict_Type;
    (Py_TYPE(op) == u) as c_int
}

#[cfg_attr(windows, link(name = "pythonXY"))]
extern "C" {
    pub fn PyDict_New() -> *mut PyObject;
    pub fn PyDictProxy_New(dict: *mut PyObject) -> *mut PyObject;
    pub fn PyDict_Clear(mp: *mut PyObject);
    pub fn PyDict_Contains(mp: *mut PyObject, key: *mut PyObject) -> c_int;
    pub fn PyDict_Copy(mp: *mut PyObject) -> *mut PyObject;

    pub fn PyDict_GetItem(mp: *mut PyObject, key: *mut PyObject) -> *mut PyObject;
    pub fn PyDict_SetItem(mp: *mut PyObject, key: *mut PyObject, item: *mut PyObject) -> c_int;
    pub fn PyDict_DelItem(mp: *mut PyObject, key: *mut PyObject) -> c_int;
    pub fn PyDict_GetItemString(dp: *mut PyObject, key: *const c_char) -> *mut PyObject;
    pub fn PyDict_SetItemString(
        dp: *mut PyObject,
        key: *const c_char,
        item: *mut PyObject,
    ) -> c_int;
    pub fn PyDict_DelItemString(dp: *mut PyObject, key: *const c_char) -> c_int;

    pub fn PyDict_Keys(mp: *mut PyObject) -> *mut PyObject;
    pub fn PyDict_Values(mp: *mut PyObject) -> *mut PyObject;
    pub fn PyDict_Items(mp: *mut PyObject) -> *mut PyObject;
    pub fn PyDict_Size(mp: *mut PyObject) -> Py_ssize_t;
    pub fn PyDict_Next(
        mp: *mut PyObject,
        pos: *mut Py_ssize_t,
        key: *mut *mut PyObject,
        value: *mut *mut PyObject,
    ) -> c_int;
    ignore! {
        pub fn _PyDict_Next(
            mp: *mut PyObject,
            pos: *mut Py_ssize_t,
            key: *mut *mut PyObject,
            value: *mut *mut PyObject,
            hash: *mut c_long,
        ) -> c_int;
        pub fn _PyDict_Contains(mp: *mut PyObject, key: *mut PyObject, hash: c_long) -> c_int;
        pub fn _PyDict_NewPresized(minused: Py_ssize_t) -> *mut PyObject;
        pub fn _PyDict_MaybeUntrack(mp: *mut PyObject);
    }
    pub fn PyDict_Update(mp: *mut PyObject, other: *mut PyObject) -> c_int;
    pub fn PyDict_Merge(mp: *mut PyObject, other: *mut PyObject, _override: c_int) -> c_int;
    pub fn PyDict_MergeFromSeq2(d: *mut PyObject, seq2: *mut PyObject, _override: c_int) -> c_int;

}


text:
<?php

namespace App;

class ManagerTest extends \PHPUnit_Framework_TestCase
{
    public static function setUpBeforeClass()
    {
        $_SERVER['HTTP_HOST'] = 'another.domain';
    }

    public static function tearDownAfterClass()
    {
        unset($_SERVER['HTTP_HOST']);
    }

    /**
     * @group app
     * @covers \Nerufio\App\Manager::Init
     * @covers \Nerufio\App\Manager::Execute
     * @expectedException \Nerufio\Core\Exception\Emergency
     */
    public function testInitialization()
    {
        $self = $this;

        \Nerufio\App\Manager::Init();

        GetObContent(function(){

            \Nerufio\App\Manager::Execute();

        },function($res) use ($self){

            $self->assertEquals('Hello world!',$res);

        });

        ChangeStaticProperty('Nerufio\App\Manager','_init',false); // Change initialize status for test
        ChangeStaticProperty('Nerufio\Mvc\View','_instance',null); // Change initialize status for test

        \Nerufio\App\Manager::Init('Controllers\Another');

        GetObContent(function(){

            \Nerufio\App\Manager::Execute();

        },function($res) use ($self){

            $self->assertEquals('Another',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Controllers\Index','another/p1/p2');

        },function($res) use ($self){

            $self->assertEquals('Another',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Controllers\Another','index/p1/p2');

        },function($res) use ($self){

            $self->assertEquals('Another',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Controllers\Another','another');

        },function($res) use ($self){

            $self->assertEquals('Another',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Controllers\Another','module1/index/p1/p2');

        },function($res) use ($self){

            $self->assertEquals('Module1|p1,p2',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Controllers\Another','module1/another/p1/p2');

        },function($res) use ($self){

            $self->assertEquals('Module1|Another|p1,p2',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Modules\Module1\Controllers\Another','index/p1/p2');

        },function($res) use ($self){

            $self->assertEquals('Module1|Another|index,p1,p2',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Modules\Module1\Controllers\Another','another');

        },function($res) use ($self){

            $self->assertEquals('Another',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Modules\Module1\Controllers\Another','module1/index/p1/p2');

        },function($res) use ($self){

            $self->assertEquals('Module1|p1,p2',$res);

        });

        GetObContent(function()use($self){

            $self->loadController('Modules\Module1\Controllers\Another','module1/another/p1/p2');

        },function($res) use ($self){

            $self->assertEquals('Module1|Another|p1,p2',$res);

        });

        ChangeStaticProperty('Nerufio\Mvc\Routing','_instance',null);

        \Nerufio\Mvc\Routing::AddRoute(':lang/*','module1/index/*',array(':lang'=>'.+'));

        GetObContent(function()use($self){

            $self->loadController('Controllers\Index','en/p1/p2/p3');

        },function($res) use ($self){

            $self->assertEquals('Module1|p1,p2,p3',$res);

        });

        \Nerufio\App\Manager::Init(); // Throw exception
    }

    /**
     * @group app
     * @covers \Nerufio\App\Manager::GetBaseUrl
     */
    public function testGetBaseUrl()
    {
        $this->assertEquals('http://another.domain/',\Nerufio\App\Manager::GetBaseUrl());

        ChangeStaticProperty('Nerufio\App\Manager','_init',false); // Change initialize status for test

        \Nerufio\App\Manager::Init(null,'http://some.domain');
        $this->assertEquals('http://some.domain',\Nerufio\App\Manager::GetBaseUrl());
    }

    public function loadController($controller,$uri)
    {
        ChangeStaticProperty('Nerufio\App\Manager','_init',false);
        ChangeStaticProperty('Nerufio\Mvc\View','_instance',null);
        ChangeStaticProperty('Nerufio\Http\Manager','_load',null);

        $_SERVER['REQUEST_URI'] = $uri;

        \Nerufio\Http\Manager::Init();
        \Nerufio\App\Manager::Init($controller);
        \Nerufio\App\Manager::Execute();
    }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Riv. Micol. 47(4): 313 (2004)

#### Original name
Mycena tenuicorticola Robich

### Remarks
null


text:
var app = tizen.application.getCurrentApplication();
var __result1, __result2;
function onSuccess(){
  __result1 = 1;
}
function onError(e){
  __result2 = e.name;
}
tizen.application.kill(app.contextId, onSuccess, onError);

var __expect1 = 1;
var __expect2 = "UnknownError"


text:
project_path: /web/_project.yaml
book_path: /web/fundamentals/_book.yaml
description: Les images représentent souvent la majorité des octets téléchargés sur une page Web, et occupent également une grande partie de l'espace visuel. En conséquence, l'optimisation des images permet souvent de réaliser les économies en octets et les améliorations des performances les plus importantes pour votre site.

{# wf_updated_on: 2014-05-09 #}
{# wf_published_on: 2014-05-06 #}

# Optimisation de l'image {: .page-title }

{% include "web/_shared/contributors/ilyagrigorik.html" %}

Les images représentent souvent la majorité des octets téléchargés sur une page Web, et occupent également une grande partie de l'espace visuel. En conséquence, l'optimisation des images permet souvent de réaliser les économies en octets et les améliorations des performances les plus importantes pour votre site Web : moins le navigateur doit télécharger d'octets, moins il y a de compétition pour la bande passante du client, et plus vite le navigateur peut télécharger et afficher le contenu utile à l'écran.

L'optimisation d'image est à la fois un art et une science : c'est un art, car il n'existe pas de réponse définitive quant à la meilleure façon de compresser une image individuelle, et c'est une science, car il existe un grand nombre de techniques et algorithmes bien développés permettant de réduire de façon significative la taille d'une image. Pour trouver les meilleurs paramètres pour votre image, vous devez analyser avec soin de nombreux facteurs : capacités du format, contenu des données encodées, qualité, dimensions en pixels, etc.

## Éliminer et remplacer les images

### TL;DR {: .hide-from-toc }
- Éliminez les ressources images inutiles.
- Utilisez les effets CSS3 chaque fois que c'est possible.
- Utilisez les polices du Web au lieu d'encoder le texte en images.

La toute première question que vous devez vous poser est la suivante : une image est-elle vraiment indispensable pour produire l'effet recherché ? Un bon design doit être simple, et offre également les meilleures performances. Si vous pouvez éliminer une image, qui nécessite souvent un grand nombre d'octet comparé aux éléments HTML, CSS, JavaScript et autres sur la page, alors c'est toujours la meilleure stratégie d'optimisation. Cela étant dit, une image bien placée peut également transmettre plus d'informations qu'un millier de mots. Il vous incombe donc de trouver le bon équilibre.

Ensuite, vous devez vous demander s'il existe une autre technologie capable de fournir les résultats souhaités de façon plus efficace :

* **Effets CSS** (dégradés, ombres, etc.) et animations CSS peuvent être utilisés pour produire des éléments à la résolution indépendante qui semblent toujours nets, quels que soient la résolution et le niveau de zoom, souvent pour une fraction du nombre d'octets nécessaires pour un fichier image.
* Les **polices Web** permettent d'utiliser de superbes types de caractères tout en préservant la possibilité de sélectionner, rechercher et redimensionner le texte, ce qui représente une amélioration importante en termes de facilité d'utilisation.

Si vous devez encoder du texte dans une image, réfléchissez-y à deux fois. Une bonne typographie est essentielle pour la qualité du design, de la marque et de la lisibilité. Mais le texte dans les images n'est pas très agréable pour les utilisateurs : le texte ne peut pas être sélectionné, recherché, agrandi, il n'est pas accessible et n'est pas adapté aux appareils avec un ppp élevé. L'utilisation de polices Web nécessite son [propre ensemble d'optimisations](https://www.igvita.com/2014/01/31/optimizing-web-font-rendering-performance/){: .external }, mais elle permet de résoudre tous ces problèmes et constitue toujours un meilleur choix pour afficher du texte.

## Images vectorielles ou matricielles

### TL;DR {: .hide-from-toc }
- Les images vectorielles sont idéales pour les images composées de formes géométriques.
- Les images vectorielles sont indépendantes du zoom et de la résolution.
- Les images matricielles doivent être utilisées pour les scènes complexes avec beaucoup de formes irrégulières et de détails.

Une fois que vous avez déterminé qu'une image est bien le format optimal pour obtenir l'effet souhaité, il est ensuite essentiel de choisir un format adapté :

Image vectorielle

Image matricielle

* Les [images vectorielles](http://fr.wikipedia.org/wiki/Image_vectorielle){: .external } utilisent des lignes, des points et des polygones pour représenter une image.
* Les [images matricielles](http://fr.wikipedia.org/wiki/Image_matricielle){: .external } représentent une image en encodant les valeurs individuelles de chaque pixel dans une grille rectangulaire.

Chaque format offre des avantages et des inconvénients. Les formats vectoriels sont mieux adaptés aux images composées de formes géométriques simples (logos, texte, icône, etc.), et offrent un résultat net à chaque résolution et niveau de zoom. Cela en fait le format idéal pour les écrans haute résolution et les éléments qui doivent être affichés dans plusieurs tailles.

Cependant, les formats vectorielles montrent leurs limites lorsque la scène est complexe, comme c'est le cas des photos : la quantité de balisage SVG pour décrire toutes les formes peut être extrêmement élevée, et le résultat ne pas être pour autant 'photoréaliste'. C'est dans de tels cas qu'il faut utiliser un format d'image matricielle tel que GIF, PNG, JPEG, ou l'un des formats les plus récents tels que JPEG-XR et WebP.

Les images matricielles n'offrent pas les mêmes propriétés : elles ne sont pas indépendantes de la résolution ou du niveau de zoom. Lorsque vous agrandissez une image matricielle, celle-ci se déforme ou devient floue. Il peut donc être nécessaire d'enregistrer plusieurs versions d'une image matricielle à différentes résolutions pour offrir une expérience optimale à vos utilisateurs.

## Implications des écrans haute résolution

### TL;DR {: .hide-from-toc }
- Les écrans haute résolution ont plusieurs pixels d'appareil par pixel CSS.
- Les images haute résolution nécessitent un nombre beaucoup plus important de pixels et d'octets.
- Les techniques d'optimisation de l'image sont les mêmes quelle que soit la résolution.

Lorsqu'on parle de pixels d'image, il est nécessaire de distinguer deux types de pixels différents : les pixels CSS et les pixels d'appareil. Un seul pixel CSS peut contenir plusieurs pixels d'appareil. Par exemple, un seul pixel d'appareil peut correspondre directement à un seul pixel d'appareil, ou être composé de plusieurs pixels d'appareil. Qu'est-ce que ça change ? Plus les pixels d'appareil sont nombreux, plus le contenu affiché à l'écran sera détaillé.

Les écrans à ppp élevé (HiDPI) offrent un résultat esthétique, mais avec un inconvénient évident : nos éléments d'image nécessitent un plus grand nombre de détails pour profiter du plus grand nombre de pixels d'appareil. La bonne nouvelle est que les images vectorielles sont parfaitement adaptées à cette tâche, puisqu'elles peuvent être affichées à n'importe quelle résolution et offrir un résultat net. Le coût de traitement pour afficher les plus petits détails peut être plus élevé, mais l'élément sous-jacent est le même et est indépendant de la résolution.

D'un autre côté, les images matricielles offrent un défi bien plus important, car elles encodent les données de l'image pixel par pixel. Par conséquent, plus il y a de pixels, plus la taille de fichier de l'image matricielle sera importante. Considérons par exemple la différence entre un élément photographique affiché à 100 x 100 pixels (CSS) :

    Résolution d'écran
    Nombre total de pixels
    Taille du fichier non compressé (4 octets par pixel)

  1x
  100 x 100 = 10 000
  40 000 octets

  2x
  100 x 100 x 4 = 40 000
  160 000 octets

  3x
  100 x 100 x 9 = 90 000
  360 000 octets

Lorsqu'on double la résolution de l'écran physique, le nombre total de pixels est multiplié par quatre : le double du nombre de pixels horizontaux multiplié par le double du nombre de pixels verticaux. Par conséquent, un écran '2x' ne contient pas seulement deux fois, mais quatre fois plus de pixels nécessaires !

Qu'est-ce que cela signifie concrètement ? Les écrans haute résolution nous permettent d'afficher de belles images, ce qui peut être un avantage pour présenter un produit. Cependant, des écrans haute résolution nécessitent aussi des images haute résolution : préférez donc des images vectorielles lorsque c'est possible, puis qu'elles sont indépendantes de la résolution et offrent toujours un résultat net. Et si vous devez utiliser une image matricielle, proposez et optimisez plusieurs versions de chaque image. Pour en savoir plus, lisez la suite.

## Optimiser les images vectorielles

### TL;DR {: .hide-from-toc }
- SVG est un format d'image basé sur le balisage XML.
- Les fichiers SVG doivent être réduits pour réduire leur taille.
- Les fichiers SVG doivent être compressés avec GZIP.

Tous les navigateurs modernes sont compatibles avec le format SVG (Scalable Vector Graphics), qui est un format d'image basé sur le balisage XML, pour les images en deux dimensions : nous pouvons intégrer le balisage SVG directement sur la page, ou comme ressource externe. Un fichier SVG peut également être créé par la plupart des logiciels de dessin vectoriel, ou à la main et directement dans votre traitement de texte préféré.

    <?xml version="1.0" encoding="utf-8"?>

    <svg version="1.2" baseProfile="tiny" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
       x="0px" y="0px" viewBox="0 0 612 792" xml:space="preserve">
    <g id="XMLID_1_">
      <g>
        <circle fill="red" stroke="black" stroke-width="2" stroke-miterlimit="10" cx="50" cy="50" r="40"/>
      </g>
    </g>
    </svg>

L'exemple ci-dessus montre un cercle simple avec un contour noir et un fond rouge. Il a été exporté depuis Adobe Illustrator. Comme vous le voyez, il contient un grand nombre de métadonnées, telles que des informations de couche, des commentaires et des espaces de nom souvent inutiles pour afficher l'élément dans le navigateur. Par conséquent, il est toujours bon de réduire la taille de vos fichiers SVG en utilisant un outil tel que [svgo](https://github.com/svg/svgo){: .external }.

Dans ce cas, svgo réduit la taille du fichier ci-dessus généré par Illustrator de 58 %, le faisant passer de 470 à 199 octets. De plus, puisque le format SVG est basé sur XML, nous pouvons également appliquer la compression GZIP pour réduire sa taille de transfert. Assurez-vous cependant que votre serveur est configuré pour compresser les éléments SVG !

## Optimiser les images matricielles

### TL;DR {: .hide-from-toc }
- Une image matricielle est une grille de pixels.
- Chaque pixel encode des informations sur la couleur et la transparence.
- Les logiciels de compression d'image utilisent différentes techniques pour réduire le nombre de bits requis pas pixel afin de réduire la taille de fichier de l'image.

Une image matricielle est simplement une grille de 'pixels' individuels en deux dimensions. Par exemple une image de 100 x 100 pixels est une séquence de 10 000 pixels. À son tour, chaque pixel stocke les valeurs '[RVBA](hhttps://en.wikipedia.org/wiki/RGBA_color_space){: .external }' : (R) canal rouge, (V) canal vert, (B) canal bleu et (A) canal alpha (transparent).

En interne, le navigateur attribue 256 valeurs (nuances) à chaque canal, ce qui se traduit par 8 bits par canal (2 ^ 8 = 256), et 4 octets par pixel (4 canaux x 8 bits = 32 bits = 4 octets). Par conséquent, si nous connaissons les dimensions de la grille, il est facile de calculer la taille du fichier :

* Une image 100 x 100 px est composée de 10 000 pixels
* 10 000 pixels x 4 octets = 40 000 octets
* 40 000 octets / 1 024 = 39 Ko

Note: Notez que quel que soit le format d'image utilisé pour transférer les données du serveur au client, lorsque l'image est décodée par le navigateur, chaque pixel occupe toujours 4 octets de mémoire. Cela peut représenter une contrainte importante pour les grandes images et les appareils qui ne disposent pas de beaucoup de mémoire, par exemple les appareils mobiles bas de gamme.

    Dimensions
    Pixels
    Taille du fichier

  100 x 100
  10 000
  39 Ko

  200 x 200
  40 000
  156 Ko

  300 x 300
  90 000
  351 Ko

  500 x 500
  250 000
  977 Ko

  800 x 800
  640 000
  2 500 Ko

Une taille de 39 Ko pour une image de 100 x 100 pixels peut sembler peu, mais la taille de fichier augmente rapidement pour les images plus importantes et rend les éléments d'image à la fois lents et coûteux à télécharger. Heureusement, ce que nous avons décrit jusqu'à maintenant est le format d'image 'non compressé'. Que pouvons-nous faire pour réduire la taille du fichier image ?

Une simple stratégie consiste à réduire la 'profondeur de bit' de l'image de 8 bits par canal à une palette de couleur plus petite : 8 bits par canal nous donne 256 valeurs par canal, et un total de 16 777 216 (2 563) couleurs. Que se passe-t-il si l'on réduit la palette à 256 couleurs ? Nous n'avons alors plus besoin que de 8 bits au total pour les canaux RVB, et réalisons immédiatement une économie de deux octets par pixel, soit une économie de 50 % sur la compression par rapport à notre format original de 4 octets par pixel !

Note: De gauche à droite (PNG) : 32 bits (16 000 couleurs), 7 bits (128 couleurs), 5 bits (32 couleurs). Les scènes complexes avec des transitions de couleur graduelles (dégradés, ciel, etc.) nécessitent des palettes de couleurs plus larges pour éviter les artéfacts visuels tels que le ciel pixellisé dans l'élément à 5 bits. D'un autre côté, si l'image n'utilise que quelques couleurs, une large palette est un gaspillage de bits précieux !

Ensuite, maintenant que nous avons optimisé les données stockées dans les pixels individuels, nous pourrions être encore plus malins et nous intéresser aux pixels à proximité : on s'aperçoit alors que dans de nombreuses images, en particulier les photos, beaucoup de pixels proches les uns des autres ont des couleurs similaires, par exemple le ciel, les textures répétitives, etc. Utilisant cette information à notre avantage, le logiciel de compression peut appliquer un '[codage différentiel](http://fr.wikipedia.org/wiki/Codage_différentiel){: .external }', avec lequel au lieu de stocker les valeurs individuelles de chaque pixel, nous pouvons stocker la différence entre les pixels proches les uns des autres : si les pixels adjacents sont identiques, la différence est de 'zéro' et il n'est alors nécessaire de stocker qu'un seul bit ! Mais ne nous arrêtons pas en si bon chemin...

L'œil humain a différents niveaux de sensibilité en fonction des différentes couleurs : nous pouvons optimiser notre codage des couleurs pour en tenir compte, en réduisant ou en augmentant la palette pour ces couleurs.
Les pixels 'à proximité' forment une grille en deux dimensions, ce qui signifie que chaque pixel a de nombreux voisins : nous pouvons utiliser ce fait pour améliorer encore davantage le codage différentiel.
Au lieu de ne regarder que les voisins immédiats de chaque pixel, nous pouvons regarder des groupes plus étendus de pixels voisins et encoder différents blocs avec différents paramètres. Et ainsi de suite...

Comme vous pouvez le voir, l'optimisation d'image devient vite compliquée (ou amusante, selon votre point de vue), et c'est un domaine de recherche universitaire et commerciale très actif. Les images occupent un grand nombre d'octets, et la valeur du développement de meilleures techniques de compression des images est inestimable ! Si vous souhaitez en apprendre davantage, consultez la [page Wikipédia](http://fr.wikipedia.org/wiki/Compression_d'image){: .external }, ou le [document de présentation des techniques de compression WebP](/speed/webp/docs/compression){: .external } pour avoir un exemple concret.

Mais une fois encore, tout ceci est très intéressant, mais très théorique : en quoi cela nous aide-t-il à optimiser les images sur nos pages ? Nous ne sommes évidemment pas capables d'inventer de nouvelles techniques de compression, mais il est important de comprendre la forme du problème : pixels RVBA, profondeur de bit, et les diverses techniques d'optimisation. Il est essentiel de comprendre tous ces concepts et de les garder à l'esprit avant d'aborder le sujet des différents formats d'image matricielle.

## Compression d'image avec et sans perte

### TL;DR {: .hide-from-toc }
- En raison de la façon dont fonctionnent nos yeux, les images sont d''excellentes candidates pour la compression avec perte.
- L'optimisation des images est une fonction de la compression avec et sans perte.
- Les différences de format des images sont dues à la différence de façon et à quels algorithmes avec et sans perte sont utilisés pour optimiser l'image.
- Il n'existe pas un seul format idéal ou 'paramètre de qualité pour toutes les images': chaque combinaison de logiciel de compression spécifique et de contenu d'image produit un résultat unique.

Pour certains types de données, tels que le code source d'une page ou un fichier exécutable, il est essentiel qu'un logiciel de compression n'endommage et ne perde aucune des informations d'origine : un seul octet manquant ou incorrect peut modifier complètement la signification des contenus du fichier ou pire, le détruire totalement. Pour certains autres types de données, telles que les images, les fichiers audio et les vidéos, il peut être parfaitement acceptable de fournir une représentation 'approximative' des données d'origine.

En fait, étant donnée la façon dont fonctionne l'œil, nous pouvons souvent nous permettre de nous débarrasser de certaines informations pour chaque pixel afin de réduire la taille de fichier d'une image. Par exemple, nos yeux ont une sensibilité différente en fonction des couleurs, ce qui signifie que nous pouvons utiliser moins de bits pour encoder certaines couleurs. En conséquence, le déroulement d'une optimisation d'image classique se compose de deux étapes principales :

1. L'image est traitée par un filtre '[avec perte](http://fr.wikipedia.org/wiki/Compression_de_données#Compression_avec_pertes){: .external }' qui élimine certaines données des pixels.
1. L'image est traitée par un filtre '[sans perte](http://en.wikipedia.org/wiki/Lossless_compression){: .external }' qui comprime les données des pixels.

** La première étape est facultative, et l'algorithme exact dépend du format d'image spécifique. Mais il est important de comprendre que n'importe quelle image peut subir une compression avec perte pour réduire sa taille.** En fait, la différence entre les différents formats d'image, tels que GIF, PNG, JPEG, etc., réside dans la combinaison d'algorithmes spécifiques qu'ils utilisent (ou omettent) lorsqu'ils appliquent les étapes avec et sans perte.

Alors, quelle est la configuration 'optimale' de l'optimisation avec et sans perte ? La réponse dépend du contenu de l'image et de vos propres critères, tels que l'équilibre entre taille du fichier et artéfacts introduits par la compression avec perte : dans certains cas, vous pouvez souhaiter ignorer l'optimisation avec perte pour communiquer une image très détaillée de façon extrêmement fidèle, et dans d'autres cas vous pourrez appliquer une optimisation avec perte agressive afin de réduire la taille de fichier de l'élément image.  C'est à ce moment-là que votre jugement et le contexte doivent entrer en jeu. Il n'existe par de paramètre universel unique.

Prenons un exemple concret. Lorsqu'on utilise un format avec perte comme JPEG, le logiciel de compression expose généralement un paramètre de 'qualité' (par exemple la barre de défilement fournie par la fonctionnalité 'Enregistrer pour le Web' dans Adobe Photoshop), le plus souvent un nombre entre 1 et 100 qui contrôle le fonctionnement interne d'un ensemble spécifique d'algorithmes avec et sans perte. Pour obtenir les meilleurs résultats, testez plusieurs paramètres de qualité pour vos images, et n'ayez pas peur d'en réduire la qualité : les résultats visuels sont souvent très bons et les économies en termes de taille de fichier peuvent être assez importantes.

Note: Notez qu'il est impossible de comparer directement les niveaux de qualité des différents formats d'image, en raison des différences dans les algorithmes utilisés pour encoder l'image : la qualité 90 JPEG produit un résultat très différent de la qualité 90 WebP. En fait, même des niveaux de qualité pour le même format d'image peuvent produire des résultats visiblement selon la mise en œuvre du logiciel de compression !

## Sélectionner le bon format d'image

### TL;DR {: .hide-from-toc }
- Commencez par sélectionner un format universel adapté : GIF, PNG, JPEG.
- Expérimentez et sélectionnez les meilleurs paramètres pour chaque format: qualité, taille de la palette, etc.
- Envisagez la possibilité d'ajouter des éléments WebP et JPEG XR pour les images à l'échelle de clients modernes

Outre différents algorithme de compression avec et sans perte, les différents formats d'image sont compatibles avec différentes fonctionnalités, telles que les animations et les canaux de transparence (alpha). En conséquence, le choix du 'bon format' pour une image spécifique dépend du résultat visuel souhaité et des exigences fonctionnelles.

    Format
    Transparence
    Animation
    Navigateur

  GIF
  Oui
  Oui
  Tous

  PNG
  Oui
  Non
  Tous

  JPEG
  Non
  Non
  Tous

  JPEG XR
  Oui
  Oui
  IE

  WebP
  Oui
  Oui
  Chrome, Opera, Android

Il existe trois formats d'image compatibles au niveau universel : GIF, PNG et JPEG. En plus de ces formats, certains navigateurs sont également compatibles avec des formats plus récents tels que WebP et JPEG XR, qui offrent une meilleure compression globale et davantage de fonctionnalités. Alors, quel format utiliser ?

1. ** Avez-vous besoin d'animations ? Si oui, le format GIF est le seul choix universel.**
  * Le format GIF limite la palette de couleur à un maximum de 256 couleurs, ce qui en fait un choix peu adapté à la plupart des images. En outre, le format PNG-8 offre une meilleure compression pour les images avec une petite palette. Par conséquent, le format GIF n'est adapté que lorsque vous avez besoin d'animations.
1. ** Avez-vous besoin de conserver de petits détails avec une résolution élevée ? Utilisez le format PNG.**
  * Le format PNG n'applique aucun algorithme de compression avec perte autre que le choix de la taille de la palette de couleur. Par conséquent, il produit la qualité d'image la plus élevée, mais avec des tailles de fichier sensiblement plus importantes que les autres formats. Utilisez-le de façon intelligente.
  * Si l'élément d'image contient des images composées de formes géométriques, pensez à le convertir à un format vectoriel (SVG) !
  * Si l'élément d'image contient du texte, réfléchissez-y à deux fois. Le texte dans les images ne peut pas être sélectionné, recherché, ni agrandi. Si vous devez transmettre une apparence personnalisée (pour une marque ou d'autres raisons), utilisez plutôt une police Web.
1. ** Optimisez-vous une photo, une capture d'écran ou un élément d'image similaire ? Utilisez le format JPEG.**
  * Le format JPEG utilise une combinaison d'optimisations avec et sans perte pour réduire la taille de fichier de l'élément d'image. Testez plusieurs niveaux de qualité JPEG pour trouver le meilleur équilibre entre qualité et taille de fichier pour votre élément.

Enfin, une fois que vous avez déterminé le format d'image optimal et les paramètres correspondants pour chacun de vos éléments, pensez à ajouter une variante supplémentaire encodée aux formats WebP et JPEG XR. Ces deux formats sont récents et malheureusement pas (encore) compatibles avec tous les navigateurs, mais ils peuvent néanmoins permettre de faire des économies importantes pour les clients les plus récents. Par exemple, WebP offre en moyenne une [réduction de la taille de fichier de 30 %](/speed/webp/docs/webp_study) par rapport à une image au format JPEG comparable.

Puisque ni WebP, ni JPEG XR n'est compatible au niveau universel, vous devrez ajouter une logique supplémentaires à votre application ou à vos serveurs pour diffuser la ressource appropriée :

* Certains CDN offrent un service d'optimisation d'image, y compris aux formats JPEG XR et WebP.
* Certains outils Open Source, par exemple PageSpeed pour Apache ou Nginx, automatisent l'optimisation, la conversion et la diffusion d'éléments adaptés.
* Vous pouvez ajouter une logique d'application supplémentaire pour détecter le client, contrôler les formats avec lesquels il est compatible et diffuser l'image au meilleur format disponible.

Enfin, notez que si vous utilisez un affichage Web pour afficher le contenu dans votre application native, vous avez un contrôle total du client, et pouvez utiliser WebP de façon exclusive ! Facebook, Google+ et bien d'autres utilisent WebP pour afficher toutes leurs images dans leurs applications. Les économies réalisées en valent la peine. Pour en savoir plus sur WebP, consultez la présentation [WebP : Deploying Faster, Smaller, and More Beautiful Images](https://www.youtube.com/watch?v=pS8udLMOOaE){: .external } sur Google I/O 2013.

## Outils et réglage des paramètres

Il n'existe pas un format d'image, un outil ou un ensemble de paramètres d'optimisation parfait, qui s'applique à toutes les images. Pour obtenir les meilleurs résultats, vous devez choisir le format et ses paramètres en fonction du contenu de l'image et de ses exigences visuelles et techniques.

    Outil
    Description

  gifsicle
  permet de créer et d'optimiser des images au format GIF

  jpegtran
  permet d'optimiser des images au format JPEG

  optipng
  permet d'optimiser sans perte des images au format PNG

  pngquant
  permet d'optimiser avec perte des images au format PNG

N'ayez pas peur de tester les paramètres de chaque logiciel de compression. Diminuez la qualité, observez le résultat, puis rincez, lavez et recommencez. Lorsque vous avez trouvé un ensemble de paramètres satisfaisant, vous pouvez l'appliquer à d'autres images semblables sur votre site. Mais ne partez pas du principe que toutes les images doivent être compressées avec les mêmes paramètres.

## Afficher des éléments d'image à l'échelle

### TL;DR {: .hide-from-toc }
- La production d'éléments à l'échelle est l'une des optimisations les plus simples et les plus efficaces.
- Accordez une attention particulière aux éléments volumineux, car ils produisent un temps système élevé.
- Réduisez le nombre de pixels inutiles en mettant vos images à l'échelle de leur taille d'affichage.

L'optimisation d'image se résume à deux critères : l'optimisation du nombre d'octets utilisés pour encoder chaque pixel de l'image, et l'optimisation du nombre total de pixels. La taille de fichier de l'image correspond simplement au nombre total de pixels multiplié par le nombre d'octets utilisés pour encoder chaque pixel. Ni plus, ni moins.

Par conséquent, l'une des techniques d'optimisation d'image les plus simples et les plus efficaces consiste à vous assurer que vous ne transportez pas plus de pixels que nécessaire pour afficher l'élément à la taille souhaitée dans le navigateur. Ça paraît plutôt simple, n'est-ce pas ? Malheureusement, la plupart des pages échouent à ce test pour la plupart de leurs images : elles envoient généralement des éléments plus volumineux et comptent sur le navigateur pour les redimensionner (ce qui consomme également des ressources supplémentaires du processeur) et les afficher à une plus faible résolution.

Note: Le fait de passer la souris sur l'élément de l'image dans Chrome DevTools révèle les tailles 'naturelle' et 'd'affichage' de celui-ci. Dans l'exemple ci-dessus, l'image de 300 x 260 pixels est téléchargée, mais son échelle est ensuite réduite (245 x 212) sur le client lorsqu'elle est affichée.

Le temps système créé pour l'expédition de pixels inutiles, simplement pour que le navigateur redimensionne l'image pour vous, est une occasion manquée de réduire et d'optimiser le nombre total d'octets requis pour afficher la page. En outre, notez que le redimensionnement ne dépend pas que du nombre de pixels retirés de l'image, mais également de sa taille naturelle.

    Taille naturelle
    Taille d'affichage
    Pixels inutiles

  110 x 110
  100 x 100
  110 x 110 - 100 x 100 = 2 100

  410 x 410
  400 x 400
  410 x 410 - 400 x 400 = 8 100

  810 x 810
  800 x 800
  810 x 810 - 800 x 800 = 16 100

Notez que dans les trois cas ci-dessus, la taille d'affichage ne mesure 'que 10 pixels de moins' que la taille naturelle de l'image. Cependant, plus la taille naturelle est importante, plus le nombre de pixels supplémentaires à encoder et expédier est important ! En conséquence, bien que vous ne puissiez peut-être pas garantir que chaque élément est fourni à la taille d'affichage exacte, **vous devez vous assurer que le nombre de pixels inutile est minime, et que vos éléments volumineux en particulier sont livrés dans une taille aussi proche que possible de leur taille d'affichage.**

## Liste de contrôle de l'optimisation d'image

L'optimisation d'image est à la fois un art et une science : c'est un art, car il n'existe pas de réponse définitive quant à la meilleure façon de compresser une image individuelle, et c'est une science, car il existe des techniques et algorithmes bien développés permettant de réduire de façon significative la taille d'une image.

Voici quelques conseils et techniques à garder à l'esprit lorsque vous travaillez à l'optimisation de vos images :

* **Préférez les formats vectoriels** : les images vectorielles sont indépendantes de la résolution et de l'échelle. Elles sont donc parfaitement adaptées aux nombreux appareils et à la haute résolution actuels.
* **Réduisez et compressez vos éléments SVG** : le balisage XML produit par la plupart des applications de dessin contient souvent des métadonnées inutiles qui peuvent être supprimées. Assurez-vous que vos serveurs sont configurés pour appliquer une compression GZIP aux éléments SVG.
* **Choisissez le meilleur format d'image matricielle** : déterminez vos exigences fonctionnelles et sélectionnez le format adapté à chaque élément.
* **Testez les paramètres de qualité optimaux pour les formats matriciels** : n'ayez pas peur de réduire les paramètres de 'qualité'. Les résultats sont souvent très bons pour une économie d'octets importante.
* **Supprimez les métadonnées d'image inutiles** : de nombreuses images matricielles contiennent des données inutiles à propos de l'élément, telles que les informations géographiques, les informations de l'appareil photo, etc. Utilisez les outils adaptés pour supprimer ces données.
* **Diffusez des images mises à l'échelle** : redimensionnez les images sur le serveur et assurez-vous que la taille 'd'affichage' est la plus proche possible de la taille 'naturelle' de l'image. Faites en particulier attention aux grandes images, car elles produisent le temps système le plus important lorsqu'elles sont redimensionnées !
* **Automatisez, automatisez, automatisez** : investissez dans des outils et une infrastructure automatisés qui garantissent que vos éléments d'image sont toujours optimisés.


text:
Static log object, through which all events are written.

```csharp
public static Events Writer;
```

## See Also

* class [Events](../RecyclableMemoryStreamManager.Events.md)
* namespace [Microsoft.IO](../../Microsoft.IO.RecyclableMemoryStream.md)

<!-- DO NOT EDIT: generated by xmldocmd for Microsoft.IO.RecyclableMemoryStream.dll -->


text:
$(document).ready(function() {

    // Configure Moment.js with the correct Locale.
    moment.locale($('body').data('locale'));

    // Use moment.js to format all the datetimes.
    $('time.ago').each(function(index) {
        // Calculate the time ago in words from the datetime.
        // Add format to help moment parse 2017-04-12 14:00:00 UTC cross browser as not ISO.
        var time_ago_in_words = moment($(this).attr('datetime')).fromNow();

        // Update the test of the element to the time ago in words.
        $(this).text(time_ago_in_words);
    });

    // Use moment.js to format all the duration timestamps.
    $('time.duration').each(function(index) {
        // Get the datetime attribute which contains an HTML valid
        // duration which we can pass to moment.
        //
        // Stripe the 's' from the end of the datetime attribute which is required
        // to make it a valid <time> tag based on the HTML spec.
        var duration_s = $(this).attr('datetime').replace(/\D/g,'');

        // Calculate a friendly duration.
        var distance_of_time_in_words = moment.duration({seconds: duration_s}).humanize();

        // Update the test of the element to the time ago in words.
        $(this).text(distance_of_time_in_words);
    });

});


text:
package com.jgeppert.struts2.jquery.components;

/**
 * @author Johannes Geppert
 */
public interface ResizableBean {

    void setResizable(String resizable);

    void setResizableAnimate(String animate);

    void setResizableAnimateDuration(String animateDuration);

    void setResizableAnimateEasing(String animateEasing);

    void setResizableAspectRatio(String aspectRatio);

    void setResizableAutoHide(String autoHide);

    void setResizableContainment(String containment);

    void setResizableDelay(String delay);

    void setResizableDistance(String distance);

    void setResizableGhost(String ghost);

    void setResizableHelper(String helper);

    void setResizableMaxHeight(String maxHeight);

    void setResizableMaxWidth(String maxWidth);

    void setResizableMinHeight(String minHeight);

    void setResizableMinWidth(String minWidth);

    void setResizableOnStartTopics(String start);

    void setResizableOnResizeTopics(String resize);

    void setResizableOnStopTopics(String stop);

    void setResizableHandles(String handles);
}


text:
package org.apache.hadoop.hdfs.tools;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
import java.util.concurrent.TimeUnit;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hdfs.protocol.Block;
import org.apache.hadoop.hdfs.protocol.CompressUtils;
import org.apache.hadoop.hdfs.server.common.Storage;
import org.apache.hadoop.hdfs.server.protocol.BlockCompressCommand;
import org.apache.hadoop.hdfs.server.protocol.InternalDatanodeProtocol;
import org.apache.hadoop.io.compress.Compressor;
import org.apache.hadoop.io.compress.Decompressor;
import org.apache.hadoop.io.compress.quicklz.QuickLzCompressor;
import org.apache.hadoop.io.compress.quicklz.QuickLzDecompressor;
import org.apache.hadoop.io.retry.RetryPolicies;
import org.apache.hadoop.io.retry.RetryPolicy;
import org.apache.hadoop.io.retry.RetryProxy;
import org.apache.hadoop.ipc.RPC;
import org.apache.hadoop.net.NetUtils;
import org.apache.hadoop.security.UnixUserGroupInformation;
import org.apache.hadoop.security.UserGroupInformation;
import org.apache.hadoop.util.StringUtils;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class BlockCompressor implements Tool {
  static{
    Configuration.addDefaultResource("hdfs-default.xml");
    Configuration.addDefaultResource("hdfs-site.xml");
  }
  private static Log LOG = LogFactory.getLog(BlockCompressor.class);

  public static final int QuickLzTYPE = 0;

  public static final int LzoTYPE = 1;

  public static final int GzipTYPE = 2;

  private static final float MIN_COMPRESS_RATE = 1.2f;

  // Block small than MIN_DATA_SIZE is impossible to compress, maybe.
  private static final int MIN_DATA_SIZE = 1024;

  private static final int BUF_SIZE = 8192;

  public static final int CHUNK_SIZE = 1024 * 1024;

  private Configuration conf;

  private int chunkSize = CHUNK_SIZE;

  private float minCompressRate = MIN_COMPRESS_RATE;

  private Compressor compressor;

  private Decompressor decompressor;

  private InternalDatanodeProtocol datanode;

  private TreeSet<Long> ignoredBlocks;

  private TreeSet<Long> compressedBlocks;

  private long sleepIntervel;

  private int min_data_size = MIN_DATA_SIZE;

  private int compressRetryTimes, type = 0, threadnum = 1;

  public static enum CompressStatus {
    OK,
    FAILED,
    IGNORE
  }

  public BlockCompressor() {
    compressor = new QuickLzCompressor(CHUNK_SIZE);
    decompressor = new QuickLzDecompressor(CHUNK_SIZE);
    ignoredBlocks = new TreeSet<Long>();
    compressedBlocks = new TreeSet<Long>();
  }

  public void setConf(Configuration conf) {
    this.conf = conf;
    chunkSize = conf.getInt("dfs.block.compress.chunk.size", CHUNK_SIZE);
    minCompressRate = conf.getFloat("dfs.block.compress.rate.min", MIN_COMPRESS_RATE);
    sleepIntervel = conf.getLong("block.compressor.sleep.interval", 1000);
    compressRetryTimes = conf.getInt("block.compressor.retry.times", 3);
    min_data_size = conf.getInt("block.compressor.min.size", MIN_DATA_SIZE);
    type = conf.getInt("block.compressor.codec.type", 0);
    threadnum = conf.getInt("block.compressor.thread.num", 1);
    Decompressor decompress = CompressUtils.getDecompressor(type);
    if(decompress == null){
      throw new IllegalArgumentException("can not support this codec type. block.compressor.codec.type" + type);
    }
    this.decompressor = decompress;
    Compressor compress = CompressUtils.getCompressor(type);
    if(compress == null){
      throw new IllegalArgumentException("can not support this codec type. block.compressor.codec.type" + type);
    }
    this.compressor = compress;

    cleanup(conf);  // cleanup tmp file
  }

  public Configuration getConf() {
    return conf;
  }

  private long[] convertSet2Array(TreeSet<Long> set){
    if(set == null)
      return new long[0];
    long [] buf = new long[set.size()];
    int i = 0;
    for(Long l : set){
      buf[i++] = l;
    }
    return buf;
  }
  public int run(String[] args) throws Exception {
    init();
    while (true) {
      try{
        long[] ign = convertSet2Array(ignoredBlocks);
        long[] complete = convertSet2Array(compressedBlocks);
        BlockCompressCommand task = datanode.getTask(ign , complete, 0);
        ignoredBlocks.clear();
        compressedBlocks.clear();
        List<String> pathlist = task.getPathList();
        if(pathlist != null && pathlist.size() != 0){
          LOG.info("get task from datanode . task num : " + pathlist.size());
          List<Thread> list = new ArrayList<Thread>(threadnum);
          for (String blockFile : pathlist) {
            compress(blockFile);
          }
        }
      } catch (Throwable e) {
        LOG.info("", e);
        //:~
      } finally{
        Thread.sleep(sleepIntervel);
      }
    }
  }

  public void init() throws IOException {
    datanode = createDatanode(conf);
  }

  public void shutdown() throws IOException {
    RPC.stopProxy(datanode);
  }

  /*
   * Build a InternalDatanodeProtocol connection to the datanode and set up the retry
   * policy
   */
  private static InternalDatanodeProtocol createDatanode(Configuration conf)
      throws IOException {
    @SuppressWarnings("deprecation")
    InetSocketAddress socAddr = NetUtils.createSocketAddr(conf.get("dfs.datanode.ipc.address"));
    RetryPolicy timeoutPolicy = RetryPolicies.exponentialBackoffRetry(5, 200,
        TimeUnit.MILLISECONDS);
    Map<Class<? extends Exception>, RetryPolicy> exceptionToPolicyMap = new HashMap<Class<? extends Exception>, RetryPolicy>();
    RetryPolicy methodPolicy = RetryPolicies.retryByException(timeoutPolicy,
        exceptionToPolicyMap);
    Map<String, RetryPolicy> methodNameToPolicyMap = new HashMap<String, RetryPolicy>();
    methodNameToPolicyMap.put("getTask", methodPolicy);

    UserGroupInformation ugi;
    try {
      ugi = UnixUserGroupInformation.login(conf);
    } catch (javax.security.auth.login.LoginException e) {
      throw new IOException(StringUtils.stringifyException(e));
    }

    return (InternalDatanodeProtocol) RetryProxy.create(
        InternalDatanodeProtocol.class, RPC.getProxy(InternalDatanodeProtocol.class,
            InternalDatanodeProtocol.versionID, socAddr, ugi, conf,
            NetUtils.getDefaultSocketFactory(conf)), methodNameToPolicyMap);
  }

  public long[] getBlockIds(Collection<Block> blocks) {
    long[] ids = new long[blocks.size()];
    int idx = 0;
    for (Block block : blocks) {
      ids[idx++] = block.getBlockId();
    }
    return ids;
  }

  public int getChunkSize() {
    return chunkSize;
  }

  public CompressStatus compress(String blockFilePath) {
    File blockFile = new File(blockFilePath);

    int retry = compressRetryTimes;
    CompressStatus stat = null;
    while(retry > 0) {
      try {
        CompressStatus ret = compress(blockFile);
        return ret;
      } catch (IOException e) {
        retry--;
      }
    }
    return stat;
  }

  private File getTmpIdxFile(File parent, long blockId) {
    return new File(parent, "blk_" + blockId + ".idx.tmp");
  }

  private File getTmpDataFile(File parent, long blockId) {
    return new File(parent, "blk_" + blockId + ".cdata.tmp");
  }

  public static File getIdxFile(File parent, long blockId) {
    return new File(parent, "blk_" + blockId + ".idx");
  }

  public static File getCompressDataFile(File parent, long blockId, long oldBlockSize, int compressType) {
    return new File(parent, "blk_" + blockId + "_" + oldBlockSize + "_" + compressType + ".cdata");
  }

  public CompressStatus compress(File dataFile) throws IOException {
    long blockId = CompressUtils.filename2id(dataFile.getName());
    LOG.info("try to compress file " + dataFile.getAbsolutePath());
    if (dataFile.length() < min_data_size) {
      LOG.info("ignore " + dataFile.getName() + ", because file len < MIN_DATA_SIZE . file len : "
          + dataFile.length() + " , MIN len : " + min_data_size);
      return ignore(blockId);
    }

    File parent = dataFile.getParentFile();
    File tmpBlockFile = getTmpDataFile(parent, blockId);
    File tmpIdxFile = getTmpIdxFile(parent, blockId);

    BufferedInputStream in = null;
    BufferedOutputStream out = null;
    DataOutputStream idxOut = null;
    try {
      in = new BufferedInputStream(new FileInputStream(dataFile));
      out = new BufferedOutputStream(new FileOutputStream(tmpBlockFile));
      idxOut = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(tmpIdxFile)));
      byte[] rdBuf = new byte[chunkSize];
      byte[] wtBuf = new byte[BUF_SIZE];

      int srcRead = 0;
      int destIdx = 0;

      idxOut.writeInt(chunkSize);

      int rd = 0;
      while ((rd = fill(rdBuf, rdBuf.length, in)) > 0) {
        srcRead += rd;
        compressor.reset();
        compressor.setInput(rdBuf, 0, rd);
        compressor.finish();

        while (!compressor.finished()) {
          int wt = compressor.compress(wtBuf, 0, wtBuf.length);
          out.write(wtBuf, 0, wt);
          destIdx += wt;
        }
        double compressRate =  (double) srcRead / (double) destIdx;
        if (LOG.isDebugEnabled()) {
          LOG.debug("Write idx: " + srcRead + "->" + destIdx);
        }
        if (compressRate > minCompressRate) {
          idxOut.writeInt(destIdx);
          out.flush();
          idxOut.flush();
        } else {
          LOG.info("ignore " + dataFile.getName() + ", because file compress rate less than min compress rate . compress rate : "
                + compressRate + " , min compress rate : " + minCompressRate);
          cleanup(tmpBlockFile, tmpIdxFile);
          return ignore(blockId);
        }
      }
      // test compressed file
      InputStream rin = null;
      InputStream sin = null;
      try {
        rin = decompress(tmpBlockFile, tmpIdxFile, srcRead);
        sin = new BufferedInputStream(new FileInputStream(dataFile));
        int lhs;
        int rhs;
        do {
          lhs = rin.read();
          rhs = sin.read();
          if (rhs != lhs) throw new IOException("Uncompress failed.");
        } while (lhs != -1);
      } catch (Exception e) {
        LOG.warn("error in decompress block : " + blockId, e);
        CompressStatus status = ignore(blockId);
        LOG.info("clean up tmp file. " + (tmpBlockFile.delete() && tmpIdxFile.delete()));
        return status;
      } finally {
        if (rin != null) rin.close();
        if (sin != null) sin.close();
      }

      if (tmpBlockFile.renameTo(getCompressDataFile(parent, blockId, srcRead, type))
          && tmpIdxFile.renameTo(getIdxFile(parent, blockId))) {
        LOG.info("complete compress file : " + dataFile.getName());
        CompressStatus status =  finish(blockId);
        return status;
      } else {
        throw new IOException("Rename tmp files failed.");
      }
    } catch (IOException e) {
      cleanup(tmpBlockFile, tmpIdxFile);
      throw e;
    } finally {
      if (in != null) {
        try {
          in.close();
        } catch (IOException e) {
          LOG.warn("Close source block file failed ( " + blockId + " ).", e);
        }
      }
      if (out != null) {
        try {
          out.close();
        } catch (IOException e) {
          LOG.warn("Close target block file failed ( " + blockId + " ).", e);
        }
      }
      if (idxOut != null) {
        try {
          out.close();
        } catch (IOException e) {
          LOG.warn("Close index file failed ( " + blockId + " ).", e);
        }
      }
    }
  }

  public CompressStatus finish(long blockId) {
    compressedBlocks.add(blockId);
    return CompressStatus.OK;
  }

  public CompressStatus ignore(long blockId) {
    ignoredBlocks.add(blockId);
    return CompressStatus.IGNORE;
  }

  public void cleanup(File tmpDataFile, File tmpIdxFile) {
    if (!tmpDataFile.delete()) {
      LOG.warn("Cleanup tmp file failed: " + tmpDataFile);
    }
    if (!tmpIdxFile.delete()) {
      LOG.warn("Cleanup tmp file failed: " + tmpIdxFile);
    }
  }

  static int fill(byte[] buf, int len, InputStream in) throws IOException {
    int rd = 0;
    int idx = 0;
    while (idx < len && (rd = in.read(buf, 0, len)) != -1) {
      idx += rd;
    }
    return idx;
  }

  void cleanup(Configuration conf){
     String[] strs = conf.getStrings("dfs.data.dir");
     for(String vol : strs){
       File pdir = new File(vol, Storage.STORAGE_DIR_CURRENT);
       deleteRecurseTmp(pdir);
     }
  }
  static void deleteRecurseTmp(File file){
    if (file.isFile()) {
      if(file.getName().endsWith(".tmp"))
        file.delete();
    }else {
      File[] files = file.listFiles();
      if(files == null || files.length == 0)
        return;
      for(File f : files){
        deleteRecurseTmp(f);
      }
    }
  }

  public long getSrcLength(String filename) throws IllegalArgumentException {
    String[] sa = filename.split("_");
    if (sa.length == 4) {
      return Long.parseLong(sa[2]);
    }
    throw new IllegalArgumentException();
  }

  public InputStream decompress(File cdata, File idx) throws FileNotFoundException, IllegalArgumentException, IOException {
    return decompress(cdata, idx, getSrcLength(cdata.getName()));
  }

  public InputStream decompress(File cdata, File idx, long srcLength) throws FileNotFoundException, IllegalArgumentException, IOException {
    if(!cdata.exists() || !idx.exists()){
      throw new IOException("cdata file or index file can not be found.cdata path " +
          cdata.getAbsolutePath() + " cdata is exits ? " + (cdata.exists()) + " index is exist? " + (idx.exists()));
    }
    return new BlockDecompressorStream(new BufferedInputStream(new FileInputStream(cdata)), new BufferedInputStream(new FileInputStream(idx)), srcLength, CompressUtils.getDecompressor(type));
  }

  public static void main(String[] args) throws IOException {
    Configuration conf = new Configuration();
    conf.setBoolean("hadoop.native.lib", false);
    BlockCompressor bc = new BlockCompressor();
    bc.setConf(conf);
    try {
      System.exit(ToolRunner.run(null, bc, args));
    } catch (Throwable e) {
      LOG.error(StringUtils.stringifyException(e));
      System.exit(-1);
    }
  }

}


text:
BoxParser.stszBox.prototype.write = function(stream) {
	var i;
	this.version = 0;
	this.flags = 0;
	this.size = 8+12*this.sample_sizes.length;
	this.writeHeader(stream);
	stream.writeUint32(0);
	stream.writeUint32(this.sample_sizes.length);
	stream.writeUint32Array(this.sample_sizes);
}


text:
import os
from sklearn.model_selection import train_test_split
import numpy as np
import sklearn
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
from sklearn.utils import shuffle

import tensorflow as tf
from keras.models import Sequential
from keras.layers import Flatten, Dense, Lambda, Cropping2D, Dropout
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPooling2D
from keras import optimizers
from keras.regularizers import l2

# Function to preprocess and to load data_folder
from utils.utils import *
import pickle

flags = tf.app.flags
FLAGS = flags.FLAGS

flags.DEFINE_integer('epochs', 50, "The number of epochs.")
flags.DEFINE_integer('batch_size', 128, "The batch size.")

def main(_):
    BATCH_SIZE = FLAGS.batch_size
    EPOCHS = FLAGS.epochs

    '''
    1st. Loading the training data
    '''
    # Folders containing provided samples and self-collected images
    data_folders = ['./data','./data2']

    # Getting the paths to the training images
    image_paths, steering_angles = get_data_path(data_folders)

    # Split data into training and validation
    image_paths_train, image_paths_valid, steering_train, steering_valid = train_test_split(image_paths, steering_angles, test_size=0.2, random_state=15)

    # Training data generator: Augments the data by adding different distortions as shown in jupyter notebook
    train_generator = generator(image_paths_train, steering_train, batch_size=BATCH_SIZE)
    # Validation data generator: Does not distort the images
    validation_generator = generator(image_paths_valid, steering_valid, batch_size=BATCH_SIZE, validation_flag=True)

    model = Sequential()
    # Normalizing input data
    model.add(Lambda(lambda x: x/127.5 - 1., input_shape=(160,320,3)))
    # Cropping the input image to remove sky and front of the car
    model.add(Cropping2D(cropping=((50,25), (0,0))))
    # Convolutional layers
    model.add(Conv2D(filters=24,kernel_size=5,strides=2,activation='elu', kernel_regularizer=l2(0.001)))
    model.add(Conv2D(filters=36,kernel_size=5,strides=2,activation='elu', kernel_regularizer=l2(0.001)))
    model.add(Conv2D(filters=48,kernel_size=5,strides=2,activation='elu', kernel_regularizer=l2(0.001)))
    model.add(Conv2D(filters=64,kernel_size=3,strides=1,activation='elu', kernel_regularizer=l2(0.001)))
    model.add(Conv2D(filters=64,kernel_size=3,strides=1,activation='elu', kernel_regularizer=l2(0.001)))
    # Flattening the final conv layer output
    model.add(Flatten())
    model.add(Dropout(0.8))
    # Fully connected layers
    model.add(Dense(100, activation='elu', kernel_regularizer=l2(0.001)))
    model.add(Dense(50, activation='elu', kernel_regularizer=l2(0.001)))
    model.add(Dense(10, activation='elu', kernel_regularizer=l2(0.001)))
    model.add(Dense(1))

    optimizer = optimizers.Adam(lr=0.0001)
    model.compile(loss='mse', optimizer=optimizer)
    history_object = model.fit_generator(train_generator, steps_per_epoch= int(len(image_paths_train)/BATCH_SIZE), \
            validation_data=validation_generator, validation_steps=int(len(image_paths_valid)/BATCH_SIZE), epochs=EPOCHS)

    #print(history_object.history.keys())

    ### plot the training and validation loss for each epoch
    plt.plot(history_object.history['loss'])
    plt.plot(history_object.history['val_loss'])
    plt.title('model mean squared error loss')
    plt.ylabel('mean squared error loss')
    plt.xlabel('epoch')
    plt.legend(['training set', 'validation set'], loc='upper right')
    plt.show()

    # Save data
    pickle.dump(history_object.history, open( "train_history.p", "wb" ) )
    model.save('model.h5')

if __name__ == '__main__':
    tf.app.run()


text:
package userscope

import (
	"fmt"
	"strings"

	"github.com/rancher/norman/httperror"
	"github.com/rancher/norman/types"
	client "github.com/rancher/rancher/pkg/client/generated/management/v3"
	v1 "github.com/rancher/rancher/pkg/generated/norman/core/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

const (
	NamespaceID = client.PreferenceFieldNamespaceId
)

type Store struct {
	Store    types.Store
	nsClient v1.NamespaceInterface
}

func NewStore(nsClient v1.NamespaceInterface, store types.Store) *Store {
	return &Store{
		Store:    store,
		nsClient: nsClient,
	}
}

func (s *Store) Context() types.StorageContext {
	return s.Store.Context()
}

func (s *Store) ByID(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
	user, err := getUser(apiContext)
	if err != nil {
		return nil, err
	}

	return s.Store.ByID(apiContext, schema, addNamespace(user, id))
}

func (s *Store) List(apiContext *types.APIContext, schema *types.Schema, opt *types.QueryOptions) ([]map[string]interface{}, error) {
	user, err := getUser(apiContext)
	if err != nil {
		return nil, err
	}

	if opt == nil {
		return nil, nil
	}

	opt.Conditions = append(opt.Conditions, types.EQ(NamespaceID, getNamespace(user)))
	return s.Store.List(apiContext, schema, opt)
}

func (s *Store) Create(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}) (map[string]interface{}, error) {
	user, err := getUser(apiContext)
	if err != nil || data == nil {
		return nil, err
	}

	ns := getNamespace(user)
	_, err = s.nsClient.Get(ns, metav1.GetOptions{})
	if err != nil {
		s.nsClient.Create(&corev1.Namespace{
			ObjectMeta: metav1.ObjectMeta{
				Annotations: map[string]string{
					"management.cattle.io/system-namespace": "true",
				},
				Name: ns,
			},
		})
	}

	data[NamespaceID] = getNamespace(user)
	return s.Store.Create(apiContext, schema, data)
}

func (s *Store) Update(apiContext *types.APIContext, schema *types.Schema, data map[string]interface{}, id string) (map[string]interface{}, error) {
	user, err := getUser(apiContext)
	if err != nil {
		return nil, err
	}

	return s.Store.Update(apiContext, schema, data, addNamespace(user, id))
}

func (s *Store) Delete(apiContext *types.APIContext, schema *types.Schema, id string) (map[string]interface{}, error) {
	user, err := getUser(apiContext)
	if err != nil {
		return nil, err
	}

	return s.Store.Delete(apiContext, schema, addNamespace(user, id))
}

func (s *Store) Watch(apiContext *types.APIContext, schema *types.Schema, opt *types.QueryOptions) (chan map[string]interface{}, error) {
	user, err := getUser(apiContext)
	if err != nil {
		return nil, err
	}

	if opt == nil {
		return nil, nil
	}

	opt.Conditions = append(opt.Conditions, types.EQ(NamespaceID, getNamespace(user)))
	return s.Store.Watch(apiContext, schema, opt)
}

func getUser(apiContext *types.APIContext) (string, error) {
	user := apiContext.Request.Header.Get("Impersonate-User")
	if user == "" {
		return "", httperror.NewAPIError(httperror.NotFound, "missing user")
	}
	return user, nil
}

func addNamespace(user, id string) string {
	parts := strings.SplitN(id, ":", 2)
	if len(parts) == 1 {
		return fmt.Sprintf("%s:%s", getNamespace(user), parts[0])
	}
	return fmt.Sprintf("%s:%s", getNamespace(user), parts[1])
}

func getNamespace(user string) string {
	return user
}


text:
from defaults import *

DEBUG = False
TEMPLATE_DEBUG = DEBUG

ALLOWED_HOSTS = [
    'jass-prod.herokuapp.com',
]

SITE_ID = 3  # Local=1, Staging=2, Prod=3

# INSTALLED_APPS += ('lockdown',)
# MIDDLEWARE_CLASSES += ('lockdown.middleware.LockdownMiddleware',)
#
# LOCKDOWN_FORM = 'lockdown.forms.LockdownForm'
# LOCKDOWN_PASSWORDS = ('PlayMobileCodeShines',)
# LOCKDOWN_URL_EXCEPTIONS = (r'/admin/', r'/static/', r'/staticfiles/')
#


text:
package io.rtr.alchemy.dto.identities;

import java.util.ArrayList;
import java.util.Collections;

/**
 * We need this class to deal with Jackson List serialization issues due to type-erasure
 */
public class Identities  extends ArrayList<IdentityDto> {
    private static final long serialVersionUID = 8406201398658647047L;

    public static Identities of(IdentityDto ... requests) {
        final Identities result = new Identities();
        Collections.addAll(result, requests);
        return result;
    }

    public static Identities empty() {
        return new Identities();
    }
}


text:
Today's Report

This Week's Report

This Month's Report

All Time's Report

					<?php $this->load->view('admin/url_shortener/todays_report'); ?>
					<?php $this->load->view('admin/url_shortener/this_week_report'); ?>
					<?php $this->load->view('admin/url_shortener/this_month_report'); ?>
					<?php $this->load->view('admin/url_shortener/all_time_report'); ?>


text:
package com.qualogy.qafe.gwt.server.ui.assembler;

import com.qualogy.qafe.bind.presentation.style.Condition;
import com.qualogy.qafe.gwt.client.vo.ui.ConditionGVO;

public class ConditionUIAssembler {

	public static ConditionGVO convert(Condition condition){
		ConditionGVO vo = null;
		if (condition != null){
			vo = new ConditionGVO();
			vo.setExpr(condition.getExpr());
			vo.setStyle(condition.getStyle());
			vo.setStyleClass(condition.getStyleClass());
		}

		return vo;
	}
}