text:
//
//  TKAlertCenter.m
//  Created by Devin Ross on 9/29/10.
//

#import "TKAlertCenter.h"
#import "UIView+TKCategory.h"

@interface TKAlertCenter()
@property (nonatomic,retain) NSMutableArray *alerts;
@end

@interface TKAlertView : UIView {
	CGRect messageRect;
	NSString *text;
	UIImage *image;
}

- (id) init;
- (void) setMessageText:(NSString*)str;
- (void) setImage:(UIImage*)image;

@end

@implementation TKAlertCenter
@synthesize alerts;

+ (TKAlertCenter*) defaultCenter {
	static TKAlertCenter *defaultCenter = nil;
	if (!defaultCenter) {
		defaultCenter = [[TKAlertCenter alloc] init];
	}
	return defaultCenter;
}

- (id) init{
	if(!(self=[super init])) return nil;

	self.alerts = [NSMutableArray array];
	_alertView = [[TKAlertView alloc] init];
	_active = NO;

	_alertFrame = [UIApplication sharedApplication].keyWindow.bounds;

	[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillAppear:) name:UIKeyboardWillShowNotification object:nil];
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(keyboardWillDisappear:) name:UIKeyboardDidHideNotification object:nil];
	[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(orientationWillChange:) name:UIApplicationWillChangeStatusBarOrientationNotification object:nil];

	return self;
}

- (void) showAlerts{

	if([self.alerts count] < 1) {
		_active = NO;
		return;
	}

	_active = YES;

	_alertView.transform = CGAffineTransformIdentity;
	_alertView.alpha = 0;
	[[UIApplication sharedApplication].keyWindow addSubview:_alertView];

	NSArray *ar = [self.alerts objectAtIndex:0];

	UIImage *img = nil;
	if([ar count] > 1) img = [[self.alerts objectAtIndex:0] objectAtIndex:1];

	[_alertView setImage:img];

	if([ar count] > 0) [_alertView setMessageText:[[self.alerts objectAtIndex:0] objectAtIndex:0]];

//	_alertView.center = CGPointMake(_alertFrame.origin.x+_alertFrame.size.width/2, 480-90);//alertFrame.origin.y+alertFrame.size.height/2);
//
//
//	CGRect rr = _alertView.frame;
//	rr.origin.x = (int)rr.origin.x;
//	rr.origin.y = (int)rr.origin.y;
//	_alertView.frame = rr;

    _alertView.center = CGPointMake([UIScreen mainScreen].bounds.size.width/2, [UIScreen mainScreen].bounds.size.height/2);

	UIInterfaceOrientation o = [UIApplication sharedApplication].statusBarOrientation;
	CGFloat degrees = 0;
	if(o == UIInterfaceOrientationLandscapeLeft ) degrees = -90;
	else if(o == UIInterfaceOrientationLandscapeRight ) degrees = 90;
	else if(o == UIInterfaceOrientationPortraitUpsideDown) degrees = 180;
	_alertView.transform = CGAffineTransformMakeRotation(degrees * M_PI / 180);
	_alertView.transform = CGAffineTransformScale(_alertView.transform, 2, 2);

	[UIView beginAnimations:nil context:nil];
	[UIView setAnimationDuration:0.15];
	[UIView setAnimationDelegate:self];
	[UIView setAnimationDidStopSelector:@selector(animationStep2)];

	_alertView.transform = CGAffineTransformMakeRotation(degrees * M_PI / 180);
	_alertView.frame = CGRectMake((int)_alertView.frame.origin.x, (int)_alertView.frame.origin.y, _alertView.frame.size.width, _alertView.frame.size.height);
	_alertView.alpha = 1;
	if (isRect) {
        CGRect frame = _alertView.frame;
        frame.origin.y = self.origin_y;
        _alertView.frame = frame;
    }
	[UIView commitAnimations];

}
- (void) animationStep2{
	[UIView beginAnimations:nil context:nil];

	// depending on how many words are in the text
	// change the animation duration accordingly
	// avg person reads 200 words per minute
	NSArray * words = [[[self.alerts objectAtIndex:0] objectAtIndex:0] componentsSeparatedByCharactersInSet:[NSCharacterSet whitespaceCharacterSet]];
	double duration = MAX(((double)[words count]*60.0/200.0),1);

	[UIView setAnimationDelay:duration + 1];
	[UIView setAnimationDelegate:self];
	[UIView setAnimationDidStopSelector:@selector(animationStep3)];

	UIInterfaceOrientation o = [UIApplication sharedApplication].statusBarOrientation;
	CGFloat degrees = 0;
	if(o == UIInterfaceOrientationLandscapeLeft ) degrees = -90;
	else if(o == UIInterfaceOrientationLandscapeRight ) degrees = 90;
	else if(o == UIInterfaceOrientationPortraitUpsideDown) degrees = 180;
	_alertView.transform = CGAffineTransformMakeRotation(degrees * M_PI / 180);
	_alertView.transform = CGAffineTransformScale(_alertView.transform, 0.5, 0.5);

	_alertView.alpha = 0;
	[UIView commitAnimations];
}

- (void) animationStep3{

	[_alertView removeFromSuperview];
	[alerts removeObjectAtIndex:0];
	[self showAlerts];

}

- (void) postAlertWithMessage:(NSString*)message image:(UIImage*)image{
	[self.alerts addObject:[NSArray arrayWithObjects:message,image,nil]];
	if(!_active) [self showAlerts];
}

- (void) postAlertWithMessage:(NSString*)message{
	[self postAlertWithMessage:message image:nil];
    isRect = NO;
}

- (void) postAlertWithMessage:(NSString *)message origin_y:(float)origin_y{
    self.origin_y = origin_y;
    isRect = YES;
    [self postAlertWithMessage:message image:nil];
}

- (void) dealloc{
	[alerts release];
	[_alertView release];
	[super dealloc];
}

CGRect subtractRect(CGRect wf,CGRect kf){

	if(!CGPointEqualToPoint(CGPointZero,kf.origin)){

		if(kf.origin.x>0) kf.size.width = kf.origin.x;
		if(kf.origin.y>0) kf.size.height = kf.origin.y;
		kf.origin = CGPointZero;

	}else{

		kf.origin.x = abs(kf.size.width - wf.size.width);
		kf.origin.y = abs(kf.size.height -  wf.size.height);

		if(kf.origin.x > 0){
			CGFloat temp = kf.origin.x;
			kf.origin.x = kf.size.width;
			kf.size.width = temp;
		}else if(kf.origin.y > 0){
			CGFloat temp = kf.origin.y;
			kf.origin.y = kf.size.height;
			kf.size.height = temp;
		}

	}
	return CGRectIntersection(wf, kf);

}

- (void) keyboardWillAppear:(NSNotification *)notification {

	NSDictionary *userInfo = [notification userInfo];
	NSValue* aValue = [userInfo objectForKey:UIKeyboardFrameEndUserInfoKey];

	//NSValue* aValue = [userInfo objectForKey:UIKeyboardBoundsUserInfoKey];

	CGRect kf = [aValue CGRectValue];
	CGRect wf = [UIApplication sharedApplication].keyWindow.bounds;

	[UIView beginAnimations:nil context:nil];
	_alertFrame = subtractRect(wf,kf);
	_alertView.center = CGPointMake(_alertFrame.origin.x+_alertFrame.size.width/2, _alertFrame.origin.y+_alertFrame.size.height/2);

	[UIView commitAnimations];

}
- (void) keyboardWillDisappear:(NSNotification *) notification {
	_alertFrame = [UIApplication sharedApplication].keyWindow.bounds;

}
- (void) orientationWillChange:(NSNotification *) notification {

	NSDictionary *userInfo = [notification userInfo];
	NSNumber *v = [userInfo objectForKey:UIApplicationStatusBarOrientationUserInfoKey];
	UIInterfaceOrientation o = [v intValue];

	CGFloat degrees = 0;
	if(o == UIInterfaceOrientationLandscapeLeft ) degrees = -90;
	else if(o == UIInterfaceOrientationLandscapeRight ) degrees = 90;
	else if(o == UIInterfaceOrientationPortraitUpsideDown) degrees = 180;

	[UIView beginAnimations:nil context:nil];
	_alertView.transform = CGAffineTransformMakeRotation(degrees * M_PI / 180);
	_alertView.frame = CGRectMake((int)_alertView.frame.origin.x, (int)_alertView.frame.origin.y, (int)_alertView.frame.size.width, (int)_alertView.frame.size.height);

	[UIView commitAnimations];

}

@end

@implementation TKAlertView

- (id) init{

	if(!(self = [super initWithFrame:CGRectMake(0, 0, 100, 100)])) return nil;

	messageRect = CGRectInset(self.bounds, 10, 10);
	self.backgroundColor = [UIColor clearColor];

	return self;

}
- (void) adjust{

	CGSize s = [text sizeWithFont:[UIFont boldSystemFontOfSize:14] constrainedToSize:CGSizeMake(160,200) lineBreakMode:NSLineBreakByWordWrapping];

	float imageAdjustment = 0;
	if (image) {
		imageAdjustment = 7+image.size.height;
	}

	self.bounds = CGRectMake(0, 0, s.width+40, s.height+15+15+imageAdjustment);

	messageRect.size = s;
	messageRect.size.height += 5;
	messageRect.origin.x = 20;
	messageRect.origin.y = 15+imageAdjustment;

	[self setNeedsLayout];
	[self setNeedsDisplay];

}
- (void) setMessageText:(NSString*)str{
	[text release];
	text = [str retain];
	[self adjust];
}
- (void) setImage:(UIImage*)img{
	[image release];
	image = [img retain];

	[self adjust];
}
- (void) drawRect:(CGRect)rect{
	[[UIColor colorWithWhite:0 alpha:0.8] set];
	[UIView drawRoundRectangleInRect:rect withRadius:10];
	[[UIColor whiteColor] set];
	[text drawInRect:messageRect withFont:[UIFont boldSystemFontOfSize:14] lineBreakMode:NSLineBreakByWordWrapping alignment:NSTextAlignmentCenter];

	CGRect r = CGRectZero;
	r.origin.y = 15;
	r.origin.x = (rect.size.width-image.size.width)/2;
	r.size = image.size;

	[image drawInRect:r];
}
- (void) dealloc{
	[text release];
	[image release];
	[super dealloc];
}

@end

redpajama_set_name: RedPajamaGithub


text:
/**
 * Created by Layman(http://github.com/anysome) on 16/3/10.
 */
import React from 'react';
import {StyleSheet, View, Text} from 'react-native';
import moment from 'moment';
import TouchableBounce from 'TouchableBounce';
import {colors, styles, px1} from '../../app';
import objective from '../../logic/Objective';

export default class ListRow extends React.Component {

  constructor(props) {
    super(props);
  }

  _transform(target) {
    let dateEnd = moment(target.dateEnd);
    let unitName = objective.getUnitName(target.unit);
    let maybe = '';
    let undoSize = 26, doneColor = colors.dark2;
    if (target.requiredAmount === 1) {
      if (target.doneAmount) {
        undoSize = 14;
        doneColor = colors.border;
      }
    } else {
      if (target.doneAmount) {
        undoSize = 14;
        doneColor = colors.border;
      }
    }
    if (target.frequency === '1') {
      maybe = '1 天 ' + target.requiredAmount + unitName;
    } else {
      let ms = target.roundDateEnd - this.props.today;
      let checkLeftDays = 1;
      if (ms > 0) {
        checkLeftDays = ms / 86400000 + 1;
      }
      let lefts = target.requiredAmount - target.roundTotal;
      if (lefts < 1) {
        maybe = '偷着乐吧';
      } else if (checkLeftDays === 1) {
        maybe = '1 天 ' + lefts + unitName;
      } else {
        let rate = lefts / checkLeftDays;
        if (rate > 1) {
          maybe = '1 天 ' + rate.toFixed(1) + unitName;
        } else {
          rate = checkLeftDays / lefts;
          maybe = rate.toFixed(1) + ' 天 1 ' + unitName;
        }
      }
    }
    let frequencyName = objective.getFrequencyName(target.frequency);
    return {
      priorityColor: objective.getPriorityColor(target.priority),
      title: target.title,
      detail: target.detail,
      timeLeft: dateEnd.add(1, 'days').fromNow(),
      progress: target.doneTotal,
      maybe: maybe,
      undoSize: undoSize,
      doneColor: doneColor,
      arrangedColor: target.arranged ? colors.border : colors.dark2,
      summary: `${frequencyName} ${target.requiredAmount} ${unitName}`
    };
  }

  render() {
    var transform = this._transform(this.props.data);
    return (
      <TouchableBounce style={[style.container, {borderLeftColor: transform.priorityColor}]}
                        onPress={this.props.onPress}
                        onLongPress={this.props.onLongPress}>
        <Text style={style.title}>「+{transform.progress}」{transform.title}</Text>
        <Text style={style.text}>
          {transform.summary},  预计 <Text style={{color: transform.arrangedColor,fontSize: transform.undoSize}}>{transform.maybe}</Text>
        </Text>
        <View style={style.containerF}>
          <Text style={style.hint}>{transform.detail}</Text>
          <Text style={[styles.text, {color: transform.doneColor}]}>{transform.timeLeft}</Text>
        </View>
      </TouchableBounce>
    );
  }
}

const style = StyleSheet.create({
  container: {
    flexDirection: 'column',
    flex: 1,
    paddingRight: 16,
    paddingLeft: 10,
    paddingTop: 8,
    paddingBottom: 8,
    backgroundColor: 'white',
    borderLeftWidth: 6,
    borderLeftColor: colors.border
  },
  title: {
    flex: 1,
    color: colors.dark1,
    fontSize: 20,
    marginLeft: -10
  },
  text: {
    paddingTop: 3,
    paddingBottom: 4,
    color: colors.border,
    fontSize: 14
  },
  containerF: {
    flex: 1,
    flexDirection: 'row',
    justifyContent: 'space-between'
  },
  hint: {
    flex: 1,
    fontSize: 12,
    paddingRight: 8,
    color: colors.border
  }
});


text:
(function (Popcorn) {

"use strict";

	var styleSheet;

	Popcorn.basePlugin( 'words' , function(options, base) {
		var popcorn,
			video,
			classes,
			container,
			textContainer,
			text, node, i;

		if (!base.target || !options.text) {
			return;
		}

		popcorn = this;
		video = popcorn.media;

		//todo: add stylesheet with basePlugin
		if (!styleSheet) {
			styleSheet = document.createElement('style');
			styleSheet.setAttribute('type', 'text/css');
			styleSheet.appendChild(
				document.createTextNode(
					'.popcorn-words { display: none; }\n' +
					'.popcorn-words > a { color: inherit; }\n' +
					'.popcorn-words.active { display: block; }\n'
			));
			document.head.appendChild(styleSheet);
		}

		container = base.makeContainer();

		container.style.cssText = options.style || '';

		base.animate(base.container);

		if (options.classes) {
			base.addClass(container, options.classes);
		}

		if (options.link) {
			//todo: localize link
			textContainer = document.createElement('a');
			textContainer.setAttribute('href', options.link);
			if (options.linkTarget) {
				textContainer.setAttribute('target', options.linkTarget);
			} else {
				textContainer.setAttribute('target', '_new');
			}

			//pause video when link is clicked
			textContainer.addEventListener('click', function() {
				video.pause();
			}, false);

			container.appendChild(textContainer);
		} else {
			textContainer = container;
		}

		//todo: localize
		text = base.toArray(options.text, /[\n\r]/);
		for (i = 0; i < text.length; i++) {
			if (i) {
				textContainer.appendChild(document.createElement('br'));
			}
			textContainer.appendChild(document.createTextNode(text[i]));
		}

		if (typeof options.onLoad === 'function') {
			options.onLoad(options);
		}

		return {
			start: function( event, options ) {
				base.addClass(base.container, 'active');
			},
			end: function( event, options ) {
				base.removeClass(base.container, 'active');
			}
		};
	});
}( Popcorn ));


text:
"""Alarmdotcom exceptions."""
from homeassistant.exceptions import HomeAssistantError

class Require2FA(HomeAssistantError):  # type: ignore
    """Error to indicate we require 2FA."""

class CannotConnect(HomeAssistantError):  # type: ignore
    """Error to indicate we cannot connect."""

class InvalidAuth(HomeAssistantError):  # type: ignore
    """Error to indicate there is invalid auth."""

class UnexpectedDataFormat(HomeAssistantError):  # type: ignore
    """Error to indicate there is invalid auth."""

class PartialInitialization(HomeAssistantError):  # type: ignore
    """Error for AlarmHub to indicate that integration has not yet been set up."""


text:
using System;
using System.Threading;
using Arcade.Run.Execution;
using Arcade.Run.Messages;
using Arcade.Run.Tasks.Projections;

namespace Arcade.Run.Tasks
{
    public sealed class ContinueFromCancelledFlowTask : ITask
    {
        private readonly Guid _correlationIdToContinueFrom;
        private readonly CancellationTokenSource _cts;
        private readonly Guid? _contextId;
        private readonly RunId _runId;

        public ContinueFromCancelledFlowTask(RunId runId, Guid correlationIdToContinueFrom, CancellationTokenSource cts, Guid? contextId)
        {
            _runId = runId;
            _correlationIdToContinueFrom = correlationIdToContinueFrom;
            _cts = cts;
            _contextId = contextId;
        }

        public RunId RunId
        {
            get { return _runId; }
        }

        public void Run(Action<IRuntimeMessage> observe)
        {
            observe(new FlowCancelledMessage(_runId, _correlationIdToContinueFrom, _cts, _contextId));
        }

        public void AcceptVisitor(ITaskVisitor visitor)
        {

        }
    }
}


text:
require 'optparse'
require 'rdoc/usage'
require 'ostruct'
require 'date'
require 'pp'

require 'progressbar'
require 'json'
require 'gmap_polyline_encoder.rb'
require 'zlib'
require 'tempfile'
require 'fileutils'

require 'proj4rb'

require 'geo_ruby'
include GeoRuby::Shp4r

class App
  VERSION = '0.2.0'

  attr_reader :options

  def initialize(arguments, stdin)
    @arguments = arguments
    @stdin = stdin

    # Set defaults
    @options = OpenStruct.new
    @options.verbose = false
    @options.quiet = false
    @options.simplify_p = true
    @options.output_file = 'output.js'
  end

  # Parse options, check arguments, then process the command
  def run

    if parsed_options? && arguments_valid?

      puts "Start at #{DateTime.now}\n\n" if @options.verbose

      output_options if @options.verbose # [Optional]

      process_arguments
      process_command

      puts "\nFinished at #{DateTime.now}" if @options.verbose

    else
      output_usage
    end

  end

  protected

    def parsed_options?

      # Specify options
      opts = OptionParser.new
      opts.on('-v', '--version')    { output_version ; exit 0 }
      opts.on('-h', '--help')       { output_help }
      opts.on('-V', '--verbose')    { @options.verbose = true }
      opts.on('-q', '--quiet')      { @options.quiet = true }

      opts.on('-o', '--output FILE', "Output file") do |f|
        @options.output_file = f
      end

      opts.on('-s', '--[no-]simplify') do |simplify|
        @options.simplify_p = simplify
      end

      opts.parse!(@arguments) rescue return false

      process_options
      true
    end

    # Performs post-parse processing on options
    def process_options
      @options.verbose = false if @options.quiet
    end

    def output_options
      puts "Options:\n"

      @options.marshal_dump.each do |name, val|
        puts "  #{name} = #{val}"
      end
    end

    # True if required arguments were provided
    def arguments_valid?
      # TODO - implement your real logic here
      true if @arguments.length >= 1

      # TODO: Does the output file already exist? Should we overwrite by default?
    end

    # Setup the arguments
    def process_arguments
      # TO DO - place in local vars, etc
    end

    def output_help
      output_version
      RDoc::usage() #exits app
    end

    def output_usage
      RDoc::usage('usage') # gets usage from comments above
    end

    def output_version
      puts "#{File.basename(__FILE__)} version #{VERSION}"
    end

    def process_command
      # Loop over each shapefile specified on the command line
      # and process the shapes contained within

      output_file = File.new(@options.output_file, "w+")

      @all_polygons = Array.new
      ARGV.each do |a|
        Dir.glob(a) do |shp|
            shp_basename = File.basename(shp)
            if shp_basename =~ /(.*)\.shp$/
                ShpFile.open(shp) do |shp|
                    pbar = ProgressBar.new(File.basename(a), shp.record_count, STDOUT)
                    pbar.format="%-14s %3d%% %s %s"

                    shp.each do |shape|
                        pbar.inc
                        shape.data["STATEFP00"] ||= ""
                        shape.data["COUNTYFP00"] ||= ""
                        shape.data["TRACTCE00"] ||= ""

                        # The FPID is useful for quickly narrowing down a search of the shapes
                        shape.data["FPID"] = shape.data["STATEFP00"] + shape.data["COUNTYFP00"] + shape.data["TRACTCE00"]

                        # Loop over each ring that makes up the polygon
                        # (mostly 1 polygon per shape, in this case)
                        @rings = Array.new
                        # shape.geometry.geomtries is an array of polygons
                        shape.geometry.geometries.each do |line_ring|
                            line_ring.each do |ring|
                                @this_ring = Array.new
                                ring.points.each do |p|
                                    # p.x and p.y are the points for this polygon

                                    # TODO: use proj4 to project these into utm

                                    @this_ring.push([p.x, p.y])
                                end
                                @rings.push(@this_ring)
                            end
                        end # end rings

                        @all_polygons.push(@rings)
                    end # end each shape
                end # end if shapefile
            end # end shapefile open

            #encoder = GMapPolylineEncoder.new()
            #shape.data["POLYLINES"] = encoder.encode(@all_polygons)
            output_file.syswrite(@all_polygons.to_json)

        end # end Dir
      end # end ARGV each

      puts
      puts "Done processing all shapefiles that were found."
    end
end

# Create and run the application
app = App.new(ARGV, STDIN)
app.run


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Qart.Core.Io.FileRolling
{
    public class FileBasedPositionStore : IFilePositionStore
    {
        //TODO concurrency
        private IDictionary<string, FilePosition> _positions;

        public string BaseDir { get; private set; }

        public FileBasedPositionStore(string baseDir)
        {
            BaseDir = baseDir;
            _positions = new Dictionary<string, FilePosition>();
        }

        public FilePosition GetPosition(string baseFileName)
        {
            FilePosition item;
            if (_positions.TryGetValue(baseFileName, out item))
            {
                return item;
            }
            else
            {
                string fileName = GetTargetFileName(baseFileName);
                if (File.Exists(fileName))
                {
                    using (var stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read))
                    using (var reader = new StreamReader(stream, Encoding.UTF8, false, 200))
                    {
                        return FilePositionSerialiser.Read(baseFileName, reader);
                    }
                }

                return null;
            }
        }

        public void SetPosition(FileId fileId, long pos)
        {
            var position = new FilePosition(fileId, pos);
            _positions[fileId.BaseFileName] = position;

            using (var stream = FileUtils.OpenFileStreamForWritingNoTruncate(GetTargetFileName(fileId.BaseFileName)))
            using (var writer = new StreamWriter(stream))
            {
                FilePositionSerialiser.Write(position, writer);
            }
        }

        private string GetTargetFileName(string fileName)
        {
            //TODO include dir as well

            return Path.Combine(BaseDir, "_" + Path.GetFileName(fileName));
        }

        public void Dispose()
        {
            //TODO flush cached postions
        }
    }
}


text:
import pytest

from tests import ClientHTTPStubber, create_session, mock

OPERATION_PARAMS = {
    'change_password': {
        'PreviousPassword': 'myoldbadpassword',
        'ProposedPassword': 'mynewgoodpassword',
        'AccessToken': 'foobar',
    },
    'confirm_forgot_password': {
        'ClientId': 'foo',
        'Username': 'myusername',
        'ConfirmationCode': 'thisismeforreal',
        'Password': 'whydowesendpasswordsviaemail',
    },
    'confirm_sign_up': {
        'ClientId': 'foo',
        'Username': 'myusername',
        'ConfirmationCode': 'ireallydowanttosignup',
    },
    'delete_user': {'AccessToken': 'foobar'},
    'delete_user_attributes': {
        'UserAttributeNames': ['myattribute'],
        'AccessToken': 'foobar',
    },
    'forgot_password': {'ClientId': 'foo', 'Username': 'myusername'},
    'get_user': {'AccessToken': 'foobar'},
    'get_user_attribute_verification_code': {
        'AttributeName': 'myattribute',
        'AccessToken': 'foobar',
    },
    'resend_confirmation_code': {'ClientId': 'foo', 'Username': 'myusername'},
    'set_user_settings': {
        'AccessToken': 'randomtoken',
        'MFAOptions': [
            {'DeliveryMedium': 'SMS', 'AttributeName': 'someattributename'}
        ],
    },
    'sign_up': {
        'ClientId': 'foo',
        'Username': 'bar',
        'Password': 'mysupersecurepassword',
    },
    'update_user_attributes': {
        'UserAttributes': [{'Name': 'someattributename', 'Value': 'newvalue'}],
        'AccessToken': 'foobar',
    },
    'verify_user_attribute': {
        'AttributeName': 'someattributename',
        'Code': 'someverificationcode',
        'AccessToken': 'foobar',
    },
}

@pytest.mark.parametrize(
    "operation_name, parameters", OPERATION_PARAMS.items()
)
def test_unsigned_operations(operation_name, parameters):
    environ = {
        'AWS_ACCESS_KEY_ID': 'access_key',
        'AWS_SECRET_ACCESS_KEY': 'secret_key',
        'AWS_CONFIG_FILE': 'no-exist-foo',
    }

    with mock.patch('os.environ', environ):
        session = create_session()
        session.config_filename = 'no-exist-foo'
        client = session.create_client('cognito-idp', 'us-west-2')
        http_stubber = ClientHTTPStubber(client)

        operation = getattr(client, operation_name)

        http_stubber.add_response(body=b'{}')
        with http_stubber:
            operation(**parameters)
            request = http_stubber.requests[0]

        assert (
            'authorization' not in request.headers
        ), 'authorization header found in unsigned operation'


text:
var type = require('dis-isa');

var _transform = (function getTransform() {
  if (typeof(process) === 'undefined') {
    return function(data) {
      if (type.isPlainObject(data)) {
        return JSON.stringify(data);
      }
      return data;
    };
  }
  else {
    return function(data) {
      return data;
    };
  }
})();

var _console = (function getConsole() {
  if (typeof(console) === 'undefined') {
    return {
      log: function() {},
      error: function() {}
    };
  }
  else {
    return console;
  }
})();

function _setHandled(data) {
  try {data.handled = true;} catch(ex) {}
}

/**
 * Logs error to the console and makes sure it is only logged once.
 */
function log(data) {
  if (type.isError(data)) {
    if (!data.handled) {
      _setHandled(data);
      _console.error(data);
    }
  }
  else {
    _console.log(_transform(data));
  }
  return data;
}

module.exports = log;


text:
package fi.kela.kanta.cda;

import java.io.IOException;
import java.util.ArrayList;

import javax.xml.bind.JAXBException;

import org.hl7.v3.POCDMT000040ClinicalDocument;
import org.hl7.v3.POCDMT000040InfrastructureRootTemplateId;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;

import fi.kela.kanta.to.LaakemaarayksenLukituksenPurkuTO;
import fi.kela.kanta.to.LaakemaaraysTO;
import fi.kela.kanta.to.ValmisteTO;
import fi.kela.kanta.to.ValmisteenYksilointitiedotTO;

/**
 * Testiluokka reseptin lukituksen purku kasaajan cdan muodostamisen testaamiseen
 *
 */
public class ReseptinLukituksenPurkuKasaajaCDATest {

    private static final String testSelitys = "TESTI SELITYS";
    private static final String testLukitusOid = "1.3.5.678.91011";
    private static final String testLukitusSetId = "1.3.5.678.91012";
    private static final String testAlkupOid = "1.12.123.1234.12345.123456";
    private static final String testAlkupSetId = "1.12.123.1234.12345.1234567";

    private ReseptinLukituksenPurkuKasaaja setupReseptinLukituksenPurkuKasaaja(
            LaakemaarayksenLukituksenPurkuTO lukituksenPurku, LaakemaaraysTO alkuperainenLaakemaarays)
            throws IOException {
        return new ReseptinLukituksenPurkuKasaaja(KantaCDATestUtils.loadProperties("testi_properties.properties"),
                lukituksenPurku, alkuperainenLaakemaarays);
    }

    @Ignore
    @Test
    public void testReseptinLukituksenPurku() throws IOException, JAXBException {
        LaakemaaraysTO laakemaarays = new LaakemaaraysTO();
        LaakemaarayksenLukituksenPurkuTO purku = new LaakemaarayksenLukituksenPurkuTO();

        taytaPakollisetTiedot(laakemaarays);
        taytaPakollisetTiedot(purku);
        laakemaarays.setOid(testAlkupOid);
        laakemaarays.setSetId(testAlkupSetId);
        ReseptinLukituksenPurkuKasaaja kasaaja = setupReseptinLukituksenPurkuKasaaja(purku, laakemaarays);
        String cda = kasaaja.kasaaReseptiAsiakirja();
        System.out.println(cda);
    }

    private void taytaPakollisetTiedot(LaakemaarayksenLukituksenPurkuTO purku) {
        purku.setPurkaja(KantaCDATestUtils.luoAmmattihenkilo());
        purku.getPurkaja().setRooli(null);
        purku.getPurkaja().setVirkanimike("Ylilääkäri");
        purku.getPurkaja().setOppiarvo("Lääketieteen lisensiaatti");
        purku.getPurkaja().setErikoisala("86173-680");
        purku.getPurkaja().setErikoisalaName("erikoislääkäri yleislääketiede");
        purku.setSelitys(testSelitys);
        purku.setLukitussanomanOid(testLukitusOid);
        purku.setLukitussanomanSetId(testLukitusSetId);
        purku.setLukitussanomanVersio(1);
    }

    private void taytaPakollisetTiedot(LaakemaaraysTO laakemaarays) {
        laakemaarays.setAmmattihenkilo(KantaCDATestUtils.luoAmmattihenkilo());
        laakemaarays.getAmmattihenkilo().setOrganisaatio(laakemaarays.getAmmattihenkilo().getOrganisaatio());
        laakemaarays.setPotilas(KantaCDATestUtils.luoPotilas());
        laakemaarays.setReseptintyyppi("1");
        ValmisteenYksilointitiedotTO yksilointitiedot = new ValmisteenYksilointitiedotTO();
        yksilointitiedot.setValmisteenLaji("valmisteenLaji");
        yksilointitiedot.setPakkauskokoteksti("pakkauskokoteksti");
        ValmisteTO valmiste = new ValmisteTO();
        valmiste.setYksilointitiedot(yksilointitiedot);
        laakemaarays.setValmiste(valmiste);
        laakemaarays.getHoitolajit().add("3");
    }

    @Test
    public void testReseptiLukituksenPurkuTemplateId() throws IOException {
        LaakemaaraysTO laakemaarays = new LaakemaaraysTO();
        LaakemaarayksenLukituksenPurkuTO purku = new LaakemaarayksenLukituksenPurkuTO();

        taytaPakollisetTiedot(laakemaarays);
        taytaPakollisetTiedot(purku);
        laakemaarays.setOid(testAlkupOid);
        laakemaarays.setSetId(testAlkupSetId);
        purku.getTemplateIds().add("1.2.246.777.11.2015.11");
        purku.getTemplateIds().add("1.2.246.777.11.2014.17");
        ReseptinLukituksenPurkuKasaaja kasaaja = setupReseptinLukituksenPurkuKasaaja(purku, laakemaarays);
        POCDMT000040ClinicalDocument cda = kasaaja.kasaaReseptiCDA();
        ArrayList<String> cdaTemplateIds = new ArrayList<String>();
        for (POCDMT000040InfrastructureRootTemplateId templateId : cda.getTemplateIds()) {
            cdaTemplateIds.add(templateId.getRoot());
            Assert.assertTrue(purku.getTemplateIds().contains(templateId.getRoot()));
        }
        Assert.assertTrue(cdaTemplateIds.contains("1.2.246.777.11.2015.11"));
        Assert.assertTrue(cdaTemplateIds.contains("1.2.246.777.11.2014.17"));
    }
}


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

    <!-- From: file:/W:/vanilla/vanilindy/StudioProject/app/src/main/res/values-uk/translatable.xml -->
    <eat-comment />

    <plurals name="added_to_playlist">
        <item quantity="one">1 пісня додана до списку %2$s.</item>
        <item quantity="other">%1$d пісень додано до списку %2$s.</item>
    </plurals>
    <plurals name="deleted">
        <item quantity="one">1 пісню видалено.</item>
        <item quantity="other">%d пісень видалено.</item>
    </plurals>
    <plurals name="enqueued">
        <item quantity="one">Одну пісню видалено з черги.</item>
        <item quantity="other">%d пісень видалено з черги.</item>
    </plurals>
    <plurals name="hours">
        <item quantity="one">1 година</item>
        <item quantity="other">%d годин</item>
    </plurals>
    <plurals name="minutes">
        <item quantity="one">1 хвилина</item>
        <item quantity="other">%d хвилин</item>
    </plurals>
    <plurals name="playing">
        <item quantity="one">1 пісня грає.</item>
        <item quantity="other">%d пісень відтворюється.</item>
    </plurals>
    <plurals name="seconds">
        <item quantity="one">1 секунда</item>
        <item quantity="other">%d секунд</item>
    </plurals>

    <string name="_album">альбом</string>
    <string name="_artist">виконавець</string>
    <string name="_composer">композитор</string>
    <string name="_format">формат</string>
    <string name="_genre">жанр</string>
    <string name="_title">назва</string>
    <string name="_track">пісня</string>
    <string name="_year">рік</string>
    <string name="about">Про програму</string>
    <string name="accelerometer_shake">Струс акселерометра</string>
    <string name="add_to_playlist">Додати до списку…</string>
    <string name="albums">Альбоми</string>
    <string name="all_songs">Всі пісні</string>
    <string name="always_show">Завжди відображати</string>
    <string name="app_name">Музика</string>
    <string name="artist_album">Виконавець, альбом</string>
    <string name="artist_album_title">Виконавець, альбом, назва</string>
    <string name="artist_album_track">Виконавець, альбом, номер пісні</string>
    <string name="artist_year">Виконавець, рік</string>
    <string name="artists">Виконавець</string>
    <string name="ascending">За зростанням</string>
    <string name="audio">Аудіо</string>
    <string name="cancel">Скасувати</string>
    <string name="choose_playlist_name">Введіть назву списку</string>
    <string name="clear_queue">Очистити чергу</string>
    <string name="clear_search">Очистити пошук</string>
    <string name="close_notification">Закрити сповіщення</string>
    <string name="controls_in_selector_summary">Показувати поточну пісню та елементи керування в бібліотеці</string>
    <string name="controls_in_selector_title">Елементи керування в бібліотеці</string>
    <string name="cover_art">Обкладинка</string>
    <string name="cover_longpress_action_title">Дія при утриманні на обкладинці</string>
    <string name="cover_press_action_title">Дія при натиску на обкладинку</string>
    <string name="create">Створити</string>
    <string name="customize_tab_order">Налаштуйте порядок та видимість тегів у бібліотеці</string>
    <string name="cycle_repeat_mode">Режим повтору</string>
    <string name="cycle_shuffle_mode">Випадкове відтворення</string>
    <string name="date_added">Дата додавання</string>
    <string name="default_action_title">Стандартна дія</string>
    <string name="default_playlist_action_title">Стандартна дія списку</string>
    <string name="delete">Видалити</string>
    <string name="delete_file_failed">Не вдалося видалити %s.</string>
    <string name="delete_playlist">Видалити список %s?</string>
    <string name="deleted">%s видалено.</string>
    <string name="descending">За спаданням</string>
    <string name="disable_cover_art_summary">Не завантажує обкладинки у всій програмі</string>
    <string name="disable_cover_art_title">Вимкнути обкладинки</string>
    <string name="disable_lockscreen_summary">Не блокувати екран при активному плеєрі</string>
    <string name="disable_lockscreen_title">Вимкнути екран блокування</string>
    <string name="display_mode_title">Режим відображення</string>
    <string name="do_nothing">Нічого не робити</string>
    <string name="done">Виконано</string>
    <string name="double_tap_summary">ПОдвійний тап по віджеті 1х1 відкриє плеєр. Віджет чекає 400мс перед реагуванням на дію.</string>
    <string name="double_tap_title">Віджет з подвійним натиском</string>
    <string name="edit">Редагувати</string>
    <string name="empty_queue">Не вибрано пісень. Додайте їх з бібліотеки або натисніть тут для додавання любих.</string>
    <string name="enable_shake_summary">Активне лише при відтворенні музики. На деяких пристроях не працює при вимкненому екрані.</string>
    <string name="enable_shake_title">Включити керування акселерометром</string>
    <string name="enqueue">Видалити з черги</string>
    <string name="enqueue_all">Очистити чергу</string>
    <string name="enqueue_current_album">Видалити альбом з черги</string>
    <string name="enqueue_current_artist">Видалити виконавця з черги</string>
    <string name="enqueue_current_genre">Видалити жанр з черги</string>
    <string name="expand">Розгорнути</string>
    <string name="files">Файли</string>
    <string name="finished_scanning">Сканування закінчено. Натисніть для сканування ще раз.</string>
    <string name="fixed_info">Інформація зверху</string>
    <string name="genres">Жанри</string>
    <string name="headset_only_summary">Заборонити відтворення музики через гучномовець.</string>
    <string name="headset_only_title">Лише зовнішній вихід</string>
    <string name="headset_pause_summary">Призупиняє при від'єднанні навушників.</string>
    <string name="headset_pause_title">Призупиняти при від'єднанні</string>
    <string name="headset_play_summary">Продовжувати при приєднанні навушників (Спрацює лише при запущеному сервісі)</string>
    <string name="headset_play_title">Продовжувати при приєднанні</string>
    <string name="idle_timeout_title">Час простою</string>
    <string name="info_below_cover">Інформація під обкладинкою</string>
    <string name="info_on_cover">Інформація на обкладинці</string>
    <string name="last_used_action">Остання дія</string>
    <string name="library">Бібліотека</string>
    <string name="library_screen">Екран бібліотеки</string>
    <string name="media_button_beep_summary">Пищати при зміні пісні подвійним натиском кнопки на гарнітурі.</string>
    <string name="media_button_beep_title">Звуковий сигнал при управлінні з гарнітури</string>
    <string name="media_button_summary">Це потрібно для контролю на екрані блокування Android 4.0 і вище.</string>
    <string name="media_button_title">Гарнітура/Bluetooth керування</string>
    <string name="media_scan">Оновити бібліотеку</string>
    <string name="misc_features">Різні функції</string>
    <string name="more_from_album">Більше з альбому</string>
    <string name="more_from_artist">Інші пісні виконавця</string>
    <string name="name">Ім'я</string>
    <string name="never_show">Не відображати</string>
    <string name="new_playlist">Новий список…</string>
    <string name="next_album">Наступний альбом</string>
    <string name="next_song">Наступна пісня</string>
    <string name="no_repeat">Не повторювати</string>
    <string name="no_shuffle">Не відтворювати у випадковому порядку</string>
    <string name="no_songs">На вашому пристрої не знайдено пісень.</string>
    <string name="none">Немає</string>
    <string name="notification_action_title">Дія сповіщення</string>
    <string name="notification_invert_color_summary">Показувати білий текст замість чорного</string>
    <string name="notification_invert_color_title">Інвертувати колір сповіщення</string>
    <string name="notification_mode_title">Режим сповіщення</string>
    <string name="notification_title_paused">%s (призупинено)</string>
    <string name="notifications">Сповіщення</string>
    <string name="number_of_tracks">Число доріжок</string>
    <string name="open_library">Відкрити бібліотеку</string>
    <string name="open_main_activity">Відкрити бібліотеку (типово)</string>
    <string name="open_mini_popup">Показати мале спливаюче вікно</string>
    <string name="overwrite">Перезаписати</string>
    <string name="play">Грати</string>
    <string name="play_all">Відтворити все</string>
    <string name="play_or_enqueue">Видали з черги при відтворенні; Відтворити при зупиненні</string>
    <string name="play_pause">Відтворення/пауза</string>
    <string name="playback_on_startup_summary">Показувати екран відтворення при запуску</string>
    <string name="playback_on_startup_title">Відкривати при запуску</string>
    <string name="playback_screen">Екран відтворення</string>
    <string name="playback_view">Зараз грає</string>
    <string name="playlists">Списки</string>
    <string name="previous_album">Попередній альбом</string>
    <string name="previous_song">Попередня пісня</string>
    <string name="queue">Черга</string>
    <string name="queue_cleared">Черга очищена</string>
    <string name="random">Випадково</string>
    <string name="random_enabling">Випадкове відтворення увімкнене</string>
    <string name="remove">Усунути</string>
    <string name="rename">Перейменувати</string>
    <string name="repeat">Повторити</string>
    <string name="repeat_current_song">Повторяти поточну пісню</string>
    <string name="restore_default">Скинути налаштування</string>
    <string name="scan_in_progress">Сканування…</string>
    <string name="scrobble_summary">Відсилати до Last.FM через ScrobbleDroid або простим Scrobbler Last.FM</string>
    <string name="scrobble_title">Використовувати ScrobbleDroid API</string>
    <string name="search">Знайти</string>
    <string name="settings">Параметри</string>
    <string name="shake_action_title">Дія при струсі</string>
    <string name="shake_threshold_title">Поріг сили при струсі</string>
    <string name="show_queue">Перейти до черги</string>
    <string name="show_when_playing">Показувати під час відтворення (стандартно)</string>
    <string name="shuffle_albums">Випадкові альбоми</string>
    <string name="shuffle_songs">Випадкові пісні</string>
    <string name="skip_to_next_song">Перейти до наступної пісні</string>
    <string name="song_load_failed">Не вдалося завантажити пісню %s. Вона пошкоджена або відсутня.</string>
    <string name="songs">Пісні</string>
    <string name="sort_by">Сортувати за</string>
    <string name="stock_broadcast_summary">Посилати події, які відсилає стандартний плеєр для роботи інших віджетів та ін.</string>
    <string name="stock_broadcast_title">Емулювати звичайні події</string>
    <string name="stop_current_song">Зупинити в кінці пісні</string>
    <string name="swipe_down_action_title">Дія при жесті вниз</string>
    <string name="swipe_up_action_title">Дія при жесті вверх</string>
    <string name="tabs">Порядок вкладок</string>
    <string name="tap_to_scan">Натисніть для сканування зовнішнього сховища</string>
    <string name="toggle_controls">Перемкнути відображення елементів керування</string>
    <string name="unknown">Невідомий</string>
    <string name="use_idle_timeout_summary">Коли увімкнено, відтворення буде зупинено після певного періоду бездіяльності</string>
    <string name="use_idle_timeout_title">Зупиняти при неактивності</string>
    <string name="volume_title">Гучність</string>
    <string name="year">Рік</string>

</resources>


text:
#ifndef NETWORK_H
#define NETWORK_H

#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <time.h>
#include <signal.h>
#include <assert.h>
#include "timers.h"

#include <string>
#include <iostream>
#include <sched.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include "socket_util.h"
#include "http_client.h"
/*
//buffer 部分,主要存储原始数据
//除了http head以外,这个服务器绝大多数的数据应该由这个buff来存储
struct buffer {
        char *buffs; //实际数据存储的地方
        int datalen;  // 存在的数据长度,方便计算
        int startid;  // 开始id
        int endid;   //结束id
        // 关系是这样的 如果存在100 个空间 存储了50个数据, 那么 startid =0,
endid = 50
        // buffmaxlen = 100;endid  应该《 buffmaxlen 才对
        int buffmaxlen;  //buffmaxlen 再长就有问题
        struct buffer *next; //下一个
        struct buffer *last;  // 链表的最后一个
};
*/
const int K = 1024;

// 60 万连接数
const int MAX_FD = 6 * 10 * K;

// 每次处理event 数目
const int MAXEPOLLEVENT = 10000;

//#define maxlen   65000

#define MAX_CPU 128

typedef int (*readfun)(int epoll, int fd, timer_link *);
typedef int (*writefun)(int epoll, int fd, timer_link *);
typedef int (*closefun)(int epoll, int fd, timer_link *);
typedef int (*timeoutfun)(int epoll, int fd, timer_link *, time_t tnow);

int accept_readfun(int epoll, int listenfd, timer_link *);
int accept_write(int epoll, int listenfd, timer_link *);

int client_readfun(int epoll, int fd, timer_link *timer);
int client_writefun(int epoll, int fd, timer_link *timer);
int client_closefun(int epoll, int fd, timer_link *timer);

int order_readfun(int epoll, int listenfd, timer_link *);

struct worker_thread_arg {
    int orderfd;  // listen 线程会用这个发送fd过来
    int cpuid;
};

struct FdProcess {

    readfun m_readfun;
    writefun m_writefun;
    closefun m_closefun;
    timeoutfun m_timeoutfun;
    time_t m_lastread;
    time_t m_timeout;  // timeout的时间
    bool m_activeclose;

    FdProcess() { init(); }
    void init() {
        m_readfun = NULL;
        m_writefun = NULL;
        m_closefun = NULL;
        m_timeoutfun = NULL;
        m_lastread = time(0);

        m_lastread = 0;

        m_activeclose = false;
    }
};

typedef struct FdProcess FdProcess;
typedef struct FdProcess *PFdProcess;
#define Log std::cerr

bool connect(int &fd, std::string host, int port);

// int listenport = 8888;

bool addtimer(timer_link *, int fd, time_t);

bool checkontimer(timer_link *, int *fd, time_t *);

bool stoptimer(timer_link *, int fd, time_t);

time_t getnexttimer(timer_link *);

void process_event(int epollfd, struct epoll_event *m_events, int timeout,
                   timer_link *timers);

void *worker_thread(void *arg);

void *main_thread(void *arg);
#endif


text:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE locale SYSTEM "../../../../../lib/pkp/dtd/locale.dtd">

<!--
  * plugins/oaiMetadataFormats/rfc1807/locale/ro_RO/locale.xml
  *
  * Copyright (c) 2003-2013 John Willinsky
  * Distributed under the GNU GPL v2. For full terms see the file docs/COPYING.
  *
  * Localization strings for the ro_RO (Romanian) locale.
  *
  -->

<locale name="ro_RO" full_name="Română">
	<message key="plugins.OAIMetadata.rfc1807.displayName">Formant de metadate RFC1807</message>
	<message key="plugins.OAIMetadata.rfc1807.description">Structurează metadatele într-un mod conform cu formatul RFC1807.</message>
</locale>