text:
#include <asf.h>
#include <string.h>
#include <stdio.h>
#include "atca_hal.h"
#include "hal_sam4s_i2c_asf.h"
#include "atca_device.h"
#include "atca_execution.h"

//!< Uncomment when debugging
/*#define DEBUG_HAL*/

/**
 * \defgroup hal_ Hardware abstraction layer (hal_)
 *
 * \brief
 * These methods define the hardware abstraction layer for communicating with a CryptoAuth device
 * using I2C driver of ASF.
 *
   @{ */

/**
 * \brief
 * Logical to physical bus mapping structure
 */
static ATCAI2CMaster_t i2c_hal_data[MAX_I2C_BUSES];   // map logical, 0-based bus number to index
static twi_master_options_t opt_twi_master;

#ifdef DEBUG_HAL
static void print_array(uint8_t *data, uint32_t data_size)
{
    uint32_t n;

    for (n = 0; n < data_size; n++)
    {
        printf("%.2x ", data[n]);
        if (((n + 1) % 16) == 0)
        {
            printf("\r\n");
            if ((n + 1) != data_size)
            {
                printf("         ");
            }
        }
    }
    if (data_size % 16 != 0)
    {
        printf("\r\n");
    }
}
#endif

/**
 * \brief
 * This HAL implementation assumes you've included the ASF TWI libraries in your project, otherwise,
 * the HAL layer will not compile because the ASF TWI drivers are a dependency
 */

/** \brief discover i2c buses available for this hardware
 * this maintains a list of logical to physical bus mappings freeing the application
 * of the a-priori knowledge
 * \param[in] i2c_buses - an array of logical bus numbers
 * \param[in] max_buses - maximum number of buses the app wants to attempt to discover
 * \return ATCA_SUCCESS
 */

ATCA_STATUS hal_i2c_discover_buses(int i2c_buses[], int max_buses)
{
    /* logical bus numbers 0-2 map to the SAM4S i2c buses:
       ID_TWI0
       ID_TWI1

        TWS0 bus will respond on the SAM4S Xplained Pro board

     */

    i2c_buses[0] = 0;
#if MAX_I2C_BUSES == 2
    i2c_buses[1] = -1;
#endif
    return ATCA_SUCCESS;

}

/** \brief discover any CryptoAuth devices on a given logical bus number
 * \param[in] bus_num - logical bus number on which to look for CryptoAuth devices
 * \param[out] cfg[] - pointer to head of an array of interface config structures which get filled in by this method
 * \param[out] *found - number of devices found on this bus
 * \return ATCA_SUCCESS
 */

ATCA_STATUS hal_i2c_discover_devices(int bus_num, ATCAIfaceCfg cfg[], int *found)
{
    ATCAIfaceCfg *head = cfg;
    uint8_t slaveAddress = 0x01;
    ATCADevice device;

#ifdef ATCA_NO_HEAP
    struct atca_device disc_device;
    struct atca_command disc_command;
    struct atca_iface disc_iface;
#endif
    ATCAPacket packet;
    ATCA_STATUS status;
    uint8_t revs608[][4] = { { 0x00, 0x00, 0x60, 0x01 }, { 0x00, 0x00, 0x60, 0x02 } };
    uint8_t revs508[][4] = { { 0x00, 0x00, 0x50, 0x00 } };
    uint8_t revs108[][4] = { { 0x80, 0x00, 0x10, 0x01 } };
    uint8_t revs204[][4] = { { 0x00, 0x02, 0x00, 0x08 }, { 0x00, 0x02, 0x00, 0x09 }, { 0x00, 0x04, 0x05, 0x00 } };
    int i;

    /** \brief default configuration, to be reused during discovery process */
    ATCAIfaceCfg discoverCfg = {
        .iface_type             = ATCA_I2C_IFACE,
        .devtype                = ATECC508A,
        .atcai2c.slave_address  = 0x07,
        .atcai2c.bus            = bus_num,
        .atcai2c.baud           = 400000,
        .wake_delay             = 800,
        .rx_retries             = 3
    };

    if (bus_num < 0)
    {
        return ATCA_COMM_FAIL;
    }

#ifdef ATCA_NO_HEAP
    disc_device.mCommands = &disc_command;
    disc_device.mIface    = &disc_iface;
    status = initATCADevice(&discoverCfg, &disc_device);
    if (status != ATCA_SUCCESS)
    {
        return status;
    }
    device = &disc_device;
#else
    device = newATCADevice(&discoverCfg);
    if (device == NULL)
    {
        return ATCA_COMM_FAIL;
    }
#endif

    // iterate through all addresses on given i2c bus
    // all valid 7-bit addresses go from 0x07 to 0x78
    for (slaveAddress = 0x07; slaveAddress <= 0x78; slaveAddress++)
    {
        discoverCfg.atcai2c.slave_address = slaveAddress << 1;  // turn it into an 8-bit address which is what the rest of the i2c HAL is expecting when a packet is sent

        memset(packet.data, 0x00, sizeof(packet.data));
        // build an info command
        packet.param1 = INFO_MODE_REVISION;
        packet.param2 = 0;
        // get devrev info and set device type accordingly
        atInfo(device->mCommands, &packet);
        if ((status = atca_execute_command(&packet, device)) != ATCA_SUCCESS)
        {
            continue;
        }

        // determine device type from common info and dev rev response byte strings... start with unknown
        discoverCfg.devtype = ATCA_DEV_UNKNOWN;
        for (i = 0; i < (int)sizeof(revs608) / 4; i++)
        {
            if (memcmp(&packet.data[1], &revs608[i], 4) == 0)
            {
                discoverCfg.devtype = ATECC608A;
                break;
            }
        }

        for (i = 0; i < (int)sizeof(revs508) / 4; i++)
        {
            if (memcmp(&packet.data[1], &revs508[i], 4) == 0)
            {
                discoverCfg.devtype = ATECC508A;
                break;
            }
        }

        for (i = 0; i < (int)sizeof(revs204) / 4; i++)
        {
            if (memcmp(&packet.data[1], &revs204[i], 4) == 0)
            {
                discoverCfg.devtype = ATSHA204A;
                break;
            }
        }

        for (i = 0; i < (int)sizeof(revs108) / 4; i++)
        {
            if (memcmp(&packet.data[1], &revs108[i], 4) == 0)
            {
                discoverCfg.devtype = ATECC108A;
                break;
            }
        }

        if (discoverCfg.devtype != ATCA_DEV_UNKNOWN)
        {
            // now the device type is known, so update the caller's cfg array element with it
            (*found)++;
            memcpy( (uint8_t*)head, (uint8_t*)&discoverCfg, sizeof(ATCAIfaceCfg));
            head->devtype = discoverCfg.devtype;
            head++;
        }

        atca_delay_ms(15);
    }

#ifdef ATCA_NO_HEAP
    releaseATCADevice(device);
#else
    deleteATCADevice(&device);
#endif

    return ATCA_SUCCESS;
}

/**
 * \brief
 * hal_i2c_init manages requests to initialize a physical interface. It manages use counts so when an interface
 * has released the physical layer, it will disable the interface for some other use.
 * You can have multiple ATCAIFace instances using the same bus, and you can have multiple ATCAIFace instances on
 * multiple i2c buses, so hal_i2c_init manages these things and ATCAIFace is abstracted from the physical details.
 */

/**
 * \brief initialize an I2C interface using given config
 *
 * \param[in] hal - opaque ptr to HAL data
 * \param[in] cfg - interface configuration
 *
 * \return ATCA_SUCCESS on success, otherwise an error code.
 */
ATCA_STATUS hal_i2c_init(void *hal, ATCAIfaceCfg *cfg)
{
    if (cfg->atcai2c.bus >= MAX_I2C_BUSES)
    {
        return ATCA_COMM_FAIL;
    }
    ATCAI2CMaster_t* data = &i2c_hal_data[cfg->atcai2c.bus];

    if (data->ref_ct <= 0)
    {
        // Bus isn't being used, enable it
        switch (cfg->atcai2c.bus)
        {
        case 0:
            data->twi_id = ID_TWI0;
            data->twi_master_instance = TWI0;
            break;
        case 1:
            data->twi_id = ID_TWI1;
            data->twi_master_instance = TWI1;
            // configure TWI1 pins
            gpio_configure_pin(PIO_PB4_IDX, (PIO_PERIPH_A | PIO_PULLUP));
            gpio_configure_pin(PIO_PB5_IDX, (PIO_PERIPH_A | PIO_PULLUP));
            // disable JTAG
            MATRIX->CCFG_SYSIO |= (1 << 4) | (1 << 5);
            break;
        default:
            return ATCA_COMM_FAIL;
        }

        pmc_enable_periph_clk(data->twi_id);
        opt_twi_master.master_clk = sysclk_get_cpu_hz();
        opt_twi_master.speed = cfg->atcai2c.baud;
        opt_twi_master.smbus = 0;
        twi_master_init(data->twi_master_instance, &opt_twi_master);

        // store this for use during the release phase
        data->bus_index = cfg->atcai2c.bus;
        // buses are shared, this is the first instance
        data->ref_ct = 1;
    }
    else
    {
        // Bus is already is use, increment reference counter
        data->ref_ct++;
    }

    ((ATCAHAL_t*)hal)->hal_data = data;

    return ATCA_SUCCESS;
}

/**
 * \brief HAL implementation of I2C post init
 *
 * \param[in] iface  instance
 *
 * \return ATCA_SUCCESS
 */
ATCA_STATUS hal_i2c_post_init(ATCAIface iface)
{
    return ATCA_SUCCESS;
}

/**
 * \brief HAL implementation of I2C send over ASF
 *
 * \param[in] iface     instance
 * \param[in] txdata    pointer to space to bytes to send
 * \param[in] txlength  number of bytes to send
 *
 * \return ATCA_SUCCESS on success, otherwise an error code.
 */
ATCA_STATUS hal_i2c_send(ATCAIface iface, uint8_t *txdata, int txlength)
{
#ifdef DEBUG_HAL
    printf("hal_i2c_send()\r\n");

    printf("\r\nCommand Packet (size:0x%.8x)\r\n", (uint32_t)txlength);
    printf("Count  : %.2x\r\n", txdata[1]);
    printf("Opcode : %.2x\r\n", txdata[2]);
    printf("Param1 : %.2x\r\n", txdata[3]);
    printf("Param2 : "); print_array(&txdata[4], 2);
    if (txdata[1] > 7)
    {
        printf("Data   : "); print_array(&txdata[6], txdata[1] - 7);
    }
    printf("CRC    : "); print_array(&txdata[txdata[1] - 1], 2);
    printf("\r\n");
#endif

    ATCAIfaceCfg *cfg = atgetifacecfg(iface);

    txdata[0] = 0x03;   // insert the Word Address Value, Command token
    txlength++;         // account for word address value byte.

    twi_package_t packet = {
        .chip           = cfg->atcai2c.slave_address >> 1,
        .addr           = { 0 },
        .addr_length    = 0,
        .buffer         = (void*)txdata,
        .length         = (uint32_t)txlength //(uint32_t)txdata[1]
    };

    // for this implementation of I2C with CryptoAuth chips, txdata is assumed to have ATCAPacket format

    // other device types that don't require i/o tokens on the front end of a command need a different
    // hal_i2c_send and wire it up instead of this one
    //this covers devices such as ATSHA204A and ATECCx08A that require a word address value pre-pended to the packet
    if (twi_master_write(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, &packet) != TWI_SUCCESS)
    {
        return ATCA_COMM_FAIL;
    }

    return ATCA_SUCCESS;
}

/**
 * \brief HAL implementation of I2C receive function for ASF I2C
 * \param[in]    iface     Device to interact with.
 * \param[out]   rxdata    Data received will be returned here.
 * \param[inout] rxlength  As input, the size of the rxdata buffer.
 *                         As output, the number of bytes received.
 * \return ATCA_SUCCESS on success, otherwise an error code.
 */
ATCA_STATUS hal_i2c_receive(ATCAIface iface, uint8_t *rxdata, uint16_t *rxlength)
{
#ifdef DEBUG_HAL
    printf("hal_i2c_receive()\r\n");
#endif

    ATCAIfaceCfg *cfg = atgetifacecfg(iface);
    int retries = cfg->rx_retries;
    uint32_t status = !ATCA_SUCCESS;
    uint16_t rxdata_max_size = *rxlength;

    twi_package_t packet = {
        .chip           = cfg->atcai2c.slave_address >> 1,
        .addr           = { 0 },
        .addr_length    = 0,
        .buffer         = (void*)rxdata,
        .length         = (uint32_t)1
    };

    *rxlength = 0;
    if (rxdata_max_size < 1)
    {
        return ATCA_SMALL_BUFFER;
    }

    while (retries-- > 0 && status != ATCA_SUCCESS)
    {
        if (twi_master_read(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, &packet) != TWI_SUCCESS)
        {
            status = ATCA_COMM_FAIL;
        }
        else
        {
            status = ATCA_SUCCESS;
        }
    }

    if (status != ATCA_SUCCESS)
    {
        return status;
    }
    if (rxdata[0] < ATCA_RSP_SIZE_MIN)
    {
        return ATCA_INVALID_SIZE;
    }
    if (rxdata[0] > rxdata_max_size)
    {
        return ATCA_SMALL_BUFFER;
    }

    //Update receive length with first byte received and set to read rest of the data
    packet.length = rxdata[0] - 1;
    packet.buffer = &rxdata[1];

    if (twi_master_read(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, &packet) != TWI_SUCCESS)
    {
        status = ATCA_COMM_FAIL;
    }
    else
    {
        status = ATCA_SUCCESS;
    }
    if (status != ATCA_SUCCESS)
    {
        return status;
    }

    *rxlength = rxdata[0];

#ifdef DEBUG_HAL
    printf("\r\nResponse Packet (size:0x%.4x)\r\n", rxlength);
    printf("Count  : %.2x\r\n", rxdata[0]);
    if (rxdata[0] > 3)
    {
        printf("Data   : "); print_array(&rxdata[1], rxdata[0] - 3);
        printf("CRC    : "); print_array(&rxdata[rxdata[0] - 2], 2);
    }
    printf("\r\n");
#endif

    return ATCA_SUCCESS;
}

/**
 * \brief method to change the bus speed of I2C
 *
 * \param[in] iface  interface on which to change bus speed
 * \param[in] speed  baud rate (typically 100000 or 400000)
 */
void change_i2c_speed(ATCAIface iface, uint32_t speed)
{
    ATCAIfaceCfg *cfg = atgetifacecfg(iface);

    pmc_enable_periph_clk(i2c_hal_data[cfg->atcai2c.bus].twi_id);
    opt_twi_master.master_clk = sysclk_get_cpu_hz();
    opt_twi_master.speed      = speed;
    opt_twi_master.smbus      = 0;
    twi_master_init(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, &opt_twi_master);
}

/**
 * \brief wake up CryptoAuth device using I2C bus
 *
 * \param[in] iface  interface to logical device to wakeup
 *
 * \return ATCA_SUCCESS on success, otherwise an error code.
 */
ATCA_STATUS hal_i2c_wake(ATCAIface iface)
{
    ATCAIfaceCfg *cfg = atgetifacecfg(iface);
    int retries = cfg->rx_retries;
    uint32_t bdrt = cfg->atcai2c.baud;
    int status = !TWI_SUCCESS;
    uint8_t data[4];

    // if not already at 100kHz, change it
    if (bdrt != 100000)
    {
        change_i2c_speed(iface, 100000);
    }

    // Send 0x00 as wake pulse
    twi_write_byte(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, 0x00);

    // rounded up to the nearest ms
    atca_delay_ms(((uint32_t)cfg->wake_delay + (1000 - 1)) / 1000);   // wait tWHI + tWLO which is configured based on device type and configuration structure

    twi_package_t packet = {
        .chip           = cfg->atcai2c.slave_address >> 1,
        .addr           = { 0 },
        .addr_length    = 0,
        .buffer         = (void*)data,
        .length         = 4
    };

    // if necessary, revert baud rate to what came in.
    if (bdrt != 100000)
    {
        change_i2c_speed(iface, bdrt);
    }

    while (retries-- > 0 && status != TWI_SUCCESS)
    {
        status = twi_master_read(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, &packet);
    }
    if (status != TWI_SUCCESS)
    {
        return ATCA_COMM_FAIL;
    }

    return hal_check_wake(data, 4);
}

/**
 * \brief idle CryptoAuth device using I2C bus
 *
 * \param[in] iface  interface to logical device to idle
 *
 * \return ATCA_SUCCESS on success, otherwise an error code.
 */
ATCA_STATUS hal_i2c_idle(ATCAIface iface)
{
    ATCAIfaceCfg *cfg = atgetifacecfg(iface);
    uint8_t data[4];

    data[0] = 0x02; // idle word address value
    twi_package_t packet = {
        .chip           = cfg->atcai2c.slave_address >> 1,
        .addr           = { 0 },
        .addr_length    = 0,
        .buffer         = (void*)data,
        .length         = 1
    };

    if (twi_master_write(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, &packet) != TWI_SUCCESS)
    {
        return ATCA_COMM_FAIL;
    }

    return ATCA_SUCCESS;
}

/**
 * \brief sleep CryptoAuth device using I2C bus
 *
 * \param[in] iface  interface to logical device to sleep
 *
 * \return ATCA_SUCCESS on success, otherwise an error code.
 */
ATCA_STATUS hal_i2c_sleep(ATCAIface iface)
{
    ATCAIfaceCfg *cfg = atgetifacecfg(iface);
    uint8_t data[4];

    data[0] = 0x01; // sleep word address value
    twi_package_t packet = {
        .chip           = cfg->atcai2c.slave_address >> 1,
        .addr           = { 0 },
        .addr_length    = 0,
        .buffer         = (void*)data,
        .length         = 1
    };

    if (twi_master_write(i2c_hal_data[cfg->atcai2c.bus].twi_master_instance, &packet) != TWI_SUCCESS)
    {
        return ATCA_COMM_FAIL;
    }

    return ATCA_SUCCESS;
}

/**
 * \brief manages reference count on given bus and releases resource if no more refences exist
 *
 * \param[in] hal_data - opaque pointer to hal data structure - known only to the HAL implementation
 *
 * \return ATCA_SUCCESS
 */
ATCA_STATUS hal_i2c_release(void *hal_data)
{
    ATCAI2CMaster_t *hal = (ATCAI2CMaster_t*)hal_data;

    // if the use count for this bus has gone to 0 references, disable it.  protect against an unbracketed release
    if (hal && --(hal->ref_ct) <= 0)
    {
        twi_reset(hal->twi_master_instance);
        hal->ref_ct = 0;
    }

    return ATCA_SUCCESS;
}

/** @} */


text:
author: steph_kim
excerpt: "Guides to hosting a model using your favorite library."
layout: article_page
nav_overview: "Supported Frameworks"
nav_index: 0
permalink: /model-deployment/
redirect_from:
  - /algorithm-development/model-guides/
show_related: false
title:  Deploy Your Model
---

Here you'll find guides for hosting your machine or deep learning model. The frameworks featured below are all commonly used in machine and deep learning, but they aren't meant to constrain you; if you want to write your own model in the language of your choice using a framework that isn't listed, that's an option as well. We currently support algorithms written in Java, Python, Rust, Ruby, R, JavaScript, and Scala—check out our Algorithm Development Guides to learn more.

You can also consume algorithms in external applications using one of our clients, which are available in over 15 languages. If you haven't yet visited any of our Client Guides, be sure to go over the tutorial in whatever language you're working.

After you learn how to call algorithms, check out our Data API and the Data Connectors we support to understand how to work with data and files.

Pick any framework listed below for a customized guide, or start with our Scikit-Learn guide, which includes a hands-on video.

Also note that our [API]({{site.baseurl}}/algorithm-development/algorithm-management) can be used to deploy and redeploy your model via Python scripts, [Jupyter Notebooks](https://github.com/algorithmiaio/model-deployment/), or [CI/CD tools such as Jenkins or GitHub Actions]({{site.baseurl}}/algorithm-development/ci-cd)).

If you have any questions about Algorithmia or hosting your model on the Algorithmia platform please get in touch!

### Supported Machine and Deep Learning Frameworks
{% assign model_tags = "algo-model-guide" | split:"|" %}

  {% assign pages = site.pages | where: "categories", "model-guides" | sort:"title" %}
  {% for post in pages %}
		{% include post-grid.html %}
  {% endfor %}

To see the dependencies included in each environment, see the matrix in [Environments]({{ site.baseurl }}/model-deployment/environments/).

redpajama_set_name: RedPajamaGithub


text:
package vu

// react is a means of linking user key sequences to code that updates state.
// Applications can bind reactions to pressed key sequences.
// FUTURE: Move from engine to application? Not a lot of value add.

import (
	"time"
)

// Reaction links an application callback to a given user pressed key sequence.
// The "Do" reaction is triggered when the user pressed key sequence matches
// the reaction id.
type Reaction interface {
	Name() string    // Unique reaction identifier i.e. "moveUp".
	Do()             // Application action handler.
	Time() time.Time // Last time this reaction was triggered.
	SetTime()        // Updates Time.
}

// Reaction interface
// ===========================================================================
// reaction - Reaction implementation

// NewReaction creates a Reaction.
func NewReaction(name string, do func()) Reaction {
	return &reaction{name, do, time.Now()}
}

// reaction implements Reaction.
type reaction struct {
	name string
	do   func()
	last time.Time // last time a command key was pressed.
}

// Reaction interface implementation.
func (r *reaction) Name() string    { return r.name }
func (r *reaction) Time() time.Time { return r.last }
func (r *reaction) SetTime()        {}
func (r *reaction) Do() {
	r.last = time.Now()
	r.do()
}

// reaction
// ===========================================================================
// reactOnce

// NewReactOnce (metered reaction) wraps a Reaction with a hold off timer so that
// the reaction is performed every so often and not every event loop.
//
// This is because key and mouse events are processed many times a
// second and even a quick key press will generate multiple user pressed key
// sequences.  This works great for movement, but some actions need to be gated
// to ensure they are not spammed.
func NewReactOnce(name string, do func()) Reaction {
	ro := &reactOnce{}
	ro.name = name
	ro.do = do
	ro.last = time.Now()
	ro.holdoff, _ = time.ParseDuration("500ms")
	return ro
}

// reactOnce implements Reaction.
type reactOnce struct {
	reaction
	holdoff time.Duration // time in milliseconds before next command key
}

// Reaction interface implementation.
func (ro *reactOnce) SetTime() { ro.last = time.Now() }
func (ro *reactOnce) Do() {
	if time.Now().After(ro.last.Add(ro.holdoff)) {
		ro.last = time.Now()
		ro.do()
	}
}


text:
<?php
/**
 * Created by JetBrains PhpStorm.
 * User: daviddjian
 * Date: 31/07/13
 * Time: 19:20
 * To change this template use File | Settings | File Templates.
 */

namespace SmtpValidatorEmail;

use SmtpValidatorEmail\Helper\ValidationHelper;
use SmtpValidatorEmail\Helper\ValidatorInitHelper;
use SmtpValidatorEmail\Service\StatusManager;

/**
 * Class ValidatorEmail
 * @package SmtpValidatorEmail
 */
class ValidatorEmail extends ValidatorInitHelper
{
    /**
     * @var StatusManager;
     */
    private $statManager;

    /**
     * Constructs the validator
     *
     * @param array|string $emails
     * @param string $sender
     * @param array $options
     *
     * possible options :
     *
     *      'domainMoreInfo' (bool) for have more information on domains of users.
     *      'delaySleep' is an array of delay(s) possible after connected Server to send the request SMTP.
     *      'catchAllIsValid' (int) can be 0 for false or 1 for true . Are 'catch-all' accounts considered valid or not?
     *      'catchAllEnabled' (int) 0 off 1 on enables catchAll test , may take more time
     *      'sameDomainLimit' (int) how many users are allowed a same domain , if limit reached , dynamic timeout will enabled
     *      'noCommIsValid' Being unable to communicate with the remote MTA could mean an address
     *                      is invalid, but it might not, depending on your use case, set the
     *                      value appropriately.
     */
    public function __construct($emails = array(), $sender, $options = array())
    {
        $this->statManager = new StatusManager();
        $this->init($emails,$sender,$options);
    }

    /**
     * Returns results
     * @return array
     */
    public function getResults()
    {
        if(!$this->statManager->checkStatus()){
            $this->runValidation($this->options);
        }
        return $this->statManager->getStatus();
    }

    /**
     * @param $options array
     * @throws Exception\ExceptionNoHelo
     * @throws Exception\ExceptionNoMailFrom
     * @throws Exception\ExceptionNoTimeout
     */
    private function runValidation($options){

        // The foreach fires for each email in array
        foreach ($this->domains as $domain => $users) {

            //TODO:Start validiation
            $count = count($options['delaySleep']);
            $i = 0;
            $loopStop = 0;
            while ($i < $count && $loopStop != 1) {
                $validator = new ValidationHelper(
                    $this->statManager,
                    $users,
                    $this->options,
                    array("fromDomain" => $this->fromDomain, "fromUser" => $this->fromUser),
                    $domain
                );

                $validator->startValidation($domain,$users);
                $validator->establishConnection();

                $transport = $validator->getTransport();
                $smtp = $transport->getSmtp();
                // are we connected?
                if ($smtp->isConnect()) {
                    sleep($options['delaySleep'][$i]);

                    // say helo, and continue if we can talk
                    if ($smtp->helo()) {

                        // try issuing MAIL FROM
                        $validator->mailFrom($this->fromUser,$this->fromDomain);

                        /**
                         * if we're still connected, proceed (cause we might get
                         * disconnected, or banned, or greylisted temporarily etc.)
                         * see mail() for more
                         */
                        if ( $smtp->isConnect()) {

                            $transport->getSmtp()->noop();

                            if( $validator->catchAll() ){
                                $loopStop = 1;
                                continue;
                            }

                            // if we're still connected, try issuing rcpts
                            if ($smtp->isConnect()) {
                                $loopStop = $validator->rcptEachUser($this->fromUser,$this->fromDomain) || 0;
                            }
                            // saying buh-bye if we're still connected, cause we're done here
                            $validator->closeConnection();
                        }

                    } else {
                        // we didn't get a good response to helo and should be disconnected already
                        $this->statManager->setStatus($users, $validator->getDom(), $options['noCommIsValid'],'bad response on helo');
                    }
                } else {
                    $this->statManager->setStatus($users, $validator->getDom(), 0,'no connection');
                }
                //TODO: Finish method;
                $validator->getDomainInfo();
                $i++;
            }
        }
    }
}


text:
package com.gmail.mararok.igui.event.mouse;

public class MouseUpEvent extends MouseButtonEvent {
	public MouseUpEvent(long time, int x, int y, MouseButton button) {
		super(time,x,y,button);
	}
}


text:
package org.apache.flink.orc.writer;

import org.apache.flink.annotation.PublicEvolving;
import org.apache.flink.annotation.VisibleForTesting;
import org.apache.flink.api.common.serialization.BulkWriter;
import org.apache.flink.core.fs.FSDataOutputStream;
import org.apache.flink.orc.vector.Vectorizer;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.orc.OrcFile;
import org.apache.orc.impl.WriterImpl;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.UUID;

import static org.apache.flink.util.Preconditions.checkNotNull;

/**
 * A factory that creates an ORC {@link BulkWriter}. The factory takes a user
 * supplied {@link Vectorizer} implementation to convert the element into an
 * {@link org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch}.
 *
 * @param <T> The type of element to write.
 */
@PublicEvolving
public class OrcBulkWriterFactory<T> implements BulkWriter.Factory<T> {

	private final Vectorizer<T> vectorizer;
	private final Properties writerProperties;
	private final Map<String, String> confMap;

	private OrcFile.WriterOptions writerOptions;

	/**
	 * Creates a new OrcBulkWriterFactory using the provided Vectorizer
	 * implementation.
	 *
	 * @param vectorizer The vectorizer implementation to convert input
	 *                   record to a VectorizerRowBatch.
	 */
	public OrcBulkWriterFactory(Vectorizer<T> vectorizer) {
		this(vectorizer, new Configuration());
	}

	/**
	 * Creates a new OrcBulkWriterFactory using the provided Vectorizer, Hadoop
	 * Configuration.
	 *
	 * @param vectorizer The vectorizer implementation to convert input
	 *                   record to a VectorizerRowBatch.
	 */
	public OrcBulkWriterFactory(Vectorizer<T> vectorizer, Configuration configuration) {
		this(vectorizer, null, configuration);
	}

	/**
	 * Creates a new OrcBulkWriterFactory using the provided Vectorizer, Hadoop
	 * Configuration, ORC writer properties.
	 *
	 * @param vectorizer 		The vectorizer implementation to convert input
	 *                          record to a VectorizerRowBatch.
	 * @param writerProperties  Properties that can be used in ORC WriterOptions.
	 */
	public OrcBulkWriterFactory(Vectorizer<T> vectorizer, Properties writerProperties, Configuration configuration) {
		this.vectorizer = checkNotNull(vectorizer);
		this.writerProperties = writerProperties;
		this.confMap = new HashMap<>();

		// Todo: Replace the Map based approach with a better approach
		for (Map.Entry<String, String> entry : configuration) {
			confMap.put(entry.getKey(), entry.getValue());
		}
	}

	@Override
	public BulkWriter<T> create(FSDataOutputStream out) throws IOException {
		OrcFile.WriterOptions opts = getWriterOptions();
		opts.physicalWriter(new PhysicalWriterImpl(out, opts));

		// The path of the Writer is not used to indicate the destination file
		// in this case since we have used a dedicated physical writer to write
		// to the give output stream directly. However, the path would be used as
		// the key of writer in the ORC memory manager, thus we need to make it unique.
		Path unusedPath = new Path(UUID.randomUUID().toString());
		return new OrcBulkWriter<>(vectorizer, new WriterImpl(null, unusedPath, opts));
	}

	@VisibleForTesting
	protected OrcFile.WriterOptions getWriterOptions() {
		if (null == writerOptions) {
			Configuration conf = new ThreadLocalClassLoaderConfiguration();
			for (Map.Entry<String, String> entry : confMap.entrySet()) {
				conf.set(entry.getKey(), entry.getValue());
			}

			writerOptions = OrcFile.writerOptions(writerProperties, conf);
			writerOptions.setSchema(this.vectorizer.getSchema());
		}

		return writerOptions;
	}
}


text:
layout: post
title: Welcome
---

Please find all the details here on our SEPR project. We will update this page frequently with our current progress on our project.
For Assessment 3 we have took over [Duck Related Team Name's](https://jm179796.github.io/SEPR/) assessment 2.
For Assessment 4 have chosen to take on [Team Fractal's](https://teamfractal.github.io) assessment 3. We have then implemented the final requirements and finished the game.


text:
package com.shaunchurch.androidpickings.ui.hello;

import javax.inject.Inject;

public class HelloPresenterImpl implements HelloPresenter {

    private final HelloView view;
    private final HelloSupplier messageSupplier;

    @Inject
    public HelloPresenterImpl(HelloView view, HelloSupplier messageSupplier) {
        this.view = view;
        this.messageSupplier = messageSupplier;
    }

    @Override
    public void requestMessage() {
        view.onMessageUpdated(messageSupplier.getMessage());
    }
}


text:
tinyMCE.addI18n('da.style_dlg',{
title:"Rediger CSS stil",
apply:"Anvend",
text_tab:"Tekst",
background_tab:"Baggrund",
block_tab:"Blok",
box_tab:"Boks",
border_tab:"Kant",
list_tab:"Liste",
positioning_tab:"Positionering",
text_props:"Tekst",
text_font:"Skrifttype",
text_size:"St\u00F8rrelse",
text_weight:"V\u00E6gt",
text_style:"Stil",
text_variant:"Variant",
text_lineheight:"Linieh\u00F8jde",
text_case:"Vesaltilstand",
text_color:"Farve",
text_decoration:"Dekoration",
text_overline:"overstreget",
text_underline:"understreget",
text_striketrough:"gennemstreget",
text_blink:"blink",
text_none:"ingen",
background_color:"Baggrundsfarve",
background_image:"Baggrundsbillede",
background_repeat:"Gentag",
background_attachment:"Vedh\u00E6ftede fil",
background_hpos:"Horisontal position",
background_vpos:"Vertikal position",
block_wordspacing:"Afstand mellem ord",
block_letterspacing:"Afstand mellem bogstaver",
block_vertical_alignment:"Vertikal justering",
block_text_align:"Tekstjustering",
block_text_indent:"Tekstindrykning",
block_whitespace:"Mellemrum",
block_display:"Vis",
box_width:"Bredde",
box_height:"H\u00F8jde",
box_float:"Flydende",
box_clear:"Ryd",
padding:"Afstand til indhold",
same:"Ens for alle",
top:"Top",
right:"H\u00F8jre",
bottom:"Bund",
left:"Venstre",
margin:"Margin",
style:"Style",
width:"Bredde",
height:"H\u00F8jde",
color:"Farve",
list_type:"Type",
bullet_image:"Punktopstillings-billede",
position:"Position",
positioning_type:"Type",
visibility:"Synlighed",
zindex:"Z-index",
overflow:"Overl\u00F8b",
placement:"Placering",
clip:"Klip"
});