text:
static NSString * XBLanguageUpdatedLanguage = @"XBLanguageUpdatedLanguage";

static XBLanguage *__sharedLanguage = nil;

@interface XBLanguage ()
{

}

@end

@implementation XBLanguage
@synthesize host;
@synthesize language = _language;
@synthesize isDebug;

+ (XBLanguage *)sharedInstance
{
    if (!__sharedLanguage)
    {
        __sharedLanguage = [[XBLanguage alloc] init];
        __sharedLanguage.language = @"en";
    }
    return __sharedLanguage;
}

- (void)selectLanguage:(NSString *)language
{
    [self setLanguage:language];
    [[NSUserDefaults standardUserDefaults] setObject:self.language forKey:@"XBLanguageSelectedLanguage"];
    [[NSUserDefaults standardUserDefaults] synchronize];
}

- (void)setLanguage:(NSString *)language
{
    language = [language stringByReplacingOccurrencesOfString:@"-" withString:@""];
    if (self.isDebug) NSLog(@"[XBLanguage] set language: %@", language);
    _language = language;
}

- (void)initialWithHost:(NSString *)_host
{
    if (self.isDebug) NSLog(@"[XBLanguage] init with host: %@", _host);
    self.host = _host;
    [self initial];
}

- (void)initial
{
    if ([[NSUserDefaults standardUserDefaults] stringForKey:@"XBLanguageSelectedLanguage"])
    {
        self.language = [[NSUserDefaults standardUserDefaults] stringForKey:@"XBLanguageSelectedLanguage"];
    }
    else
    {
        self.language = [[NSLocale preferredLanguages] objectAtIndex:0];
    }
    NSArray *find = [XBL_storageLanguage getFormat:@"name=%@" argument:@[self.language]];
    if ([find count] == 0)
    {
        [self suggestLanguage:self.language];
    }
    [self getVersion];
}

- (void)getVersion
{
    if (self.isDebug) NSLog(@"[XBLanguage] start get version");
    XBCacheRequest *request = XBCacheRequest([self linkForPath:@"pluslocalization/get_version"]);
    request.disableIndicator = YES;
    request.disableCache = YES;
    [request startAsynchronousWithCallback:^(XBCacheRequest *request, NSString *resultString, BOOL fromCache, NSError *error, id object) {

        if (object)
        {
            if (self.isDebug) NSLog(@"[XBLanguage] get version: %@", object);
        }
        else
        {
            if (self.isDebug) NSLog(@"[XBLanguage] get version: %@", request.responseString);
        }
        NSInteger recentVersion = [[NSUserDefaults standardUserDefaults] integerForKey:@"XBLanguageVersion"];
        NSInteger serverVersion = [object[@"language_version"] integerValue];
        if (recentVersion != serverVersion)
        {
            [[NSUserDefaults standardUserDefaults] setInteger:serverVersion forKey:@"XBLanguageVersion"];
            [[NSUserDefaults standardUserDefaults] synchronize];
            [self updateLanguage];
        }
    }];
}

- (void)suggestLanguage:(NSString *)__language
{
    if (self.isDebug) NSLog(@"[XBLanguage] start suggest language: %@", __language);

    XBCacheRequest *request = XBCacheRequest([self linkForPath:@"pluslocalization/ask_language"]);
    request.disableIndicator = YES;
    request.disableCache = YES;
    [request setDataPost:[@{@"language": __language} mutableCopy]];
    [request startAsynchronousWithCallback:^(XBCacheRequest *request, NSString *result, BOOL fromCache, NSError *error, id object) {
        if (self.isDebug) NSLog(@"[XBLanguage] suggest language: %@", result);
    }];
}

- (void)updateLanguage
{
    if (self.isDebug) NSLog(@"[XBLanguage] start update language");
    XBCacheRequest *request = XBCacheRequest([self linkForPath:@"pluslocalization/get_language_supported"]);
    request.disableIndicator = YES;
    request.disableCache = YES;
    [request startAsynchronousWithCallback:^(XBCacheRequest *request, NSString *resultString, BOOL fromCache, NSError *error, id object) {
        if (object)
        {
            if (self.isDebug)  NSLog(@"[XBLanguage] update language: %@", object);
        }
        else
        {
            if (self.isDebug) NSLog(@"[XBLanguage] update language: %@", resultString);
        }
        if (object)
        {
            [XBL_storageLanguage clean];
            for (NSDictionary *item in object[@"data"])
            {
                [XBL_storageLanguage addText:@{@"shortname": item[@"name"],
                                               @"name": item[@"long_name"],
                                               @"support": item[@"support"]}];
            }
            [[NSUserDefaults standardUserDefaults] setObject:object[@"primary"] forKey:@"XBLanguagePrimaryLanguage"];
            [[NSUserDefaults standardUserDefaults] synchronize];
            [self updateText];
        }
    }];
}

- (void)updateText
{
    if (self.isDebug) NSLog(@"[XBLanguage] start update text");
    XBCacheRequest *request = XBCacheRequest([self linkForPath:@"pluslocalization/get_list_text"]);
    request.disableCache = YES;
    request.disableIndicator = YES;
    [request startAsynchronousWithCallback:^(XBCacheRequest *request, NSString *resultString, BOOL fromCache, NSError *error, id object) {
        if (object)
        {
            if (self.isDebug) NSLog(@"[XBLanguage] update text: %@", object);
        }
        else
        {
            if (self.isDebug) NSLog(@"[XBLanguage] update text: %@", resultString);
        }
        if ([object[@"code"] intValue] == 200)
        {
            for (NSDictionary *item in object[@"data"])
            {
                NSMutableDictionary *mutableItem = [item mutableCopy];
                NSString *text = mutableItem[@"keyname"];
                NSString *screen = mutableItem[@"screen"];
                [mutableItem removeObjectsForKeys:@[@"keyname", @"screen"]];
                for (NSString *key in [mutableItem allKeys])
                {
                    [XBL_storageText addText:@{@"text": text,
                                               @"screen": screen,
                                               @"language": key,
                                               @"translatedText": mutableItem[key]}];
                }
            }
        }
        [[XBLanguage sharedInstance] saveContext];
        [[NSNotificationCenter defaultCenter] postNotificationName:XBLanguageUpdatedLanguage object:nil];
    }];
}

- (NSString *)stringForKey:(NSString *)key andScreen:(NSString *)screen
{
    if (!self.language)
    {
        return key;
    }
    if (screen == nil)
    {
        screen = @"default";
    }

    XBL_storageText *text = [self textFor:key screen:screen language:self.language];
    if (!text)
    {
        if (![[NSUserDefaults standardUserDefaults] stringForKey:@"XBLanguagePrimaryLanguage"])
        {
            if (self.isDebug) NSLog(@"[XBLanguage] using key for text: %@ for %@ %@ %@", NSLocalizedString(key, nil), key, screen, self.language);
            [self suggest:key screen:screen];
            return NSLocalizedString(key, nil);
        }

        text = [self textFor:key screen:screen language:[[NSUserDefaults standardUserDefaults] stringForKey:@"XBLanguagePrimaryLanguage"]];
        if (!text)
        {
            if (self.isDebug) NSLog(@"[XBLanguage] using key for text: %@ for %@ %@ %@", NSLocalizedString(key, nil), key, screen, self.language);
            [self suggest:key screen:screen];
            return NSLocalizedString(key, nil);
        }
        else
        {
            if (self.isDebug) NSLog(@"[XBLanguage] using primarylanguage for text: %@ for %@ %@ %@", NSLocalizedString(text.translatedText, nil), key, screen, self.language);
            return text.translatedText;
        }
    }
    else
    {
        if (self.isDebug) NSLog(@"[XBLanguage] using translated text: %@ for %@ %@ %@", text.translatedText, key, screen, self.language);
        return text.translatedText;
    }
}

- (XBL_storageText *)textFor:(NSString *)key screen:(NSString *)screen language:(NSString *)language
{
    NSArray *languages = [XBL_storageLanguage getFormat:@"shortname=%@ or support contains[cd] %@" argument:@[language, language]];
    if ([languages count] == 0)
    {
        return nil;
    }
    XBL_storageLanguage *l = [languages firstObject];
    NSArray *array = [XBL_storageText getFormat:@"text=%@ and screen=%@ and self.language=%@" argument:@[key, screen, l.shortname]];
    return [array lastObject];
}

- (void)suggest:(NSString *)key screen:(NSString *)screen
{
    XBCacheRequest *request = XBCacheRequest([self linkForPath:@"pluslocalization/add_text"]);
    request.disableIndicator = YES;
    request.disableCache = YES;
    [request setDataPost:[@{@"text": key,
                            @"screen": screen} mutableCopy]];
    [request startAsynchronousWithCallback:nil];
}

- (NSString *)linkForPath:(NSString *)path
{
    if (!host)
    {
        return path;
    }
    else
    {
        return [NSString stringWithFormat:@"%@/%@", host, path];
    }
}

// Process with plist only

- (void)loadDefaultPlist:(NSString *)plist
{
    NSDictionary *dict = [NSDictionary dictionaryWithContentsOfPlist:plist];
    NSInteger recentVersion = [[NSUserDefaults standardUserDefaults] integerForKey:@"XBLanguageVersion"];
    if (recentVersion == 0)
    {
        int plistVersion = [dict[@"version"] intValue];
        [[NSUserDefaults standardUserDefaults] setInteger:plistVersion forKey:@"XBLanguageVersion"];

        for (NSString *language in [dict[@"languages"] allKeys])
        {
            NSDictionary *languageInformation = dict[@"languages"][language];

            [XBL_storageLanguage addText:@{@"shortname": languageInformation[@"shortname"],
                                           @"name": languageInformation[@"name"],
                                           @"support": languageInformation[@"support"]}];
            for (NSDictionary * textInformation in languageInformation[@"text"])
            {
                [XBL_storageText addText:@{@"text": textInformation[@"text"],
                                           @"screen": textInformation[@"screen"],
                                           @"language": language,
                                           @"translatedText": textInformation[@"translatedText"]}];
            }
        }
        [[XBLanguage sharedInstance] saveContext];
        [[NSUserDefaults standardUserDefaults] synchronize];
    }
}

- (NSArray *)allLanguages:(XBLGetAllLanguage)callback
{
    return [XBL_storageLanguage getAll];
}

#pragma mark - Core Data stack

@synthesize managedObjectContext = _managedObjectContext;
@synthesize managedObjectModel = _managedObjectModel;
@synthesize persistentStoreCoordinator = _persistentStoreCoordinator;

- (NSURL *)applicationDocumentsDirectory {
    // The directory the application uses to store the Core Data store file. This code uses a directory named "com.libreteam._9closets" in the application's documents directory.
    return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
}

- (NSManagedObjectModel *)managedObjectModel {
    // The managed object model for the application. It is a fatal error for the application not to be able to find and load its model.
    if (_managedObjectModel != nil) {
        return _managedObjectModel;
    }
    NSBundle *bundle = [NSBundle bundleWithPath:[[NSBundle mainBundle] pathForResource:@"XBLanguage" ofType:@"bundle"]];
    NSURL *modelURL = [bundle URLForResource:@"XBLanguage" withExtension:@"momd"];
    _managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
    return _managedObjectModel;
}

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator {
    // The persistent store coordinator for the application. This implementation creates and return a coordinator, having added the store for the application to it.
    if (_persistentStoreCoordinator != nil) {
        return _persistentStoreCoordinator;
    }

    // Create the coordinator and store

    _persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
    NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"XBLanguage.sqlite"];
    NSError *error = nil;
    NSString *failureReason = @"There was an error creating or loading the application's saved data.";
    if (![_persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {
        // Report any error we got.
        NSMutableDictionary *dict = [NSMutableDictionary dictionary];
        dict[NSLocalizedDescriptionKey] = @"Failed to initialize the application's saved data";
        dict[NSLocalizedFailureReasonErrorKey] = failureReason;
        dict[NSUnderlyingErrorKey] = error;
        error = [NSError errorWithDomain:@"YOUR_ERROR_DOMAIN" code:9999 userInfo:dict];
        // Replace this with code to handle the error appropriately.
        // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
        NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
        abort();
    }

    return _persistentStoreCoordinator;
}

- (NSManagedObjectContext *)managedObjectContext {
    // Returns the managed object context for the application (which is already bound to the persistent store coordinator for the application.)
    if (_managedObjectContext != nil) {
        return _managedObjectContext;
    }

    NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
    if (!coordinator) {
        return nil;
    }
    _managedObjectContext = [[NSManagedObjectContext alloc] init];
    [_managedObjectContext setPersistentStoreCoordinator:coordinator];
    return _managedObjectContext;
}

#pragma mark - Core Data Saving support

- (void)saveContext {
    NSManagedObjectContext *managedObjectContext = self.managedObjectContext;
    if (managedObjectContext != nil) {
        NSError *error = nil;
        if ([managedObjectContext hasChanges] && ![managedObjectContext save:&error]) {
            // Replace this implementation with code to handle the error appropriately.
            // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
            NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
            abort();
        }
    }
}

@end


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;

using AM.Runtime;

using JetBrains.Annotations;

using ManagedIrbis;
using ManagedIrbis.Client;

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTests.ManagedIrbis.Client
{
    [TestClass]
    public class ProviderManagerTest
        : Common.CommonUnitTest
    {
        [TestMethod]
        public void ProviderManager_Construction_1()
        {
            Dictionary<string, Type> registry = ProviderManager.Registry;
            Assert.IsNotNull(registry);
            // Assert.AreEqual(5, registry.Count);
        }

        [TestMethod]
        public void ProviderManager_GetProvider_1()
        {
            IrbisProvider provider = ProviderManager.GetProvider
                (
                    ProviderManager.Null,
                    false
                );
            Assert.IsNotNull(provider);

            provider = ProviderManager.GetProvider
                (
                    "NoSuchProvider",
                    false
                );
            Assert.IsNull(provider);

            const string NullTypeProvider = "NullTypeProvider";
            ProviderManager.Registry[NullTypeProvider] = null;
            provider = ProviderManager.GetProvider
                (
                    NullTypeProvider,
                    false
                );
            Assert.IsNull(provider);
        }

        [TestMethod]
        [ExpectedException(typeof(IrbisException))]
        public void ProviderManager_GetProvider_2()
        {
            ProviderManager.GetProvider
                (
                    "NoSuchProvider",
                    true
                );
        }

        [TestMethod]
        [ExpectedException(typeof(IrbisException))]
        public void ProviderManager_GetProvider_3()
        {
            const string NullTypeProvider = "NullTypeProvider";
            ProviderManager.Registry[NullTypeProvider] = null;
            ProviderManager.GetProvider
                (
                    NullTypeProvider,
                    true
                );
        }

        [TestMethod]
        [ExpectedException(typeof(IrbisException))]
        public void ProviderManager_GetPreconfiguredProvider_1()
        {
            ProviderManager.GetPreconfiguredProvider();
        }

        [TestMethod]
        public void ProviderManager_GetAndConfigureProvider_1()
        {
            string connectionString = "Provider=Null;Some garbage;";
            IrbisProvider provider = ProviderManager
                .GetAndConfigureProvider(connectionString);
            Assert.IsNotNull(provider);
        }

        [TestMethod]
        public void ProviderManager_GetAndConfigureProvider_2()
        {
            string connectionString = "Some garbage;";
            ProviderManager.Registry[ProviderManager.Default]
                = typeof(NullProvider);
            IrbisProvider provider = ProviderManager
                .GetAndConfigureProvider(connectionString);
            Assert.IsNotNull(provider);
        }
    }
}

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

    Copyright (c) 2002-2005	David Ross,	Chris Scott

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

    $Id: app-config.xml,v 1.3 2005/11/17 19:24:21 rossd Exp $

-->

<mach-ii>
    <properties>

        <property name="applicationRoot" value="/coldspring/examples/feedviewer" />
		<property name="applicationVersion" value="0.1" />
		<property name="defaultEvent" value="c.showHome" />
		<property name="eventParameter" value="event" />
		<property name="parameterPrecedence" value="form" />
		<property name="maxEvents" value="100" />
		<property name="exceptionEvent" value="exceptionEvent" />

		<property name="styleSheetPath" value="../feedviewer/view/css/style.css" />

		<!-- configuration file for coldspring managed services -->
		<property name="ColdspringComponentRelativePath" value="../feedviewer/services.xml" />

	    <!-- properties needed for xml storage... the ${} will make the coldspring plugin evaluate the property -->
	    <property name="xmlstoragepath" value="${expandPath('../feedviewer/data/xml/')}"/>

	    <!-- properties needed for rdbms storage -->
	        <!-- datasource name -->
    	    <property name="dsn" value="dbAggregator_mssql" />
    	    <!-- datasource vendor -->
    	    <property name="dsvendor" value="mssql" />

    </properties>

    <listeners>
		<listener name="categoryListener" type="coldspring.examples.feedviewer-m2.controller.categoryListener">
			<invoker type="MachII.framework.invokers.CFCInvoker_Event" />
		</listener>

		<listener name="channelListener" type="coldspring.examples.feedviewer-m2.controller.channelListener">
			<invoker type="MachII.framework.invokers.CFCInvoker_Event" />
		</listener>

		<listener name="entryListener" type="coldspring.examples.feedviewer-m2.controller.entryListener">
			<invoker type="MachII.framework.invokers.CFCInvoker_Event" />
		</listener>

		<listener name="aggregatorListener" type="coldspring.examples.feedviewer-m2.controller.aggregatorListener">
			<invoker type="MachII.framework.invokers.CFCInvoker_Event" />
		</listener>
    </listeners>

    <event-filters>

    </event-filters>

    <event-handlers>
        <event-handler event="c.showHome" access="public">
            <announce event="viewNav"/>
            <announce event="viewEntries"/>
        </event-handler>

        <event-handler event="viewNav" access="private">
            <notify listener="categoryListener" method="getAllCategories" resultKey="request.categories"/>
            <event-arg name="categories" variable="request.categories"/>

            <notify listener="channelListener" method="getAllChannels" resultKey="request.channels"/>
            <event-arg name="channels" variable="request.channels"/>

            <view-page name="allCategories" contentKey="request.leftColContent"/>
            <view-page name="allChannels" contentKey="request.leftColContent" append="true"/>

        </event-handler>

        <event-handler event="viewEntries" access="private">
            <notify listener="entryListener" method="getAllEntries" resultKey="request.entries"/>
            <event-arg name="entries" variable="request.entries"/>
            <view-page name="entries" contentKey="request.mainContent"/>
        </event-handler>

         <!-- category operations -->
        <event-handler event="c.showCategory" access="public">
            <announce event="viewNav"/>
            <announce event="viewExistingCategory"/>
        </event-handler>

        <event-handler event="c.newCategory" access="public">
            <announce event="viewNav"/>
            <announce event="viewNewCategory"/>
        </event-handler>

        <event-handler event="c.saveCategory" access="public">
            <announce event="viewNav"/>
            <event-bean name="category" type="coldspring.examples.feedviewer.model.category.category"/>
            <notify listener="categoryListener" method="saveCategory"/>
        </event-handler>

        <event-handler event="c.removeCategory" access="public">
            <announce event="viewNav"/>
            <notify listener="categoryListener" method="getCategoryById" resultKey="request.category"/>
            <event-arg name="category" variable="request.category"/>
            <notify listener="categoryListener" method="removeCategory"/>
        </event-handler>

        <!-- category private events -->
        <event-handler event="viewExistingCategory" access="private">
            <notify listener="categoryListener" method="getCategoryById" resultKey="request.category"/>
            <event-arg name="category" variable="request.category"/>

            <notify listener="channelListener" method="getChannelsByCategoryId" resultKey="request.categorychannels"/>
            <event-arg name="categorychannels" variable="request.categorychannels"/>

            <announce event="renderCategory"/>
        </event-handler>

        <event-handler event="viewNewCategory" access="private">
            <event-bean name="category" type="coldspring.examples.feedviewer.model.category.category"/>
             <announce event="renderCategory"/>
         </event-handler>

        <event-handler event="renderCategory" access="private">
               <view-page name="Category" contentKey="request.mainContent"/>
        </event-handler>

        <!-- channel operations -->
        <event-handler event="c.showChannel" access="public">
            <announce event="viewNav"/>
            <announce event="viewExistingChannel"/>
        </event-handler>

        <event-handler event="c.newChannel" access="public">
            <announce event="viewNav"/>
            <announce event="viewNewChannel"/>
        </event-handler>

        <event-handler event="c.saveChannel" access="public">
            <announce event="viewNav"/>
            <event-bean name="channel" type="coldspring.examples.feedviewer.model.channel.channel"/>
            <notify listener="channelListener" method="saveChannel"/>
            <notify listener="aggregatorListener" method="aggregrateChannelFeed"/>
        </event-handler>

       <event-handler event="c.removeChannel" access="public">
            <announce event="viewNav"/>
            <notify listener="channelListener" method="getChannelById" resultKey="request.channel"/>
            <event-arg name="channel" variable="request.channel"/>
            <notify listener="channelListener" method="removeChannel"/>
        </event-handler>

        <!-- channel private events -->
        <event-handler event="viewExistingChannel" access="private">
            <notify listener="channelListener" method="getChannelById" resultKey="request.channel"/>
            <event-arg name="channel" variable="request.channel"/>

            <notify listener="entryListener" method="getEntriesByChannelId" resultKey="request.channelentries"/>
            <event-arg name="channelentries" variable="request.channelentries"/>

            <announce event="renderChannel"/>
        </event-handler>

        <event-handler event="viewNewChannel" access="private">
            <event-bean name="channel" type="coldspring.examples.feedviewer.model.channel.channel"/>
            <announce event="renderChannel"/>
        </event-handler>

        <event-handler event="renderChannel" access="private">
               <notify listener="categoryListener" method="getAllCategories" resultKey="request.categories"/>
               <event-arg name="categories" variable="request.categories"/>

               <view-page name="Channel" contentKey="request.mainContent"/>
        </event-handler>

        <!-- re-aggregates a single channel's entries -->
        <event-handler event="c.refreshChannelEntries" access="public">
            <announce event="viewNav"/>

            <notify listener="channelListener" method="getChannelById" resultKey="request.channel"/>
            <event-arg name="channel" variable="request.channel"/>

            <notify listener="aggregatorListener" method="aggregrateChannelFeed"/>

            <notify listener="entryListener" method="getEntriesByChannelId" resultKey="request.channelentries"/>
            <event-arg name="channelentries" variable="request.channelentries"/>

            <announce event="renderChannel"/>
        </event-handler>

        <event-handler event="exceptionEvent" access="public">
			<!-- exception handler -->
			<view-page name="exception" contentKey="request.mainContent"/>
            <event-arg name="mainContent" variable="request.mainContent"/>
			<announce event="renderPage"/>
		</event-handler>

   		<event-handler event="renderPage" access="public">
   		    <view-page name="header" contentKey="request.headerContent"/>
            <event-arg name="headerContent" variable="request.headerContent"/>
            <view-page name="footer" contentKey="request.footerContent"/>
            <event-arg name="footerContent" variable="request.footerContent"/>

            <view-page name="mainLayout" />
		</event-handler>

    </event-handlers>

    <page-views>
        <page-view name="allCategories" page="/view/html/dspAllCategories.cfm" />
        <page-view name="allChannels" page="/view/html/dspAllChannels.cfm" />

        <page-view name="entries" page="/view/html/dspEntries.cfm" />

        <page-view name="Category" page="/view/html/dspCategory.cfm" />
        <page-view name="Channel" page="/view/html/dspChannel.cfm" />

        <page-view name="header" page="/view/html/dspHeader.cfm" />
        <page-view name="footer" page="/view/html/dspFooter.cfm" />
        <page-view name="mainLayout" page="/view/html/dspMainLayout.cfm" />
        <page-view name="exception" page="/view/html/dspException.cfm" />
    </page-views>

    <plugins>
        <plugin name="appPlugin" type="coldspring.examples.feedviewer-m2.controller.appPlugin">
        	<parameters>
				<parameter name="renderEventName" value="renderPage"/>
		    </parameters>
        </plugin>

   		<plugin name="coldSpringPlugin" type="coldspring.machii.ColdspringPlugin">
			<parameters>
				<parameter name="beanFactoryPropertyName" value="serviceFactory"/>
				<parameter name="configFilePropertyName" value="ColdspringComponentRelativePath"/>
				<parameter name="configFilePathIsRelative" value="true"/>
			</parameters>
		</plugin>

    </plugins>

</mach-ii>


text:
import {
  buildQueryContext,
  GenericDataType,
  QueryFormData,
} from '@superset-ui/core';

/**
 * The buildQuery function is used to create an instance of QueryContext that's
 * sent to the chart data endpoint. In addition to containing information of which
 * datasource to use, it specifies the type (e.g. full payload, samples, query) and
 * format (e.g. CSV or JSON) of the result and whether or not to force refresh the data from
 * the datasource as opposed to using a cached copy of the data, if available.
 *
 * More importantly though, QueryContext contains a property `queries`, which is an array of
 * QueryObjects specifying individual data requests to be made. A QueryObject specifies which
 * columns, metrics and filters, among others, to use during the query. Usually it will be enough
 * to specify just one query based on the baseQueryObject, but for some more advanced use cases
 * it is possible to define post processing operations in the QueryObject, or multiple queries
 * if a viz needs multiple different result sets.
 */
export default function buildQuery(formData: QueryFormData) {
  const { groupby } = formData;
  const [column = ''] = groupby || [];
  // @ts-ignore (need update interface Column )
  return buildQueryContext(formData, baseQueryObject => [
    {
      ...baseQueryObject,
      columns: [],
      groupby: [],
      metrics: [
        {
          aggregate: 'MIN',
          column: {
            column_name: column,
            id: 1,
            type_generic: GenericDataType.NUMERIC,
          },
          expressionType: 'SIMPLE',
          hasCustomLabel: true,
          label: 'min',
        },
        {
          aggregate: 'MAX',
          column: {
            column_name: column,
            id: 2,
            type_generic: GenericDataType.NUMERIC,
          },
          expressionType: 'SIMPLE',
          hasCustomLabel: true,
          label: 'max',
        },
      ],
    },
  ]);
}


text:
package com.devskiller.friendly_id.sample.customized;

import java.util.UUID;

import org.springframework.stereotype.Service;

@Service
class FooService {

	Bar find(UUID uuid) {
		System.out.println("find: " + uuid);
		return new Bar(uuid, uuid);
	}

	void update(UUID id, Bar bar) {
		System.out.println("update: " + id + ":" + bar);
	}
}


text:
typedef struct TDeviceInfo
{
	struct TDeviceInfo	*pNext;
	char			*pName;
	void			*pDevice;
	boolean			 bBlockDevice;
}
TDeviceInfo;

typedef struct TDeviceNameService
{
	TDeviceInfo *m_pList;
}
TDeviceNameService;

void DeviceNameService (TDeviceNameService *pThis);
void _DeviceNameService (TDeviceNameService *pThis);

void DeviceNameServiceAddDevice (TDeviceNameService *pThis, const char *pName, void *pDevice, boolean bBlockDevice);

void *DeviceNameServiceGetDevice (TDeviceNameService *pThis, const char *pName, boolean bBlockDevice);

TDeviceNameService *DeviceNameServiceGet (void);

#endif


text:
title: Basic A/B Testing plots and stats with R
author: manos_parzakonis
layout: post
permalink: /basic-ab-testing-plots-and-stats-with-r/
excerpt: "Start analysing your A/B tests with R"
bfa_virtual_template:
  - single
wp_cta_content_placement:
  - off
wp_cta_slide_out_alignment:
  - right
wp_cta_slide_out_reveal:
  - 100
wp_cta_slide_out_speed:
  - 1
wp_cta_slide_out_keep_open:
  - no
wp_cta_popup_timeout:
  - 7
wp_cta_popup_cookie:
  - yes
wp_cta_popup_cookie_length:
  - 7
wp_cta_popup_pageviews:
  - 0
categories:
  - measure
  - statistics
tags:
  - ab test
  - ggplot
  - google analytics
  - plots
  - R
---
Have you used Google Analytics Content Experiments?

I’ve been using it lately and the most useful thing is that all data are integrated into the API to do what you want to do except for the standard reports. So, you can get them into your favorite data analysis tool and get more things done. In the following I simulate an example for an e-commerce site, so I am interested in checking the next (among others)

  * did the proposed variation increased the Funnel entrances?
  * did the feature uplift the Average Order Value (AOV) ?
  * did the conversion rate (sales wise) improved?

We can easily accomplish this using the Google Analytics API and R. We have found a way to get data off Google Analytics using R previously  (see : [Google Analytics + R = FUN!][1])

    The code that gets the above chart into a presentation of yours is hosted over at GitHub. We source the multiplot.r file in order to be able to add multiple plot of the ggplot kind within a loop (see this)

      ..

      initiate_RGoogleAnalytics.r

      First commit

      <time title="2014-01-12 10:37:41" datetime="2014-01-12T10:37:41-08:00"> </time>

      multiplot.r

      First commit

      <time title="2014-01-12 10:37:41" datetime="2014-01-12T10:37:41-08:00"> </time>

      plot_experiments_across_profiles.r

      First commit

      <time title="2014-01-12 10:37:41" datetime="2014-01-12T10:37:41-08:00"> </time>

 [1]: http://www.statsravingmad.com/blog/measure/google-analytics-r-fun/#comment-12398


text:
import { combineReducers } from 'redux'

import { CounterConstants, CounterReducer } from '../routes/Counter'
import { AsyncConstants, AsyncReducer } from '../routes/Async'

// Fix: "React-Redux: Combining reducers: Unexpected Keys"
// http://stackoverflow.com/a/33678198/789076
export const initialReducers = {
  [CounterConstants.REDUCER_NAME]: CounterReducer,
  [AsyncConstants.REDUCER_NAME]  : AsyncReducer,
}

export const makeRootReducer = asyncReducers => combineReducers({
    // Add sync reducers here
  ...initialReducers,
  ...asyncReducers,
})

export default makeRootReducer


text:
from .UpdaterTransmissionNegotiation import NegotiationResultInterface, TransmissionNegotiationInterface
from .Updater import UpdaterInterface, UpdaterAlgorithmInterface
from .UpdaterDataProcessor import UpdaterDataProcessorInterface
from .UpdaterDataAssembly import DataAssemblyInterface


text:
Subscript assignment operation. Keys and values can be scalars or `list`s.

**Examples:**

[`pdict`](./pstar_pdict.md) assignment works normally for any `hash`able `key`:
```python
pd = pdict()
pd['foo'] = 1
assert (pd.foo == pd['foo'] == 1)
```

[`pdict`](./pstar_pdict.md) assignment can also work with a `list` of `hash`able `key`s:
```python
pd[['bar', 'baz']] = plist[2.0, 'three']
assert (pd.bar == pd['bar'] == 2.0)
assert (pd.baz == pd['baz'] == 'three')
```

**Args:**

>    **`key`**: Any `hash`able object, or a `list` of `hash`able objects.

>    **`value`**: Any value, or a [`plist`](./pstar_plist.md) of values that matches the shape of `key`, if it
>           is a `list`.

**Returns:**

>    `self`, to allow chaining with direct calls to `pdict.__setitem__`.

## [Source](../pstar/pstar.py#L229-L263)


text:
package com.github.bezsias.multimap;

import java.io.ObjectOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;

interface Writer<T> {
    void write(T t, ObjectOutputStream os, DataOutputStream dos) throws IOException;
}


text:
from beritest_tools import BaseBERITestCase
from nose.plugins.attrib import attr

class test_teqi_lt(BaseBERITestCase):
    @attr('trapi')
    def test_teqi_handled(self):
        self.assertRegisterEqual(self.MIPS.a2, 0, "teqi trapped when less than")


text:
<?php
namespace PayPal\Test\Api;

use PayPal\Api\Refund;
use PayPal\Test\Constants;

class RefundTest extends \PHPUnit_Framework_TestCase
{

    private $refund;

    public static $captureId = "CAP-123";
    public static $createTime = "2013-02-28T00:00:00Z";
    public static $id = "R-5678";
    public static $parentPayment = "PAY-123";

    public static function createRefund()
    {
        $refund = new Refund();
        $refund->setCreateTime(self::$createTime);
        $refund->setAmount(AmountTest::createAmount());
        $refund->setCaptureId(self::$captureId);
        $refund->setId(self::$id);
        $refund->setLinks(array(LinksTest::getObject()));
        $refund->setParentPayment(self::$parentPayment);

        return $refund;
    }

    public function setup()
    {
        $this->refund = self::createRefund();
    }

    public function testGetterSetter()
    {
        $this->assertEquals(self::$captureId, $this->refund->getCaptureId());
        $this->assertEquals(self::$createTime, $this->refund->getCreateTime());
        $this->assertEquals(self::$id, $this->refund->getId());
        $this->assertEquals(self::$parentPayment, $this->refund->getParentPayment());
        $this->assertEquals(AmountTest::$currency, $this->refund->getAmount()->getCurrency());
        $links = $this->refund->getLinks();
    }

    public function testSerializeDeserialize()
    {
        $r1 = $this->refund;

        $r2 = new Refund();
        $r2->fromJson($r1->toJson());

        $this->assertEquals($r1, $r2);
    }

    public function testOperations()
    {

    }
}


text:
Breaking changes:

* Remove `room_name` module
  * Room name size limits were never enforced, so they are now just regular
    `String`s in Ruma ([Spec change removing the size limit][spec])

[spec]: https://github.com/matrix-org/matrix-spec-proposals/pull/3669

# 0.8.1

Improvements:

* Remove unused dependency on `url`

# 0.8.0

Breaking changes:

* Rework the `Error` type (merge / rename variants)

# 0.7.0

Improvements:

* Add more `Error` variants

# 0.6.0

Breaking changes:

* Most validation functions no longer return the colon position on success

Improvements:

* Add `mxc_uri` validation

# 0.5.0

Breaking changes:

* Make `Error` type non-exhaustive

# 0.4.0

Breaking changes:

* Fix a typo in a public function name: `user_id::localpart_is_fully_conforming`

# 0.3.0

Breaking changes:

* Remove the `serde` feature

# 0.2.4

Improvements:

* Restore the `serde` feature which was accidentally removed in a patch release

# 0.2.3

Improvements:

* Add a `compat` feature
  * Under this feature, more user IDs are accepted that exist in the while but are not
    spec-compliant

# 0.2.2

Improvements:

* Add verification of `mxc://` URIs

# 0.2.1

Improvements:

* Drop unused dependencies

# 0.2.0

Breaking changes:

* Remove `key_algorithms` module (moved to ruma-identifiers as `crypto_algorithms`)


text:
import astroid
import pytest

from pylint.checkers import typecheck
from pylint.interfaces import UNDEFINED
from pylint.testutils import CheckerTestCase, Message, set_config

try:
    from coverage import tracer as _  # pylint: disable=unused-import

    C_EXTENTIONS_AVAILABLE = True
except ImportError:
    _ = None
    C_EXTENTIONS_AVAILABLE = False

needs_c_extension = pytest.mark.skipif(
    not C_EXTENTIONS_AVAILABLE, reason="Requires coverage (source of C-extension)"
)

class TestTypeChecker(CheckerTestCase):
    "Tests for pylint.checkers.typecheck"
    CHECKER_CLASS = typecheck.TypeChecker

    def test_no_member_in_getattr(self):
        """Make sure that a module attribute access is checked by pylint."""

        node = astroid.extract_node(
            """
        import optparse
        optparse.THIS_does_not_EXIST
        """
        )
        with self.assertAddsMessages(
            Message(
                "no-member",
                node=node,
                args=("Module", "optparse", "THIS_does_not_EXIST", ""),
            )
        ):
            self.checker.visit_attribute(node)

    @set_config(ignored_modules=("argparse",))
    def test_no_member_in_getattr_ignored(self):
        """Make sure that a module attribute access check is omitted with a
        module that is configured to be ignored.
        """

        node = astroid.extract_node(
            """
        import argparse
        argparse.THIS_does_not_EXIST
        """
        )
        with self.assertNoMessages():
            self.checker.visit_attribute(node)

    @set_config(ignored_modules=("xml.etree.",))
    def test_ignored_modules_invalid_pattern(self):
        node = astroid.extract_node(
            """
        import xml
        xml.etree.Lala
        """
        )
        message = Message(
            "no-member", node=node, args=("Module", "xml.etree", "Lala", "")
        )
        with self.assertAddsMessages(message):
            self.checker.visit_attribute(node)

    @set_config(ignored_modules=("xml",))
    def test_ignored_modules_root_one_applies_as_well(self):
        # Check that when a root module is completely ignored, submodules are skipped.
        node = astroid.extract_node(
            """
        import xml
        xml.etree.Lala
        """
        )
        with self.assertNoMessages():
            self.checker.visit_attribute(node)

    @set_config(ignored_modules=("xml.etree*",))
    def test_ignored_modules_patterns(self):
        node = astroid.extract_node(
            """
        import xml
        xml.etree.portocola #@
        """
        )
        with self.assertNoMessages():
            self.checker.visit_attribute(node)

    @set_config(ignored_classes=("xml.*",))
    def test_ignored_classes_no_recursive_pattern(self):
        node = astroid.extract_node(
            """
        import xml
        xml.etree.ElementTree.Test
        """
        )
        message = Message(
            "no-member", node=node, args=("Module", "xml.etree.ElementTree", "Test", "")
        )
        with self.assertAddsMessages(message):
            self.checker.visit_attribute(node)

    @set_config(ignored_classes=("optparse.Values",))
    def test_ignored_classes_qualified_name(self):
        """Test that ignored-classes supports qualified name for ignoring."""
        node = astroid.extract_node(
            """
        import optparse
        optparse.Values.lala
        """
        )
        with self.assertNoMessages():
            self.checker.visit_attribute(node)

    @set_config(ignored_classes=("Values",))
    def test_ignored_classes_only_name(self):
        """Test that ignored_classes works with the name only."""
        node = astroid.extract_node(
            """
        import optparse
        optparse.Values.lala
        """
        )
        with self.assertNoMessages():
            self.checker.visit_attribute(node)

    @set_config(suggestion_mode=False)
    @needs_c_extension
    def test_nomember_on_c_extension_error_msg(self):
        node = astroid.extract_node(
            """
        from coverage import tracer
        tracer.CTracer  #@
        """
        )
        message = Message(
            "no-member", node=node, args=("Module", "coverage.tracer", "CTracer", "")
        )
        with self.assertAddsMessages(message):
            self.checker.visit_attribute(node)

    @set_config(suggestion_mode=True)
    @needs_c_extension
    def test_nomember_on_c_extension_info_msg(self):
        node = astroid.extract_node(
            """
        from coverage import tracer
        tracer.CTracer  #@
        """
        )
        message = Message(
            "c-extension-no-member",
            node=node,
            args=("Module", "coverage.tracer", "CTracer", ""),
        )
        with self.assertAddsMessages(message):
            self.checker.visit_attribute(node)

    @set_config(
        contextmanager_decorators=(
            "contextlib.contextmanager",
            ".custom_contextmanager",
        )
    )
    def test_custom_context_manager(self):
        """Test that @custom_contextmanager is recognized as configured."""
        node = astroid.extract_node(
            """
        from contextlib import contextmanager
        def custom_contextmanager(f):
            return contextmanager(f)
        @custom_contextmanager
        def dec():
            yield
        with dec():
            pass
        """
        )
        with self.assertNoMessages():
            self.checker.visit_with(node)

    def test_invalid_metaclass(self):
        module = astroid.parse(
            """
        class InvalidAsMetaclass(object):
            pass

        class FirstInvalid(object, metaclass=int):
            pass

        class SecondInvalid(object, metaclass=InvalidAsMetaclass):
            pass

        class ThirdInvalid(object, metaclass=2):
            pass
        """
        )
        for class_obj, metaclass_name in (
            ("ThirdInvalid", "2"),
            ("SecondInvalid", "InvalidAsMetaclass"),
            ("FirstInvalid", "int"),
        ):
            classdef = module[class_obj]
            message = Message(
                "invalid-metaclass", node=classdef, args=(metaclass_name,)
            )
            with self.assertAddsMessages(message):
                self.checker.visit_classdef(classdef)

    def test_invalid_metaclass_function_metaclasses(self):
        module = astroid.parse(
            """
        def invalid_metaclass_1(name, bases, attrs):
            return int
        def invalid_metaclass_2(name, bases, attrs):
            return 1
        class Invalid(metaclass=invalid_metaclass_1):
            pass
        class InvalidSecond(metaclass=invalid_metaclass_2):
            pass
        """
        )
        for class_obj, metaclass_name in (("Invalid", "int"), ("InvalidSecond", "1")):
            classdef = module[class_obj]
            message = Message(
                "invalid-metaclass", node=classdef, args=(metaclass_name,)
            )
            with self.assertAddsMessages(message):
                self.checker.visit_classdef(classdef)

    def test_typing_namedtuple_not_callable_issue1295(self):
        module = astroid.parse(
            """
        import typing
        Named = typing.NamedTuple('Named', [('foo', int), ('bar', int)])
        named = Named(1, 2)
        """
        )
        call = module.body[-1].value
        callables = call.func.inferred()
        assert len(callables) == 1
        assert callables[0].callable()
        with self.assertNoMessages():
            self.checker.visit_call(call)

    def test_typing_namedtuple_unsubscriptable_object_issue1295(self):
        module = astroid.parse(
            """
        import typing
        MyType = typing.Tuple[str, str]
        """
        )
        subscript = module.body[-1].value
        with self.assertNoMessages():
            self.checker.visit_subscript(subscript)

    def test_staticmethod_multiprocessing_call(self):
        """Make sure not-callable isn't raised for descriptors

        astroid can't process descriptors correctly so
        pylint needs to ignore not-callable for them
        right now

        Test for https://github.com/PyCQA/pylint/issues/1699
        """
        call = astroid.extract_node(
            """
        import multiprocessing
        multiprocessing.current_process() #@
        """
        )
        with self.assertNoMessages():
            self.checker.visit_call(call)

    def test_not_callable_uninferable_property(self):
        """Make sure not-callable isn't raised for uninferable
        properties
        """
        call = astroid.extract_node(
            """
        class A:
            @property
            def call(self):
                return undefined

        a = A()
        a.call() #@
        """
        )
        with self.assertNoMessages():
            self.checker.visit_call(call)

    def test_descriptor_call(self):
        call = astroid.extract_node(
            """
        def func():
            pass

        class ADescriptor:
            def __get__(self, instance, owner):
                return func

        class AggregateCls:
            a = ADescriptor()

        AggregateCls().a() #@
        """
        )
        with self.assertNoMessages():
            self.checker.visit_call(call)

    def test_unknown_parent(self):
        """Make sure the callable check does not crash when a node's parent
        cannot be determined.
        """
        call = astroid.extract_node(
            """
        def get_num(n):
            return 2 * n
        get_num(10)()
        """
        )
        with self.assertAddsMessages(
            Message("not-callable", node=call, args="get_num(10)")
        ):
            self.checker.visit_call(call)

class TestTypeCheckerOnDecorators(CheckerTestCase):
    "Tests for pylint.checkers.typecheck on decorated functions."
    CHECKER_CLASS = typecheck.TypeChecker

    def test_issue3882_class_decorators(self):
        decorators = """
        class Unsubscriptable:
            def __init__(self, f):
                self.f = f

        class Subscriptable:
            def __init__(self, f):
                self.f = f

            def __getitem__(self, item):
                return item
        """
        for generic in "Optional", "List", "ClassVar", "Final", "Literal":
            self.typing_objects_are_subscriptable(generic)

        self.getitem_on_modules()
        self.decorated_by_a_subscriptable_class(decorators)
        self.decorated_by_an_unsubscriptable_class(decorators)

        self.decorated_by_subscriptable_then_unsubscriptable_class(decorators)
        self.decorated_by_unsubscriptable_then_subscriptable_class(decorators)

    def getitem_on_modules(self):
        """Mainly validate the code won't crash if we're not having a function."""
        module = astroid.parse(
            """
        import collections
        test = collections[int]
        """
        )
        subscript = module.body[-1].value
        with self.assertAddsMessages(
            Message(
                "unsubscriptable-object",
                node=subscript.value,
                args="collections",
                confidence=UNDEFINED,
            )
        ):
            self.checker.visit_subscript(subscript)

    def typing_objects_are_subscriptable(self, generic):
        module = astroid.parse(
            f"""
        import typing
        test = typing.{generic}[int]
        """
        )
        subscript = module.body[-1].value
        with self.assertNoMessages():
            self.checker.visit_subscript(subscript)

    def decorated_by_a_subscriptable_class(self, decorators):
        module = astroid.parse(
            decorators
            + """
        @Subscriptable
        def decorated():
            ...

        test = decorated[None]
        """
        )
        subscript = module.body[-1].value
        with self.assertNoMessages():
            self.checker.visit_subscript(subscript)

    def decorated_by_subscriptable_then_unsubscriptable_class(self, decorators):
        module = astroid.parse(
            decorators
            + """
        @Unsubscriptable
        @Subscriptable
        def decorated():
            ...

        test = decorated[None]
        """
        )
        subscript = module.body[-1].value
        with self.assertAddsMessages(
            Message(
                "unsubscriptable-object",
                node=subscript.value,
                args="decorated",
                confidence=UNDEFINED,
            )
        ):
            self.checker.visit_subscript(subscript)

    def decorated_by_unsubscriptable_then_subscriptable_class(self, decorators):
        module = astroid.parse(
            decorators
            + """
        @Subscriptable
        @Unsubscriptable
        def decorated():
            ...

        test = decorated[None]
        """
        )
        subscript = module.body[-1].value
        with self.assertNoMessages():
            self.checker.visit_subscript(subscript)

    def decorated_by_an_unsubscriptable_class(self, decorators):
        module = astroid.parse(
            decorators
            + """
        @Unsubscriptable
        def decorated():
            ...

        test = decorated[None]
        """
        )
        subscript = module.body[-1].value
        with self.assertAddsMessages(
            Message(
                "unsubscriptable-object",
                node=subscript.value,
                args="decorated",
                confidence=UNDEFINED,
            )
        ):
            self.checker.visit_subscript(subscript)


text:
$deployToolsDir = Split-Path ((Get-Variable MyInvocation -Scope 0).Value.MyCommand.Path)

if (Test-Path variable:\OctopusParameters)
{
    foreach($kp in $OctopusParameters.GetEnumerator())
    {
        Set-Content ("env:\" + $kp.Key) ($kp.Value) -Force
    }
}

if(!(Test-Path "env:\ConfigOnly"))
{
    Set-Content "env:\ConfigOnly" $false
}

function ensconce
{
    if (@($input).Count -ne 0)
    {
        $input.Reset()
        $results = $input | & "$deployToolsDir\ensconce.exe" $args 2>&1
    }
    else {
        $results = & "$deployToolsDir\ensconce.exe" $args 2>&1
    }
    if ($LASTEXITCODE -ne 0)
    {
        if (Test-Path env:\TEAMCITY_VERSION)
        {
            Write-Host "##teamcity[buildStatus status='FAILURE' text='{build.status.text}; Ensconce failure']"
            $results
            exit $LASTEXITCODE
        }
        else {
        throw (
"Ensconce operation failed.
$results")
        }
    }
    $results
}

function EnsurePath([string]$name)
{
	$path = $name | ensconce -i

	if ((Test-Path $path) -eq $False)
	{
		md $path
	}
}

function is64bit() {
  return ( (Get-WmiObject Win32_OperatingSystem).OSArchitecture -eq "64-bit")
}


text:
from setuptools import setup
import sys

from noipy import __version__, __author__, __email__, __license__

install_requires = [
    "requests>=2.0",
]

if sys.version_info[:2] < (2, 7):
    install_requires.append("argparse")

with open("README.rst") as f:
    readme = f.read()
with open("CHANGELOG.rst") as f:
    changelog = f.read()

setup(
    name="noipy",
    version=__version__,
    description="Command line tool for DDNS IP address updating.",
    long_description=readme + "\n\n" + changelog,
    license=__license__,
    author=__author__,
    author_email=__email__,
    url="https://github.com/povieira/noipy",
    packages=["noipy"],
    install_requires=install_requires,
    keywords=["no-ip", "dyndns", "duckdns", "ddns", "api"],
    classifiers=[
        "Development Status :: 5 - Production/Stable",
        "Intended Audience :: Developers",
        "Intended Audience :: End Users/Desktop",
        "Intended Audience :: System Administrators",
        "License :: OSI Approved :: Apache Software License",
        "Operating System :: OS Independent",
        "Programming Language :: Python",
        "Programming Language :: Python :: 2",
        "Programming Language :: Python :: 2.6",
        "Programming Language :: Python :: 2.7",
        "Programming Language :: Python :: 3",
        "Programming Language :: Python :: 3.2",
        "Programming Language :: Python :: 3.3",
        "Programming Language :: Python :: 3.4",
        "Programming Language :: Python :: Implementation :: CPython",
        "Programming Language :: Python :: Implementation :: PyPy",
        "Topic :: Internet :: Name Service (DNS)",
    ],
    entry_points={
        "console_scripts": [
            "noipy = noipy.main:main",
        ],
    },
    zip_safe=True,
    test_suite="test.test_noipy"
)