"""
A few bits of helper functions for comment views.
"""

import textwrap

from django.http import HttpResponseRedirect
from django.shortcuts import render_to_response, resolve_url
from django.template import RequestContext
from django.core.exceptions import ObjectDoesNotExist
from django.contrib import comments
from django.utils.http import is_safe_url
from django.utils.six.moves.urllib.parse import urlencode

def next_redirect(request, fallback, **get_kwargs):
    """
    Handle the "where should I go next?" part of comment views.

    The next value could be a
    ``?next=...`` GET arg or the URL of a given view (``fallback``). See
    the view modules for examples.

    Returns an ``HttpResponseRedirect``.
    """
    next = request.POST.get('next')
    if not is_safe_url(url=next, host=request.get_host()):
        next = resolve_url(fallback)

    if get_kwargs:
        if '#' in next:
            tmp = next.rsplit('#', 1)
            next = tmp[0]
            anchor = '#' + tmp[1]
        else:
            anchor = ''

        joiner = '&' if '?' in next else '?'
        next += joiner + urlencode(get_kwargs) + anchor
    return HttpResponseRedirect(next)

def confirmation_view(template, doc="Display a confirmation view."):
    """
    Confirmation view generator for the "comment was
    posted/flagged/deleted/approved" views.
    """
    def confirmed(request):
        comment = None
        if 'c' in request.GET:
            try:
                comment = comments.get_model().objects.get(pk=request.GET['c'])
            except (ObjectDoesNotExist, ValueError):
                pass
        return render_to_response(template,
            {'comment': comment},
            context_instance=RequestContext(request)
        )

    confirmed.__doc__ = textwrap.dedent("""\
        %s

        Templates: :template:`%s``
        Context:
            comment
                The posted comment
        """ % (doc, template)
    )
    return confirmed

import collections

class OrderedSet(collections.MutableSet):

    def __init__(self, iterable=None):
        self.end = end = [] 
        end += [None, end, end]         # sentinel node for doubly linked list
        self.map = {}                   # key --> [key, prev, next]
        if iterable is not None:
            self |= iterable

    def __len__(self):
        return len(self.map)

    def __contains__(self, key):
        return key in self.map

    def add(self, key):
        if key not in self.map:
            end = self.end
            curr = end[1]
            curr[2] = end[1] = self.map[key] = [key, curr, end]

    def discard(self, key):
        if key in self.map:        
            key, prev, next = self.map.pop(key)
            prev[2] = next
            next[1] = prev

    def __iter__(self):
        end = self.end
        curr = end[2]
        while curr is not end:
            yield curr[0]
            curr = curr[2]

    def __reversed__(self):
        end = self.end
        curr = end[1]
        while curr is not end:
            yield curr[0]
            curr = curr[1]

    def pop(self, last=True):
        if not self:
            raise KeyError('set is empty')
        key = self.end[1][0] if last else self.end[2][0]
        self.discard(key)
        return key

    def __repr__(self):
        if not self:
            return '%s()' % (self.__class__.__name__,)
        return '%s(%r)' % (self.__class__.__name__, list(self))

    def __eq__(self, other):
        if isinstance(other, OrderedSet):
            return len(self) == len(other) and list(self) == list(other)
        return set(self) == set(other)

            
if __name__ == '__main__':
    s = OrderedSet('abracadaba')
    t = OrderedSet('simsalabim')
    print(s | t)
    print(s & t)
    print(s - t)

#!/adsc/DDEA_PROTO/bin/python
# coding: utf-8
"""
======================================================================
Learning and Visualizing the BMS sensor-time-weather data structure
======================================================================
This example employs several unsupervised learning techniques to extract
the energy data structure from variations in Building Automation System (BAS) 
and historial weather data.
The fundermental timelet for analysis are 15 min, referred to as Q. 
** currently use H (Hour) as a fundermental timelet, need to change later **

The following analysis steps are designed and to be executed. 

Data Pre-processing
--------------------------
- Data Retrieval and Standardization
- Outlier Detection
- Interpolation 

Data Summarization
--------------------------
- Data Transformation
- Sensor Clustering

Model Discovery Bayesian Network
--------------------------
- Automatic State Classification
- Structure Discovery and Analysis
"""
#print(__doc__)
# Author: Deokwooo Jung deokwoo.jung@gmail.compile
##################################################################
# General Moduels
from __future__ import division # To forace float point division
import os
import sys
import numpy as np
from numpy.linalg import inv
from numpy.linalg import norm
import uuid

import pylab as pl
from scipy import signal
from scipy import stats
from scipy.interpolate import interp1d

import matplotlib.pyplot as plt
from multiprocessing import Pool
#from datetime import datetime
import datetime as dt
from dateutil import tz
import shlex, subprocess
import mytool as mt
import time
import retrieve_weather as rw
import itertools
import calendar
import random
from matplotlib.collections import LineCollection
import pprint
import radar_chart

# Custom library
from data_tools import *
from data_retrieval import *
from pack_cluster import *
from data_preprocess import *
from shared_constants import *
from pre_bn_state_processing import *
from data_summerization import *
##################################################################
# Interactive mode for plotting
plt.ion() 

##################################################################
# Processing Configuraiton Settings
##################################################################
# all BEMS and weather data is built into a signel variable, 'data_dict'.
# 'data_dict' is a  'dictionary' data structure of python. 
# For debugging or experiment purpose, the program allows to store 'data_dict' variable 
# to data_dict.bin by setting a flag variabe, IS_USING_SAVED_DICT
# IS_USING_SAVED_DICT=0  (Default) : Build a new 'data_dict' variabe and store it to 'data_dict.bin'
# IS_USING_SAVED_DICT=1  :  Skip to build 'data_dict' and load 'data_dict.bin' instead 
# IS_USING_SAVED_DICT=-1  : Neither build nor load 'data_dict' 

# Default flag for processing
PRE_BN_STAGE=0
if PRE_BN_STAGE>0:
    IS_USING_SAVED_DICT=1
    CHECK_DATA_FORMAT=0
    Data_Summarization=1

# Setting Analysis period  where ANS_START_T and ANS_START_T are the starting and
# and the ending timestamp.
ANS_START_T=dt.datetime(2013,6,1,0)
ANS_END_T=dt.datetime(2013,12,1,0)
# Setting for analysis time interval where all BEMS and weather data is aligned
# for a slotted time line quantized by TIMELET_INV. 
TIMELET_INV=dt.timedelta(minutes=60)
print TIMELET_INV, 'time slot interval is set for this data set !!'
print '-------------------------------------------------------------------'

# Compute Average Feature if  PROC_AVG ==True
PROC_AVG=True
# Compute Differential Feature if PROC_DIFF ==True
PROC_DIFF=True

##################################################################
# List buildings and substation names
# Skip all data PRE_BN_STAGE 
#['GW1','GW2','VAK1','VAK2']
bldg_key_set=['GW2']

if PRE_BN_STAGE==0:
    bldg_key_set_run=[]
    print 'skip PRE_BN_STAGE....'
        
else:
    bldg_key_set_run=bldg_key_set


#  Retrieving a set of sensors having a key value in bldg_key_set
for bldg_key in bldg_key_set_run:
    print '###############################################################################'
    print '###############################################################################'
    print 'Processing '+ bldg_key+'.....'
    print '###############################################################################'
    print '###############################################################################'

    #temp=subprocess.check_output('ls '+DATA_DIR+'*'+bldg_key+'*.bin', shell=True)
    temp=subprocess.check_output('ls '+DATA_DIR+'*'+bldg_key+'*.bin | grep POWER', shell=True)
    input_files_temp =shlex.split(temp)
    # Get rid of duplicated files
    input_files_temp=list(set(input_files_temp))
    input_files=input_files_temp
       
    ###############################################################################
    # This directly searches files from bin file name
    print '###############################################################################'
    print '#  Data Pre-Processing'
    print '###############################################################################'
    # define input_files  to be read
    if IS_USING_SAVED_DICT==0:
        print 'Extract a common time range...'
        ANS_START_T,ANS_END_T,input_file_to_be_included=\
        time_range_check(input_files,ANS_START_T,ANS_END_T,TIMELET_INV)
        print 'time range readjusted  to  (' ,ANS_START_T, ', ', ANS_END_T,')'
        start__dictproc_t=time.time()
        data_dict,purge_list=\
        construct_data_dict(input_file_to_be_included,ANS_START_T,ANS_END_T,TIMELET_INV,\
        binfilename=PROC_OUT_DIR + 'data_dict',IS_USING_PARALLEL=IS_USING_PARALLEL_OPT)
        end__dictproc_t=time.time()
        print 'the time of construct data dict.bin is ', end__dictproc_t-start__dictproc_t, ' sec'
        print '--------------------------------------'                
    elif IS_USING_SAVED_DICT==1:
        print 'Loading data dictionary......'
        start__dictproc_t=time.time()         
        data_dict = mt.loadObjectBinaryFast(PROC_OUT_DIR +'data_dict.bin')
        end__dictproc_t=time.time()
        print 'the time of loading data dict.bin is ', end__dictproc_t-start__dictproc_t, ' sec'
        print '--------------------------------------'
    else:
        print 'Skip data dict' 
    
    if CHECK_DATA_FORMAT==1:
        # This is for data verification purpose 
        # You cab skip it if you are sure that there would be no bug in the 'construct_data_dict' function. 
        list_of_wrong_data_format=verify_data_format(data_dict)
        if len(list_of_wrong_data_format)>0:
            print 'Measurement list below'    
            print '----------------------------------------'    
            print list_of_wrong_data_format
            raise NameError('Errors in data format')
    
    # This perform data summerization process. 
    if Data_Summarization==1:
        bldg_out=data_summerization(bldg_key,data_dict,PROC_AVG=True,PROC_DIFF=True)

RECON_BLDG_BIN_OUT=0
if RECON_BLDG_BIN_OUT==1:
    for bldg_key in ['GW1_','GW2_','VAK1_','VAK2_']:
        avgdata_dict=mt.loadObjectBinaryFast('./VTT/'+bldg_key+'avgdata_dict.bin')
        diffdata_dict=mt.loadObjectBinaryFast('./VTT/'+bldg_key+'diffdata_dict.bin')
        data_dict=mt.loadObjectBinaryFast('./VTT/'+bldg_key+'data_dict.bin')
        cmd_str=remove_dot(bldg_key)+'out={\'data_dict\':data_dict}'
        exec(cmd_str)
        cmd_str=remove_dot(bldg_key)+'out.update({\'avgdata_dict\':avgdata_dict})'
        exec(cmd_str)
        cmd_str=remove_dot(bldg_key)+'out.update({\'diffdata_dict\':diffdata_dict})'
        exec(cmd_str)
        cmd_str=remove_dot(bldg_key)+'out.update({\'bldg_key\':remove_dot(bldg_key)})'
        exec(cmd_str)
        cmd_str='mt.saveObjectBinaryFast('+remove_dot(bldg_key)+'out'+',\''+PROC_OUT_DIR+remove_dot(bldg_key)+'out.bin\')'
        exec(cmd_str)
    

print '###############################################################################'
print '#  Model_Discovery'
print '###############################################################################'
#bldg_key_set=['GW1','GW2','VAK1','VAK2']
Model_Discovery=1
pwr_key='_POWER_';
bldg_dict={}
for bldg_load_key in  bldg_key_set:
    print 'Building for ',bldg_load_key, '....'
    try:
        bldg_tag='vtt_'+bldg_load_key
        bldg_load_out=mt.loadObjectBinaryFast(PROC_OUT_DIR+bldg_load_key+'_out.bin')
    except:
        print bldg_load_key+' bin file not found in PROC_OUT_DIR, skip....'
        pass
    mt.saveObjectBinaryFast(bldg_load_out['data_dict'],PROC_OUT_DIR+'data_dict.bin')
    if 'avgdata_dict' in bldg_load_out.keys():
        mt.saveObjectBinaryFast(bldg_load_out['avgdata_dict'],PROC_OUT_DIR+'avgdata_dict.bin')
    if 'diffdata_dict' in bldg_load_out.keys():
        mt.saveObjectBinaryFast(bldg_load_out['diffdata_dict'],PROC_OUT_DIR+'diffdata_dict.bin')
    pname_key= pwr_key
    bldg_dict.update({bldg_tag:create_bldg_obj(PROC_OUT_DIR,bldg_tag,pname_key)})
    bldg_=obj(bldg_dict)
    #cmd_str='bldg_.'+bldg_tag+'.data_out=obj(bldg_load_out)'
    #exec(cmd_str)
    cmd_str='bldg_obj=bldg_.'+bldg_tag
    exec(cmd_str)
    
    anal_out={}
    if 'avgdata_dict' in bldg_load_out.keys():
        anal_out.update({'avg':bn_prob_analysis(bldg_obj,sig_tag_='avg')})
    if 'diffdata_dict' in bldg_load_out.keys():
        anal_out.update({'diff':bn_prob_analysis(bldg_obj,sig_tag_='diff')})
    cmd_str='bldg_.'+bldg_tag+'.anal_out=obj(anal_out)'            
    exec(cmd_str)

# Save vtt building object file.     
mt.saveObjectBinaryFast(bldg_ ,PROC_OUT_DIR+'vtt_bldg_obj.bin')

# this is a vtt specific sensor name conversion 
def convert_vtt_name(id_labels):
    if isinstance(id_labels,list)==False:
        id_labels=[id_labels]
    out_name=[key_label_ for key_label_ in id_labels ]
    return out_name

bldg_.convert_name=convert_vtt_name

#######################################################################################
# Analysis For VTT
#######################################################################################
# Analysis of BN network result - All result will be saved in fig_dir.
BN_ANAL=1
if BN_ANAL==1:
    # Plotting individual LHs
    PLOTTING_LH=0
    if PLOTTING_LH==1:
        plotting_bldg_lh(bldg_,attr_class='sensor',num_picks=30)
        plotting_bldg_lh(bldg_,attr_class='time',num_picks=30)
        plotting_bldg_lh(bldg_,attr_class='weather',num_picks=30)
    
    PLOTTING_BN=1
    if PLOTTING_BN==1:
        plotting_bldg_bn(bldg_)
    

print '**************************** End of Program ****************************'





from south.db import db
from django.db import models
from cms.plugins.picture.models import *

class Migration:
    
    depends_on = (
        ("cms", "0001_initial"),
    )

    def forwards(self, orm):
        
        # Adding model 'Picture'
        db.create_table('picture_picture', (
            ('link', models.CharField(_("link"), max_length=255, null=True, blank=True)),
            ('image', models.ImageField(_("image"), upload_to=CMSPlugin.get_media_path)),
            ('cmsplugin_ptr', models.OneToOneField(orm['cms.CMSPlugin'])),
            ('alt', models.CharField(_("alternate text"), max_length=255, null=True, blank=True)),
        ))
        db.send_create_signal('picture', ['Picture'])
        
    
    
    def backwards(self, orm):
        
        # Deleting model 'Picture'
        db.delete_table('picture_picture')
        
    
    
    models = {
        'cms.cmsplugin': {
            '_stub': True,
            'id': ('models.AutoField', [], {'primary_key': 'True'})
        },
        'cms.page': {
            'Meta': {'ordering': "('tree_id','lft')"},
            '_stub': True,
            'id': ('models.AutoField', [], {'primary_key': 'True'})
        }
    }
    
    

# Copyright 2014 Deutsche Telekom AG
# All Rights Reserved.
#
#    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.

import tempest.common.generator.base_generator as base
from tempest.openstack.common import log as logging


LOG = logging.getLogger(__name__)


class ValidTestGenerator(base.BasicGeneratorSet):
    @base.generator_type("string")
    @base.simple_generator
    def generate_valid_string(self, schema):
        size = schema.get("minLength", 1)
        # TODO(dkr mko): handle format and pattern
        return "x" * size

    @base.generator_type("integer")
    @base.simple_generator
    def generate_valid_integer(self, schema):
        # TODO(dkr mko): handle multipleOf
        if "minimum" in schema:
            minimum = schema["minimum"]
            if "exclusiveMinimum" not in schema:
                return minimum
            else:
                return minimum + 1
        if "maximum" in schema:
            maximum = schema["maximum"]
            if "exclusiveMaximum" not in schema:
                return maximum
            else:
                return maximum - 1
        return 0

    @base.generator_type("object")
    @base.simple_generator
    def generate_valid_object(self, schema):
        obj = {}
        for k, v in schema["properties"].iteritems():
            obj[k] = self.generate_valid(v)
        return obj

    def generate(self, schema):
        schema_type = schema["type"]
        if isinstance(schema_type, list):
            if "integer" in schema_type:
                schema_type = "integer"
            else:
                raise Exception("non-integer list types not supported")
        result = []
        if schema_type not in self.types_dict:
            raise TypeError("generator (%s) doesn't support type: %s"
                            % (self.__class__.__name__, schema_type))
        for generator in self.types_dict[schema_type]:
            ret = generator(schema)
            if ret is not None:
                if isinstance(ret, list):
                    result.extend(ret)
                elif isinstance(ret, tuple):
                    result.append(ret)
                else:
                    raise Exception("generator (%s) returns invalid result: %s"
                                    % (generator, ret))
        return result

    def generate_valid(self, schema):
        return self.generate(schema)[0][1]


__version__ = '0.1.2'
__author__ = 'Juan Batiz-Benet'
__email__ = 'juan@benet.ai'
__doc__ = '''
aws datastore implementation.

Tested with:
* boto 2.5.2

'''

#TODO: Implement queries using a key index.
#TODO: Implement TTL (and key configurations)


from boto.s3.key import Key as S3Key
from boto.exception import S3ResponseError

import datastore.core


class S3BucketDatastore(datastore.Datastore):
  '''Simple aws s3 datastore. Does not support queries.

  The s3 interface is very similar to datastore's. The only differences are:
  - values must be strings (SerializerShimDatastore)
  - keys must be converted into strings

  Hello World:

      >>> import datastore.aws
      >>> from boto.s3.connection import S3Connection
      >>>
      >>> s3conn = S3Connection('<aws access key>', '<aws secret key>')
      >>> s3bucket = s3conn.get_bucket('<bucket name>')
      >>> ds = datastore.aws.S3BucketDatastore(s3bucket)
      >>>
      >>> hello = datastore.Key('hello')
      >>> ds.put(hello, 'world')
      >>> ds.contains(hello)
      True
      >>> ds.get(hello)
      'world'
      >>> ds.delete(hello)
      >>> ds.get(hello)
      None

  '''

  def __init__(self, s3bucket):
    '''Initialize the datastore with given s3 bucket `s3bucket`.

    Args:
      s3bucket: An s3 bucket to use.

    Example::

      from boto.s3.connection import S3Connection
      s3conn = S3Connection('<aws access key>', '<aws secret key>')
      s3bucket = s3conn.get_bucket('<bucket name>')
      s3ds = S3BucketDatastore(s3bucket)
    '''
    self._s3bucket = s3bucket

  def _s3key(self, key):
    '''Return an s3 key for given datastore key.'''
    k = S3Key(self._s3bucket)
    k.key = str(key)
    return k

  @classmethod
  def _s3keys_get_contents_as_string_gen(cls, s3keys):
    '''s3 content retriever generator.'''
    for s3key in s3keys:
      yield s3key.get_contents_as_string()


  def get(self, key):
    '''Return the object named by key or None if it does not exist.

    Args:
      key: Key naming the object to retrieve

    Returns:
      object or None
    '''
    try:
      return self._s3key(key).get_contents_as_string()
    except S3ResponseError, e:
      return None

  def put(self, key, value):
    '''Stores the object `value` named by `key`.

    Args:
      key: Key naming `value`
      value: the object to store.
    '''
    self._s3key(key).set_contents_from_string(value)

  def delete(self, key):
    '''Removes the object named by `key`.

    Args:
      key: Key naming the object to remove.
    '''
    self._s3key(key).delete()

  def query(self, query):
    '''Returns an iterable of objects matching criteria expressed in `query`

    Implementations of query will be the largest differentiating factor
    amongst datastores. All datastores **must** implement query, even using
    query's worst case scenario, see :ref:class:`Query` for details.

    Args:
      query: Query object describing the objects to return.

    Raturns:
      iterable cursor with all objects matching criteria
    '''
    allkeys = self._s3bucket.list(prefix=str(query.key).strip('/'))
    iterable = self._s3keys_get_contents_as_string_gen(allkeys)
    return query(iterable) # must apply filters, order, etc naively.


  def contains(self, key):
    '''Returns whether the object named by `key` exists.

    Args:
      key: Key naming the object to check.

    Returns:
      boalean whether the object exists
    '''
    return self._s3key(key).exists()

import sys
import pytest

from io import StringIO

from django.core.management import call_command

from awx.main.management.commands.update_password import UpdatePassword


def run_command(name, *args, **options):
    command_runner = options.pop('command_runner', call_command)
    stdin_fileobj = options.pop('stdin_fileobj', None)
    options.setdefault('verbosity', 1)
    original_stdin = sys.stdin
    original_stdout = sys.stdout
    original_stderr = sys.stderr
    if stdin_fileobj:
        sys.stdin = stdin_fileobj
    sys.stdout = StringIO()
    sys.stderr = StringIO()
    result = None
    try:
        result = command_runner(name, *args, **options)
    except Exception as e:
        result = e
    finally:
        captured_stdout = sys.stdout.getvalue()
        captured_stderr = sys.stderr.getvalue()
        sys.stdin = original_stdin
        sys.stdout = original_stdout
        sys.stderr = original_stderr
    return result, captured_stdout, captured_stderr


@pytest.mark.parametrize(
    "username,password,expected,changed", [
        ('admin', 'dingleberry', 'Password updated', True),
        ('admin', 'admin', 'Password not updated', False),
        (None, 'foo', 'username required', False),
        ('admin', None, 'password required', False),
    ]
)
def test_update_password_command(mocker, username, password, expected, changed):
    with mocker.patch.object(UpdatePassword, 'update_password', return_value=changed):
        result, stdout, stderr = run_command('update_password', username=username, password=password)
        if result is None:
            assert stdout == expected
        else:
            assert str(result) == expected

#!/usr/bin/env python
from flexbe_core import EventState, Logger


class OperatorDecisionState(EventState):
    '''
    Implements a state where the operator has to manually choose an outcome.
    Autonomy Level of all outcomes should be set to Full,
    because this state is not able to choose an outcome on its own.
    Only exception is the suggested outcome, which will be returned immediately by default.
    This state can be used to create alternative execution paths
    by setting the suggestion to High autonomy instead of Full.

    -- outcomes     string[]    A list of all possible outcomes of this state.
    -- hint         string      Text displayed to the operator to give instructions how to decide.
    -- suggestion   string      The outcome which is suggested.
                                Will be returned if the level of autonomy is high enough.
    '''

    def __init__(self, outcomes, hint=None, suggestion=None):
        super(OperatorDecisionState, self).__init__(outcomes=outcomes)
        self._hint = hint
        self._suggestion = suggestion

    def execute(self, userdata):
        if self._suggestion is not None and self._suggestion in self._outcomes:
            return self._suggestion

    def on_enter(self, userdata):
        if self._hint is not None:
            Logger.loghint(self._hint)

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2017 Google
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# ----------------------------------------------------------------------------
#
#     ***     AUTO GENERATED CODE    ***    AUTO GENERATED CODE     ***
#
# ----------------------------------------------------------------------------
#
#     This file is automatically generated by Magic Modules and manual
#     changes will be clobbered when the file is regenerated.
#
#     Please read more about how to change this file at
#     https://www.github.com/GoogleCloudPlatform/magic-modules
#
# ----------------------------------------------------------------------------

from __future__ import absolute_import, division, print_function
__metaclass__ = type

################################################################################
# Documentation
################################################################################

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ["preview"],
                    'supported_by': 'community'}

DOCUMENTATION = '''
---
module: gcp_compute_router_facts
description:
  - Gather facts for GCP Router
short_description: Gather facts for GCP Router
version_added: 2.7
author: Google Inc. (@googlecloudplatform)
requirements:
    - python >= 2.6
    - requests >= 2.18.4
    - google-auth >= 1.3.0
options:
    filters:
       description:
           A list of filter value pairs. Available filters are listed here
           U(https://cloud.google.com/sdk/gcloud/reference/topic/filters).
           Each additional filter in the list will act be added as an AND condition
           (filter1 and filter2)
    region:
        description:
            - Region where the router resides.
        required: true
extends_documentation_fragment: gcp
'''

EXAMPLES = '''
- name:  a router facts
  gcp_compute_router_facts:
      region: us-central1
      filters:
      - name = test_object
      project: test_project
      auth_kind: service_account
      service_account_file: "/tmp/auth.pem"
'''

RETURN = '''
items:
    description: List of items
    returned: always
    type: complex
    contains:
        id:
            description:
                - The unique identifier for the resource.
            returned: success
            type: int
        creation_timestamp:
            description:
                - Creation timestamp in RFC3339 text format.
            returned: success
            type: str
        name:
            description:
                - Name of the resource. The name must be 1-63 characters long, and comply with RFC1035.
                  Specifically, the name must be 1-63 characters long and match the regular expression
                  `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase
                  letter, and all following characters must be a dash, lowercase letter, or digit,
                  except the last character, which cannot be a dash.
            returned: success
            type: str
        description:
            description:
                - An optional description of this resource.
            returned: success
            type: str
        network:
            description:
                - A reference to the network to which this router belongs.
            returned: success
            type: dict
        bgp:
            description:
                - BGP information specific to this router.
            returned: success
            type: complex
            contains:
                asn:
                    description:
                        - Local BGP Autonomous System Number (ASN). Must be an RFC6996 private ASN, either
                          16-bit or 32-bit. The value will be fixed for this router resource. All VPN tunnels
                          that link to this router will have the same local ASN.
                    returned: success
                    type: int
                advertise_mode:
                    description:
                        - User-specified flag to indicate which mode to use for advertisement.
                        - 'Valid values of this enum field are: DEFAULT, CUSTOM .'
                    returned: success
                    type: str
                advertised_groups:
                    description:
                        - User-specified list of prefix groups to advertise in custom mode.
                        - This field can only be populated if advertiseMode is CUSTOM and is advertised to
                          all peers of the router. These groups will be advertised in addition to any specified
                          prefixes. Leave this field blank to advertise no custom groups.
                        - 'This enum field has the one valid value: ALL_SUBNETS .'
                    returned: success
                    type: list
                advertised_ip_ranges:
                    description:
                        - User-specified list of individual IP ranges to advertise in custom mode. This field
                          can only be populated if advertiseMode is CUSTOM and is advertised to all peers
                          of the router. These IP ranges will be advertised in addition to any specified groups.
                        - Leave this field blank to advertise no custom IP ranges.
                    returned: success
                    type: complex
                    contains:
                        range:
                            description:
                                - The IP range to advertise. The value must be a CIDR-formatted string.
                            returned: success
                            type: str
                        description:
                            description:
                                - User-specified description for the IP range.
                            returned: success
                            type: str
        region:
            description:
                - Region where the router resides.
            returned: success
            type: str
'''

################################################################################
# Imports
################################################################################
from ansible.module_utils.gcp_utils import navigate_hash, GcpSession, GcpModule, GcpRequest
import json

################################################################################
# Main
################################################################################


def main():
    module = GcpModule(
        argument_spec=dict(
            filters=dict(type='list', elements='str'),
            region=dict(required=True, type='str')
        )
    )

    if 'scopes' not in module.params:
        module.params['scopes'] = ['https://www.googleapis.com/auth/compute']

    items = fetch_list(module, collection(module), query_options(module.params['filters']))
    if items.get('items'):
        items = items.get('items')
    else:
        items = []
    return_value = {
        'items': items
    }
    module.exit_json(**return_value)


def collection(module):
    return "https://www.googleapis.com/compute/v1/projects/{project}/regions/{region}/routers".format(**module.params)


def fetch_list(module, link, query):
    auth = GcpSession(module, 'compute')
    response = auth.get(link, params={'filter': query})
    return return_if_object(module, response)


def query_options(filters):
    if not filters:
        return ''

    if len(filters) == 1:
        return filters[0]
    else:
        queries = []
        for f in filters:
            # For multiple queries, all queries should have ()
            if f[0] != '(' and f[-1] != ')':
                queries.append("(%s)" % ''.join(f))
            else:
                queries.append(f)

        return ' '.join(queries)


def return_if_object(module, response):
    # If not found, return nothing.
    if response.status_code == 404:
        return None

    # If no content, return nothing.
    if response.status_code == 204:
        return None

    try:
        module.raise_for_status(response)
        result = response.json()
    except getattr(json.decoder, 'JSONDecodeError', ValueError) as inst:
        module.fail_json(msg="Invalid JSON response with error: %s" % inst)

    if navigate_hash(result, ['error', 'errors']):
        module.fail_json(msg=navigate_hash(result, ['error', 'errors']))

    return result


if __name__ == "__main__":
    main()

##   features.py 
##
##   Copyright (C) 2003-2004 Alexey "Snake" Nezhdanov
##
##   This program is free software; you can redistribute it and/or modify
##   it under the terms of the GNU General Public License as published by
##   the Free Software Foundation; either version 2, or (at your option)
##   any later version.
##
##   This program is distributed in the hope that it will be useful,
##   but WITHOUT ANY WARRANTY; without even the implied warranty of
##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##   GNU General Public License for more details.

# $Id: features.py,v 1.25 2009/04/07 07:11:48 snakeru Exp $

"""
This module contains variable stuff that is not worth splitting into separate modules.
Here is:
    DISCO client and agents-to-DISCO and browse-to-DISCO emulators.
    IBR and password manager.
    jabber:iq:privacy methods
All these methods takes 'disp' first argument that should be already connected
(and in most cases already authorised) dispatcher instance.
"""

from protocol import *

REGISTER_DATA_RECEIVED='REGISTER DATA RECEIVED'

### DISCO ### http://jabber.org/protocol/disco ### JEP-0030 ####################
### Browse ### jabber:iq:browse ### JEP-0030 ###################################
### Agents ### jabber:iq:agents ### JEP-0030 ###################################
def _discover(disp,ns,jid,node=None,fb2b=0,fb2a=1):
    """ Try to obtain info from the remote object.
        If remote object doesn't support disco fall back to browse (if fb2b is true)
        and if it doesnt support browse (or fb2b is not true) fall back to agents protocol
        (if gb2a is true). Returns obtained info. Used internally. """
    iq=Iq(to=jid,typ='get',queryNS=ns)
    if node: iq.setQuerynode(node)
    rep=disp.SendAndWaitForResponse(iq)
    if fb2b and not isResultNode(rep): rep=disp.SendAndWaitForResponse(Iq(to=jid,typ='get',queryNS=NS_BROWSE))   # Fallback to browse
    if fb2a and not isResultNode(rep): rep=disp.SendAndWaitForResponse(Iq(to=jid,typ='get',queryNS=NS_AGENTS))   # Fallback to agents
    if isResultNode(rep): return [n for n in rep.getQueryPayload() if isinstance(n, Node)]
    return []

def discoverItems(disp,jid,node=None):
    """ Query remote object about any items that it contains. Return items list. """
    """ According to JEP-0030:
        query MAY have node attribute
        item: MUST HAVE jid attribute and MAY HAVE name, node, action attributes.
        action attribute of item can be either of remove or update value."""
    ret=[]
    for i in _discover(disp,NS_DISCO_ITEMS,jid,node):
        if i.getName()=='agent' and i.getTag('name'): i.setAttr('name',i.getTagData('name'))
        ret.append(i.attrs)
    return ret

def discoverInfo(disp,jid,node=None):
    """ Query remote object about info that it publishes. Returns identities and features lists."""
    """ According to JEP-0030:
        query MAY have node attribute
        identity: MUST HAVE category and name attributes and MAY HAVE type attribute.
        feature: MUST HAVE var attribute"""
    identities , features = [] , []
    for i in _discover(disp,NS_DISCO_INFO,jid,node):
        if i.getName()=='identity': identities.append(i.attrs)
        elif i.getName()=='feature': features.append(i.getAttr('var'))
        elif i.getName()=='agent':
            if i.getTag('name'): i.setAttr('name',i.getTagData('name'))
            if i.getTag('description'): i.setAttr('name',i.getTagData('description'))
            identities.append(i.attrs)
            if i.getTag('groupchat'): features.append(NS_GROUPCHAT)
            if i.getTag('register'): features.append(NS_REGISTER)
            if i.getTag('search'): features.append(NS_SEARCH)
    return identities , features

### Registration ### jabber:iq:register ### JEP-0077 ###########################
def getRegInfo(disp,host,info={},sync=True):
    """ Gets registration form from remote host.
        You can pre-fill the info dictionary.
        F.e. if you are requesting info on registering user joey than specify 
        info as {'username':'joey'}. See JEP-0077 for details.
        'disp' must be connected dispatcher instance."""
    iq=Iq('get',NS_REGISTER,to=host)
    for i in info.keys(): iq.setTagData(i,info[i])
    if sync:
        resp=disp.SendAndWaitForResponse(iq)
        _ReceivedRegInfo(disp.Dispatcher,resp, host)
        return resp
    else: disp.SendAndCallForResponse(iq,_ReceivedRegInfo, {'agent': host})

def _ReceivedRegInfo(con, resp, agent):
    iq=Iq('get',NS_REGISTER,to=agent)
    if not isResultNode(resp): return
    df=resp.getTag('query',namespace=NS_REGISTER).getTag('x',namespace=NS_DATA)
    if df:
        con.Event(NS_REGISTER,REGISTER_DATA_RECEIVED,(agent, DataForm(node=df)))
        return
    df=DataForm(typ='form')
    for i in resp.getQueryPayload():
        if type(i)<>type(iq): pass
        elif i.getName()=='instructions': df.addInstructions(i.getData())
        else: df.setField(i.getName()).setValue(i.getData())
    con.Event(NS_REGISTER,REGISTER_DATA_RECEIVED,(agent, df))

def register(disp,host,info):
    """ Perform registration on remote server with provided info.
        disp must be connected dispatcher instance.
        Returns true or false depending on registration result.
        If registration fails you can get additional info from the dispatcher's owner
        attributes lastErrNode, lastErr and lastErrCode.
    """
    iq=Iq('set',NS_REGISTER,to=host)
    if type(info)<>type({}): info=info.asDict()
    for i in info.keys(): iq.setTag('query').setTagData(i,info[i])
    resp=disp.SendAndWaitForResponse(iq)
    if isResultNode(resp): return 1

def unregister(disp,host):
    """ Unregisters with host (permanently removes account).
        disp must be connected and authorized dispatcher instance.
        Returns true on success."""
    resp=disp.SendAndWaitForResponse(Iq('set',NS_REGISTER,to=host,payload=[Node('remove')]))
    if isResultNode(resp): return 1

def changePasswordTo(disp,newpassword,host=None):
    """ Changes password on specified or current (if not specified) server.
        disp must be connected and authorized dispatcher instance.
        Returns true on success."""
    if not host: host=disp._owner.Server
    resp=disp.SendAndWaitForResponse(Iq('set',NS_REGISTER,to=host,payload=[Node('username',payload=[disp._owner.Server]),Node('password',payload=[newpassword])]))
    if isResultNode(resp): return 1

### Privacy ### jabber:iq:privacy ### draft-ietf-xmpp-im-19 ####################
#type=[jid|group|subscription]
#action=[allow|deny]

def getPrivacyLists(disp):
    """ Requests privacy lists from connected server.
        Returns dictionary of existing lists on success."""
    try:
        dict={'lists':[]}
        resp=disp.SendAndWaitForResponse(Iq('get',NS_PRIVACY))
        if not isResultNode(resp): return
        for list in resp.getQueryPayload():
            if list.getName()=='list': dict['lists'].append(list.getAttr('name'))
            else: dict[list.getName()]=list.getAttr('name')
        return dict
    except: pass

def getPrivacyList(disp,listname):
    """ Requests specific privacy list listname. Returns list of XML nodes (rules)
        taken from the server responce."""
    try:
        resp=disp.SendAndWaitForResponse(Iq('get',NS_PRIVACY,payload=[Node('list',{'name':listname})]))
        if isResultNode(resp): return resp.getQueryPayload()[0]
    except: pass

def setActivePrivacyList(disp,listname=None,typ='active'):
    """ Switches privacy list 'listname' to specified type.
        By default the type is 'active'. Returns true on success."""
    if listname: attrs={'name':listname}
    else: attrs={}
    resp=disp.SendAndWaitForResponse(Iq('set',NS_PRIVACY,payload=[Node(typ,attrs)]))
    if isResultNode(resp): return 1

def setDefaultPrivacyList(disp,listname=None):
    """ Sets the default privacy list as 'listname'. Returns true on success."""
    return setActivePrivacyList(disp,listname,'default')

def setPrivacyList(disp,list):
    """ Set the ruleset. 'list' should be the simpleXML node formatted
        according to RFC 3921 (XMPP-IM) (I.e. Node('list',{'name':listname},payload=[...]) )
        Returns true on success."""
    resp=disp.SendAndWaitForResponse(Iq('set',NS_PRIVACY,payload=[list]))
    if isResultNode(resp): return 1

def delPrivacyList(disp,listname):
    """ Deletes privacy list 'listname'. Returns true on success."""
    resp=disp.SendAndWaitForResponse(Iq('set',NS_PRIVACY,payload=[Node('list',{'name':listname})]))
    if isResultNode(resp): return 1

# encoding: utf-8

from south.db import db
from django.db import models
from south.v2 import SchemaMigration
from pybb.compat import get_image_field_full_name, get_user_model_path, get_user_frozen_models
from pybb.defaults import PYBB_INITIAL_CUSTOM_USER_MIGRATION


AUTH_USER = get_user_model_path()
AUTH_USER_COLUMN = AUTH_USER.split('.')[-1].lower()


if PYBB_INITIAL_CUSTOM_USER_MIGRATION:
    # Runs custom user migrations (if there are) before
    # running pybb migrations
    DEPENDS_ON_CUSTOM_USER_MIGRATION = (
        (AUTH_USER.split('.')[0], PYBB_INITIAL_CUSTOM_USER_MIGRATION),
    )
else:
    DEPENDS_ON_CUSTOM_USER_MIGRATION = ()


class Migration(SchemaMigration):
    depends_on = DEPENDS_ON_CUSTOM_USER_MIGRATION

    def forwards(self, orm):

        # Adding model 'Post'
        db.create_table('pybb_post', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('body', self.gf('django.db.models.fields.TextField')()),
            ('body_html', self.gf('django.db.models.fields.TextField')()),
            ('body_text', self.gf('django.db.models.fields.TextField')()),
            ('topic', self.gf('django.db.models.fields.related.ForeignKey')(related_name='posts', to=orm['pybb.Topic'])),
            ('user', self.gf('django.db.models.fields.related.ForeignKey')(related_name='posts', to=orm[AUTH_USER])),
            ('created', self.gf('django.db.models.fields.DateTimeField')(db_index=True, blank=True)),
            ('updated', self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True)),
            ('user_ip', self.gf('django.db.models.fields.IPAddressField')(default='0.0.0.0', max_length=15, blank=True)),
            ('markup', self.gf('django.db.models.fields.CharField')(max_length=15)),
        ))
        db.send_create_signal('pybb', ['Post'])

        # Adding model 'Category'
        db.create_table('pybb_category', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('name', self.gf('django.db.models.fields.CharField')(max_length=80)),
            ('position', self.gf('django.db.models.fields.IntegerField')(default=0, blank=True)),
        ))
        db.send_create_signal('pybb', ['Category'])

        # Adding model 'Forum'
        db.create_table('pybb_forum', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('category', self.gf('django.db.models.fields.related.ForeignKey')(related_name='forums', to=orm['pybb.Category'])),
            ('name', self.gf('django.db.models.fields.CharField')(max_length=80)),
            ('position', self.gf('django.db.models.fields.IntegerField')(default=0, blank=True)),
            ('description', self.gf('django.db.models.fields.TextField')(blank=True)),
            ('updated', self.gf('django.db.models.fields.DateTimeField')(null=True, blank=True)),
            ('post_count', self.gf('django.db.models.fields.IntegerField')(default=0, blank=True)),
            ('topic_count', self.gf('django.db.models.fields.IntegerField')(default=0, blank=True)),
        ))
        db.send_create_signal('pybb', ['Forum'])

        # Adding model 'Profile'
        db.create_table('pybb_profile', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('signature', self.gf('django.db.models.fields.TextField')(max_length=1024, blank=True)),
            ('signature_html', self.gf('django.db.models.fields.TextField')(max_length=1054, blank=True)),
            ('time_zone', self.gf('django.db.models.fields.FloatField')(default=3.0)),
            ('language', self.gf('django.db.models.fields.CharField')(default='en-us', max_length=10, blank=True)),
            ('show_signatures', self.gf('django.db.models.fields.BooleanField')(default=True)),
            ('post_count', self.gf('django.db.models.fields.IntegerField')(default=0, blank=True)),
            ('avatar', self.gf(get_image_field_full_name())(max_length=100, null=True, blank=True)),
            ('user', self.gf('annoying.fields.AutoOneToOneField')(related_name='pybb_profile', unique=True, to=orm[AUTH_USER])),
            ('markup', self.gf('django.db.models.fields.CharField')(max_length=15)),
            ('ban_status', self.gf('django.db.models.fields.SmallIntegerField')(default=0)),
            ('ban_till', self.gf('django.db.models.fields.DateTimeField')(default=None, null=True, blank=True)),
        ))
        db.send_create_signal('pybb', ['Profile'])

        # Adding model 'Attachment'
        db.create_table('pybb_attachment', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('post', self.gf('django.db.models.fields.related.ForeignKey')(related_name='attachments', to=orm['pybb.Post'])),
            ('size', self.gf('django.db.models.fields.IntegerField')()),
            ('hash', self.gf('django.db.models.fields.CharField')(blank=True, default='', max_length=40, db_index=True)),
            ('content_type', self.gf('django.db.models.fields.CharField')(max_length=255)),
            ('name', self.gf('django.db.models.fields.TextField')()),
            ('path', self.gf('django.db.models.fields.CharField')(max_length=255)),
        ))
        db.send_create_signal('pybb', ['Attachment'])
        
        # Adding model 'ReadTracking'
        db.create_table('pybb_readtracking', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm[AUTH_USER])),
            ('topics', self.gf('django.db.models.fields.TextField')(null=True)),
            ('last_read', self.gf('django.db.models.fields.DateTimeField')(null=True)),
        ))
        db.send_create_signal('pybb', ['ReadTracking'])

        # Adding model 'Topic'
        db.create_table('pybb_topic', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('forum', self.gf('django.db.models.fields.related.ForeignKey')(related_name='topics', to=orm['pybb.Forum'])),
            ('name', self.gf('django.db.models.fields.CharField')(max_length=255)),
            ('created', self.gf('django.db.models.fields.DateTimeField')(null=True)),
            ('updated', self.gf('django.db.models.fields.DateTimeField')(null=True)),
            ('user', self.gf('django.db.models.fields.related.ForeignKey')(to=orm[AUTH_USER])),
            ('views', self.gf('django.db.models.fields.IntegerField')(default=0, blank=True)),
            ('sticky', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('closed', self.gf('django.db.models.fields.BooleanField')(default=False)),
            ('post_count', self.gf('django.db.models.fields.IntegerField')(default=0, blank=True)),
        ))
        db.send_create_signal('pybb', ['Topic'])
        
        # Adding M2M table for field subscribers on 'Topic'
        db.create_table('pybb_topic_subscribers', (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('topic', models.ForeignKey(orm['pybb.topic'], null=False)),
            (AUTH_USER_COLUMN, models.ForeignKey(orm[AUTH_USER], null=False))
        ))
        db.create_unique('pybb_topic_subscribers', ['topic_id', '%s_id' % AUTH_USER_COLUMN])

        # Adding M2M table for field moderators on 'Forum'
        db.create_table('pybb_forum_moderators', (
            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
            ('forum', models.ForeignKey(orm['pybb.forum'], null=False)),
            (AUTH_USER_COLUMN, models.ForeignKey(orm[AUTH_USER], null=False))
        ))
        db.create_unique('pybb_forum_moderators', ['forum_id', '%s_id' % AUTH_USER_COLUMN])
    
    
    def backwards(self, orm):
        
        # Deleting model 'Post'
        db.delete_table('pybb_post')
        
        # Deleting model 'Category'
        db.delete_table('pybb_category')
        
        # Deleting model 'Forum'
        db.delete_table('pybb_forum')
        
        # Deleting model 'Profile'
        db.delete_table('pybb_profile')
        
        # Deleting model 'Attachment'
        db.delete_table('pybb_attachment')
        
        # Deleting model 'ReadTracking'
        db.delete_table('pybb_readtracking')
        
        # Deleting model 'Topic'
        db.delete_table('pybb_topic')
        
        # Dropping ManyToManyField 'Topic.subscribers'
        db.delete_table('pybb_topic_subscribers')
        
        # Dropping ManyToManyField 'Forum.moderators'
        db.delete_table('pybb_forum_moderators')
        
    
    
    models = {
        'auth.group': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '80', 'unique': 'True'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'})
        },
        'auth.permission': {
            'Meta': {'unique_together': "(('content_type', 'codename'),)"},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        'contenttypes.contenttype': {
            'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'pybb.attachment': {
            'content_type': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'hash': ('django.db.models.fields.CharField', [], {'db_index': 'True', 'max_length': '40', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.TextField', [], {}),
            'path': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'post': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'attachments'", 'to': "orm['pybb.Post']"}),
            'size': ('django.db.models.fields.IntegerField', [], {})
        },
        'pybb.category': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '80'}),
            'position': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'})
        },
        'pybb.forum': {
            'category': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'forums'", 'to': "orm['pybb.Category']"}),
            'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'moderators': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['%s']"% AUTH_USER, 'null': 'True', 'blank': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '80'}),
            'position': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'}),
            'post_count': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'}),
            'topic_count': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'}),
            'updated': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'})
        },
        'pybb.post': {
            'body': ('django.db.models.fields.TextField', [], {}),
            'body_html': ('django.db.models.fields.TextField', [], {}),
            'body_text': ('django.db.models.fields.TextField', [], {}),
            'created': ('django.db.models.fields.DateTimeField', [], {'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'markup': ('django.db.models.fields.CharField', [], {'default': "'bbcode'", 'max_length': '15'}),
            'topic': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'posts'", 'to': "orm['pybb.Topic']"}),
            'updated': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'posts'", 'to': "orm['%s']"% AUTH_USER}),
            'user_ip': ('django.db.models.fields.IPAddressField', [], {'default': "'0.0.0.0'", 'max_length': '15', 'blank': 'True'})
        },
        'pybb.profile': {
            'avatar': ('django.db.models.fields.files.ImageField', [], {'max_length': '100', 'blank': 'True'}),
            'ban_status': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
            'ban_till': ('django.db.models.fields.DateTimeField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'language': ('django.db.models.fields.CharField', [], {'max_length': '10', 'blank': 'True'}),
            'markup': ('django.db.models.fields.CharField', [], {'default': "'bbcode'", 'max_length': '15'}),
            'post_count': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'}),
            'show_signatures': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'blank': 'True'}),
            'signature': ('django.db.models.fields.TextField', [], {'max_length': '1024', 'blank': 'True'}),
            'signature_html': ('django.db.models.fields.TextField', [], {'max_length': '1054', 'blank': 'True'}),
            'time_zone': ('django.db.models.fields.FloatField', [], {'default': '3.0'}),
            'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['%s']"% AUTH_USER, 'related_name': "'pybb_profile'", 'unique': 'True'})
        },
        'pybb.readtracking': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'last_read': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),
            'topics': ('django.db.models.fields.TextField', [], {'null': 'True'}),
            'user': ('django.db.models.fields.related.OneToOneField', [], {'unique': 'True', 'to': "orm['%s']"% AUTH_USER})
        },
        'pybb.topic': {
            'closed': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'created': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),
            'forum': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'topics'", 'to': "orm['pybb.Forum']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'post_count': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'}),
            'sticky': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'subscribers': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['%s']"% AUTH_USER, 'blank': 'True'}),
            'updated': ('django.db.models.fields.DateTimeField', [], {'blank': 'True', 'null': 'True'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['%s']"% AUTH_USER}),
            'views': ('django.db.models.fields.IntegerField', [], {'default': '0', 'blank': 'True'})
        }
    }
    models.update(get_user_frozen_models(AUTH_USER))

    complete_apps = ['pybb']

# pgn.py rel. 1.1 17-sep-2004
#
# Demonstration of the parsing module, implementing a pgn parser.
#
# The aim of this parser is not to support database application,
# but to create automagically a pgn annotated reading the log console file
# of a lecture of ICC (Internet Chess Club), saved by Blitzin.
# Of course you can modify the Abstract Syntax Tree to your purpose.
#
# Copyright 2004, by Alberto Santini http://www.albertosantini.it/chess/
#
from pyparsing import alphanums, nums, quotedString
from pyparsing import Combine, Forward, Group, Literal, oneOf, OneOrMore, Optional, Suppress, ZeroOrMore, White, Word
from pyparsing import ParseException

#
# define pgn grammar
#

tag = Suppress("[") + Word(alphanums) + Combine(quotedString) + Suppress("]")
comment = Suppress("{") + Word(alphanums + " ") + Suppress("}")

dot = Literal(".")
piece = oneOf("K Q B N R")
file_coord = oneOf("a b c d e f g h")
rank_coord = oneOf("1 2 3 4 5 6 7 8")
capture = oneOf("x :")
promote = Literal("=")
castle_queenside = Literal("O-O-O") | Literal("0-0-0") | Literal("o-o-o")
castle_kingside = Literal("O-O") | Literal("0-0") | Literal("o-o")

move_number = Optional(comment) + Word(nums) + dot
m1 = file_coord + rank_coord # pawn move e.g. d4
m2 = file_coord + capture + file_coord + rank_coord # pawn capture move e.g. dxe5
m3 = file_coord + "8" + promote + piece # pawn promotion e.g. e8=Q
m4 = piece + file_coord + rank_coord # piece move e.g. Be6
m5 = piece + file_coord + file_coord + rank_coord # piece move e.g. Nbd2
m6 = piece + rank_coord + file_coord + rank_coord # piece move e.g. R4a7
m7 = piece + capture + file_coord + rank_coord # piece capture move e.g. Bxh7
m8 = castle_queenside | castle_kingside # castling e.g. o-o

check = oneOf("+ ++")
mate = Literal("#")
annotation = Word("!?", max=2)
nag = " $" + Word(nums)
decoration = check | mate | annotation | nag

variant = Forward()
half_move = Combine((m3 | m1 | m2 | m4 | m5 | m6 | m7 | m8) + Optional(decoration)) \
  + Optional(comment) +Optional(variant)
move = Suppress(move_number) + half_move + Optional(half_move)
variant << "(" + OneOrMore(move) + ")"
# grouping the plies (half-moves) for each move: useful to group annotations, variants...
# suggested by Paul McGuire :)
move = Group(Suppress(move_number) + half_move + Optional(half_move))
variant << Group("(" + OneOrMore(move) + ")")
game_terminator = oneOf("1-0 0-1 1/2-1/2 *")

pgnGrammar = Suppress(ZeroOrMore(tag))  + ZeroOrMore(move) + Suppress(game_terminator)

def parsePGN( pgn, bnf=pgnGrammar, fn=None ):
  try:
    return bnf.parseString( pgn )
  except ParseException, err:
    print err.line
    print " "*(err.column-1) + "^"
    print err

if __name__ == "__main__":
  # input string
  pgn = """
[Event "ICC 5 0 u"]
[Site "Internet Chess Club"]
[Date "2004.01.25"]
[Round "-"]
[White "guest920"]
[Black "IceBox"]
[Result "0-1"]
[ICCResult "White checkmated"]
[BlackElo "1498"]
[Opening "French defense"]
[ECO "C00"]
[NIC "FR.01"]
[Time "04:44:56"]
[TimeControl "300+0"]

1. e4 e6 2. Nf3 d5 $2 3. exd5 (3. e5 g6 4. h4) exd5 4. Qe2+ Qe7 5. Qxe7+ Bxe7 6. d3 Nf6 7. Be3
Bg4 8. Nbd2 c5 9. h3 Be6 10. O-O-O Nc6 11. g4 Bd6 12. g5 Nd7 13. Rg1 d4 14.
g6 fxg6 15. Bg5 Rf8 16. a3 Bd5 17. Re1+ Nde5 18. Nxe5 Nxe5 19. Bf4 Rf5 20.
Bxe5 Rxe5 21. Rg5 Rxe1# {Black wins} 0-1
"""
  # parse input string
  tokens = parsePGN(pgn, pgnGrammar)
  print "tokens = ", tokens

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from setuptools import setup, find_packages

try:
    readme_text = file('README.rst', 'rb').read()
except IOError,e:
    readme_text = ''

setup(name = "gsconfig",
    version = "1.0.0",
    description = "GeoServer REST Configuration",
    long_description = readme_text,
    keywords = "GeoServer REST Configuration",
    license = "MIT",
    url = "https://github.com/boundlessgeo/gsconfig",
    author = "David Winslow, Sebastian Benthall",
    author_email = "dwinslow@opengeo.org",
    install_requires = [
        'httplib2>=0.7.4',
        'gisdata==0.5.4'
    ],
    package_dir = {'':'src'},
    packages = find_packages('src'),
    test_suite = "test.catalogtests",
    classifiers = [
                 'Development Status :: 4 - Beta',
                 'Intended Audience :: Developers',
                 'Intended Audience :: Science/Research',
                 'License :: OSI Approved :: MIT License',
                 'Operating System :: OS Independent',
                 'Programming Language :: Python',
                 'Topic :: Scientific/Engineering :: GIS',
                ]
)


# This file is part of OpenHatch.
# Copyright (C) 2009 OpenHatch, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


from south.db import db
from django.db import models
from mysite.profile.models import *

class Migration:
    
    def forwards(self, orm):
        
        # Adding field 'PortfolioEntry.is_published'
        db.add_column('profile_portfolioentry', 'is_published', orm['profile.portfolioentry:is_published'])
        
        # Changing field 'DataImportAttempt.date_created'
        # (to signature: django.db.models.fields.DateTimeField(default=datetime.datetime(2009, 10, 29, 21, 52, 38, 701735)))
        db.alter_column('profile_dataimportattempt', 'date_created', orm['profile.dataimportattempt:date_created'])
        
        # Changing field 'PortfolioEntry.date_created'
        # (to signature: django.db.models.fields.DateTimeField(default=datetime.datetime(2009, 10, 29, 21, 52, 39, 254639)))
        db.alter_column('profile_portfolioentry', 'date_created', orm['profile.portfolioentry:date_created'])
        
        # Changing field 'Citation.date_created'
        # (to signature: django.db.models.fields.DateTimeField(default=datetime.datetime(2009, 10, 29, 21, 52, 39, 313650)))
        db.alter_column('profile_citation', 'date_created', orm['profile.citation:date_created'])
        
    
    
    def backwards(self, orm):
        
        # Deleting field 'PortfolioEntry.is_published'
        db.delete_column('profile_portfolioentry', 'is_published')
        
        # Changing field 'DataImportAttempt.date_created'
        # (to signature: django.db.models.fields.DateTimeField(default=datetime.datetime(2009, 10, 29, 15, 40, 11, 889042)))
        db.alter_column('profile_dataimportattempt', 'date_created', orm['profile.dataimportattempt:date_created'])
        
        # Changing field 'PortfolioEntry.date_created'
        # (to signature: django.db.models.fields.DateTimeField(default=datetime.datetime(2009, 10, 29, 15, 40, 11, 412825)))
        db.alter_column('profile_portfolioentry', 'date_created', orm['profile.portfolioentry:date_created'])
        
        # Changing field 'Citation.date_created'
        # (to signature: django.db.models.fields.DateTimeField(default=datetime.datetime(2009, 10, 29, 15, 40, 11, 832834)))
        db.alter_column('profile_citation', 'date_created', orm['profile.citation:date_created'])
        
    
    
    models = {
        'auth.group': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'})
        },
        'auth.permission': {
            'Meta': {'unique_together': "(('content_type', 'codename'),)"},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        'auth.user': {
            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True', 'blank': 'True'}),
            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'blank': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
        },
        'contenttypes.contenttype': {
            'Meta': {'unique_together': "(('app_label', 'model'),)", 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'profile.citation': {
            'contributor_role': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True'}),
            'data_import_attempt': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.DataImportAttempt']", 'null': 'True'}),
            'date_created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2009, 10, 29, 21, 52, 40, 124865)'}),
            'distinct_months': ('django.db.models.fields.IntegerField', [], {'null': 'True'}),
            'first_commit_time': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'is_published': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'languages': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True'}),
            'old_summary': ('django.db.models.fields.TextField', [], {'default': 'None', 'null': 'True'}),
            'portfolio_entry': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.PortfolioEntry']"}),
            'url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True'})
        },
        'profile.dataimportattempt': {
            'completed': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'date_created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2009, 10, 29, 21, 52, 40, 225441)'}),
            'failed': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.Person']"}),
            'query': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
            'source': ('django.db.models.fields.CharField', [], {'max_length': '2'})
        },
        'profile.link_person_tag': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.Person']"}),
            'source': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
            'tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.Tag']"})
        },
        'profile.link_project_tag': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'project': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['search.Project']"}),
            'source': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
            'tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.Tag']"})
        },
        'profile.link_projectexp_tag': {
            'Meta': {'unique_together': "[('tag', 'project_exp', 'source')]"},
            'favorite': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'project_exp': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.ProjectExp']"}),
            'source': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
            'tag': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.Tag']"})
        },
        'profile.link_sf_proj_dude_fm': {
            'Meta': {'unique_together': "[('person', 'project')]"},
            'date_collected': ('django.db.models.fields.DateTimeField', [], {}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_admin': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.SourceForgePerson']"}),
            'position': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
            'project': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.SourceForgeProject']"})
        },
        'profile.person': {
            'gotten_name_from_ohloh': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'interested_in_working_on': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '1024'}),
            'last_polled': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(1970, 1, 1, 0, 0)'}),
            'photo': ('django.db.models.fields.files.ImageField', [], {'default': "''", 'max_length': '100'}),
            'show_email': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'unique': 'True'})
        },
        'profile.portfolioentry': {
            'date_created': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2009, 10, 29, 21, 52, 39, 522055)'}),
            'experience_description': ('django.db.models.fields.TextField', [], {}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_deleted': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'is_published': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.Person']"}),
            'project': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['search.Project']"}),
            'project_description': ('django.db.models.fields.TextField', [], {})
        },
        'profile.projectexp': {
            'data_import_attempt': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.DataImportAttempt']", 'null': 'True'}),
            'description': ('django.db.models.fields.TextField', [], {}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'man_months': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True'}),
            'modified': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'person': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.Person']", 'null': 'True'}),
            'person_role': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
            'primary_language': ('django.db.models.fields.CharField', [], {'max_length': '200', 'null': 'True'}),
            'project': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['search.Project']"}),
            'should_show_this': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'blank': 'True'}),
            'source': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True'}),
            'url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True'})
        },
        'profile.sourceforgeperson': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'max_length': '200'})
        },
        'profile.sourceforgeproject': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'unixname': ('django.db.models.fields.CharField', [], {'max_length': '200'})
        },
        'profile.tag': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'tag_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['profile.TagType']"}),
            'text': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        'profile.tagtype': {
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'prefix': ('django.db.models.fields.CharField', [], {'max_length': '20'})
        },
        'search.project': {
            'date_icon_was_fetched_from_ohloh': ('django.db.models.fields.DateTimeField', [], {'default': 'None', 'null': 'True'}),
            'icon': ('django.db.models.fields.files.ImageField', [], {'default': 'None', 'max_length': '100', 'null': 'True'}),
            'icon_smaller_for_badge': ('django.db.models.fields.files.ImageField', [], {'default': 'None', 'max_length': '100', 'null': 'True'}),
            'icon_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'language': ('django.db.models.fields.CharField', [], {'max_length': '200'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '200'})
        }
    }
    
    complete_apps = ['profile']

# -*- cpy-indent-level: 4; indent-tabs-mode: nil -*-
# ex: set expandtab softtabstop=4 shiftwidth=4:
#
# Copyright (C) 2008,2009,2010,2011,2013,2014,2015,2016  Contributor
#
# 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.
"""Load all exporters"""

import os
import logging
from traceback import format_exc

__all__ = []

_thisdir = os.path.dirname(os.path.realpath(__file__))
for f in os.listdir(_thisdir):
    full = os.path.join(_thisdir, f)
    if os.path.isfile(full) and f.endswith('.py') and f != '__init__.py':
        moduleshort = f[:-3]
        modulename = __name__ + '.' + moduleshort
        try:
            mymodule = __import__(modulename)
        except Exception as e:  # pragma: no cover
            logger = logging.getLogger(__name__)
            logger.info("Error importing %s: %s", modulename, format_exc())
            continue

"""
    This module defines common methods used in simulator specific build modules

    @author Tom Close
"""

##########################################################################
#
#  Copyright 2011 Okinawa Institute of Science and Technology (OIST), Okinawa
#
##########################################################################
from __future__ import absolute_import
from builtins import object
from future.utils import PY3
import platform
import os
import subprocess as sp
import time
from itertools import chain
from copy import deepcopy
import shutil
from os.path import join
from jinja2 import Environment, FileSystemLoader, StrictUndefined
from future.utils import with_metaclass
from abc import ABCMeta, abstractmethod
import sympy
from nineml import units
from nineml.exceptions import NineMLNameError, NineMLSerializationError
from pype9.exceptions import (
    Pype9BuildError, Pype9CommandNotFoundError, Pype9RuntimeError)
from ..cells.with_synapses import read
import pype9.annotations
from pype9.annotations import PYPE9_NS, BUILD_PROPS
from os.path import expanduser
import re
from nineml.serialization import url_re
import sysconfig
from pype9 import __version__
from pype9.utils.paths import remove_ignore_missing
from pype9.utils.logging import logger

BASE_BUILD_DIR = os.path.join(
    expanduser("~"),
    '.pype9',
    'build',
    'v{}'.format(__version__),
    'python{}'.format(sysconfig.get_config_var('py_version')))


class BaseCodeGenerator(with_metaclass(ABCMeta, object)):
    """
    Parameters
    ----------
        base_dir : str | None
            The base directory for the generated code. If None a directory
            will be created in user's home directory.
    """

    BUILD_MODE_OPTIONS = ['lazy',  # Build iff source has been updated
                          'force',  # Build always
                          'require',  # Don't build, requires pre-built
                          'build_only',  # Only build
                          'generate_only',  # Only generate source files
                          'purge'  # Remove all configure files and rebuild
                          ]

    _PARAMS_DIR = 'params'
    _SRC_DIR = 'src'
    _INSTL_DIR = 'install'
    _CMPL_DIR = 'compile'  # Ignored for NEURON but used for NEST
    _BUILT_COMP_CLASS = 'built_component_class.xml'

    # Python functions and annotations to be made available in the templates
    _globals = dict(
        [('len', len), ('zip', zip), ('enumerate', enumerate),
         ('range', range), ('next', next), ('chain', chain), ('sorted',
         sorted), ('hash', hash), ('deepcopy', deepcopy), ('units', units),
         ('hasattr', hasattr), ('set', set), ('list', list), ('None', None),
         ('sympy', sympy)] +
        [(n, v) for n, v in list(pype9.annotations.__dict__.items())
         if n != '__builtins__'])

    # Derived classes should provide mapping from 9ml dimensions to default
    # units
    DEFAULT_UNITS = {}

    def __init__(self, base_dir=None, **kwargs):  # @UnusedVariable
        if base_dir is None:
            base_dir = BASE_BUILD_DIR
        self._base_dir = os.path.join(
            base_dir, self.SIMULATOR_NAME + self.SIMULATOR_VERSION)

    def __repr__(self):
        return "{}CodeGenerator(base_dir='{}')".format(
            self.SIMULATOR_NAME.capitalize(), self.base_dir)

    def __eq__(self, other):
        try:
            return (self.SIMULATOR_NAME == other.SIMULATOR_NAME and
                    self.base_dir == other.base_dir)
        except AttributeError:
            return False

    def __ne__(self, other):
        return not self.__eq__(other)

    @property
    def base_dir(self):
        return self._base_dir

    @abstractmethod
    def generate_source_files(self, dynamics, src_dir, name, **kwargs):
        """
        Generates the source files for the relevant simulator
        """
        pass

    def configure_build_files(self, name, src_dir, compile_dir, install_dir,
                              **kwargs):
        """
        Configures the build files before compiling
        """
        pass

    @abstractmethod
    def compile_source_files(self, compile_dir, name):
        pass

    def generate(self, component_class, build_mode='lazy', url=None, **kwargs):
        """
        Generates and builds the required simulator-specific files for a given
        NineML cell class

        Parameters
        ----------
        component_class : nineml.Dynamics
            9ML Dynamics object
        name : str
            Name of the generated cell class
        install_dir : str
            Path to the directory where the NMODL files
            will be generated and compiled
        build_mode : str
            Available build options:
                lazy - only build if files are modified
                force - always generate and build
                purge - remove all config files, generate and rebuild
                require - require built binaries are present
                build_only - build and then quit
                generate_only - generate src and then quit
                recompile - don't generate src but compile
        build_version : str
            A suffix appended to the cell build name to distinguish
            it from other code generated from the component class
        url : str
            The URL where the component class is stored (used to form the
            build path)
        kwargs : dict
            A dictionary of (potentially simulator- specific) template
            arguments
        """
        # Save original working directory to reinstate it afterwards (just to
        # be polite)
        name = component_class.name
        orig_dir = os.getcwd()
        if url is None:
            url = component_class.url
        # Calculate compile directory path within build directory
        src_dir = self.get_source_dir(name, url)
        compile_dir = self.get_compile_dir(name, url)
        install_dir = self.get_install_dir(name, url)
        # Path of the build component class
        built_comp_class_pth = os.path.join(src_dir, self._BUILT_COMP_CLASS)
        # Determine whether the installation needs rebuilding or whether there
        # is an existing library module to use.
        if build_mode == 'purge':
            remove_ignore_missing(src_dir)
            remove_ignore_missing(install_dir)
            remove_ignore_missing(compile_dir)
            generate_source = compile_source = True
        elif build_mode in ('force', 'build_only'):  # Force build
            generate_source = compile_source = True
        elif build_mode == 'require':  # Just check that prebuild is present
            generate_source = compile_source = False
        elif build_mode == 'generate_only':  # Only generate
            generate_source = True
            compile_source = False
        elif build_mode == 'lazy':  # Generate if source has been modified
            compile_source = True
            if not os.path.exists(built_comp_class_pth):
                generate_source = True
            else:
                try:
                    built_component_class = read(built_comp_class_pth)[name]
                    if built_component_class.equals(component_class,
                                                    annotations_ns=[PYPE9_NS]):
                        generate_source = False
                        logger.info("Found existing source in '{}' directory, "
                                    "code generation skipped (set 'build_mode'"
                                    " argument to 'force' or 'build_only' to "
                                    "enforce regeneration)".format(src_dir))
                    else:
                        generate_source = True
                        logger.info("Found existing source in '{}' directory, "
                                    "but the component classes differ so "
                                    "regenerating sources".format(src_dir))
                except (NineMLNameError, NineMLSerializationError):
                    generate_source = True
                    logger.info("Found existing source in '{}' directory, "
                                "but could not find '{}' component class so "
                                "regenerating sources".format(name, src_dir))
        # Check if required directories are present depending on build_mode
        elif build_mode == 'require':
            if not os.path.exists(install_dir):
                raise Pype9BuildError(
                    "Prebuilt installation directory '{}' is not "
                    "present, and is required for  'require' build option"
                    .format(install_dir))
        else:
            raise Pype9BuildError(
                "Unrecognised build option '{}', must be one of ('{}')"
                .format(build_mode, "', '".join(self.BUILD_MODE_OPTIONS)))
        # Generate source files from NineML code
        if generate_source:
            self.clean_src_dir(src_dir, name)
            self.generate_source_files(
                name=name,
                component_class=component_class,
                src_dir=src_dir,
                compile_dir=compile_dir,
                install_dir=install_dir,
                **kwargs)
            component_class.write(built_comp_class_pth,
                                  preserve_order=True, version=2.0)
        if compile_source:
            # Clean existing compile & install directories from previous builds
            if generate_source:
                self.clean_compile_dir(compile_dir,
                                       purge=(build_mode == 'purge'))
                self.configure_build_files(
                    name=name, src_dir=src_dir, compile_dir=compile_dir,
                    install_dir=install_dir, **kwargs)
                self.clean_install_dir(install_dir)
            self.compile_source_files(compile_dir, name)
        # Switch back to original dir
        os.chdir(orig_dir)
        # Cache any dimension maps that were calculated during the generation
        # process
        return install_dir

    def get_build_dir(self, name, url):
        return os.path.join(self.base_dir, self.url_build_path(url), name)

    def get_source_dir(self, name, url):
        return os.path.abspath(os.path.join(
            self.get_build_dir(name, url), self._SRC_DIR))

    def get_compile_dir(self, name, url):
        return os.path.abspath(os.path.join(
            self.get_build_dir(name, url), self._CMPL_DIR))

    def get_install_dir(self, name, url):
        return os.path.abspath(os.path.join(
            self.get_build_dir(name, url), self._INSTL_DIR))

    def clean_src_dir(self, src_dir, component_name):  # @UnusedVariable
        # Clean existing src directories from previous builds.
        shutil.rmtree(src_dir, ignore_errors=True)
        try:
            os.makedirs(src_dir)
        except OSError as e:
            raise Pype9BuildError(
                "Could not create source directory ({}), please check the "
                "required permissions or specify a different \"build dir"
                "base\" ('build_dir_base'):\n{}".format(src_dir, e))

    def clean_compile_dir(self, compile_dir, purge=False):  # @UnusedVariable
        # Clean existing compile & install directories from previous builds
        shutil.rmtree(compile_dir, ignore_errors=True)
        try:
            os.makedirs(compile_dir)
        except OSError as e:
            raise Pype9BuildError(
                "Could not create compile directory ({}), please check the "
                "required permissions or specify a different \"build dir"
                "base\" ('build_dir_base'):\n{}".format(compile_dir, e))

    def clean_install_dir(self, install_dir):
        # Clean existing compile & install directories from previous builds
        shutil.rmtree(install_dir, ignore_errors=True)
        try:
            os.makedirs(install_dir)
        except OSError as e:
            raise Pype9BuildError(
                "Could not create install directory ({}), please check the "
                "required permissions or specify a different \"build dir"
                "base\" ('build_dir_base'):\n{}".format(install_dir, e))

    def render_to_file(self, template, args, filename, directory, switches={},
                       post_hoc_subs={}):
        # Initialise the template loader to include the flag directories
        template_paths = [
            self.BASE_TMPL_PATH,
            os.path.join(self.BASE_TMPL_PATH, 'includes')]
        # Add include paths for various switches (e.g. solver type)
        for name, value in list(switches.items()):
            if value is not None:
                template_paths.append(os.path.join(self.BASE_TMPL_PATH,
                                                   'includes', name, value))
        # Add default path for template includes
        template_paths.append(
            os.path.join(self.BASE_TMPL_PATH, 'includes', 'default'))
        # Initialise the Jinja2 environment
        jinja_env = Environment(loader=FileSystemLoader(template_paths),
                                trim_blocks=True, lstrip_blocks=True,
                                undefined=StrictUndefined)
        # Add some globals used by the template code
        jinja_env.globals.update(**self._globals)
        # Actually render the contents
        contents = jinja_env.get_template(template).render(**args)
        for old, new in list(post_hoc_subs.items()):
            contents = contents.replace(old, new)
        # Write the contents to file
        with open(os.path.join(directory, filename), 'w') as f:
            f.write(contents)

    def path_to_utility(self, utility_name, env_var='', **kwargs):  # @UnusedVariable @IgnorePep8
        """
        Returns the full path to an executable by searching the "PATH"
        environment variable

        Parameters
        ----------
        utility_name : str
            Name of executable to search the execution path
        env_var : str
            Name of a environment variable to lookup first before searching
            path
        default : str | None
            The default value to assign to the path if it cannot be found.

        Returns
        -------
        utility_path : str
            Full path to executable
        """
        if kwargs and list(kwargs) != ['default']:
            raise Pype9RuntimeError(
                "Should only provide 'default' as kwarg to path_to_utility "
                "provided ({})".format(kwargs))
        try:
            utility_path = os.environ[env_var]
        except KeyError:
            if platform.system() == 'Windows':
                utility_name += '.exe'
            # Get the system path
            system_path = os.environ['PATH'].split(os.pathsep)
            # Append NEST_INSTALL_DIR/NRNHOME if present
            system_path.extend(self.simulator_specific_paths())
            # Check the system path for the command
            utility_path = None
            for dr in system_path:
                path = join(dr, utility_name)
                if os.path.exists(path):
                    utility_path = path
                    break
            if not utility_path:
                try:
                    utility_path = kwargs['default']
                except KeyError:
                    raise Pype9CommandNotFoundError(
                        "Could not find executable '{}' on the system path "
                        "'{}'".format(utility_name, ':'.join(system_path)))
        else:
            if not os.path.exists(utility_path):
                raise Pype9CommandNotFoundError(
                    "Could not find executable '{}' at path '{}' provided by "
                    "'{}' environment variable"
                    .format(utility_name, env_var))
        return utility_path

    def simulator_specific_paths(self):
        """
        To be overridden by derived classes if required.
        """
        return []

    def transform_for_build(self, name, component_class, **kwargs):  # @UnusedVariable @IgnorePep8
        """
        Copies and transforms the component class to match the format of the
        simulator (overridden in derived class)

        Parameters
        ----------
        name : str
            The name of the transformed component class
        component_class : nineml.Dynamics
            The component class to be transformed
        """
        # ---------------------------------------------------------------------
        # Clone original component class and properties
        # ---------------------------------------------------------------------
        component_class = component_class.clone()
        component_class.name = name
        self._set_build_props(component_class, **kwargs)
        return component_class

    def _set_build_props(self, component_class, **build_props):
        """
        Sets the build properties in the component class annotations

        Parameters
        ----------
        component_class : Dynamics | MultiDynamics
            The build component class
        build_props : dict(str, str)
            Build properties to save into the annotations of the build
            component class
        """
        for k, v in list(build_props.items()) + [
                ('version', pype9.__version__)]:
            component_class.annotations.set((BUILD_PROPS, PYPE9_NS), k, v)

    def run_command(self, cmd, fail_msg=None, **kwargs):
        env = os.environ.copy()
        try:
            process = sp.Popen(cmd, stdout=sp.PIPE,
                               stderr=sp.PIPE, env=env, **kwargs)
            stdout, stderr = process.communicate()
            if PY3:
                stdout = str(stdout.decode('utf-8'))
                stderr = str(stderr.decode('utf-8'))
            logger.debug("'{}' stdout:\n{}".format(cmd, stdout))
            logger.debug("'{}' stderr:\n{}".format(cmd, stderr))
        except sp.CalledProcessError as e:
            if fail_msg is None:
                raise
            else:
                msg = fail_msg.format(e)
                raise Pype9BuildError(msg)
        return stdout, stderr

    @classmethod
    def get_mod_time(cls, url):
        if url is None:
            mod_time = time.ctime(0)  # Return the earliest date if no url
        else:
            mod_time = time.ctime(os.path.getmtime(url))
        return mod_time

    @classmethod
    def url_build_path(cls, url):
        if url is None:
            path = 'generated'
        else:
            if url_re.match(url) is not None:
                path = os.path.join(
                    'url',
                    re.match(r'(:?\w+://)?([\.\/\w]+).*', url).group(1))
            else:
                path = os.path.join('file', os.path.realpath(url)[1:])
        return path

    def load_libraries(self, name, url, **kwargs):
        """
        To be overridden by derived classes to allow the model to be loaded
        from compiled external libraries
        """
        pass

#!/usr/bin/env python
#
# Copyright 2010 Google Inc.  All Rights Reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

"""Tests Google Test's exception catching behavior.

This script invokes googletest-catch-exceptions-test_ and
googletest-catch-exceptions-ex-test_ (programs written with
Google Test) and verifies their output.
"""

import gtest_test_utils

# Constants.
FLAG_PREFIX = '--gtest_'
LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
NO_CATCH_EXCEPTIONS_FLAG = FLAG_PREFIX + 'catch_exceptions=0'
FILTER_FLAG = FLAG_PREFIX + 'filter'

# Path to the googletest-catch-exceptions-ex-test_ binary, compiled with
# exceptions enabled.
EX_EXE_PATH = gtest_test_utils.GetTestExecutablePath(
    'googletest-catch-exceptions-ex-test_')

# Path to the googletest-catch-exceptions-test_ binary, compiled with
# exceptions disabled.
EXE_PATH = gtest_test_utils.GetTestExecutablePath(
    'googletest-catch-exceptions-no-ex-test_')

environ = gtest_test_utils.environ
SetEnvVar = gtest_test_utils.SetEnvVar

# Tests in this file run a Google-Test-based test program and expect it
# to terminate prematurely.  Therefore they are incompatible with
# the premature-exit-file protocol by design.  Unset the
# premature-exit filepath to prevent Google Test from creating
# the file.
SetEnvVar(gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)

TEST_LIST = gtest_test_utils.Subprocess(
    [EXE_PATH, LIST_TESTS_FLAG], env=environ).output

SUPPORTS_SEH_EXCEPTIONS = 'ThrowsSehException' in TEST_LIST

if SUPPORTS_SEH_EXCEPTIONS:
  BINARY_OUTPUT = gtest_test_utils.Subprocess([EXE_PATH], env=environ).output

EX_BINARY_OUTPUT = gtest_test_utils.Subprocess(
    [EX_EXE_PATH], env=environ).output


# The tests.
if SUPPORTS_SEH_EXCEPTIONS:
  # pylint:disable-msg=C6302
  class CatchSehExceptionsTest(gtest_test_utils.TestCase):
    """Tests exception-catching behavior."""


    def TestSehExceptions(self, test_output):
      self.assert_('SEH exception with code 0x2a thrown '
                   'in the test fixture\'s constructor'
                   in test_output)
      self.assert_('SEH exception with code 0x2a thrown '
                   'in the test fixture\'s destructor'
                   in test_output)
      self.assert_('SEH exception with code 0x2a thrown in SetUpTestSuite()'
                   in test_output)
      self.assert_('SEH exception with code 0x2a thrown in TearDownTestSuite()'
                   in test_output)
      self.assert_('SEH exception with code 0x2a thrown in SetUp()'
                   in test_output)
      self.assert_('SEH exception with code 0x2a thrown in TearDown()'
                   in test_output)
      self.assert_('SEH exception with code 0x2a thrown in the test body'
                   in test_output)

    def testCatchesSehExceptionsWithCxxExceptionsEnabled(self):
      self.TestSehExceptions(EX_BINARY_OUTPUT)

    def testCatchesSehExceptionsWithCxxExceptionsDisabled(self):
      self.TestSehExceptions(BINARY_OUTPUT)


class CatchCxxExceptionsTest(gtest_test_utils.TestCase):
  """Tests C++ exception-catching behavior.

     Tests in this test case verify that:
     * C++ exceptions are caught and logged as C++ (not SEH) exceptions
     * Exception thrown affect the remainder of the test work flow in the
       expected manner.
  """

  def testCatchesCxxExceptionsInFixtureConstructor(self):
    self.assertTrue(
        'C++ exception with description '
        '"Standard C++ exception" thrown '
        'in the test fixture\'s constructor' in EX_BINARY_OUTPUT,
        EX_BINARY_OUTPUT)
    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
                 'This failure belongs in this test only if '
                 '"CxxExceptionInConstructorTest" (no quotes) '
                 'appears on the same line as words "called unexpectedly"')

  if ('CxxExceptionInDestructorTest.ThrowsExceptionInDestructor' in
      EX_BINARY_OUTPUT):

    def testCatchesCxxExceptionsInFixtureDestructor(self):
      self.assertTrue(
          'C++ exception with description '
          '"Standard C++ exception" thrown '
          'in the test fixture\'s destructor' in EX_BINARY_OUTPUT,
          EX_BINARY_OUTPUT)
      self.assertTrue(
          'CxxExceptionInDestructorTest::TearDownTestSuite() '
          'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)

  def testCatchesCxxExceptionsInSetUpTestCase(self):
    self.assertTrue(
        'C++ exception with description "Standard C++ exception"'
        ' thrown in SetUpTestSuite()' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInConstructorTest::TearDownTestSuite() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTestSuiteTest constructor '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTestSuiteTest destructor '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTestSuiteTest::SetUp() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTestSuiteTest::TearDown() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTestSuiteTest test body '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)

  def testCatchesCxxExceptionsInTearDownTestCase(self):
    self.assertTrue(
        'C++ exception with description "Standard C++ exception"'
        ' thrown in TearDownTestSuite()' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)

  def testCatchesCxxExceptionsInSetUp(self):
    self.assertTrue(
        'C++ exception with description "Standard C++ exception"'
        ' thrown in SetUp()' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTest::TearDownTestSuite() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTest destructor '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInSetUpTest::TearDown() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assert_('unexpected' not in EX_BINARY_OUTPUT,
                 'This failure belongs in this test only if '
                 '"CxxExceptionInSetUpTest" (no quotes) '
                 'appears on the same line as words "called unexpectedly"')

  def testCatchesCxxExceptionsInTearDown(self):
    self.assertTrue(
        'C++ exception with description "Standard C++ exception"'
        ' thrown in TearDown()' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInTearDownTest::TearDownTestSuite() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInTearDownTest destructor '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)

  def testCatchesCxxExceptionsInTestBody(self):
    self.assertTrue(
        'C++ exception with description "Standard C++ exception"'
        ' thrown in the test body' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInTestBodyTest::TearDownTestSuite() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInTestBodyTest destructor '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)
    self.assertTrue(
        'CxxExceptionInTestBodyTest::TearDown() '
        'called as expected.' in EX_BINARY_OUTPUT, EX_BINARY_OUTPUT)

  def testCatchesNonStdCxxExceptions(self):
    self.assertTrue(
        'Unknown C++ exception thrown in the test body' in EX_BINARY_OUTPUT,
        EX_BINARY_OUTPUT)

  def testUnhandledCxxExceptionsAbortTheProgram(self):
    # Filters out SEH exception tests on Windows. Unhandled SEH exceptions
    # cause tests to show pop-up windows there.
    FITLER_OUT_SEH_TESTS_FLAG = FILTER_FLAG + '=-*Seh*'
    # By default, Google Test doesn't catch the exceptions.
    uncaught_exceptions_ex_binary_output = gtest_test_utils.Subprocess(
        [EX_EXE_PATH,
         NO_CATCH_EXCEPTIONS_FLAG,
         FITLER_OUT_SEH_TESTS_FLAG],
        env=environ).output

    self.assert_('Unhandled C++ exception terminating the program'
                 in uncaught_exceptions_ex_binary_output)
    self.assert_('unexpected' not in uncaught_exceptions_ex_binary_output)


if __name__ == '__main__':
  gtest_test_utils.Main()

SPCM_ERROR_ORIGIN_MASK = (-2147483648)
SPCM_ERROR_ORIGIN_LOCAL = 0x00000000
SPCM_ERROR_ORIGIN_REMOTE = (-2147483648)
ERR_OK = 0x0000
ERR_INIT = 0x0001
ERR_NR = 0x0002
ERR_TYP = 0x0003
ERR_FNCNOTSUPPORTED = 0x0004
ERR_BRDREMAP = 0x0005
ERR_KERNELVERSION = 0x0006
ERR_HWDRVVERSION = 0x0007
ERR_ADRRANGE = 0x0008
ERR_INVALIDHANDLE = 0x0009
ERR_BOARDNOTFOUND = 0x000A
ERR_BOARDINUSE = 0x000B
ERR_EXPHW64BITADR = 0x000C
ERR_FWVERSION = 0x000D
ERR_LASTERR = 0x0010
ERR_ABORT = 0x0020
ERR_BOARDLOCKED = 0x0030
ERR_DEVICE_MAPPING = 0x0032
ERR_NETWORKSETUP = 0x0040
ERR_NETWORKTRANSFER = 0x0041
ERR_FWPOWERCYCLE = 0x0042
ERR_NETWORKTIMEOUT = 0x0043
ERR_BUFFERSIZE = 0x0044
ERR_RESTRICTEDACCESS = 0x0045
ERR_INVALIDPARAM = 0x0046
ERR_REG = 0x0100
ERR_VALUE = 0x0101
ERR_FEATURE = 0x0102
ERR_SEQUENCE = 0x0103
ERR_READABORT = 0x0104
ERR_NOACCESS = 0x0105
ERR_POWERDOWN = 0x0106
ERR_TIMEOUT = 0x0107
ERR_CALLTYPE = 0x0108
ERR_EXCEEDSINT32 = 0x0109
ERR_NOWRITEALLOWED = 0x010A
ERR_SETUP = 0x010B
ERR_CLOCKNOTLOCKED = 0x010C
ERR_MEMINIT = 0x010D
ERR_POWERSUPPLY = 0x010E
ERR_ADCCOMMUNICATION = 0x010F
ERR_CHANNEL = 0x0110
ERR_NOTIFYSIZE = 0x0111
ERR_RUNNING = 0x0120
ERR_ADJUST = 0x0130
ERR_PRETRIGGERLEN = 0x0140
ERR_DIRMISMATCH = 0x0141
ERR_POSTEXCDSEGMENT = 0x0142
ERR_SEGMENTINMEM = 0x0143
ERR_MULTIPLEPW = 0x0144
ERR_NOCHANNELPWOR = 0x0145
ERR_ANDORMASKOVRLAP = 0x0146
ERR_ANDMASKEDGE = 0x0147
ERR_ORMASKLEVEL = 0x0148
ERR_EDGEPERMOD = 0x0149
ERR_DOLEVELMINDIFF = 0x014A
ERR_STARHUBENABLE = 0x014B
ERR_PATPWSMALLEDGE = 0x014C
ERR_NOPCI = 0x0200
ERR_PCIVERSION = 0x0201
ERR_PCINOBOARDS = 0x0202
ERR_PCICHECKSUM = 0x0203
ERR_DMALOCKED = 0x0204
ERR_MEMALLOC = 0x0205
ERR_EEPROMLOAD = 0x0206
ERR_CARDNOSUPPORT = 0x0207
ERR_CONFIGACCESS = 0x0208
ERR_FIFOBUFOVERRUN = 0x0300
ERR_FIFOHWOVERRUN = 0x0301
ERR_FIFOFINISHED = 0x0302
ERR_FIFOSETUP = 0x0309
ERR_TIMESTAMP_SYNC = 0x0310
ERR_STARHUB = 0x0320
ERR_INTERNAL_ERROR = 0xFFFF

# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from telemetry.page import page as page_module
from telemetry.page import page_set as page_set_module


class ToughMemoryMultiTabPage(page_module.Page):

  def __init__(self, url, page_set):
    super(ToughMemoryMultiTabPage, self).__init__(url=url, page_set=page_set)
    self.credentials_path = 'data/credentials.json'
    self.user_agent_type = 'mobile'
    self.archive_data_file = 'data/key_mobile_sites.json'


class ToughMemoryMultiTabPageSet(page_set_module.PageSet):

  """ Mobile sites for exercising multi-tab memory issues """

  def __init__(self):
    super(ToughMemoryMultiTabPageSet, self).__init__(
      credentials_path='data/credentials.json',
      user_agent_type='mobile',
      archive_data_file='data/key_mobile_sites.json')

    urls_list = [
      'https://www.google.com/#hl=en&q=barack+obama',
      'http://theverge.com',
      'http://techcrunch.com'
    ]

    for url in urls_list:
      self.AddPage(ToughMemoryMultiTabPage(url, self))

import antlr3
import testbase
import unittest

class t010lexer(testbase.ANTLRTest):
    def setUp(self):
        self.compileGrammar()
        
        
    def lexerClass(self, base):
        class TLexer(base):
            def emitErrorMessage(self, msg):
                # report errors to /dev/null
                pass

            def reportError(self, re):
                # no error recovery yet, just crash!
                raise re

        return TLexer
    
        
    def testValid(self):
        stream = antlr3.StringStream('foobar _Ab98 \n A12sdf')
        lexer = self.getLexer(stream)

        token = lexer.nextToken()
        assert token.type == self.lexerModule.IDENTIFIER
        assert token.start == 0, token.start
        assert token.stop == 5, token.stop
        assert token.text == 'foobar', token.text

        token = lexer.nextToken()
        assert token.type == self.lexerModule.WS
        assert token.start == 6, token.start
        assert token.stop == 6, token.stop
        assert token.text == ' ', token.text

        token = lexer.nextToken()
        assert token.type == self.lexerModule.IDENTIFIER
        assert token.start == 7, token.start
        assert token.stop == 11, token.stop
        assert token.text == '_Ab98', token.text

        token = lexer.nextToken()
        assert token.type == self.lexerModule.WS
        assert token.start == 12, token.start
        assert token.stop == 14, token.stop
        assert token.text == ' \n ', token.text

        token = lexer.nextToken()
        assert token.type == self.lexerModule.IDENTIFIER
        assert token.start == 15, token.start
        assert token.stop == 20, token.stop
        assert token.text == 'A12sdf', token.text

        token = lexer.nextToken()
        assert token.type == self.lexerModule.EOF


    def testMalformedInput(self):
        stream = antlr3.StringStream('a-b')
        lexer = self.getLexer(stream)

        lexer.nextToken()
        try:
            token = lexer.nextToken()
            raise AssertionError, token

        except antlr3.NoViableAltException, exc:
            assert exc.unexpectedType == '-', repr(exc.unexpectedType)
            assert exc.charPositionInLine == 1, repr(exc.charPositionInLine)
            assert exc.line == 1, repr(exc.line)

            

if __name__ == '__main__':
    unittest.main()

#!/usr/bin/python
# -*- coding: utf-8 -*-

# (c) 2014, Ruggero Marchei <ruggero.marchei@daemonzone.net>
# (c) 2015, Brian Coca <bcoca@ansible.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>


import os
import stat
import fnmatch
import time
import re

DOCUMENTATION = '''
---
module: find
author: Brian Coca (based on Ruggero Marchei's Tidy)
version_added: "2.0"
short_description: return a list of files based on specific criteria
requirements: []
description:
    - Return a list files based on specific criteria. Multiple criteria are AND'd together.
options:
    age:
        required: false
        default: null
        description:
            - Select files whose age is equal to or greater than the specified time.
              Use a negative age to find files equal to or less than the specified time.
              You can choose seconds, minutes, hours, days, or weeks by specifying the
              first letter of any of those words (e.g., "1w").
    patterns:
        required: false
        default: '*'
        description:
            - One or more (shell or regex) patterns, which type is controled by C(use_regex) option.
            - The patterns restrict the list of files to be returned to those whose basenames match at
              least one of the patterns specified. Multiple patterns can be specified using a list.
        aliases: ['pattern']
    contains:
        required: false
        default: null
        description:
            - One or more re patterns which should be matched against the file content
    paths:
        required: true
        aliases: [ "name", "path" ]
        description:
            - List of paths to the file or directory to search. All paths must be fully qualified.
    file_type:
        required: false
        description:
            - Type of file to select
        choices: [ "file", "directory" ]
        default: "file"
    recurse:
        required: false
        default: "no"
        choices: [ "yes", "no" ]
        description:
            - If target is a directory, recursively descend into the directory looking for files.
    size:
        required: false
        default: null
        description:
            - Select files whose size is equal to or greater than the specified size.
              Use a negative size to find files equal to or less than the specified size.
              Unqualified values are in bytes, but b, k, m, g, and t can be appended to specify
              bytes, kilobytes, megabytes, gigabytes, and terabytes, respectively.
              Size is not evaluated for directories.
    age_stamp:
        required: false
        default: "mtime"
        choices: [ "atime", "mtime", "ctime" ]
        description:
            - Choose the file property against which we compare age. Default is mtime.
    hidden:
        required: false
        default: "False"
        choices: [ True, False ]
        description:
            - Set this to true to include hidden files, otherwise they'll be ignored.
    follow:
        required: false
        default: "False"
        choices: [ True, False ]
        description:
            - Set this to true to follow symlinks in path for systems with python 2.6+
    get_checksum:
        required: false
        default: "False"
        choices: [ True, False ]
        description:
            - Set this to true to retrieve a file's sha1 checksum
    use_regex:
        required: false
        default: "False"
        choices: [ True, False ]
        description:
            - If false the patterns are file globs (shell) if true they are python regexes
'''


EXAMPLES = '''
# Recursively find /tmp files older than 2 days
- find: paths="/tmp" age="2d" recurse=yes

# Recursively find /tmp files older than 4 weeks and equal or greater than 1 megabyte
- find: paths="/tmp" age="4w" size="1m" recurse=yes

# Recursively find /var/tmp files with last access time greater than 3600 seconds
- find: paths="/var/tmp" age="3600" age_stamp=atime recurse=yes

# find /var/log files equal or greater than 10 megabytes ending with .old or .log.gz
- find: paths="/var/tmp" patterns="*.old,*.log.gz" size="10m"

# find /var/log files equal or greater than 10 megabytes ending with .old or .log.gz via regex
- find: paths="/var/tmp" patterns="^.*?\.(?:old|log\.gz)$" size="10m" use_regex=True
'''

RETURN = '''
files:
    description: all matches found with the specified criteria (see stat module for full output of each dictionary)
    returned: success
    type: list of dictionaries
    sample: [
        { path="/var/tmp/test1",
          mode=0644,
          ...,
          checksum=16fac7be61a6e4591a33ef4b729c5c3302307523
        },
        { path="/var/tmp/test2",
          ...
        },
        ]
matched:
    description: number of matches
    returned: success
    type: string
    sample: 14
examined:
    description: number of filesystem objects looked at
    returned: success
    type: string
    sample: 34
'''

def pfilter(f, patterns=None, use_regex=False):
    '''filter using glob patterns'''

    if patterns is None:
        return True

    if use_regex:
        for p in patterns:
            r =  re.compile(p)
            if r.match(f):
                return True
    else:

        for p in patterns:
            if fnmatch.fnmatch(f, p):
                return True

    return False


def agefilter(st, now, age, timestamp):
    '''filter files older than age'''
    if age is None or \
      (age >= 0 and now - st.__getattribute__("st_%s" % timestamp) >= abs(age)) or \
      (age < 0 and now - st.__getattribute__("st_%s" % timestamp) <= abs(age)):

        return True
    return False


def sizefilter(st, size):
    '''filter files greater than size'''
    if size is None or \
       (size >= 0 and st.st_size >= abs(size)) or \
       (size < 0 and st.st_size <= abs(size)):

        return True

    return False

def contentfilter(fsname, pattern):
    '''filter files which contain the given expression'''
    if pattern is None: return True

    try:
       f = open(fsname)
       prog = re.compile(pattern)
       for line in f:
           if prog.match (line):
               f.close()
               return True

       f.close() 
    except:
       pass

    return False

def statinfo(st):
    return {
        'mode'     : "%04o" % stat.S_IMODE(st.st_mode),
        'isdir'    : stat.S_ISDIR(st.st_mode),
        'ischr'    : stat.S_ISCHR(st.st_mode),
        'isblk'    : stat.S_ISBLK(st.st_mode),
        'isreg'    : stat.S_ISREG(st.st_mode),
        'isfifo'   : stat.S_ISFIFO(st.st_mode),
        'islnk'    : stat.S_ISLNK(st.st_mode),
        'issock'   : stat.S_ISSOCK(st.st_mode),
        'uid'      : st.st_uid,
        'gid'      : st.st_gid,
        'size'     : st.st_size,
        'inode'    : st.st_ino,
        'dev'      : st.st_dev,
        'nlink'    : st.st_nlink,
        'atime'    : st.st_atime,
        'mtime'    : st.st_mtime,
        'ctime'    : st.st_ctime,
        'wusr'     : bool(st.st_mode & stat.S_IWUSR),
        'rusr'     : bool(st.st_mode & stat.S_IRUSR),
        'xusr'     : bool(st.st_mode & stat.S_IXUSR),
        'wgrp'     : bool(st.st_mode & stat.S_IWGRP),
        'rgrp'     : bool(st.st_mode & stat.S_IRGRP),
        'xgrp'     : bool(st.st_mode & stat.S_IXGRP),
        'woth'     : bool(st.st_mode & stat.S_IWOTH),
        'roth'     : bool(st.st_mode & stat.S_IROTH),
        'xoth'     : bool(st.st_mode & stat.S_IXOTH),
        'isuid'    : bool(st.st_mode & stat.S_ISUID),
        'isgid'    : bool(st.st_mode & stat.S_ISGID),
    }


def main():
    module = AnsibleModule(
        argument_spec = dict(
            paths         = dict(required=True, aliases=['name','path'], type='list'),
            patterns      = dict(default=['*'], type='list', aliases=['pattern']),
            contains      = dict(default=None, type='str'),
            file_type     = dict(default="file", choices=['file', 'directory'], type='str'),
            age           = dict(default=None, type='str'),
            age_stamp     = dict(default="mtime", choices=['atime','mtime','ctime'], type='str'),
            size          = dict(default=None, type='str'),
            recurse       = dict(default='no', type='bool'),
            hidden        = dict(default="False", type='bool'),
            follow        = dict(default="False", type='bool'),
            get_checksum  = dict(default="False", type='bool'),
            use_regex     = dict(default="False", type='bool'),
        ),
        supports_check_mode=True,
    )

    params = module.params

    filelist = []

    if params['age'] is None:
        age = None
    else:
        # convert age to seconds:
        m = re.match("^(-?\d+)(s|m|h|d|w)?$", params['age'].lower())
        seconds_per_unit = {"s": 1, "m": 60, "h": 3600, "d": 86400, "w": 604800}
        if m:
            age = int(m.group(1)) * seconds_per_unit.get(m.group(2), 1)
        else:
            module.fail_json(age=params['age'], msg="failed to process age")

    if params['size'] is None:
        size = None
    else:
        # convert size to bytes:
        m = re.match("^(-?\d+)(b|k|m|g|t)?$", params['size'].lower())
        bytes_per_unit = {"b": 1, "k": 1024, "m": 1024**2, "g": 1024**3, "t": 1024**4}
        if m:
            size = int(m.group(1)) * bytes_per_unit.get(m.group(2), 1)
        else:
            module.fail_json(size=params['size'], msg="failed to process size")

    now = time.time()
    msg = ''
    looked = 0
    for npath in params['paths']:
        if os.path.isdir(npath):

            ''' ignore followlinks for python version < 2.6 '''
            for root,dirs,files in (sys.version_info < (2,6,0) and os.walk(npath)) or \
                                    os.walk( npath, followlinks=params['follow']):
                looked = looked + len(files) + len(dirs)
                for fsobj in (files + dirs):
                    fsname=os.path.normpath(os.path.join(root, fsobj))

                    if os.path.basename(fsname).startswith('.') and not params['hidden']:
                       continue

                    try:
                        st = os.stat(fsname)
                    except:
                        msg+="%s was skipped as it does not seem to be a valid file or it cannot be accessed\n" % fsname
                        continue

                    r = {'path': fsname}
                    if stat.S_ISDIR(st.st_mode) and params['file_type'] == 'directory':
                        if pfilter(fsobj, params['patterns'], params['use_regex']) and agefilter(st, now, age, params['age_stamp']):

                            r.update(statinfo(st))
                            filelist.append(r)

                    elif stat.S_ISREG(st.st_mode) and params['file_type'] == 'file':
                        if pfilter(fsobj, params['patterns'], params['use_regex']) and \
                           agefilter(st, now, age, params['age_stamp']) and \
                           sizefilter(st, size) and \
                           contentfilter(fsname, params['contains']):

                            r.update(statinfo(st))
                            if params['get_checksum']:
                                r['checksum'] = module.sha1(fsname)
                            filelist.append(r)

                if not params['recurse']:
                    break
        else:
            msg+="%s was skipped as it does not seem to be a valid directory or it cannot be accessed\n" % npath

    matched = len(filelist)
    module.exit_json(files=filelist, changed=False, msg=msg, matched=matched, examined=looked)

# import module snippets
from ansible.module_utils.basic import *
main()


# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Example of debugging TensorFlow runtime errors using tfdbg."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import argparse
import sys

import numpy as np
import tensorflow as tf

from tensorflow.python import debug as tf_debug


def main(_):
  sess = tf.Session()

  # Construct the TensorFlow network.
  ph_float = tf.placeholder(tf.float32, name="ph_float")
  x = tf.transpose(ph_float, name="x")
  v = tf.Variable(np.array([[-2.0], [-3.0], [6.0]], dtype=np.float32), name="v")
  m = tf.constant(
      np.array([[0.0, 1.0, 2.0], [-4.0, -1.0, 0.0]]),
      dtype=tf.float32,
      name="m")
  y = tf.matmul(m, x, name="y")
  z = tf.matmul(m, v, name="z")

  if FLAGS.debug:
    sess = tf_debug.LocalCLIDebugWrapperSession(sess, ui_type=FLAGS.ui_type)

  if FLAGS.error == "shape_mismatch":
    print(sess.run(y, feed_dict={ph_float: np.array([[0.0], [1.0], [2.0]])}))
  elif FLAGS.error == "uninitialized_variable":
    print(sess.run(z))
  elif FLAGS.error == "no_error":
    print(sess.run(y, feed_dict={ph_float: np.array([[0.0, 1.0, 2.0]])}))
  else:
    raise ValueError("Unrecognized error type: " + FLAGS.error)


if __name__ == "__main__":
  parser = argparse.ArgumentParser()
  parser.register("type", "bool", lambda v: v.lower() == "true")
  parser.add_argument(
      "--error",
      type=str,
      default="shape_mismatch",
      help="""\
      Type of the error to generate (shape_mismatch | uninitialized_variable |
      no_error).\
      """)
  parser.add_argument(
      "--ui_type",
      type=str,
      default="curses",
      help="Command-line user interface type (curses | readline)")
  parser.add_argument(
      "--debug",
      type="bool",
      nargs="?",
      const=True,
      default=False,
      help="Use debugger to track down bad values during training")
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

# This code is part of Ansible, but is an independent component.
# This particular file snippet, and this file snippet only, is BSD licensed.
# Modules you write using this snippet, which is embedded dynamically by Ansible
# still belong to the author of the module, and may assign their own license
# to the complete work.
#
# Copyright (c) 2015 Peter Sprygada, <psprygada@ansible.com>
# Copyright (c) 2017 Red Hat Inc.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
#    * Redistributions of source code must retain the above copyright
#      notice, this list of conditions and the following disclaimer.
#    * Redistributions in binary form must reproduce the above copyright notice,
#      this list of conditions and the following disclaimer in the documentation
#      and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
from ansible.module_utils._text import to_text
from ansible.module_utils.basic import env_fallback, return_values
from ansible.module_utils.network_common import to_list, ComplexList
from ansible.module_utils.connection import exec_command

_DEVICE_CONFIGS = {}

iosxr_provider_spec = {
    'host': dict(),
    'port': dict(type='int'),
    'username': dict(fallback=(env_fallback, ['ANSIBLE_NET_USERNAME'])),
    'password': dict(fallback=(env_fallback, ['ANSIBLE_NET_PASSWORD']), no_log=True),
    'ssh_keyfile': dict(fallback=(env_fallback, ['ANSIBLE_NET_SSH_KEYFILE']), type='path'),
    'timeout': dict(type='int'),
}
iosxr_argument_spec = {
    'provider': dict(type='dict', options=iosxr_provider_spec)
}
iosxr_argument_spec.update(iosxr_provider_spec)


def get_argspec():
    return iosxr_argument_spec


def check_args(module, warnings):
    for key in iosxr_argument_spec:
        if module._name == 'iosxr_user':
            if key not in ['password', 'provider'] and module.params[key]:
                warnings.append('argument %s has been deprecated and will be in a future version' % key)
        else:
            if key != 'provider' and module.params[key]:
                warnings.append('argument %s has been deprecated and will be removed in a future version' % key)


def get_config(module, flags=[]):
    cmd = 'show running-config '
    cmd += ' '.join(flags)
    cmd = cmd.strip()

    try:
        return _DEVICE_CONFIGS[cmd]
    except KeyError:
        rc, out, err = exec_command(module, cmd)
        if rc != 0:
            module.fail_json(msg='unable to retrieve current config', stderr=to_text(err, errors='surrogate_or_strict'))
        cfg = to_text(out, errors='surrogate_or_strict').strip()
        _DEVICE_CONFIGS[cmd] = cfg
        return cfg


def to_commands(module, commands):
    spec = {
        'command': dict(key=True),
        'prompt': dict(),
        'answer': dict()
    }
    transform = ComplexList(spec, module)
    return transform(commands)


def run_commands(module, commands, check_rc=True):
    responses = list()
    commands = to_commands(module, to_list(commands))
    for cmd in to_list(commands):
        cmd = module.jsonify(cmd)
        rc, out, err = exec_command(module, cmd)
        if check_rc and rc != 0:
            module.fail_json(msg=to_text(err, errors='surrogate_or_strict'), rc=rc)
        responses.append(to_text(out, errors='surrogate_or_strict'))
    return responses


def load_config(module, commands, warnings, commit=False, replace=False, comment=None, admin=False):
    cmd = 'configure terminal'
    if admin:
        cmd = 'admin ' + cmd

    rc, out, err = exec_command(module, cmd)
    if rc != 0:
        module.fail_json(msg='unable to enter configuration mode', err=to_text(err, errors='surrogate_or_strict'))

    failed = False
    for command in to_list(commands):
        if command == 'end':
            continue

        rc, out, err = exec_command(module, command)
        if rc != 0:
            failed = True
            break

    if failed:
        exec_command(module, 'abort')
        module.fail_json(msg=to_text(err, errors='surrogate_or_strict'), commands=commands, rc=rc)

    rc, diff, err = exec_command(module, 'show commit changes diff')
    if rc != 0:
        # If we failed, maybe we are in an old version so
        # we run show configuration instead
        rc, diff, err = exec_command(module, 'show configuration')
        if module._diff:
            warnings.append('device platform does not support config diff')

    if commit:
        cmd = 'commit'
        if comment:
            cmd += ' comment {0}'.format(comment)
    else:
        cmd = 'abort'

    rc, out, err = exec_command(module, cmd)
    if rc != 0:
        exec_command(module, 'abort')
        module.fail_json(msg=err, commands=commands, rc=rc)

    return to_text(diff, errors='surrogate_or_strict')

# -*-mode: python; fill-column: 75; tab-width: 8; coding: iso-latin-1-unix -*-
#
# $Id: CmpImg.py 36560 2004-07-18 06:16:08Z tim_one $
#
# Tix Demostration Program
#
# This sample program is structured in such a way so that it can be
# executed from the Tix demo program "tixwidgets.py": it must have a
# procedure called "RunSample". It should also have the "if" statment
# at the end of this file so that it can be run as a standalone
# program.

# This file demonstrates the use of the compound images: it uses compound
# images to display a text string together with a pixmap inside
# buttons
#

import Tix

network_pixmap = """/* XPM */
static char * netw_xpm[] = {
/* width height ncolors chars_per_pixel */
"32 32 7 1",
/* colors */
"       s None  c None",
".      c #000000000000",
"X      c white",
"o      c #c000c000c000",
"O      c #404040",
"+      c blue",
"@      c red",
/* pixels */
"                                ",
"                 .............. ",
"                 .XXXXXXXXXXXX. ",
"                 .XooooooooooO. ",
"                 .Xo.......XoO. ",
"                 .Xo.++++o+XoO. ",
"                 .Xo.++++o+XoO. ",
"                 .Xo.++oo++XoO. ",
"                 .Xo.++++++XoO. ",
"                 .Xo.+o++++XoO. ",
"                 .Xo.++++++XoO. ",
"                 .Xo.XXXXXXXoO. ",
"                 .XooooooooooO. ",
"                 .Xo@ooo....oO. ",
" ..............  .XooooooooooO. ",
" .XXXXXXXXXXXX.  .XooooooooooO. ",
" .XooooooooooO.  .OOOOOOOOOOOO. ",
" .Xo.......XoO.  .............. ",
" .Xo.++++o+XoO.        @        ",
" .Xo.++++o+XoO.        @        ",
" .Xo.++oo++XoO.        @        ",
" .Xo.++++++XoO.        @        ",
" .Xo.+o++++XoO.        @        ",
" .Xo.++++++XoO.      .....      ",
" .Xo.XXXXXXXoO.      .XXX.      ",
" .XooooooooooO.@@@@@@.X O.      ",
" .Xo@ooo....oO.      .OOO.      ",
" .XooooooooooO.      .....      ",
" .XooooooooooO.                 ",
" .OOOOOOOOOOOO.                 ",
" ..............                 ",
"                                "};
"""

hard_disk_pixmap = """/* XPM */
static char * drivea_xpm[] = {
/* width height ncolors chars_per_pixel */
"32 32 5 1",
/* colors */
"       s None  c None",
".      c #000000000000",
"X      c white",
"o      c #c000c000c000",
"O      c #800080008000",
/* pixels */
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"   ..........................   ",
"   .XXXXXXXXXXXXXXXXXXXXXXXo.   ",
"   .XooooooooooooooooooooooO.   ",
"   .Xooooooooooooooooo..oooO.   ",
"   .Xooooooooooooooooo..oooO.   ",
"   .XooooooooooooooooooooooO.   ",
"   .Xoooooooo.......oooooooO.   ",
"   .Xoo...................oO.   ",
"   .Xoooooooo.......oooooooO.   ",
"   .XooooooooooooooooooooooO.   ",
"   .XooooooooooooooooooooooO.   ",
"   .XooooooooooooooooooooooO.   ",
"   .XooooooooooooooooooooooO.   ",
"   .oOOOOOOOOOOOOOOOOOOOOOOO.   ",
"   ..........................   ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                ",
"                                "};
"""

network_bitmap = """
#define netw_width 32
#define netw_height 32
static unsigned char netw_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00, 0x02, 0x40,
   0x00, 0x00, 0xfa, 0x5f, 0x00, 0x00, 0x0a, 0x50, 0x00, 0x00, 0x0a, 0x52,
   0x00, 0x00, 0x0a, 0x52, 0x00, 0x00, 0x8a, 0x51, 0x00, 0x00, 0x0a, 0x50,
   0x00, 0x00, 0x4a, 0x50, 0x00, 0x00, 0x0a, 0x50, 0x00, 0x00, 0x0a, 0x50,
   0x00, 0x00, 0xfa, 0x5f, 0x00, 0x00, 0x02, 0x40, 0xfe, 0x7f, 0x52, 0x55,
   0x02, 0x40, 0xaa, 0x6a, 0xfa, 0x5f, 0xfe, 0x7f, 0x0a, 0x50, 0xfe, 0x7f,
   0x0a, 0x52, 0x80, 0x00, 0x0a, 0x52, 0x80, 0x00, 0x8a, 0x51, 0x80, 0x00,
   0x0a, 0x50, 0x80, 0x00, 0x4a, 0x50, 0x80, 0x00, 0x0a, 0x50, 0xe0, 0x03,
   0x0a, 0x50, 0x20, 0x02, 0xfa, 0xdf, 0x3f, 0x03, 0x02, 0x40, 0xa0, 0x02,
   0x52, 0x55, 0xe0, 0x03, 0xaa, 0x6a, 0x00, 0x00, 0xfe, 0x7f, 0x00, 0x00,
   0xfe, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
"""

hard_disk_bitmap = """
#define drivea_width 32
#define drivea_height 32
static unsigned char drivea_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0xf8, 0xff, 0xff, 0x1f, 0x08, 0x00, 0x00, 0x18, 0xa8, 0xaa, 0xaa, 0x1a,
   0x48, 0x55, 0xd5, 0x1d, 0xa8, 0xaa, 0xaa, 0x1b, 0x48, 0x55, 0x55, 0x1d,
   0xa8, 0xfa, 0xaf, 0x1a, 0xc8, 0xff, 0xff, 0x1d, 0xa8, 0xfa, 0xaf, 0x1a,
   0x48, 0x55, 0x55, 0x1d, 0xa8, 0xaa, 0xaa, 0x1a, 0x48, 0x55, 0x55, 0x1d,
   0xa8, 0xaa, 0xaa, 0x1a, 0xf8, 0xff, 0xff, 0x1f, 0xf8, 0xff, 0xff, 0x1f,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
"""

def RunSample(w):
    w.img0 = Tix.Image('pixmap', data=network_pixmap)
    if not w.img0:
        w.img0 = Tix.Image('bitmap', data=network_bitmap)
    w.img1 = Tix.Image('pixmap', data=hard_disk_pixmap)
    if not w.img0:
        w.img1 = Tix.Image('bitmap', data=hard_disk_bitmap)

    hdd = Tix.Button(w, padx=4, pady=1, width=120)
    net = Tix.Button(w, padx=4, pady=1, width=120)

    # Create the first image: we create a line, then put a string,
    # a space and a image into this line, from left to right.
    # The result: we have a one-line image that consists of three
    # individual items
    #
    # The tk.calls should be methods in Tix ...
    w.hdd_img = Tix.Image('compound', window=hdd)
    w.hdd_img.tk.call(str(w.hdd_img), 'add', 'line')
    w.hdd_img.tk.call(str(w.hdd_img), 'add', 'text', '-text', 'Hard Disk',
                    '-underline', '0')
    w.hdd_img.tk.call(str(w.hdd_img), 'add', 'space', '-width', '7')
    w.hdd_img.tk.call(str(w.hdd_img), 'add', 'image', '-image', w.img1)

    # Put this image into the first button
    #
    hdd['image'] = w.hdd_img

    # Next button
    w.net_img = Tix.Image('compound', window=net)
    w.net_img.tk.call(str(w.net_img), 'add', 'line')
    w.net_img.tk.call(str(w.net_img), 'add', 'text', '-text', 'Network',
                    '-underline', '0')
    w.net_img.tk.call(str(w.net_img), 'add', 'space', '-width', '7')
    w.net_img.tk.call(str(w.net_img), 'add', 'image', '-image', w.img0)

    # Put this image into the first button
    #
    net['image'] = w.net_img

    close = Tix.Button(w, pady=1, text='Close',
                       command=lambda w=w: w.destroy())

    hdd.pack(side=Tix.LEFT, padx=10, pady=10, fill=Tix.Y, expand=1)
    net.pack(side=Tix.LEFT, padx=10, pady=10, fill=Tix.Y, expand=1)
    close.pack(side=Tix.LEFT, padx=10, pady=10, fill=Tix.Y, expand=1)

if __name__ == '__main__':
    root = Tix.Tk()
    RunSample(root)
    root.mainloop()

#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.
#

from __future__ import print_function

from pyspark import SparkContext
# $example on$
from pyspark.mllib.linalg import Matrices, Vectors
from pyspark.mllib.regression import LabeledPoint
from pyspark.mllib.stat import Statistics
# $example off$

if __name__ == "__main__":
    sc = SparkContext(appName="HypothesisTestingExample")

    # $example on$
    vec = Vectors.dense(0.1, 0.15, 0.2, 0.3, 0.25)  # a vector composed of the frequencies of events

    # compute the goodness of fit. If a second vector to test against
    # is not supplied as a parameter, the test runs against a uniform distribution.
    goodnessOfFitTestResult = Statistics.chiSqTest(vec)

    # summary of the test including the p-value, degrees of freedom,
    # test statistic, the method used, and the null hypothesis.
    print("%s\n" % goodnessOfFitTestResult)

    mat = Matrices.dense(3, 2, [1.0, 3.0, 5.0, 2.0, 4.0, 6.0])  # a contingency matrix

    # conduct Pearson's independence test on the input contingency matrix
    independenceTestResult = Statistics.chiSqTest(mat)

    # summary of the test including the p-value, degrees of freedom,
    # test statistic, the method used, and the null hypothesis.
    print("%s\n" % independenceTestResult)

    obs = sc.parallelize(
        [LabeledPoint(1.0, [1.0, 0.0, 3.0]),
         LabeledPoint(1.0, [1.0, 2.0, 0.0]),
         LabeledPoint(1.0, [-1.0, 0.0, -0.5])]
    )  # LabeledPoint(feature, label)

    # The contingency table is constructed from an RDD of LabeledPoint and used to conduct
    # the independence test. Returns an array containing the ChiSquaredTestResult for every feature
    # against the label.
    featureTestResults = Statistics.chiSqTest(obs)

    for i, result in enumerate(featureTestResults):
        print("Column %d:\n%s" % (i + 1, result))
    # $example off$

    sc.stop()

"""Middleware for embargoing site and courses.

IMPORTANT NOTE: This code WILL NOT WORK if you have a misconfigured proxy
server.  If you are configuring embargo functionality, or if you are
experiencing mysterious problems with embargoing, please check that your
reverse proxy is setting any of the well known client IP address headers (ex.,
HTTP_X_FORWARDED_FOR).

This middleware allows you to:

* Embargoing courses (access restriction by courses)
* Embargoing site (access restriction of the main site)

Embargo can restrict by states and whitelist/blacklist (IP Addresses
(ie. 10.0.0.0), Networks (ie. 10.0.0.0/24)), or the user profile country.

Usage:

# Enable the middleware in your settings

# To enable Embargo for particular courses, set:
FEATURES['EMBARGO'] = True # blocked ip will be redirected to /embargo

# To enable the Embargo feature for the whole site, set:
FEATURES['SITE_EMBARGOED'] = True

# With SITE_EMBARGOED, you can define an external url to redirect with:
EMBARGO_SITE_REDIRECT_URL = 'https://www.edx.org/'

# if EMBARGO_SITE_REDIRECT_URL is missing, a HttpResponseForbidden is returned.

"""
from functools import partial
import logging
import pygeoip
from lazy import lazy

from django.core.exceptions import MiddlewareNotUsed
from django.core.cache import cache
from django.conf import settings
from django.shortcuts import redirect
from django.http import HttpResponseRedirect, HttpResponseForbidden
from ipware.ip import get_ip
from util.request import course_id_from_url

from student.models import unique_id_for_user
from embargo.models import EmbargoedCourse, EmbargoedState, IPFilter

log = logging.getLogger(__name__)


class EmbargoMiddleware(object):
    """
    Middleware for embargoing site and courses

    This is configured by creating ``EmbargoedCourse``, ``EmbargoedState``, and
    optionally ``IPFilter`` rows in the database, using the django admin site.
    """

    # Reasons a user might be blocked.
    # These are used to generate info messages in the logs.
    REASONS = {
        "ip_blacklist": u"Restricting IP address {ip_addr} {from_course} because IP is blacklisted.",
        "ip_country": u"Restricting IP address {ip_addr} {from_course} because IP is from country {ip_country}.",
        "profile_country": (
            u"Restricting user {user_id} {from_course} because "
            u"the user set the profile country to {profile_country}."
        )
    }

    def __init__(self):
        self.site_enabled = settings.FEATURES.get('SITE_EMBARGOED', False)
        # If embargoing is turned off, make this middleware do nothing
        if not settings.FEATURES.get('EMBARGO', False) and not self.site_enabled:
            raise MiddlewareNotUsed()

    def process_request(self, request):
        """
        Processes embargo requests.
        """
        url = request.path
        course_id = course_id_from_url(url)
        course_is_embargoed = EmbargoedCourse.is_embargoed(course_id)

        # If they're trying to access a course that cares about embargoes
        if self.site_enabled or course_is_embargoed:

            # Construct the list of functions that check whether the user is embargoed.
            # We wrap each of these functions in a decorator that logs the reason the user
            # was blocked.
            # Each function should return `True` iff the user is blocked by an embargo.
            check_functions = [
                self._log_embargo_reason(check_func, course_id, course_is_embargoed)
                for check_func in [
                    partial(self._is_embargoed_by_ip, get_ip(request)),
                    partial(self._is_embargoed_by_profile_country, request.user)
                ]
            ]

            # Perform each of the checks
            # If the user fails any of the checks, immediately redirect them
            # and skip later checks.
            for check_func in check_functions:
                if check_func():
                    return self._embargo_redirect_response

        # If all the check functions pass, implicitly return None
        # so that the middleware processor can continue processing
        # the response.

    def _is_embargoed_by_ip(self, ip_addr, course_id=u"", course_is_embargoed=False):
        """
        Check whether the user is embargoed based on the IP address.

        Args:
            ip_addr (str): The IP address the request originated from.

        Keyword Args:
            course_id (unicode): The course the user is trying to access.
            course_is_embargoed (boolean): Whether the course the user is accessing has been embargoed.

        Returns:
            A unicode message if the user is embargoed, otherwise `None`

        """
        # If blacklisted, immediately fail
        if ip_addr in IPFilter.current().blacklist_ips:
            return self.REASONS['ip_blacklist'].format(
                ip_addr=ip_addr,
                from_course=self._from_course_msg(course_id, course_is_embargoed)
            )

        # If we're white-listed, then allow access
        if ip_addr in IPFilter.current().whitelist_ips:
            return None

        # Retrieve the country code from the IP address
        # and check it against the list of embargoed countries
        ip_country = self._country_code_from_ip(ip_addr)
        if ip_country in self._embargoed_countries:
            return self.REASONS['ip_country'].format(
                ip_addr=ip_addr,
                ip_country=ip_country,
                from_course=self._from_course_msg(course_id, course_is_embargoed)
            )

        # If none of the other checks caught anything,
        # implicitly return None to indicate that the user can access the course

    def _is_embargoed_by_profile_country(self, user, course_id="", course_is_embargoed=False):
        """
        Check whether the user is embargoed based on the country code in the user's profile.

        Args:
            user (User): The user attempting to access courseware.

        Keyword Args:
            course_id (unicode): The course the user is trying to access.
            course_is_embargoed (boolean): Whether the course the user is accessing has been embargoed.

        Returns:
            A unicode message if the user is embargoed, otherwise `None`

        """
        cache_key = u'user.{user_id}.profile.country'.format(user_id=user.id)
        profile_country = cache.get(cache_key)
        if profile_country is None:
            profile = getattr(user, 'profile', None)
            if profile is not None and profile.country.code is not None:
                profile_country = profile.country.code.upper()
            else:
                profile_country = ""
            cache.set(cache_key, profile_country)

        if profile_country in self._embargoed_countries:
            return self.REASONS['profile_country'].format(
                user_id=unique_id_for_user(user),
                profile_country=profile_country,
                from_course=self._from_course_msg(course_id, course_is_embargoed)
            )
        else:
            return None

    def _country_code_from_ip(self, ip_addr):
        """
        Return the country code associated with an IP address.
        Handles both IPv4 and IPv6 addresses.

        Args:
            ip_addr (str): The IP address to look up.

        Returns:
            str: A 2-letter country code.

        """
        if ip_addr.find(':') >= 0:
            return pygeoip.GeoIP(settings.GEOIPV6_PATH).country_code_by_addr(ip_addr)
        else:
            return pygeoip.GeoIP(settings.GEOIP_PATH).country_code_by_addr(ip_addr)

    @property
    def _embargo_redirect_response(self):
        """
        The HTTP response to send when the user is blocked from a course.
        This will either be a redirect to a URL configured in Django settings
        or a forbidden response.

        Returns:
            HTTPResponse

        """
        response = redirect('embargo')

        # Set the proper response if site is enabled
        if self.site_enabled:
            redirect_url = getattr(settings, 'EMBARGO_SITE_REDIRECT_URL', None)
            response = (
                HttpResponseRedirect(redirect_url)
                if redirect_url
                else HttpResponseForbidden('Access Denied')
            )

        return response

    @lazy
    def _embargoed_countries(self):
        """
        Return the list of 2-letter country codes for embargoed countries.
        The result is cached within the scope of the response.

        Returns:
            list

        """
        return EmbargoedState.current().embargoed_countries_list

    def _from_course_msg(self, course_id, course_is_embargoed):
        """
        Format a message indicating whether the user was blocked from a specific course.
        This can be used in info messages, but should not be used in user-facing messages.

        Args:
            course_id (unicode): The ID of the course being accessed.
            course_is_embarged (boolean): Whether the course being accessed is embargoed.

        Returns:
            unicode

        """
        return (
            u"from course {course_id}".format(course_id=course_id)
            if course_is_embargoed
            else u""
        )

    def _log_embargo_reason(self, check_func, course_id, course_is_embargoed):
        """
        Decorator for embargo check functions that will:
            * execute the check function
            * check whether the user is blocked by an embargo, and if so, log the reason
            * return a boolean indicating whether the user was blocked.

        Args:
            check_func (partial): A function that should return unicode reason if the user
                was blocked, otherwise should return None.  This function will be passed
                `course_id` and `course_is_embarged` kwargs so it can format a detailed
                reason message.

            course_id (unicode): The ID of the course the user is trying to access.

            course_is_embargoed (boolean): Whether the course the user is trying
                to access is under an embargo.

        Returns:
            boolean: True iff the user was blocked by an embargo

        """
        def _inner():
            # Perform the check and retrieve the reason string.
            # The reason will be `None` if the user passes the check and can access the course.
            # We pass in the course ID and whether the course is embargoed
            # so that the check function can fill in the "reason" message with more specific details.
            reason = check_func(
                course_id=course_id,
                course_is_embargoed=course_is_embargoed
            )

            # If the reason was `None`, indicate that the user was not blocked.
            if reason is None:
                return False

            # Otherwise, log the reason the user was blocked
            # and return True.
            else:
                msg = u"Embargo: {reason}".format(reason=reason)
                log.info(msg)
                return True

        return _inner

# -*- coding: utf-8 -*-
"""
Admin site configuration for third party authentication
"""

from django.contrib import admin

from config_models.admin import ConfigurationModelAdmin, KeyedConfigurationModelAdmin
from .models import OAuth2ProviderConfig, SAMLProviderConfig, SAMLConfiguration, SAMLProviderData, LTIProviderConfig
from .tasks import fetch_saml_metadata


class OAuth2ProviderConfigAdmin(KeyedConfigurationModelAdmin):
    """ Django Admin class for OAuth2ProviderConfig """
    def get_list_display(self, request):
        """ Don't show every single field in the admin change list """
        return (
            'name', 'enabled', 'backend_name', 'secondary', 'skip_registration_form',
            'skip_email_verification', 'change_date', 'changed_by', 'edit_link',
        )

admin.site.register(OAuth2ProviderConfig, OAuth2ProviderConfigAdmin)


class SAMLProviderConfigAdmin(KeyedConfigurationModelAdmin):
    """ Django Admin class for SAMLProviderConfig """
    def get_list_display(self, request):
        """ Don't show every single field in the admin change list """
        return (
            'name', 'enabled', 'backend_name', 'entity_id', 'metadata_source',
            'has_data', 'icon_class', 'change_date', 'changed_by', 'edit_link'
        )

    def has_data(self, inst):
        """ Do we have cached metadata for this SAML provider? """
        if not inst.is_active:
            return None  # N/A
        data = SAMLProviderData.current(inst.entity_id)
        return bool(data and data.is_valid())
    has_data.short_description = u'Metadata Ready'
    has_data.boolean = True

    def save_model(self, request, obj, form, change):
        """
        Post save: Queue an asynchronous metadata fetch to update SAMLProviderData.
        We only want to do this for manual edits done using the admin interface.

        Note: This only works if the celery worker and the app worker are using the
        same 'configuration' cache.
        """
        super(SAMLProviderConfigAdmin, self).save_model(request, obj, form, change)
        fetch_saml_metadata.apply_async((), countdown=2)

admin.site.register(SAMLProviderConfig, SAMLProviderConfigAdmin)


class SAMLConfigurationAdmin(ConfigurationModelAdmin):
    """ Django Admin class for SAMLConfiguration """
    def get_list_display(self, request):
        """ Shorten the public/private keys in the change view """
        return (
            'change_date', 'changed_by', 'enabled', 'entity_id',
            'org_info_str', 'key_summary',
        )

    def key_summary(self, inst):
        """ Short summary of the key pairs configured """
        public_key = inst.get_setting('SP_PUBLIC_CERT')
        private_key = inst.get_setting('SP_PRIVATE_KEY')
        if not public_key or not private_key:
            return u'<em>Key pair incomplete/missing</em>'
        pub1, pub2 = public_key[0:10], public_key[-10:]
        priv1, priv2 = private_key[0:10], private_key[-10:]
        return u'Public: {}…{}<br>Private: {}…{}'.format(pub1, pub2, priv1, priv2)
    key_summary.allow_tags = True

admin.site.register(SAMLConfiguration, SAMLConfigurationAdmin)


class SAMLProviderDataAdmin(admin.ModelAdmin):
    """ Django Admin class for SAMLProviderData (Read Only) """
    list_display = ('entity_id', 'is_valid', 'fetched_at', 'expires_at', 'sso_url')
    readonly_fields = ('is_valid', )

    def get_readonly_fields(self, request, obj=None):
        if obj:  # editing an existing object
            return self.model._meta.get_all_field_names()  # pylint: disable=protected-access
        return self.readonly_fields

admin.site.register(SAMLProviderData, SAMLProviderDataAdmin)


class LTIProviderConfigAdmin(KeyedConfigurationModelAdmin):
    """ Django Admin class for LTIProviderConfig """

    exclude = (
        'icon_class',
        'secondary',
    )

    def get_list_display(self, request):
        """ Don't show every single field in the admin change list """
        return (
            'name',
            'enabled',
            'lti_consumer_key',
            'lti_max_timestamp_age',
            'change_date',
            'changed_by',
            'edit_link',
        )

admin.site.register(LTIProviderConfig, LTIProviderConfigAdmin)

import unittest, sys, time
sys.path.extend(['.','..','../..','py'])
import h2o2 as h2o
import h2o_cmd, h2o_import as h2i
from h2o_test import dump_json, verboseprint, OutputObj

class Basic(unittest.TestCase):
    def tearDown(self):
        h2o.check_sandbox_for_errors()

    @classmethod
    def setUpClass(cls):
        h2o.init(1, java_heap_GB=4)

    @classmethod
    def tearDownClass(cls):
        h2o.tear_down_cloud()

    def test_GBM_basic_regress(self):
        bucket = 'home-0xdiag-datasets'
        importFolderPath = 'standard'
        trainFilename = 'covtype.shuffled.90pct.data'
        train_key = 'covtype.train.hex'
        model_key = 'GBMModelKey'
        timeoutSecs = 1800
        csvPathname = importFolderPath + "/" + trainFilename

        parseResult = h2i.import_parse(bucket=bucket, path=csvPathname, schema='local',
            hex_key=train_key, timeoutSecs=timeoutSecs)
        pA = h2o_cmd.ParseObj(parseResult)
        iA = h2o_cmd.InspectObj(pA.parse_key)
        parse_key = pA.parse_key
        numRows = iA.numRows
        numCols = iA.numCols
        labelList = iA.labelList


        labelListUsed = list(labelList)
        numColsUsed = numCols

        parameters = {
            'validation_frame': train_key,
            'ignored_columns': None,
            'response_column': 'C55',
            # 'balance_classes':
            # 'max_after_balance_size':
            'ntrees': 2,
            'max_depth': 10,
            'min_rows': 3,
            'nbins': 40,
            'learn_rate': 0.2,
            # FIX! doesn't like it?
            # 'loss': 'Bernoulli',
            # FIX..no variable importance for GBM yet?
            # 'variable_importance': False,
            # 'seed': 
        }

        model_key = 'covtype_gbm.hex'
        bmResult = h2o.n0.build_model(
            algo='gbm',
            model_id=model_key,
            training_frame=parse_key,
            parameters=parameters,
            timeoutSecs=60)
        bm = OutputObj(bmResult, 'bm')

        modelResult = h2o.n0.models(key=model_key)
        model = OutputObj(modelResult['models'][0]['output'], 'model')

        cmmResult = h2o.n0.compute_model_metrics(model=model_key, frame=parse_key, timeoutSecs=60)
        cmm = OutputObj(cmmResult, 'cmm')
        # just check that it's something non-zero
        # assert cmm.cm['prediction_error']!=0.0

        mmResult = h2o.n0.model_metrics(model=model_key, frame=parse_key, timeoutSecs=60)
        mmResultShort = mmResult['model_metrics'][0]
        del mmResultShort['frame'] # too much!
        mm = OutputObj(mmResultShort, 'mm')


        prResult = h2o.n0.predict(model=model_key, frame=parse_key, timeoutSecs=60)
        pr = OutputObj(prResult['model_metrics'][0]['predictions'], 'pr')

        # too slow!
        # h2o_cmd.runStoreView()

if __name__ == '__main__':
    h2o.unit_main()

from __future__ import division

import argparse
import atexit
import os

import numpy as np
import pycuda.driver as cuda

import neurokernel.LPU.utils.simpleio as sio

import retina.retina as ret
import retina.geometry.hexagon as hx
import retina.classmapper as cls_map
from retina.screen.map.mapimpl import AlbersProjectionMap


def gen_input(config):
    cuda.init()
    ctx = cuda.Device(0).make_context()
    atexit.register(ctx.pop)

    suffix = config['General']['file_suffix']

    eye_num = config['General']['eye_num']

    eulerangles = config['Retina']['eulerangles']
    radius = config['Retina']['radius']

    rings = config['Retina']['rings']
    steps = config['General']['steps']

    screen_write_step = config['Retina']['screen_write_step']
    config['Retina']['screen_write_step'] = 1
    screen_type = config['Retina']['screentype']
    screen_cls = cls_map.get_screen_cls(screen_type)

    for i in range(eye_num):
        screen = screen_cls(config)
        screen_file = 'intensities_tmp{}.h5'.format(i)
        screen.setup_file(screen_file)
    
        retina_elev_file = 'retina_elev{}.h5'.format(i)
        retina_azim_file = 'retina_azim{}.h5'.format(i)

        screen_dima_file = 'grid_dima{}.h5'.format(i)
        screen_dimb_file = 'grid_dimb{}.h5'.format(i)

        retina_dima_file = 'retina_dima{}.h5'.format(i)
        retina_dimb_file = 'retina_dimb{}.h5'.format(i)

        input_file = 'retina_input{}.h5'.format(i)

        transform = AlbersProjectionMap(radius,
                                        eulerangles[3*i:3*(i+1)]).invmap
        hexagon = hx.HexagonArray(num_rings=rings, radius=radius,
                                  transform=transform)
        retina = ret.RetinaArray(hexagon, config)
        print('Acceptance angle: {}'.format(retina.acceptance_angle))
        print('Neurons: {}'.format(retina.num_photoreceptors))

        elev_v, azim_v = retina.get_ommatidia_pos()

        rfs = _get_receptive_fields(retina, screen, screen_type)
        steps_count = steps
        write_mode = 'w'
        while (steps_count > 0):
            steps_batch = min(100, steps_count)
            im = screen.get_screen_intensity_steps(steps_batch)
            photor_inputs = rfs.filter(im)
            sio.write_array(photor_inputs, filename=input_file, mode=write_mode)
            steps_count -= steps_batch
            write_mode = 'a'
        
        tmp = sio.read_array(screen_file)
        sio.write_array(tmp[::screen_write_step],
                        'intensities{}{}.h5'.format(suffix, i),
                        complevel = 9)
        del tmp
        os.remove(screen_file)

        for data, filename in [(elev_v, retina_elev_file),
                               (azim_v, retina_azim_file),
                               (screen.grid[0], screen_dima_file),
                               (screen.grid[1], screen_dimb_file),
                               (rfs.refa, retina_dima_file),
                               (rfs.refb, retina_dimb_file)]:
            sio.write_array(data, filename)

def _get_receptive_fields(retina, screen, screen_type):
    mapdr_cls = cls_map.get_mapdr_cls(screen_type)
    projection_map = mapdr_cls.from_retina_screen(retina, screen)

    rf_params = projection_map.map(*retina.get_all_photoreceptors_dir())
    if np.isnan(np.sum(rf_params)):
        print('Warning, Nan entry in array of receptive field centers')
    vrf_cls = cls_map.get_vrf_cls(screen_type)
    rfs = vrf_cls(screen.grid)
    rfs.load_parameters(refa=rf_params[0], refb=rf_params[1],
                        acceptance_angle=retina.get_angle(),
                        radius=screen.radius)
    return rfs


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-r', '--rings', type=int,
                        default=14,
                        help='number of layers of ommatidia on circle')
    parser.add_argument('-l', dest='sublpus', type=int,
                        default=0,
                        help='number of sublpus')
    parser.add_argument('--steps', default=1000, type=int,
                        help='simulation steps')
    args = parser.parse_args()

    gen_input(args.steps, args.rings, 1, args.sublpus)


if __name__ == '__main__':
    main()


#
# Copyright 2016 The BigDL Authors.
#
# 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.
#


import itertools
import re
from optparse import OptionParser

from bigdl.dataset import news20
from bigdl.nn.layer import *
from bigdl.nn.criterion import *
from bigdl.optim.optimizer import *
from bigdl.util.common import *
from bigdl.util.common import Sample


def text_to_words(review_text):
    letters_only = re.sub("[^a-zA-Z]", " ", review_text)
    words = letters_only.lower().split()
    return words


def analyze_texts(data_rdd):
    def index(w_c_i):
        ((w, c), i) = w_c_i
        return (w, (i + 1, c))
    return data_rdd.flatMap(lambda text_label: text_to_words(text_label[0])) \
        .map(lambda word: (word, 1)).reduceByKey(lambda a, b: a + b) \
        .sortBy(lambda w_c: - w_c[1]).zipWithIndex() \
        .map(lambda w_c_i: index(w_c_i)).collect()


# pad([1, 2, 3, 4, 5], 0, 6)
def pad(l, fill_value, width):
    if len(l) >= width:
        return l[0: width]
    else:
        l.extend([fill_value] * (width - len(l)))
        return l


def to_vec(token, b_w2v, embedding_dim):
    if token in b_w2v:
        return b_w2v[token]
    else:
        return pad([], 0, embedding_dim)


def to_sample(vectors, label, embedding_dim):
    # flatten nested list
    flatten_features = list(itertools.chain(*vectors))
    features = np.array(flatten_features, dtype='float').reshape(
        [sequence_len, embedding_dim])

    if model_type.lower() == "cnn":
        features = features.transpose(1, 0)
    return Sample.from_ndarray(features, np.array(label))


def build_model(class_num):
    model = Sequential()

    if model_type.lower() == "cnn":
        model.add(Reshape([embedding_dim, 1, sequence_len]))
        model.add(SpatialConvolution(embedding_dim, 128, 5, 1))
        model.add(ReLU())
        model.add(SpatialMaxPooling(5, 1, 5, 1))
        model.add(SpatialConvolution(128, 128, 5, 1))
        model.add(ReLU())
        model.add(SpatialMaxPooling(5, 1, 5, 1))
        model.add(Reshape([128]))
    elif model_type.lower() == "lstm":
        model.add(Recurrent()
                  .add(LSTM(embedding_dim, 128, p)))
        model.add(Select(2, -1))
    elif model_type.lower() == "gru":
        model.add(Recurrent()
                  .add(GRU(embedding_dim, 128, p)))
        model.add(Select(2, -1))
    else:
        raise ValueError('model can only be cnn, lstm, or gru')

    model.add(Linear(128, 100))
    model.add(Linear(100, class_num))
    model.add(LogSoftMax())
    return model


def train(sc, data_path,
          batch_size,
          sequence_len, max_words, embedding_dim, training_split):
    print('Processing text dataset')
    texts = news20.get_news20(source_dir=data_path)
    data_rdd = sc.parallelize(texts, 2)

    word_to_ic = analyze_texts(data_rdd)

    # Only take the top wc between [10, sequence_len]
    word_to_ic = dict(word_to_ic[10: max_words])
    bword_to_ic = sc.broadcast(word_to_ic)

    w2v = news20.get_glove_w2v(dim=embedding_dim)
    filtered_w2v = dict((w, v) for w, v in w2v.items() if w in word_to_ic)
    bfiltered_w2v = sc.broadcast(filtered_w2v)

    tokens_rdd = data_rdd.map(lambda text_label:
                              ([w for w in text_to_words(text_label[0]) if
                                w in bword_to_ic.value], text_label[1]))
    padded_tokens_rdd = tokens_rdd.map(
        lambda tokens_label: (pad(tokens_label[0], "##", sequence_len), tokens_label[1]))
    vector_rdd = padded_tokens_rdd.map(lambda tokens_label:
                                       ([to_vec(w, bfiltered_w2v.value,
                                                embedding_dim) for w in
                                         tokens_label[0]], tokens_label[1]))
    sample_rdd = vector_rdd.map(
        lambda vectors_label: to_sample(vectors_label[0], vectors_label[1], embedding_dim))

    train_rdd, val_rdd = sample_rdd.randomSplit(
        [training_split, 1-training_split])

    optimizer = Optimizer(
        model=build_model(news20.CLASS_NUM),
        training_rdd=train_rdd,
        criterion=ClassNLLCriterion(),
        end_trigger=MaxEpoch(max_epoch),
        batch_size=batch_size,
        optim_method=Adagrad(learningrate=0.01, learningrate_decay=0.0002))

    optimizer.set_validation(
        batch_size=batch_size,
        val_rdd=val_rdd,
        trigger=EveryEpoch(),
        val_method=[Top1Accuracy()]
    )
    train_model = optimizer.optimize()

if __name__ == "__main__":
    parser = OptionParser()
    parser.add_option("-a", "--action", dest="action", default="train")
    parser.add_option("-b", "--batchSize", dest="batchSize", default="128")
    parser.add_option("-e", "--embedding_dim", dest="embedding_dim", default="50")  # noqa
    parser.add_option("-m", "--max_epoch", dest="max_epoch", default="15")
    parser.add_option("--model", dest="model_type", default="cnn")
    parser.add_option("-p", "--p", dest="p", default="0.0")
    parser.add_option("-d", "--data_path", dest="data_path", default="/tmp/news20/")

    (options, args) = parser.parse_args(sys.argv)
    if options.action == "train":
        batch_size = int(options.batchSize)
        embedding_dim = int(options.embedding_dim)
        max_epoch = int(options.max_epoch)
        p = float(options.p)
        model_type = options.model_type
        sequence_len = 50
        max_words = 1000
        training_split = 0.8
        sc = SparkContext(appName="text_classifier",
                          conf=create_spark_conf())
        data_path = options.data_path
        redire_spark_logs()
        show_bigdl_info_logs()
        init_engine()
        train(sc, data_path,
              batch_size,
              sequence_len, max_words, embedding_dim, training_split)
        sc.stop()
    elif options.action == "test":
        pass

#    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.

import mock

from nova.scheduler.filters import ram_filter
from nova import test
from nova.tests.unit.scheduler import fakes


class TestRamFilter(test.NoDBTestCase):

    def setUp(self):
        super(TestRamFilter, self).setUp()
        self.filt_cls = ram_filter.RamFilter()

    def test_ram_filter_fails_on_memory(self):
        filter_properties = {'instance_type': {'memory_mb': 1024}}
        host = fakes.FakeHostState('host1', 'node1',
                {'free_ram_mb': 1023, 'total_usable_ram_mb': 1024,
                 'ram_allocation_ratio': 1.0})
        self.assertFalse(self.filt_cls.host_passes(host, filter_properties))

    def test_ram_filter_passes(self):
        filter_properties = {'instance_type': {'memory_mb': 1024}}
        host = fakes.FakeHostState('host1', 'node1',
                {'free_ram_mb': 1024, 'total_usable_ram_mb': 1024,
                 'ram_allocation_ratio': 1.0})
        self.assertTrue(self.filt_cls.host_passes(host, filter_properties))

    def test_ram_filter_oversubscribe(self):
        filter_properties = {'instance_type': {'memory_mb': 1024}}
        host = fakes.FakeHostState('host1', 'node1',
                {'free_ram_mb': -1024, 'total_usable_ram_mb': 2048,
                 'ram_allocation_ratio': 2.0})
        self.assertTrue(self.filt_cls.host_passes(host, filter_properties))
        self.assertEqual(2048 * 2.0, host.limits['memory_mb'])

    def test_ram_filter_oversubscribe_singe_instance_fails(self):
        filter_properties = {'instance_type': {'memory_mb': 1024}}
        host = fakes.FakeHostState('host1', 'node1',
                {'free_ram_mb': 512, 'total_usable_ram_mb': 512,
                 'ram_allocation_ratio': 2.0})
        self.assertFalse(self.filt_cls.host_passes(host, filter_properties))


@mock.patch('nova.scheduler.filters.utils.aggregate_values_from_key')
class TestAggregateRamFilter(test.NoDBTestCase):

    def setUp(self):
        super(TestAggregateRamFilter, self).setUp()
        self.filt_cls = ram_filter.AggregateRamFilter()

    def test_aggregate_ram_filter_value_error(self, agg_mock):
        filter_properties = {'context': mock.sentinel.ctx,
                             'instance_type': {'memory_mb': 1024}}
        host = fakes.FakeHostState('host1', 'node1',
                {'free_ram_mb': 1024, 'total_usable_ram_mb': 1024,
                 'ram_allocation_ratio': 1.0})
        agg_mock.return_value = set(['XXX'])
        self.assertTrue(self.filt_cls.host_passes(host, filter_properties))
        self.assertEqual(1024 * 1.0, host.limits['memory_mb'])

    def test_aggregate_ram_filter_default_value(self, agg_mock):
        filter_properties = {'context': mock.sentinel.ctx,
                             'instance_type': {'memory_mb': 1024}}
        host = fakes.FakeHostState('host1', 'node1',
                {'free_ram_mb': 1023, 'total_usable_ram_mb': 1024,
                 'ram_allocation_ratio': 1.0})
        # False: fallback to default flag w/o aggregates
        agg_mock.return_value = set()
        self.assertFalse(self.filt_cls.host_passes(host, filter_properties))
        agg_mock.return_value = set(['2.0'])
        # True: use ratio from aggregates
        self.assertTrue(self.filt_cls.host_passes(host, filter_properties))
        self.assertEqual(1024 * 2.0, host.limits['memory_mb'])

    def test_aggregate_ram_filter_conflict_values(self, agg_mock):
        filter_properties = {'context': mock.sentinel.ctx,
                             'instance_type': {'memory_mb': 1024}}
        host = fakes.FakeHostState('host1', 'node1',
                {'free_ram_mb': 1023, 'total_usable_ram_mb': 1024,
                 'ram_allocation_ratio': 1.0})
        agg_mock.return_value = set(['1.5', '2.0'])
        # use the minimum ratio from aggregates
        self.assertTrue(self.filt_cls.host_passes(host, filter_properties))
        self.assertEqual(1024 * 1.5, host.limits['memory_mb'])

# This file is part of Fail2Ban.
#
# Fail2Ban is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# Fail2Ban is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Fail2Ban; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

# Author: Cyril Jaquier
# 
# $Revision: 696 $

__author__ = "Cyril Jaquier"
__version__ = "$Revision: 696 $"
__date__ = "$Date: 2008-05-19 23:05:32 +0200 (Mon, 19 May 2008) $"
__copyright__ = "Copyright (c) 2004 Cyril Jaquier"
__license__ = "GPL"

from failmanager import FailManagerEmpty
from filter import FileFilter
from mytime import MyTime

import time, logging, gamin

# Gets the instance of the logger.
logSys = logging.getLogger("fail2ban.filter")

##
# Log reader class.
#
# This class reads a log file and detects login failures or anything else
# that matches a given regular expression. This class is instanciated by
# a Jail object.

class FilterGamin(FileFilter):

	##
	# Constructor.
	#
	# Initialize the filter object with default values.
	# @param jail the jail object
	
	def __init__(self, jail):
		FileFilter.__init__(self, jail)
		self.__modified = False
		# Gamin monitor
		self.monitor = gamin.WatchMonitor()
		logSys.debug("Created FilterGamin")


	def callback(self, path, event):
		logSys.debug("Got event: " + `event` + " for " + path)
		if event in (gamin.GAMCreated, gamin.GAMChanged, gamin.GAMExists):
			logSys.debug("File changed: " + path)
			self.getFailures(path)
			self.__modified = True


	##
	# Add a log file path
	#
	# @param path log file path

	def addLogPath(self, path, tail = False):
		if self.containsLogPath(path):
			logSys.error(path + " already exists")
		else:
			self.monitor.watch_file(path, self.callback)
			FileFilter.addLogPath(self, path, tail)
			logSys.info("Added logfile = %s" % path)			
	
	##
	# Delete a log path
	#
	# @param path the log file to delete
	
	def delLogPath(self, path):
		if not self.containsLogPath(path):
			logSys.error(path + " is not monitored")
		else:
			self.monitor.stop_watch(path)
			FileFilter.delLogPath(self, path)
			logSys.info("Removed logfile = %s" % path)
		
	##
	# Main loop.
	#
	# This function is the main loop of the thread. It checks if the
	# file has been modified and looks for failures.
	# @return True when the thread exits nicely

	def run(self):
		self.setActive(True)
		while self._isActive():
			if not self.getIdle():
				# We cannot block here because we want to be able to
				# exit.
				if self.monitor.event_pending():
					self.monitor.handle_events()

				if self.__modified:
					try:
						while True:
							ticket = self.failManager.toBan()
							self.jail.putFailTicket(ticket)
					except FailManagerEmpty:
						self.failManager.cleanup(MyTime.time())
					self.dateDetector.sortTemplate()
					self.__modified = False
				time.sleep(self.getSleepTime())
			else:
				time.sleep(self.getSleepTime())
		# Cleanup Gamin
		self.__cleanup()
		logSys.debug(self.jail.getName() + ": filter terminated")
		return True

	##
	# Desallocates the resources used by Gamin.

	def __cleanup(self):
		for path in self.getLogPath():
			self.monitor.stop_watch(path.getFileName())
		del self.monitor

# -*- coding: utf-8 -*-

"""
    Exodus Add-on

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""

import re, urllib, urlparse, json

from resources.lib.modules import cleantitle
from resources.lib.modules import client


class source:
    def __init__(self):
        self.priority = 1
        self.language = ['fr']
        self.domains = ['streamay.ws']
        self.base_link = 'http://streamay.ws'
        self.search_link = '/search'

    def movie(self, imdb, title, localtitle, aliases, year):
        return self.__search(title, localtitle, year, 'Film')

    def tvshow(self, imdb, tvdb, tvshowtitle, localtvshowtitle, aliases, year):
        return self.__search(tvshowtitle, localtvshowtitle, year, 'Série')

    def episode(self, url, imdb, tvdb, title, premiered, season, episode):
        try:
            if not url:
                return

            r = client.request(urlparse.urljoin(self.base_link, url))
            r = client.parseDOM(r, 'a', attrs={'class': 'item', 'href': '[^\'"]*/saison-%s/episode-%s[^\'"]*' % (season, episode)}, ret='href')[0]

            url = re.findall('(?://.+?|)(/.+)', r)[0]
            url = client.replaceHTMLCodes(url)
            url = url.encode('utf-8')
            return url
        except:
            return

    def sources(self, url, hostDict, hostprDict):
        sources = []

        try:
            if not url:
                return

            hostDict = [(i.rsplit('.', 1)[0], i) for i in hostDict]
            hostDict.append(['okru', 'ok.ru'])
            locDict = [i[0] for i in hostDict]

            url = urlparse.urljoin(self.base_link, url)

            r = client.request(url)
            r = client.parseDOM(r, 'ul', attrs={'class': '[^\'"]*lecteurs nop[^\'"]*'})
            r = client.parseDOM(r, 'li')
            r = [(client.parseDOM(i, 'a', ret='data-streamer'), client.parseDOM(i, 'a', ret='data-id')) for i in r]
            r = [(i[0][0], i[1][0], re.search('([a-zA-Z]+)(?:_([a-zA-Z]+))?', i[0][0]), ) for i in r if i[0] and i[1]]
            r = [(i[0], i[1], i[2].group(1), i[2].group(2)) for i in r if i[2]]

            for streamer, id, host, info in r:
                if host not in locDict:
                    continue

                host = [x[1] for x in hostDict if x[0] == host][0]
                link = urlparse.urljoin(self.base_link, '/%s/%s/%s' % (('streamerSerie' if '/series/' in url else 'streamer'), id, streamer))

                sources.append({'source': host, 'quality': 'SD', 'url': link, 'language': 'FR', 'info': info if info else '', 'direct': False, 'debridonly': False})

            return sources
        except:
            return sources

    def resolve(self, url):
        try:
            url = json.loads(client.request(url)).get('code')
            url = url.replace('\/', '/')
            url = client.replaceHTMLCodes(url).encode('utf-8')
            if url.startswith('/'): url = 'http:%s' % url
            return url
        except:
            return

    def __search(self, title, localtitle, year, content_type):
        try:
            t = cleantitle.get(title)
            tq = cleantitle.get(localtitle)
            y = ['%s' % str(year), '%s' % str(int(year) + 1), '%s' % str(int(year) - 1), '0']

            query = urlparse.urljoin(self.base_link, self.search_link)

            post = urllib.urlencode({'k': "%s"}) % tq
            r = client.request(query, post=post)
            r = json.loads(r)

            r = [i.get('result') for i in r if i.get('type', '').encode('utf-8') == content_type]
            r = [(i.get('url'), i.get('originalTitle'), i.get('title'), i.get('anneeProduction', 0), i.get('dateStart', 0)) for i in r]
            r = [(i[0], re.sub('<.+?>|</.+?>', '', i[1] if i[1] else ''), re.sub('<.+?>|</.+?>', '', i[2] if i[2] else ''), i[3] if i[3] else re.findall('(\d{4})', i[4])[0]) for i in r if i[3] or i[4]]
            r = sorted(r, key=lambda i: int(i[3]), reverse=True)  # with year > no year
            r = [i[0] for i in r if i[3] in y and (t.lower() == cleantitle.get(i[1].lower()) or tq.lower() == cleantitle.query(i[2].lower()))][0]

            url = re.findall('(?://.+?|)(/.+)', r)[0]
            url = client.replaceHTMLCodes(url)
            url = url.encode('utf-8')

            return url
        except:
            return

# -*- coding: utf-8 -*-

from gitdh import git, module
from collections import Mapping
from configparser import ConfigParser
import os.path

class Config(ConfigParser):

	@staticmethod
	def fromPath(path):
		if os.path.isfile(path):
			return Config.fromFilePath(path)
		elif os.path.isdir(path):
			return Config.fromGitRepo(path)
		else:
			raise Exception("Can't read config from '%s'" % (path,))

	@staticmethod
	def fromGitRepo(repoPath):
		gC = git.Git(repoPath)

		if not 'gitdh' in gC.getBranches():
			raise Exception("No Branch 'gitdh' in repository '%s'" % (repoPath,))

		gFile = None
		for file in gC.getFiles(branch='gitdh'):
			if file.getFileName() == 'gitdh.conf':
				gFile = file
				break
		if gFile is None:
			raise Exception("No File 'gitdh.conf' in branch 'gitdh' in repository '%s'" % (repoPath,))

		config = Config()
		config.read_string(gFile.getFileContent())
		config.repoPath = repoPath
		return config

	@staticmethod
	def fromFilePath(filePath):
		with open(filePath) as f:
			config = Config.fromFile(f)

		return config

	@staticmethod
	def fromFile(fileObj):
		c = Config()
		c.read_file(fileObj)
		return c

	def __init__(self):
		super().__init__()
		self.branches = ConfigBranches(self)
		self._repoPath = None

	@property
	def repoPath(self):
		if self._repoPath is None:
			return self.get('Git', 'RepositoryPath', fallback=None)
		return self._repoPath

	@repoPath.setter
	def repoPath(self, repoPath):
		self._repoPath = repoPath


class ConfigBranches(Mapping):
	def __init__(self, cfgParser):
		self._cfgParser = cfgParser
		self._confRegEx = None

	def getboolean(self, section, option, fallback=None, *, raw=False, vars=None):
		if not self._isBranchSection(section):
			return fallback
		return self._cfgParser.getboolean(section, option, fallback=fallback, raw=raw, vars=vars)

	def keys(self):
		return (s for s in self._cfgParser if self._isBranchSection(s))

	def __len__(self):
		return len([i for i in self.keys()])

	def __contains__(self, item):
		return item in self.keys()

	def __iter__(self):
		return self.keys()

	def __getitem__(self, key):
		if not self._isBranchSection(key):
			raise KeyError("Invalid branch section '%s'" % (key,))
		return self._cfgParser[key]

	def _isBranchSection(self, key):
		if self._confRegEx is None:
			self._confRegEx = module.ModuleLoader().getConfRegEx()
		regEx = self._confRegEx
		return regEx.match(key) is None

# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
# Copyright 2010 Canonical
# Author: Alex Launi
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 3, as published
# by the Free Software Foundation.

from time import sleep

from gtk import Clipboard
from testtools.matchers import Equals, NotEquals

from autopilot.matchers import Eventually
from autopilot.tests import AutopilotTestCase


class DashTestCase(AutopilotTestCase):
    def setUp(self):
        super(DashTestCase, self).setUp()
        self.set_unity_log_level("unity.shell", "DEBUG")
        self.set_unity_log_level("unity.launcher", "DEBUG")
        self.dash.ensure_hidden()
        # On shutdown, ensure hidden too.  Also add a delay.  Cleanup is LIFO.
        self.addCleanup(self.dash.ensure_hidden)
        self.addCleanup(sleep, 1)


class DashRevealTests(DashTestCase):
    """Test the Unity dash Reveal."""

    def test_dash_reveal(self):
        """Ensure we can show and hide the dash."""
        self.dash.ensure_visible()
        self.dash.ensure_hidden()

    def test_application_lens_shortcut(self):
        """Application lense must reveal when Super+a is pressed."""
        self.dash.reveal_application_lens()
        self.assertThat(self.dash.active_lens, Eventually(Equals('applications.lens')))

    def test_music_lens_shortcut(self):
        """Music lense must reveal when Super+w is pressed."""
        self.dash.reveal_music_lens()
        self.assertThat(self.dash.active_lens, Eventually(Equals('music.lens')))

    def test_file_lens_shortcut(self):
        """File lense must reveal when Super+f is pressed."""
        self.dash.reveal_file_lens()
        self.assertThat(self.dash.active_lens, Eventually(Equals('files.lens')))

    def test_command_lens_shortcut(self):
        """Run Command lens must reveat on alt+F2."""
        self.dash.reveal_command_lens()
        self.assertThat(self.dash.active_lens, Eventually(Equals('commands.lens')))

    def test_alt_f4_close_dash(self):
        """Dash must close on alt+F4."""
        self.dash.ensure_visible()
        self.keyboard.press_and_release("Alt+F4")
        self.assertThat(self.dash.visible, Eventually(Equals(False)))


class DashSearchInputTests(DashTestCase):
    """Test features involving input to the dash search"""

    def assertSearchText(self, text):
        self.assertThat(self.dash.search_string, Eventually(Equals(text)))

    def test_search_keyboard_focus(self):
        """Dash must put keyboard focus on the search bar at all times."""
        self.dash.ensure_visible()
        self.keyboard.type("Hello")
        self.assertSearchText("Hello")


class DashMultiKeyTests(DashSearchInputTests):
    def setUp(self):
        # set the multi key first so that we're not getting a new _DISPLAY while keys are held down.
        old_value = self.call_gsettings_cmd('get', 'org.gnome.libgnomekbd.keyboard', 'options')
        self.addCleanup(self.call_gsettings_cmd, 'set', 'org.gnome.libgnomekbd.keyboard', 'options', old_value)
        self.call_gsettings_cmd('set', 'org.gnome.libgnomekbd.keyboard', 'options', "['Compose key\tcompose:caps']")

        super(DashMultiKeyTests, self).setUp()

    def test_multi_key(self):
        """Pressing 'Multi_key' must not add any characters to the search."""
        self.dash.reveal_application_lens()
        self.keyboard.press_and_release('Multi_key')
        self.keyboard.type("o")
        self.assertSearchText("")

    def test_multi_key_o(self):
        """Pressing the sequences 'Multi_key' + '^' + 'o' must produce 'ô'."""
        self.dash.reveal_application_lens()
        self.keyboard.press_and_release('Multi_key')
        self.keyboard.type("^o")
        self.assertSearchText("ô")

    def test_multi_key_copyright(self):
        """Pressing the sequences 'Multi_key' + 'c' + 'o' must produce '©'."""
        self.dash.reveal_application_lens()
        self.keyboard.press_and_release('Multi_key')
        self.keyboard.type("oc")
        self.assertSearchText("©")

    def test_multi_key_delete(self):
        """Pressing 'Multi_key' must not get stuck looking for a sequence."""
        self.dash.reveal_application_lens()
        self.keyboard.type("dd")
        self.keyboard.press_and_release('Multi_key')
        self.keyboard.press_and_release('BackSpace')
        self.keyboard.press_and_release('BackSpace')
        self.assertSearchText("d")


class DashKeyNavTests(DashTestCase):
    """Test the unity Dash keyboard navigation."""

    def test_lensbar_gets_keyfocus(self):
        """Test that the lensbar gets key focus after using Down keypresses."""
        self.dash.ensure_visible()

        # Make sure that the lens bar can get the focus
        for i in range(self.dash.get_num_rows()):
            self.keyboard.press_and_release("Down")
        lensbar = self.dash.view.get_lensbar()
        self.assertThat(lensbar.focused_lens_icon, Eventually(NotEquals('')))

    def test_lensbar_focus_changes(self):
        """Lensbar focused icon should change with Left and Right keypresses."""
        self.dash.ensure_visible()

        for i in range(self.dash.get_num_rows()):
            self.keyboard.press_and_release("Down")
        lensbar = self.dash.view.get_lensbar()

        current_focused_icon = lensbar.focused_lens_icon

        self.keyboard.press_and_release("Right");
        self.assertThat(lensbar.focused_lens_icon, Eventually(NotEquals(current_focused_icon)))

        self.keyboard.press_and_release("Left")
        self.assertThat(lensbar.focused_lens_icon, Eventually(Equals(current_focused_icon)))

    def test_lensbar_enter_activation(self):
        """Must be able to activate LensBar icons that have focus with an Enter keypress."""
        self.dash.ensure_visible()

        for i in range(self.dash.get_num_rows()):
            self.keyboard.press_and_release("Down")
        self.keyboard.press_and_release("Right");
        lensbar = self.dash.view.get_lensbar()
        focused_icon = lensbar.focused_lens_icon
        self.keyboard.press_and_release("Enter");

        self.assertThat(lensbar.active_lens, Eventually(Equals(focused_icon)))

        # lensbar should lose focus after activation.
        # TODO this should be a different test to make sure focus
        # returns to the correct place.
        self.assertThat(lensbar.focused_lens_icon, Eventually(Equals("")))

    def test_category_header_keynav(self):
        """ Tests that a category header gets focus when 'down' is pressed after the
        dash is opened

        OK important to note that this test only tests that A category is
        focused, not the first and from doing this it seems that it's common
        for a header other than the first to get focus.
        """
        self.dash.ensure_visible()
        # Make sure that a category have the focus.
        self.keyboard.press_and_release("Down")
        lens = self.dash.get_current_lens()
        category = lens.get_focused_category()
        self.assertIsNot(category, None)
        # Make sure that the category is highlighted.
        self.assertTrue(category.header_is_highlighted)

    def test_control_tab_lens_cycle(self):
        """This test makes sure that Ctrl+Tab cycles lenses."""
        self.dash.ensure_visible()

        self.keyboard.press('Control')
        self.keyboard.press_and_release('Tab')
        self.keyboard.release('Control')

        lensbar = self.dash.view.get_lensbar()
        self.assertEqual(lensbar.active_lens, u'applications.lens')

        self.keyboard.press('Control')
        self.keyboard.press('Shift')
        self.keyboard.press_and_release('Tab')
        self.keyboard.release('Control')
        self.keyboard.release('Shift')

        self.assertThat(lensbar.active_lens, Eventually(Equals('home.lens')))

    def test_tab_cycle_category_headers(self):
        """ Makes sure that pressing tab cycles through the category headers"""
        self.dash.ensure_visible()
        lens = self.dash.get_current_lens()

        # Test that tab cycles through the categories.
        # + 1 is to cycle back to first header
        for i in range(lens.get_num_visible_categories() + 1):
            self.keyboard.press_and_release('Tab')
            category = lens.get_focused_category()
            self.assertIsNot(category, None)

    def test_tab_with_filter_bar(self):
        """ This test makes sure that Tab works well with the filter bara."""
        self.dash.reveal_application_lens()
        lens = self.dash.get_current_lens()

        # Tabs to last category
        for i in range(lens.get_num_visible_categories()):
            self.keyboard.press_and_release('Tab')

        self.keyboard.press_and_release('Tab')
        self.assertThat(self.dash.searchbar.expander_has_focus, Eventually(Equals(True)))

        filter_bar = lens.get_filterbar()
        if not self.dash.searchbar.showing_filters:
            self.keyboard.press_and_release('Enter')
            self.assertThat(self.dash.searchbar.showing_filters, Eventually(Equals(True)))
            self.addCleanup(filter_bar.ensure_collapsed)

        for i in range(filter_bar.get_num_filters()):
            self.keyboard.press_and_release('Tab')
            new_focused_filter = filter_bar.get_focused_filter()
            self.assertIsNotNone(new_focused_filter)

        # Ensure that tab cycles back to a category header
        self.keyboard.press_and_release('Tab')
        category = lens.get_focused_category()
        self.assertIsNot(category, None)

    def test_alt_f1_disabled(self):
        """This test that Alt+F1 is disabled when the dash is opened."""
        self.dash.ensure_visible()
        # can't use launcher emulator since we'll fail to start keynav:
        self.keybinding("launcher/keynav")
        # can't use Eventually here - sleep long enough for the launcher controller
        # to react to the keypress (well, hopefully not)
        sleep(5)
        self.assertThat(self.launcher.key_nav_is_active, Equals(False))


class DashClipboardTests(DashTestCase):
    """Test the Unity clipboard"""

    def test_ctrl_a(self):
        """ This test if ctrl+a selects all text """
        self.dash.ensure_visible()

        self.keyboard.type("SelectAll")
        self.assertThat(self.dash.search_string, Eventually(Equals("SelectAll")))

        self.keyboard.press_and_release("Ctrl+a")
        self.keyboard.press_and_release("Delete")
        self.assertThat(self.dash.search_string, Eventually(Equals('')))

    def test_ctrl_c(self):
        """ This test if ctrl+c copies text into the clipboard """
        self.dash.ensure_visible()

        self.keyboard.type("Copy")
        self.assertThat(self.dash.search_string, Eventually(Equals("Copy")))

        self.keyboard.press_and_release("Ctrl+a")
        self.keyboard.press_and_release("Ctrl+c")

        cb = Clipboard(selection="CLIPBOARD")
        self.assertThat(self.dash.search_string, Eventually(Equals(cb.wait_for_text())))

    def test_ctrl_x(self):
        """ This test if ctrl+x deletes all text and copys it """
        self.dash.ensure_visible()

        self.keyboard.type("Cut")
        self.assertThat(self.dash.search_string, Eventually(Equals("Cut")))

        self.keyboard.press_and_release("Ctrl+a")
        self.keyboard.press_and_release("Ctrl+x")
        self.assertThat(self.dash.search_string, Eventually(Equals("")))

        cb = Clipboard(selection="CLIPBOARD")
        self.assertEqual(cb.wait_for_text(), u'Cut')

    def test_ctrl_c_v(self):
        """ This test if ctrl+c and ctrl+v copies and pastes text"""
        self.dash.ensure_visible()

        self.keyboard.type("CopyPaste")
        self.assertThat(self.dash.search_string, Eventually(Equals("CopyPaste")))

        self.keyboard.press_and_release("Ctrl+a")
        self.keyboard.press_and_release("Ctrl+c")
        self.keyboard.press_and_release("Ctrl+v")
        self.keyboard.press_and_release("Ctrl+v")

        self.assertThat(self.dash.search_string, Eventually(Equals('CopyPasteCopyPaste')))

    def test_ctrl_x_v(self):
        """ This test if ctrl+x and ctrl+v cuts and pastes text"""
        self.dash.ensure_visible()

        self.keyboard.type("CutPaste")
        self.assertThat(self.dash.search_string, Eventually(Equals("CutPaste")))

        self.keyboard.press_and_release("Ctrl+a")
        self.keyboard.press_and_release("Ctrl+x")
        self.keyboard.press_and_release("Ctrl+v")
        self.keyboard.press_and_release("Ctrl+v")

        self.assertThat(self.dash.search_string, Eventually(Equals('CutPasteCutPaste')))


class DashKeyboardFocusTests(DashTestCase):
    """Tests that keyboard focus works."""

    def test_filterbar_expansion_leaves_kb_focus(self):
        """Expanding or collapsing the filterbar must keave keyboard focus in the
        search bar.
        """
        self.dash.reveal_application_lens()
        filter_bar = self.dash.get_current_lens().get_filterbar()
        filter_bar.ensure_collapsed()

        self.keyboard.type("hello")
        filter_bar.ensure_expanded()
        self.addCleanup(filter_bar.ensure_collapsed)
        self.keyboard.type(" world")
        self.assertThat(self.dash.search_string, Eventually(Equals("hello world")))


class DashLensResultsTests(DashTestCase):
    """Tests results from the lens view."""

    def test_results_message_empty_search(self):
        """This tests a message is not shown when there is no text."""
        self.dash.reveal_application_lens()
        lens = self.dash.get_current_lens()
        self.assertThat(lens.no_results_active, Eventually(Equals(False)))

    def test_results_message(self):
        """This test no mesage will be shown when results are there."""
        self.dash.reveal_application_lens()
        self.keyboard.type("Terminal")
        self.assertThat(self.dash.search_string, Eventually(Equals("Terminal")))
        lens = self.dash.get_current_lens()
        self.assertThat(lens.no_results_active, Eventually(Equals(False)))

    def test_no_results_message(self):
        """This test shows a message will appear in the lens."""
        self.dash.reveal_application_lens()
        self.keyboard.type("qwerlkjzvxc")
        self.assertThat(self.dash.search_string, Eventually(Equals("qwerlkjzvxc")))
        lens = self.dash.get_current_lens()
        self.assertThat(lens.no_results_active, Eventually(Equals(True)))

    def test_results_update_on_filter_changed(self):
        """This test makes sure the results change when filters change."""
        self.dash.reveal_application_lens()
        lens = self.dash.get_current_lens()
        self.keyboard.type(" ")
        self.assertThat(self.dash.search_string, Eventually(Equals(" ")))
        results_category = lens.get_category_by_name("Installed")
        old_results = results_category.get_results()

        # FIXME: This should be a method on the dash emulator perhaps, or
        # maybe a proper method of this class. It should NOT be an inline
        # function that is only called once!
        def activate_filter(add_cleanup = False):
            # Tabs to last category
            for i in range(lens.get_num_visible_categories()):
                self.keyboard.press_and_release('Tab')

            self.keyboard.press_and_release('Tab')
            self.assertThat(self.dash.searchbar.expander_has_focus, Eventually(Equals(True)))

            filter_bar = lens.get_filterbar()
            if not self.dash.searchbar.showing_filters:
                self.keyboard.press_and_release('Enter')
                self.assertThat(self.dash.searchbar.showing_filters, Eventually(Equals(True)))
                if add_cleanup:
                    self.addCleanup(filter_bar.ensure_collapsed)

            # Tab to the "Type" filter in apps lens
            self.keyboard.press_and_release('Tab')
            new_focused_filter = filter_bar.get_focused_filter()
            self.assertIsNotNone(new_focused_filter)

            self.keyboard.press_and_release("Down")
            self.keyboard.press_and_release("Down")
            self.keyboard.press_and_release("Down")
            # We should be on the Education category
            self.keyboard.press_and_release('Enter')

        activate_filter(True)
        self.addCleanup(activate_filter)

        results_category = lens.get_category_by_name("Installed")
        results = results_category.get_results()
        self.assertIsNot(results, old_results)

        # so we can clean up properly
        self.keyboard.press_and_release('BackSpace')


class DashVisualTests(DashTestCase):
    """Tests that the dash visual is correct."""

    def test_see_more_result_alignment(self):
        """The see more results label should be baseline aligned
        with the category name label.
        """
        self.dash.reveal_application_lens()

        lens = self.dash.get_current_lens()
        groups = lens.get_groups()

        for group in groups:
            if (group.is_visible and group.expand_label_is_visible):
                expand_label_y = group.expand_label_y + group.expand_label_baseline
                name_label_y = group.name_label_y + group.name_label_baseline
                self.assertThat(expand_label_y, Equals(name_label_y))


class DashLensBarTests(DashTestCase):
    """Tests that the lensbar works well."""

    def setUp(self):
        super(DashLensBarTests, self).setUp()
        self.dash.ensure_visible()
        self.lensbar = self.dash.view.get_lensbar()

    def test_click_inside_highlight(self):
        """Lens selection should work when clicking in
        the rectangle outside of the icon.
        """
        app_icon = self.lensbar.get_icon_by_name(u'applications.lens')

        self.mouse.move(app_icon.x + (app_icon.width / 2),
                        app_icon.y + (app_icon.height / 2))
        self.mouse.click()

        self.assertThat(self.lensbar.active_lens, Eventually(Equals('applications.lens')))


class DashBorderTests(DashTestCase):
    """Tests that the dash border works well.
    """
    def setUp(self):
        super(DashBorderTests, self).setUp()
        self.dash.ensure_visible()

    def test_click_right_border(self):
        """Clicking on the right dash border should do nothing,
        *NOT* close the dash.
        """
        if (self.dash.view.form_factor != "desktop"):
            self.skip("Not in desktop form-factor.")

        x = self.dash.view.x + self.dash.view.width + self.dash.view.right_border_width / 2;
        y = self.dash.view.y + self.dash.view.height / 2;

        self.mouse.move(x, y)
        self.mouse.click()

        self.assertThat(self.dash.visible, Eventually(Equals(True)))

    def test_click_bottom_border(self):
        """Clicking on the bottom dash border should do nothing,
        *NOT* close the dash.
        """
        if (self.dash.view.form_factor != "desktop"):
            self.skip("Not in desktop form-factor.")

        x = self.dash.view.x + self.dash.view.width / 2;
        y = self.dash.view.y + self.dash.view.height + self.dash.view.bottom_border_height / 2;

        self.mouse.move(x, y)
        self.mouse.click()

        self.assertThat(self.dash.visible, Eventually(Equals(True)))


#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# funcext documentation build configuration file, created by
# sphinx-quickstart on Tue Jul  9 22:26:36 2013.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.

import sys
import os

# If extensions (or modules to document with autodoc) are in another
# directory, add these directories to sys.path here. If the directory is
# relative to the documentation root, use os.path.abspath to make it
# absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))

# Get the project root dir, which is the parent dir of this
cwd = os.getcwd()
project_root = os.path.dirname(cwd)

# Insert the project root dir as the first element in the PYTHONPATH.
# This lets us ensure that the source package is imported, and that its
# version is used.
sys.path.insert(0, project_root)

import funcext

# -- General configuration ---------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'

# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode']

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix of source filenames.
source_suffix = '.rst'

# The encoding of source files.
#source_encoding = 'utf-8-sig'

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = u'funcext'
copyright = u"2017, Ariel De Ocampo"

# The version info for the project you're documenting, acts as replacement
# for |version| and |release|, also used in various other places throughout
# the built documents.
#
# The short X.Y version.
version = funcext.__version__
# The full version, including alpha/beta/rc tags.
release = funcext.__version__

# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None

# There are two options for replacing |today|: either, you set today to
# some non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']

# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None

# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True

# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True

# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'

# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []

# If true, keep warnings as "system message" paragraphs in the built
# documents.
#keep_warnings = False


# -- Options for HTML output -------------------------------------------

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
html_theme = 'default'

# Theme options are theme-specific and customize the look and feel of a
# theme further.  For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}

# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []

# The name for this set of Sphinx documents.  If None, it defaults to
# "<project> v<release> documentation".
#html_title = None

# A shorter title for the navigation bar.  Default is the same as
# html_title.
#html_short_title = None

# The name of an image file (relative to this directory) to place at the
# top of the sidebar.
#html_logo = None

# The name of an image file (within the static path) to use as favicon
# of the docs.  This file should be a Windows icon file (.ico) being
# 16x16 or 32x32 pixels large.
#html_favicon = None

# Add any paths that contain custom static files (such as style sheets)
# here, relative to this directory. They are copied after the builtin
# static files, so a file named "default.css" will overwrite the builtin
# "default.css".
html_static_path = ['_static']

# If not '', a 'Last updated on:' timestamp is inserted at every page
# bottom, using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'

# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True

# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}

# Additional templates that should be rendered to pages, maps page names
# to template names.
#html_additional_pages = {}

# If false, no module index is generated.
#html_domain_indices = True

# If false, no index is generated.
#html_use_index = True

# If true, the index is split into individual pages for each letter.
#html_split_index = False

# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True

# If true, "Created using Sphinx" is shown in the HTML footer.
# Default is True.
#html_show_sphinx = True

# If true, "(C) Copyright ..." is shown in the HTML footer.
# Default is True.
#html_show_copyright = True

# If true, an OpenSearch description file will be output, and all pages
# will contain a <link> tag referring to it.  The value of this option
# must be the base URL from which the finished HTML is served.
#html_use_opensearch = ''

# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None

# Output file base name for HTML help builder.
htmlhelp_basename = 'funcextdoc'


# -- Options for LaTeX output ------------------------------------------

latex_elements = {
    # The paper size ('letterpaper' or 'a4paper').
    #'papersize': 'letterpaper',

    # The font size ('10pt', '11pt' or '12pt').
    #'pointsize': '10pt',

    # Additional stuff for the LaTeX preamble.
    #'preamble': '',
}

# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass
# [howto/manual]).
latex_documents = [
    ('index', 'funcext.tex',
     u'funcext Documentation',
     u'Ariel De Ocampo', 'manual'),
]

# The name of an image file (relative to this directory) to place at
# the top of the title page.
#latex_logo = None

# For "manual" documents, if this is true, then toplevel headings
# are parts, not chapters.
#latex_use_parts = False

# If true, show page references after internal links.
#latex_show_pagerefs = False

# If true, show URL addresses after external links.
#latex_show_urls = False

# Documents to append as an appendix to all manuals.
#latex_appendices = []

# If false, no module index is generated.
#latex_domain_indices = True


# -- Options for manual page output ------------------------------------

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
    ('index', 'funcext',
     u'funcext Documentation',
     [u'Ariel De Ocampo'], 1)
]

# If true, show URL addresses after external links.
#man_show_urls = False


# -- Options for Texinfo output ----------------------------------------

# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
#  dir menu entry, description, category)
texinfo_documents = [
    ('index', 'funcext',
     u'funcext Documentation',
     u'Ariel De Ocampo',
     'funcext',
     'One line description of project.',
     'Miscellaneous'),
]

# Documents to append as an appendix to all manuals.
#texinfo_appendices = []

# If false, no module index is generated.
#texinfo_domain_indices = True

# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'

# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False

# -*- coding: utf-8 -*-
"""
Written by Daniel M. Aukes.
Email: danaukes<at>seas.harvard.edu.
Please see LICENSE.txt for full license.
"""

import PySide.QtCore as qc
import PySide.QtGui as qg
from . import modes
from popupcad.graphics2d.graphicsitems import Common
import popupcad


class InteractiveVertexBase(qg.QGraphicsEllipseItem, Common):
    radius = 10
    z_below = 100
    z_above = 105

    def __init__(self, symbol, *args, **kwargs):
        try:
            temppos = kwargs.pop('pos')
        except KeyError:
            temppos = None

        super(InteractiveVertexBase, self).__init__(*args, **kwargs)
        self.states = modes.EdgeVertexStates()
        self.modes = modes.EdgeVertexModes()
        self.defaultpen = qg.QPen(
            qg.QColor.fromRgbF(
                0,
                0,
                0,
                0),
            0.0,
            qc.Qt.PenStyle.NoPen)

        self.setAcceptHoverEvents(True)
        self.setRect(-
                     1. *
                     self.radius /
                     2, -
                     1. *
                     self.radius /
                     2, self.radius, self.radius)
        self.setZValue(self.z_below)

        self.state = self.states.state_neutral
        self.updatemode(self.modes.mode_normal)
        self.updatestate(self.states.state_neutral)
        self.setFlag(self.ItemIsFocusable, True)
        self.changed_trigger = False
        if temppos is not None:
            self.setPos(temppos)
        self.setselectable(True)
        self.generic = symbol
        self.setFlag(self.ItemIsMovable, True)
        self.updateshape()
#        self.setFlag(self.ItemSendsGeometryChanges,True)

    def updatemode(self, mode):
        self.mode = getattr(self.modes, mode)
        self.setPen(self.querypen())
        self.setBrush(self.querybrush())
        self.update()

    def updatestate(self, state):
        self.state = getattr(self.states, state)
        self.setPen(self.querypen())
        self.setBrush(self.querybrush())
        self.update()

    def querypen(self):
        if self.mode == self.modes.mode_render:
            pen = self.defaultpen
        else:
            if self.state == self.states.state_hover:
                pen = qg.QPen(
                    qg.QColor.fromRgbF(
                        0,
                        0,
                        0,
                        1),
                    1.0,
                    qc.Qt.SolidLine,
                    qc.Qt.RoundCap,
                    qc.Qt.RoundJoin)
            if self.state == self.states.state_pressed:
                pen = qg.QPen(
                    qg.QColor.fromRgbF(
                        0,
                        0,
                        0,
                        1),
                    1.0,
                    qc.Qt.SolidLine,
                    qc.Qt.RoundCap,
                    qc.Qt.RoundJoin)
            if self.state == self.states.state_neutral:
                pen = qg.QPen(
                    qg.QColor.fromRgbF(
                        0,
                        0,
                        0,
                        1),
                    1.0,
                    qc.Qt.SolidLine,
                    qc.Qt.RoundCap,
                    qc.Qt.RoundJoin)
        pen.setCosmetic(True)
        return pen

    def querybrush(self):
        if self.mode == self.modes.mode_render:
            brush = qg.QBrush(qg.QColor.fromRgbF(0, 0, 0, 0), qc.Qt.NoBrush)
        else:
            if self.state == self.states.state_hover:
                brush = qg.QBrush(
                    qg.QColor.fromRgbF(
                        1, .5, 0, 1), qc.Qt.SolidPattern)
            if self.state == self.states.state_pressed:
                brush = qg.QBrush(
                    qg.QColor.fromRgbF(
                        1,
                        0,
                        0,
                        1),
                    qc.Qt.SolidPattern)
            if self.state == self.states.state_neutral:
                brush = qg.QBrush(
                    qg.QColor.fromRgbF(
                        0,
                        0,
                        0,
                        1),
                    qc.Qt.SolidPattern)
        return brush

    def setselectable(self, test):
        self.setFlag(self.ItemIsSelectable, test)

    def hoverEnterEvent(self, event):
        super(InteractiveVertexBase, self).hoverEnterEvent(event)

        self.updatestate(self.states.state_hover)

    def hoverLeaveEvent(self, event):
        super(InteractiveVertexBase, self).hoverLeaveEvent(event)
        self.setZValue(self.z_below)
        self.updatestate(self.states.state_neutral)

#    def itemChange(self,change,value):
#        if change == self.GraphicsItemChange.ItemPositionHasChanged:
#            if self.changed_trigger:
#                self.changed_trigger = False
#                self.scene().savesnapshot.emit()
#            self.get_generic().setpos(self.pos().toTuple())
#
#        return super(InteractiveVertexBase,self).itemChange(change,value)

    def mousePressEvent(self, event):
        self.changed_trigger = True
        self.moved_trigger = False
        self.updatestate(self.states.state_pressed)
        self.scene().itemclicked.emit(self.get_generic())
        super(InteractiveVertexBase, self).mousePressEvent(event)

    def mouseMoveEvent(self, event):
        import numpy
        if self.changed_trigger:
            self.changed_trigger = False
            self.moved_trigger = True
            self.scene().savesnapshot.emit()
        dp = event.scenePos() - event.lastScenePos()
        dp = tuple(numpy.array(dp.toTuple()) / popupcad.view_scaling)
        self.generic.constrained_shift(dp, self.constraintsystem())
        self.scene().updateshape()

    def mouseReleaseEvent(self, event):
        super(InteractiveVertexBase, self).mouseReleaseEvent(event)
        self.updatestate(self.states.state_hover)
        self.changed_trigger = False
        if self.moved_trigger:
            self.moved_trigger = False
            self.scene().constraint_update_request.emit(self.generic)

    def setPos(self, pos):
        import numpy
        pos = tuple(numpy.array(pos.toTuple()) / popupcad.view_scaling)
        self.generic.setpos(pos)
        self.updateshape()

    def get_generic(self):
        try:
            return self.generic
        except AttributeError:
            self.generic = self.symbolic
            del self.symbolic
            return self.generic


#    def pos(self):
#        pos= super(InteractiveVertexBase,self).pos()
#        return pos

    def updateshape(self):
        postuple = self.get_generic().getpos(scaling=popupcad.view_scaling)
        pos = qc.QPointF(*postuple)
        super(InteractiveVertexBase, self).setPos(pos)

    def set_view_scale(self, view_scale):
        self._view_scale = view_scale
        self.setScale(view_scale)
    def get_view_scale(self):
        try:
            return self._view_scale
        except AttributeError:
            self._view_scale = 1
            return self._view_scale
    view_scale = property(get_view_scale,set_view_scale)

    def updatescale(self):
        try:
            self.set_view_scale(1 / self.scene().views()[0].zoom())
        except AttributeError:
            pass

from django.conf.urls import url
from django.contrib.auth.views import logout
from emailconfirmation.views import confirm_email

from ajax_validation.views import validate
from account.forms import SignupForm
from . import views

from django.views.generic import TemplateView


urlpatterns = [
    url(r"^email/$", views.email,
        name="acct_email"),
    url(r"^signup/$", views.signup,
        name="acct_signup"),
    url(r"^login/$", views.login,
        name="acct_login"),
    url(r"^password_change/$",
        views.password_change, name="acct_passwd"),
    url(r"^password_set/$", views.password_set,
        name="acct_passwd_set"),
    url(r"^timezone/$", views.timezone_change,
        name="acct_timezone_change"),

    url(r"^language/$", views.language_change,
        name="acct_language_change"),
    url(r"^logout/$", logout, {"template_name": "account/logout.html"},
        name="acct_logout"),

    url(r"^confirm_email/(\w+)/$", confirm_email,
        name="acct_confirm_email"),

    # password reset
    url(r"^password_reset/$", views.password_reset,
        name="acct_passwd_reset"),
    url(r"^password_reset/done/$", views.password_reset_done,
        name="acct_passwd_reset_done"),
    url(r"^password_reset_key/(?P<uidb36>[0-9A-Za-z]+)-(?P<key>.+)/$",
        views.password_reset_from_key, name="acct_passwd_reset_key"),

    # ajax validation
    url(r"^validate/$", validate, {"form_class": SignupForm},
        name="signup_form_validate"),
]

#!/usr/bin/python
# coding: utf-8

TEXTFILE_DIR = '/var/lib/prometheus/node-exporter'
DEFAULT_HELP_TEXT = 'A metric'

# - node_set_metric:
#     name:      "location_dc"
#     content:   "msk"
#     help_test: "a metric"
#     state:     present
#   become_user: prometheus

# - node_set_metric:
#     name:      "obsolete"
#     state:     absent
#   become_user: prometheus

import os
import filecmp
from tempfile import mkstemp


def metric_file_path(name):
    return os.path.join(TEXTFILE_DIR, "{}.prom".format(name))


def metric_remove(name):
    textfile = metric_file_path(name)

    try:
        if os.path.isfile(textfile):
            os.remove(textfile)
            return {"msg":"OK", "failed":False, "changed":True}
    except OSError as e:
        return {"msg":e, "failed":True, "changed":False}

    return {"msg":"OK", "failed":False, "changed":False}


def metric_set(name, content, help_text):
    full_name = "node_{}".format(name)
    textfile = metric_file_path(name)

    try:
        fd, tmp_path = mkstemp(prefix=name, dir=TEXTFILE_DIR)
        os.write(fd, "# HELP {} {}\n".format(full_name, help_text))
        os.write(fd, "# TYPE {} untyped\n".format(full_name))
        os.write(fd, "{}{}{}=\"{}\"{} 1\n".format(full_name, '{', full_name, content, "}"))
        os.close(fd)
    except OSError as e:
        if os.path.isfile(tmp_path):
            os.remove(tmp_path)
        return {"msg":e, "failed":True, "changed":False}

    if os.path.isfile(textfile):
        if filecmp.cmp(tmp_path, textfile, False):
            os.remove(tmp_path)
            return {"msg":"OK", "failed":False, "changed":False}

        try:
            os.remove(textfile)
        except OSError as e:
            return {"msg":e, "failed":True, "changed":False}

    try:
        os.rename(tmp_path, textfile)
    except OSError as e:
        return {"msg":e, "failed":True, "changed":True}

    os.chmod(textfile, 0644)

    return {"msg":"OK", "failed":False, "changed":True}


def main():
    module = AnsibleModule(
        argument_spec = dict(
            name      = dict(type='str', required=True),
            content   = dict(type='str', required=False, default=None),
            help_text = dict(type='str', required=False, default=DEFAULT_HELP_TEXT),
            state  = dict(choices=['present','absent'], required=False, default='present'),
        )
    )

    name      = module.params['name']
    content   = module.params['content']
    help_text = module.params['help_text']
    state     = module.params['state']

    if state == 'absent':
        module.exit_json(**metric_remove(name))

    if state == 'present' and content is None:
        module.exit_json(msg="content must be defined", failed=True)

    module.exit_json(**metric_set(name, content, help_text))


from ansible.module_utils.basic import *
main()

#!/usr/bin/env python
# -*- encoding: utf-8 -*-

import os
import sys
from subprocess import check_call as execute
from types import ModuleType

import django
from django.utils.importlib import import_module


os.environ["DJANGO_SETTINGS_MODULE"] = "settings.default_only_cassandra"

test_dir = os.path.dirname(__file__)
sys.path.insert(0, test_dir)


def run_tests(foo, settings='settings', extra=(), test_builtin=False):
    if isinstance(foo, ModuleType):
        settings = foo.__name__
        apps = list(foo.INSTALLED_APPS)
    else:
        apps = list(foo)

    if not test_builtin:
        apps = [
            name for name in apps if not name.startswith('django.contrib.')]

    # pre-1.6 test runners don't understand full module names
    if django.VERSION < (1, 6):
        apps = [app.replace('django.contrib.', '') for app in apps]
        apps = [name for name in apps if not name.startswith('testproject.')]

    os.chdir(test_dir)
    print('\n============================\n'
          'Running tests with settings: {}\n'
          '============================\n'.format(settings))
    return execute(
        ['./manage.py', 'test', '--settings', settings] + list(extra) + apps)


def main():

    default_only_cass = import_module(
        'settings.default_only_cassandra')
    secondary_cassandra = import_module(
        'settings.secondary_cassandra')
    multi_cassandra = import_module(
        'settings.multi_cassandra')

    if django.VERSION[0:2] >= (1, 7):
        django.setup()

    run_tests(default_only_cass)
    run_tests(secondary_cassandra)
    run_tests(multi_cassandra)
    sys.exit(0)

if __name__ == "__main__":
    main()

#
# Author:: Matthew Kent (<mkent@magoazul.com>)
# Copyright:: Copyright 2009-2016, Matthew Kent
# License:: Apache License, Version 2.0
#
# 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.
#

# yum-dump.py
# Inspired by yumhelper.py by David Lutterkort
#
# Produce a list of installed, available and re-installable packages using yum
# and dump the results to stdout.
#
# yum-dump invokes yum similarly to the command line interface which makes it
# subject to most of the configuration parameters in yum.conf. yum-dump will
# also load yum plugins in the same manor as yum - these can affect the output.
#
# Can be run as non root, but that won't update the cache.
#
# Intended to support yum 2.x and 3.x

import os
import sys
import time
import yum
import re
import errno

from yum import Errors
from optparse import OptionParser
from distutils import version

YUM_PID_FILE='/var/run/yum.pid'

YUM_VER = version.StrictVersion(yum.__version__)
YUM_MAJOR = YUM_VER.version[0]

if YUM_MAJOR > 3 or YUM_MAJOR < 2:
  print >> sys.stderr, "yum-dump Error: Can't match supported yum version" \
    " (%s)" % yum.__version__
  sys.exit(1)

# Required for Provides output
if YUM_MAJOR == 2:
  import rpm
  import rpmUtils.miscutils

def setup(yb, options):
  # Only want our output
  #
  if YUM_MAJOR == 3:
    try:
      if YUM_VER >= version.StrictVersion("3.2.22"):
        yb.preconf.errorlevel=0
        yb.preconf.debuglevel=0

        # initialize the config
        yb.conf
      else:
        yb.doConfigSetup(errorlevel=0, debuglevel=0)
    except yum.Errors.ConfigError, e:
      # suppresses an ignored exception at exit
      yb.preconf = None
      print >> sys.stderr, "yum-dump Config Error: %s" % e
      return 1
    except ValueError, e:
      yb.preconf = None
      print >> sys.stderr, "yum-dump Options Error: %s" % e
      return 1
  elif YUM_MAJOR == 2:
    yb.doConfigSetup()

    def __log(a,b): pass

    yb.log = __log
    yb.errorlog = __log

  # Give Chef every possible package version, it can decide what to do with them
  if YUM_MAJOR == 3:
    yb.conf.showdupesfromrepos = True
  elif YUM_MAJOR == 2:
    yb.conf.setConfigOption('showdupesfromrepos', True)

  # Optionally run only on cached repositories, but non root must use the cache
  if os.geteuid() != 0:
    if YUM_MAJOR == 3:
      yb.conf.cache = True
    elif YUM_MAJOR == 2:
      yb.conf.setConfigOption('cache', True)
  else:
    if YUM_MAJOR == 3:
      yb.conf.cache = options.cache
    elif YUM_MAJOR == 2:
      yb.conf.setConfigOption('cache', options.cache)

  # Handle repo toggle via id or glob exactly like yum
  for opt, repos in options.repo_control:
      for repo in repos:
        if opt == '--enablerepo':
            yb.repos.enableRepo(repo)
        elif opt == '--disablerepo':
            yb.repos.disableRepo(repo)

  return 0

def dump_packages(yb, list, output_provides):
  packages = {}

  if YUM_MAJOR == 2:
    yb.doTsSetup()
    yb.doRepoSetup()
    yb.doSackSetup()

  db = yb.doPackageLists(list)

  for pkg in db.installed:
    pkg.type = 'i'
    packages[str(pkg)] = pkg

  if YUM_VER >= version.StrictVersion("3.2.21"):
    for pkg in db.available:
      pkg.type = 'a'
      packages[str(pkg)] = pkg

    # These are both installed and available
    for pkg in db.reinstall_available:
      pkg.type = 'r'
      packages[str(pkg)] = pkg
  else:
    # Old style method - no reinstall list
    for pkg in yb.pkgSack.returnPackages():

      if str(pkg) in packages:
        if packages[str(pkg)].type == "i":
          packages[str(pkg)].type = 'r'
          continue

      pkg.type = 'a'
      packages[str(pkg)] = pkg

  unique_packages = packages.values()

  unique_packages.sort(lambda x, y: cmp(x.name, y.name))

  for pkg in unique_packages:
    if output_provides == "all" or \
        (output_provides == "installed" and (pkg.type == "i" or pkg.type == "r")):

      # yum 2 doesn't have provides_print, implement it ourselves using methods
      # based on requires gathering in packages.py
      if YUM_MAJOR == 2:
        provlist = []

        # Installed and available are gathered in different ways
        if pkg.type == 'i' or pkg.type == 'r':
          names = pkg.hdr[rpm.RPMTAG_PROVIDENAME]
          flags = pkg.hdr[rpm.RPMTAG_PROVIDEFLAGS]
          ver = pkg.hdr[rpm.RPMTAG_PROVIDEVERSION]
          if names is not None:
            tmplst = zip(names, flags, ver)

          for (n, f, v) in tmplst:
            prov = rpmUtils.miscutils.formatRequire(n, v, f)
            provlist.append(prov)
        # This is slow :(
        elif pkg.type == 'a':
          for prcoTuple in pkg.returnPrco('provides'):
              prcostr = pkg.prcoPrintable(prcoTuple)
              provlist.append(prcostr)

        provides = provlist
      else:
        provides = pkg.provides_print
    else:
      provides = "[]"

    print '%s %s %s %s %s %s %s %s' % (
      pkg.name,
      pkg.epoch,
      pkg.version,
      pkg.release,
      pkg.arch,
      provides,
      pkg.type,
      pkg.repoid )

  return 0

def yum_dump(options):
  lock_obtained = False

  yb = yum.YumBase()

  status = setup(yb, options)
  if status != 0:
    return status

  if options.output_options:
    print "[option installonlypkgs] %s" % " ".join(yb.conf.installonlypkgs)

  # Non root can't handle locking on rhel/centos 4
  if os.geteuid() != 0:
    return dump_packages(yb, options.package_list, options.output_provides)

  # Wrap the collection and output of packages in yum's global lock to prevent
  # any inconsistencies.
  try:
    # Spin up to --yum-lock-timeout option
    countdown = options.yum_lock_timeout
    while True:
      try:
        yb.doLock(YUM_PID_FILE)
        lock_obtained = True
      except Errors.LockError, e:
        time.sleep(1)
        countdown -= 1
        if countdown == 0:
           print >> sys.stderr, "yum-dump Locking Error! Couldn't obtain an " \
             "exclusive yum lock in %d seconds. Giving up." % options.yum_lock_timeout
           return 200
      else:
        break

    return dump_packages(yb, options.package_list, options.output_provides)

  # Ensure we clear the lock and cleanup any resources
  finally:
    try:
      yb.closeRpmDB()
      if lock_obtained == True:
        yb.doUnlock(YUM_PID_FILE)
    except Errors.LockError, e:
      print >> sys.stderr, "yum-dump Unlock Error: %s" % e
      return 200

# Preserve order of enable/disable repo args like yum does
def gather_repo_opts(option, opt, value, parser):
  if getattr(parser.values, option.dest, None) is None:
    setattr(parser.values, option.dest, [])
  getattr(parser.values, option.dest).append((opt, value.split(',')))

def main():
  usage = "Usage: %prog [options]\n" + \
          "Output a list of installed, available and re-installable packages via yum"
  parser = OptionParser(usage=usage)
  parser.add_option("-C", "--cache",
                    action="store_true", dest="cache", default=False,
                    help="run entirely from cache, don't update cache")
  parser.add_option("-o", "--options",
                    action="store_true", dest="output_options", default=False,
                    help="output select yum options useful to Chef")
  parser.add_option("-p", "--installed-provides",
                    action="store_const", const="installed", dest="output_provides", default="none",
                    help="output Provides for installed packages, big/wide output")
  parser.add_option("-P", "--all-provides",
                    action="store_const", const="all", dest="output_provides", default="none",
                    help="output Provides for all package, slow, big/wide output")
  parser.add_option("-i", "--installed",
                    action="store_const", const="installed", dest="package_list", default="all",
                    help="output only installed packages")
  parser.add_option("-a", "--available",
                    action="store_const", const="available", dest="package_list", default="all",
                    help="output only available and re-installable packages")
  parser.add_option("--enablerepo",
                    action="callback",  callback=gather_repo_opts, type="string", dest="repo_control", default=[],
                    help="enable disabled repositories by id or glob")
  parser.add_option("--disablerepo",
                    action="callback",  callback=gather_repo_opts, type="string", dest="repo_control", default=[],
                    help="disable repositories by id or glob")
  parser.add_option("--yum-lock-timeout",
                    action="store",  type="int", dest="yum_lock_timeout", default=30,
                    help="Time in seconds to wait for yum process lock")

  (options, args) = parser.parse_args()

  try:
    return yum_dump(options)

  except yum.Errors.RepoError, e:
    print >> sys.stderr, "yum-dump Repository Error: %s" % e
    return 1

  except yum.Errors.YumBaseError, e:
    print >> sys.stderr, "yum-dump General Error: %s" % e
    return 1

try:
  status = main()
# Suppress a nasty broken pipe error when output is piped to utilities like 'head'
except IOError, e:
  if e.errno == errno.EPIPE:
    sys.exit(1)
  else:
    raise

sys.exit(status)

# -*- coding: utf-8 -*-

import os
import sys

try:
    from gluon import current
except ImportError:
    print >> sys.stderr, """
The installed version of Web2py is too old -- it does not define current.
Please upgrade Web2py to a more recent version.
"""

# Version of 000_config.py
# Increment this if the user should update their running instance
VERSION = 1

#def update_check(environment, template="default"):
def update_check(settings):
    """
        Check whether the dependencies are sufficient to run Eden

        @ToDo: Load deployment_settings so that we can configure the update_check
               - need to rework so that 000_config.py is parsed 1st

        @param settings: the deployment_settings
    """

    # Get Web2py environment into our globals.
    #globals().update(**environment)
    request = current.request

    # Fatal errors
    errors = []
    # Non-fatal warnings
    warnings = []

    # -------------------------------------------------------------------------
    # Check Python libraries

    # Get mandatory global dependencies
    app_path = request.folder

    gr_path = os.path.join(app_path, "requirements.txt")
    or_path = os.path.join(app_path, "optional_requirements.txt")

    global_dep = parse_requirements({}, gr_path)
    optional_dep = parse_requirements({}, or_path)

    templates = settings.get_template()
    location = settings.get_template_location()
    if not isinstance(templates, (tuple, list)):
        templates = (templates,)
    template_dep = {}
    template_optional_dep = {}
    for template in templates:
        tr_path = os.path.join(app_path, location, "templates", template, "requirements.txt")
        tor_path = os.path.join(app_path, location, "templates", template, "optional_requirements.txt")
        parse_requirements(template_dep, tr_path)
        parse_requirements(template_optional_dep, tor_path)

    # Remove optional dependencies which are already accounted for in template dependencies
    unique = set(optional_dep.keys()).difference(set(template_dep.keys()))
    for dependency in optional_dep.keys():
        if dependency not in unique:
            del optional_dep[dependency]

    # Override optional dependency messages from template
    unique = set(optional_dep.keys()).difference(set(template_optional_dep.keys()))
    for dependency in optional_dep.keys():
        if dependency not in unique:
            del optional_dep[dependency]

    errors, warnings = s3_check_python_lib(global_dep, template_dep, template_optional_dep, optional_dep)
    # @ToDo: Move these to Template
    # for now this is done in s3db.climate_first_run()
    if settings.has_module("climate"):
        if settings.get_database_type() != "postgres":
            errors.append("Climate unresolved dependency: PostgreSQL required")
        try:
           import rpy2
        except ImportError:
           errors.append("Climate unresolved dependency: RPy2 required")
        try:
           from Scientific.IO import NetCDF
        except ImportError:
           warnings.append("Climate unresolved dependency: NetCDF required if you want to import readings")
        try:
           from scipy import stats
        except ImportError:
           warnings.append("Climate unresolved dependency: SciPy required if you want to generate graphs on the map")

    # -------------------------------------------------------------------------
    # Check Web2Py version
    #
    # Currently, the minimum usable Web2py is determined by whether the
    # Scheduler is available
    web2py_minimum_version = "Version 2.4.7-stable+timestamp.2013.05.27.11.49.44"
    # Offset of datetime in return value of parse_version.
    datetime_index = 4
    web2py_version_ok = True
    try:
        from gluon.fileutils import parse_version
    except ImportError:
        web2py_version_ok = False
    if web2py_version_ok:
        try:
            web2py_minimum_parsed = parse_version(web2py_minimum_version)
            web2py_minimum_datetime = web2py_minimum_parsed[datetime_index]
            web2py_installed_version = request.global_settings.web2py_version
            if isinstance(web2py_installed_version, str):
                # Post 2.4.2, request.global_settings.web2py_version is unparsed
                web2py_installed_parsed = parse_version(web2py_installed_version)
                web2py_installed_datetime = web2py_installed_parsed[datetime_index]
            else:
                # 2.4.2 & earlier style
                web2py_installed_datetime = web2py_installed_version[datetime_index]
            web2py_version_ok = web2py_installed_datetime >= web2py_minimum_datetime
        except:
            # Will get AttributeError if Web2py's parse_version is too old for
            # its current version format, which changed in 2.3.2.
            web2py_version_ok = False
    if not web2py_version_ok:
        warnings.append(
            "The installed version of Web2py is too old to support the current version of Sahana Eden."
            "\nPlease upgrade Web2py to at least version: %s" % \
            web2py_minimum_version)

    # -------------------------------------------------------------------------
    # Create required directories if needed
    databases_dir = os.path.join(app_path, "databases")
    try:
        os.stat(databases_dir)
    except OSError:
        # not found, create it
        os.mkdir(databases_dir)

    # -------------------------------------------------------------------------
    # Copy in Templates
    # - 000_config.py (machine-specific settings)
    # - rest are run in-place
    #
    template_folder = os.path.join(app_path, "modules", "templates")

    template_files = {
        # source : destination
        "000_config.py" : os.path.join("models", "000_config.py"),
    }

    copied_from_template = []

    for t in template_files:
        src_path = os.path.join(template_folder, t)
        dst_path = os.path.join(app_path, template_files[t])
        try:
            os.stat(dst_path)
        except OSError:
            # Not found, copy from template
            if t == "000_config.py":
                input = open(src_path)
                output = open(dst_path, "w")
                for line in input:
                    if "akeytochange" in line:
                        # Generate a random hmac_key to secure the passwords in case
                        # the database is compromised
                        import uuid
                        hmac_key = uuid.uuid4()
                        line = 'settings.auth.hmac_key = "%s"' % hmac_key
                    output.write(line)
                output.close()
                input.close()
            else:
                import shutil
                shutil.copy(src_path, dst_path)
            copied_from_template.append(template_files[t])

            # @ToDo: WebSetup
            #  http://eden.sahanafoundation.org/wiki/DeveloperGuidelines/WebSetup
            #if not os.path.exists("%s/applications/websetup" % os.getcwd()):
            #    # @ToDo: Check Permissions
            #    # Copy files into this folder (@ToDo: Pythonise)
            #    cp -r private/websetup "%s/applications" % os.getcwd()
            # Launch WebSetup
            #redirect(URL(a="websetup", c="default", f="index",
            #             vars=dict(appname=request.application,
            #                       firstTime="True")))
        else:
            # Found the file in the destination
            # Check if it has been edited
            import re
            edited_pattern = r"FINISHED_EDITING_\w*\s*=\s*(True|False)"
            edited_matcher = re.compile(edited_pattern).match
            has_edited = False
            with open(dst_path) as f:
                for line in f:
                    edited_result = edited_matcher(line)
                    if edited_result:
                        has_edited = True
                        edited = edited_result.group(1)
                        break
            if has_edited and (edited != "True"):
                errors.append("Please edit %s before starting the system." % t)
            # Check if it's up to date (i.e. a critical update requirement)
            version_pattern = r"VERSION =\s*([0-9]+)"
            version_matcher = re.compile(version_pattern).match
            has_version = False
            with open(dst_path) as f:
                for line in f:
                    version_result = version_matcher(line)
                    if version_result:
                        has_version = True
                        version = version_result.group(1)
                        break
            if not has_version:
                error = "Your %s is using settings from the old templates system. Please switch to the new templates system: http://eden.sahanafoundation.org/wiki/DeveloperGuidelines/Templates" % t
                errors.append(error)
            elif int(version) != VERSION:
                error = "Your %s is using settings from template version %s. Please update with new settings from template version %s before starting the system." % \
                                (t, version, VERSION)
                errors.append(error)

    if copied_from_template:
        errors.append(
            "The following files were copied from templates and should be edited: %s" %
            ", ".join(copied_from_template))

    return {"error_messages": errors, "warning_messages": warnings}

# -------------------------------------------------------------------------
def parse_requirements(output, filepath):
    """
    """

    try:
        with open(filepath) as filehandle:
            dependencies = filehandle.read().splitlines()
            msg = ""
            for dependency in dependencies:
                if dependency[0] == "#":
                    # either a normal comment or custom message
                    if dependency[:9] == "# Warning" or dependency[7] == "# Error:":
                        msg = dependency.split(":", 1)[1]
                else:
                    import re
                    # Check if the module name is different from the package name
                    if "#" in dependency:
                        dep = dependency.split("#", 1)[1]
                        output[dep] = msg
                    else:
                        pattern = re.compile(r'([A-Za-z0-9_-]+)')
                        try:
                            dep = pattern.match(dependency).group(1)
                            output[dep] = msg
                        except AttributeError:
                            # Invalid dependency syntax
                            pass
                    msg = ""
    except IOError:
        # No override for Template
        pass

    return output

# -------------------------------------------------------------------------
def s3_check_python_lib(global_mandatory, template_mandatory, template_optional, global_optional):
    """
        checks for optional as well as mandatory python libraries
    """

    errors = []
    warnings = []

    for dependency, err in global_mandatory.iteritems():
        try:
            if "from" in dependency:
                exec dependency
            else:
                exec "import %s" % dependency
        except ImportError:
            if err:
                errors.append(err)
            else:
                errors.append("S3 unresolved dependency: %s required for Sahana to run" % dependency)

    for dependency, err in template_mandatory.iteritems():
        try:
            if "from" in dependency:
                exec dependency
            else:
                exec "import %s" % dependency
        except ImportError:
            if err:
                errors.append(err)
            else:
                errors.append("Unresolved template dependency: %s required" % dependency)

    for dependency, warn in template_optional.iteritems():
        try:
            if "from" in dependency:
                exec dependency
            else:
                exec "import %s" % dependency
        except ImportError:
            if warn:
                warnings.append(warn)
            else:
                warnings.append("Unresolved optional dependency: %s required" % dependency)

    for dependency, warn in global_optional.iteritems():
        try:
            if "from" in dependency:
                exec dependency
            else:
                exec "import %s" % dependency
        except ImportError:
            if warn:
                warnings.append(warn)
            else:
                warnings.append("Unresolved optional dependency: %s required" % dependency)

    return errors, warnings

# END =========================================================================

# Copyright 2015-2016 Yelp Inc.
#
# 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.
import os
import random

import yaml


def _get_smartstack_proxy_ports_from_file(root, file):
    """Given a root and file (as from os.walk), attempt to return the highest
    smartstack proxy port number (int) from that file. Returns 0 if there is no
    smartstack proxy_port.
    """
    ports = set()
    with open(os.path.join(root, file)) as f:
        data = yaml.safe_load(f)

    if file.endswith("service.yaml") and "smartstack" in data:
        # Specifying this in service.yaml is old and deprecated and doesn't
        # support multiple namespaces.
        ports = {int(data["smartstack"].get("proxy_port", 0))}
    elif file.endswith("smartstack.yaml"):
        for namespace in data.keys():
            ports.add(data[namespace].get("proxy_port", 0))

    return ports


def read_etc_services():
    with open("/etc/services") as fd:
        return fd.readlines()


def get_inuse_ports_from_etc_services():
    ports = set()
    for line in read_etc_services():
        if line.startswith("#"):
            continue
        try:
            p = line.split()[1]
            port = int(p.split("/")[0])
            ports.add(port)
        except Exception:
            pass
    return ports


def suggest_smartstack_proxy_port(
    yelpsoa_config_root, range_min=19000, range_max=21000
):
    """Pick a random available port in the 19000-21000 block"""
    available_proxy_ports = set(range(range_min, range_max + 1))
    for root, dirs, files in os.walk(yelpsoa_config_root):
        for f in files:
            if f.endswith("smartstack.yaml"):
                try:
                    used_ports = _get_smartstack_proxy_ports_from_file(root, f)
                    for used_port in used_ports:
                        available_proxy_ports.discard(used_port)
                except Exception:
                    pass
    available_proxy_ports.difference_update(get_inuse_ports_from_etc_services())
    try:
        return random.choice(list(available_proxy_ports))
    except IndexError:
        raise Exception(
            f"There are no more ports available in the range [{range_min}, {range_max}]"
        )


# vim: expandtab tabstop=4 sts=4 shiftwidth=4:

# -*- coding: utf-8 -*-
##############################################################################
#    
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.     
#
##############################################################################

from openerp.osv import fields, osv

class res_partner(osv.osv):
    _name = 'res.partner'
    _inherit = 'res.partner'

    def _purchase_invoice_count(self, cr, uid, ids, field_name, arg, context=None):
        PurchaseOrder = self.pool['purchase.order']
        Invoice = self.pool['account.invoice']
        return {
            partner_id: {
                'purchase_order_count': PurchaseOrder.search_count(cr,uid, [('partner_id', '=', partner_id)], context=context),
                'supplier_invoice_count': Invoice.search_count(cr,uid, [('partner_id', '=', partner_id), ('type','=','in_invoice')], context=context)
            }
            for partner_id in ids
        }

    def _commercial_fields(self, cr, uid, context=None):
        return super(res_partner, self)._commercial_fields(cr, uid, context=context) + ['property_product_pricelist_purchase']

    _columns = {
        'property_product_pricelist_purchase': fields.property(
          type='many2one', 
          relation='product.pricelist', 
          domain=[('type','=','purchase')],
          string="Purchase Pricelist", 
          help="This pricelist will be used, instead of the default one, for purchases from the current partner"),
        'purchase_order_count': fields.function(_purchase_invoice_count, string='# of Purchase Order', type='integer', multi="count"),
        'supplier_invoice_count': fields.function(_purchase_invoice_count, string='# Supplier Invoices', type='integer', multi="count"),
    }

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:


#!/usr/bin/env python
#
# Copyright 2009 the V8 project authors. All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
#       notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
#       copyright notice, this list of conditions and the following
#       disclaimer in the documentation and/or other materials provided
#       with the distribution.
#     * Neither the name of Google Inc. nor the names of its
#       contributors may be used to endorse or promote products derived
#       from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# This is an utility for converting V8 heap logs into .hp files that can
# be further processed using 'hp2ps' tool (bundled with GHC and Valgrind)
# to produce heap usage histograms.

# Sample usage:
# $ ./shell --log-gc script.js
# $ tools/process-heap-prof.py v8.log | hp2ps -c > script-heap-graph.ps
# ('-c' enables color, see hp2ps manual page for more options)
# or
# $ tools/process-heap-prof.py --js-cons-profile v8.log | hp2ps -c > script-heap-graph.ps
# to get JS constructor profile


import csv, sys, time, optparse

def ProcessLogFile(filename, options):
  if options.js_cons_profile:
    itemname = 'heap-js-cons-item'
  else:
    itemname = 'heap-sample-item'

  first_call_time = None
  sample_time = 0.0
  sampling = False
  try:
    logfile = open(filename, 'rb')
    try:
      logreader = csv.reader(logfile)

      print('JOB "v8"')
      print('DATE "%s"' % time.asctime(time.localtime()))
      print('SAMPLE_UNIT "seconds"')
      print('VALUE_UNIT "bytes"')

      for row in logreader:
        if row[0] == 'heap-sample-begin' and row[1] == 'Heap':
          sample_time = float(row[3])/1000.0
          if first_call_time == None:
            first_call_time = sample_time
          sample_time -= first_call_time
          print('BEGIN_SAMPLE %.2f' % sample_time)
          sampling = True
        elif row[0] == 'heap-sample-end' and row[1] == 'Heap':
          print('END_SAMPLE %.2f' % sample_time)
          sampling = False
        elif row[0] == itemname and sampling:
          print(row[1]),
          if options.count:
            print('%d' % (int(row[2]))),
          if options.size:
            print('%d' % (int(row[3]))),
          print
    finally:
      logfile.close()
  except:
    sys.exit('can\'t open %s' % filename)


def BuildOptions():
  result = optparse.OptionParser()
  result.add_option("--js_cons_profile", help="Constructor profile",
      default=False, action="store_true")
  result.add_option("--size", help="Report object size",
      default=False, action="store_true")
  result.add_option("--count", help="Report object count",
      default=False, action="store_true")
  return result


def ProcessOptions(options):
  if not options.size and not options.count:
    options.size = True
  return True


def Main():
  parser = BuildOptions()
  (options, args) = parser.parse_args()
  if not ProcessOptions(options):
    parser.print_help()
    sys.exit();

  if not args:
    print "Missing logfile"
    sys.exit();

  ProcessLogFile(args[0], options)


if __name__ == '__main__':
  sys.exit(Main())

import matplotlib.pyplot as plt
import numpy as np
from sklearn.svm import SVC
from sklearn.datasets import make_blobs
from .plot_2d_separator import plot_2d_separator


def make_handcrafted_dataset():
    # a carefully hand-designed dataset lol
    X, y = make_blobs(centers=2, random_state=4, n_samples=30)
    y[np.array([7, 27])] = 0
    mask = np.ones(len(X), dtype=np.bool)
    mask[np.array([0, 1, 5, 26])] = 0
    X, y = X[mask], y[mask]
    return X, y


def plot_rbf_svm_parameters():
    X, y = make_handcrafted_dataset()

    fig, axes = plt.subplots(1, 3, figsize=(12, 4))
    for ax, C in zip(axes, [1e0, 5, 10, 100]):
        ax.scatter(X[:, 0], X[:, 1], s=150, c=np.array(['red', 'blue'])[y])

        svm = SVC(kernel='rbf', C=C).fit(X, y)
        plot_2d_separator(svm, X, ax=ax, eps=.5)
        ax.set_title("C = %f" % C)

    fig, axes = plt.subplots(1, 4, figsize=(15, 3))
    for ax, gamma in zip(axes, [0.1, .5, 1, 10]):
        ax.scatter(X[:, 0], X[:, 1], s=150, c=np.array(['red', 'blue'])[y])
        svm = SVC(gamma=gamma, kernel='rbf', C=1).fit(X, y)
        plot_2d_separator(svm, X, ax=ax, eps=.5)
        ax.set_title("gamma = %f" % gamma)


def plot_svm(log_C, log_gamma):
    X, y = make_handcrafted_dataset()
    C = 10. ** log_C
    gamma = 10. ** log_gamma
    svm = SVC(kernel='rbf', C=C, gamma=gamma).fit(X, y)
    ax = plt.gca()
    plot_2d_separator(svm, X, ax=ax, eps=.5)
    # plot data
    ax.scatter(X[:, 0], X[:, 1], s=150, c=np.array(['red', 'blue'])[y])
    # plot support vectors
    sv = svm.support_vectors_
    ax.scatter(sv[:, 0], sv[:, 1], s=230, facecolors='none', zorder=10, linewidth=3)
    ax.set_title("C = %.4f gamma = %.4f" % (C, gamma))


def plot_svm_interactive():
    from IPython.html.widgets import interactive, FloatSlider
    C_slider = FloatSlider(min=-3, max=3, step=.1, value=0, readout=False)
    gamma_slider = FloatSlider(min=-2, max=2, step=.1, value=0, readout=False)
    return interactive(plot_svm, log_C=C_slider, log_gamma=gamma_slider)

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.
#

import datetime
import unittest

import mock

from airflow import DAG
from airflow.providers.microsoft.azure.operators.file_to_wasb import FileToWasbOperator


class TestFileToWasbOperator(unittest.TestCase):

    _config = {
        'file_path': 'file',
        'container_name': 'container',
        'blob_name': 'blob',
        'wasb_conn_id': 'wasb_default',
        'retries': 3,
    }

    def setUp(self):
        args = {
            'owner': 'airflow',
            'start_date': datetime.datetime(2017, 1, 1)
        }
        self.dag = DAG('test_dag_id', default_args=args)

    def test_init(self):
        operator = FileToWasbOperator(
            task_id='wasb_operator',
            dag=self.dag,
            **self._config
        )
        self.assertEqual(operator.file_path, self._config['file_path'])
        self.assertEqual(operator.container_name,
                         self._config['container_name'])
        self.assertEqual(operator.blob_name, self._config['blob_name'])
        self.assertEqual(operator.wasb_conn_id, self._config['wasb_conn_id'])
        self.assertEqual(operator.load_options, {})
        self.assertEqual(operator.retries, self._config['retries'])

        operator = FileToWasbOperator(
            task_id='wasb_operator',
            dag=self.dag,
            load_options={'timeout': 2},
            **self._config
        )
        self.assertEqual(operator.load_options, {'timeout': 2})

    @mock.patch('airflow.providers.microsoft.azure.operators.file_to_wasb.WasbHook',
                autospec=True)
    def test_execute(self, mock_hook):
        mock_instance = mock_hook.return_value
        operator = FileToWasbOperator(
            task_id='wasb_sensor',
            dag=self.dag,
            load_options={'timeout': 2},
            **self._config
        )
        operator.execute(None)
        mock_instance.load_file.assert_called_once_with(
            'file', 'container', 'blob', timeout=2
        )


if __name__ == '__main__':
    unittest.main()

'''
    Copyright (C) 2013-2015 xtr4nge [_AT_] gmail.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
'''

import requests
from requests import session
from consoleMessages import ConsoleMessages 

requests.packages.urllib3.disable_warnings() # DISABLE SSL CHECK WARNINGS

class Webclient:

    def __init__(self, config):
        self.consoleMessages = ConsoleMessages()
        self.server = config.get("api","server")
        self.token = config.get("api","token")
        
        self.global_webserver = self.server
        self.path = "/modules/api/includes/ws_action.php"
        self.s = requests.session()
        self.token = self.token

        try:
            self.login()
            self.loginCheck()
            self.consoleMessages.show_msg("Session established. Have fun ;)")
        except:
            self.consoleMessages.show_error("The session cannot be established. Check the connection details.")

    def login(self):

        payload = {
            'action': 'login',
            'token': self.token
        }
        
        self.s = requests.session()
        self.s.get(self.global_webserver, verify=False) # DISABLE SSL CHECK
        self.s.post(self.global_webserver + '/login.php', data=payload)

    def loginCheck(self):
                
        response = self.s.get(self.global_webserver + '/login_check.php')
        
        if response.text != "":
            self.login()
        
        if response.text != "":
            self.consoleMessages.show_error("Ah, Ah, Ah! You didn't say the magic word!")
            sys.exit()
        
        return True
        
    def submitPost(self, data):
        response = self.s.post(self.global_webserver + data)
        return response.json
    
        if response.text == "":
            return True
        else:
            return False

    def call_api(self, execute):
        out =  self.submitGet("api=" + str(execute))
        try:
            return out.json()
        except:
            pass
    
    def submitGet(self, data):
        response = self.s.get(self.global_webserver + self.path + "?" + data)
        return response

from __future__ import unicode_literals

from .common import InfoExtractor
from ..utils import (
    int_or_none,
    remove_end,
    unified_strdate,
)


class NDTVIE(InfoExtractor):
    _VALID_URL = r'https?://(?:www\.)?ndtv\.com/video/(?:[^/]+/)+[^/?^&]+-(?P<id>\d+)'

    _TEST = {
        'url': 'http://www.ndtv.com/video/news/news/ndtv-exclusive-don-t-need-character-certificate-from-rahul-gandhi-says-arvind-kejriwal-300710',
        'md5': '39f992dbe5fb531c395d8bbedb1e5e88',
        'info_dict': {
            'id': '300710',
            'ext': 'mp4',
            'title': "NDTV exclusive: Don't need character certificate from Rahul Gandhi, says Arvind Kejriwal",
            'description': 'md5:ab2d4b4a6056c5cb4caa6d729deabf02',
            'upload_date': '20131208',
            'duration': 1327,
            'thumbnail': r're:https?://.*\.jpg',
        },
    }

    def _real_extract(self, url):
        video_id = self._match_id(url)
        webpage = self._download_webpage(url, video_id)

        title = remove_end(self._og_search_title(webpage), ' - NDTV')

        filename = self._search_regex(
            r"__filename='([^']+)'", webpage, 'video filename')
        video_url = 'http://bitcast-b.bitgravity.com/ndtvod/23372/ndtv/%s' % filename

        duration = int_or_none(self._search_regex(
            r"__duration='([^']+)'", webpage, 'duration', fatal=False))

        upload_date = unified_strdate(self._html_search_meta(
            'publish-date', webpage, 'upload date', fatal=False))

        description = remove_end(self._og_search_description(webpage), ' (Read more)')

        return {
            'id': video_id,
            'url': video_url,
            'title': title,
            'description': description,
            'thumbnail': self._og_search_thumbnail(webpage),
            'duration': duration,
            'upload_date': upload_date,
        }

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from openerp import SUPERUSER_ID
from openerp.osv import fields, osv

class document_page_create_menu(osv.osv_memory):
    """ Create Menu """
    _name = "document.page.create.menu"
    _description = "Wizard Create Menu"

    _columns = {
        'menu_name': fields.char('Menu Name', size=256, required=True),
        'menu_parent_id': fields.many2one('ir.ui.menu', 'Parent Menu', required=True),
    }

    def default_get(self, cr, uid, fields, context=None):
        if context is None:
            context = {}
        res = super(document_page_create_menu,self).default_get(cr, uid, fields, context=context)
        page_id = context.get('active_id')
        obj_page = self.pool.get('document.page')
        page = obj_page.browse(cr, uid, page_id, context=context)
        res['menu_name'] = page.name
        return res

    def document_page_menu_create(self, cr, uid, ids, context=None):
        if context is None:
            context = {}
        obj_page = self.pool.get('document.page')
        obj_view = self.pool.get('ir.ui.view')
        obj_menu = self.pool.get('ir.ui.menu')
        obj_action = self.pool.get('ir.actions.act_window')
        page_id = context.get('active_id', False)
        page = obj_page.browse(cr, uid, page_id, context=context)

        datas = self.browse(cr, uid, ids, context=context)
        data = False
        if datas:
            data = datas[0]
        if not data:
            return {}
        value = {
            'name': 'Document Page',
            'view_type': 'form',
            'view_mode': 'form,tree',
            'res_model': 'document.page',
            'view_id': False,
            'type': 'ir.actions.act_window',
            'target': 'inlineview',
        }
        value['domain'] = "[('parent_id','=',%d)]" % (page.id)
        value['res_id'] = page.id

        action_id = obj_action.create(cr, uid, value)
        # only the super user is allowed to create menu due to security rules on ir.values
        menu_id = obj_menu.create(cr, SUPERUSER_ID, {
                        'name': data.menu_name,
                        'parent_id':data.menu_parent_id.id,
                        'icon': 'STOCK_DIALOG_QUESTION',
                        'action': 'ir.actions.act_window,'+ str(action_id),
                        }, context)
        obj_page.write(cr, uid, [page_id], {'menu_id':menu_id})
        return {
            'type': 'ir.actions.client',
            'tag': 'reload',
        }


# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

import os
from shutil import copyfile

import threading

from sft.runner.Runner import Runner


class Trainer(Runner):
	def run(self, experiment, threaded=False):
		world_config = self.get_world_config(experiment)
		scenarios = self.init_scenarios(world_config)
		nb_agent_runs = max(1, world_config.nb_agent_runs)
		self.copy_agent_configs(experiment, nb_agent_runs)
		agent_configs = self.get_agent_configs(experiment)
		# generate distinct seeds for every agent copy and repeat this list for every distinct agent
		seeds = self.gen_seeds(nb_agent_runs) * (len(agent_configs) / nb_agent_runs)
		self.run_agents(world_config, agent_configs, scenarios, seeds, threaded)
		self.reset_agent_configs(experiment)

	def get_agent_dir(self, exp_module):
		exp_path = exp_module.__file__
		# check if running from .pyc file and change path to .py
		if exp_path.endswith("pyc"):
			exp_path = exp_path[:-1]
		return exp_path[:-len("__init__.py")] + "agents"

	def get_agent_files(self, exp_module):
		agent_dir = self.get_agent_dir(exp_module)
		return [agent_dir + "/" + a for a in os.listdir(agent_dir) if
					   a != "__init__.py" and not a.endswith("pyc")]  # [:-3] to remove ".py"

	def copy_agent_configs(self, exp_module, nb_action_runs):
		agent_files = self.get_agent_files(exp_module)
		# create nb_action_runs instances of every agent
		for agent_file in agent_files:
			# copy agent files
			for i in range(1, nb_action_runs):
				copyfile(agent_file, "%s_%d.py" % (agent_file[:-3], i))
			# for the first instance just rename the original file
			os.rename(agent_file, agent_file[:-3] + "_0.py")

	def reset_agent_configs(self, exp_module):
		agent_files = self.get_agent_files(exp_module)
		for agent_file in agent_files:
			if agent_file.endswith("_0.py"):
				os.rename(agent_file, agent_file[:-5] + ".py")
			else:
				os.remove(agent_file)
		# also delete .pyc files
		agent_dir = self.get_agent_dir(exp_module)
		for f in os.listdir(agent_dir):
			if f.endswith("pyc"):
				os.remove(agent_dir + "/" + f)

	def run_agents(self, world_config, agent_configs, scenarios, seeds, threaded):
		if threaded:
			threads = []
			for agent in agent_configs:
				thread = threading.Thread(target=self.run_agent, args=(agent, scenarios))
				thread.daemon = False
				thread.start()
				threads.append(thread)
			for t in threads:
				t.join()
		else:
			for agent, seed in zip(agent_configs, seeds):
				self.run_agent(agent, scenarios, seed)
		world_config.world_logger.close_files()

	def init_scenarios(self, world_config):
		seed = self.set_seed()
		world_config.world_logger.log_message("Using seed %s for initializing scenarios" % str(seed))
		scenarios = []
		for n in range(world_config.epochs):
			scenario = world_config.world_gen.get_next()
			scenarios.append(scenario)
			world_config.sampler.next_epoch()
			world_config.world_logger.log_init_state_and_world(scenario.world, scenario.pos)
			world_config.world_logger.next_epoch()
		return scenarios

	def _get_eps(self, config, epoch):
		eps = config.epsilon_update.get_value(epoch)
		return eps

	def _incorp_agent_reward(self, agent, state, action, state2, reward_value):
		agent.incorporate_reward(state, action, state2, reward_value)

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
========================================================================
Gaussian Processes regression: goodness-of-fit on the 'diabetes' dataset
========================================================================

In this example, we fit a Gaussian Process model onto the diabetes
dataset.

We determine the correlation parameters with maximum likelihood
estimation (MLE). We use an anisotropic squared exponential
correlation model with a constant regression model. We also use a
nugget of 1e-2 to account for the (strong) noise in the targets.

We compute a cross-validation estimate of the coefficient of
determination (R2) without reperforming MLE, using the set of correlation
parameters found on the whole dataset.
"""
print(__doc__)

# Author: Vincent Dubourg <vincent.dubourg@gmail.com>
# Licence: BSD 3 clause

from sklearn import datasets
from sklearn.gaussian_process import GaussianProcess
from sklearn.cross_validation import cross_val_score, KFold

# Load the dataset from scikit's data sets
diabetes = datasets.load_diabetes()
X, y = diabetes.data, diabetes.target

# Instanciate a GP model
gp = GaussianProcess(regr='constant', corr='absolute_exponential',
                     theta0=[1e-4] * 10, thetaL=[1e-12] * 10,
                     thetaU=[1e-2] * 10, nugget=1e-2, optimizer='Welch')

# Fit the GP model to the data performing maximum likelihood estimation
gp.fit(X, y)

# Deactivate maximum likelihood estimation for the cross-validation loop
gp.theta0 = gp.theta_  # Given correlation parameter = MLE
gp.thetaL, gp.thetaU = None, None  # None bounds deactivate MLE

# Perform a cross-validation estimate of the coefficient of determination using
# the cross_validation module using all CPUs available on the machine
K = 20  # folds
R2 = cross_val_score(gp, X, y=y, cv=KFold(y.size, K), n_jobs=1).mean()
print("The %d-Folds estimate of the coefficient of determination is R2 = %s"
      % (K, R2))

# Copyright (C) 2007 Joe Gregorio
#
# Licensed under the MIT License

"""MIME-Type Parser

This module provides basic functions for handling mime-types. It can handle
matching mime-types against a list of media-ranges. See section 14.1 of the
HTTP specification [RFC 2616] for a complete explanation.

   http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.1

Contents:
 - parse_mime_type():   Parses a mime-type into its component parts.
 - parse_media_range(): Media-ranges are mime-types with wild-cards and a 'q'
                          quality parameter.
 - quality():           Determines the quality ('q') of a mime-type when
                          compared against a list of media-ranges.
 - quality_parsed():    Just like quality() except the second parameter must be
                          pre-parsed.
 - best_match():        Choose the mime-type with the highest quality ('q')
                          from a list of candidates.
"""

__version__ = '0.1.3'
__author__ = 'Joe Gregorio'
__email__ = 'joe@bitworking.org'
__license__ = 'MIT License'
__credits__ = ''


def parse_mime_type(mime_type):
    """Parses a mime-type into its component parts.

    Carves up a mime-type and returns a tuple of the (type, subtype, params)
    where 'params' is a dictionary of all the parameters for the media range.
    For example, the media range 'application/xhtml;q=0.5' would get parsed
    into:

       ('application', 'xhtml', {'q', '0.5'})
       """
    parts = mime_type.split(';')
    params = dict([tuple([s.strip() for s in param.split('=', 1)])\
            for param in parts[1:]
                  ])
    full_type = parts[0].strip()
    # Java URLConnection class sends an Accept header that includes a
    # single '*'. Turn it into a legal wildcard.
    if full_type == '*':
        full_type = '*/*'
    (type, subtype) = full_type.split('/')

    return (type.strip(), subtype.strip(), params)


def parse_media_range(range):
    """Parse a media-range into its component parts.

    Carves up a media range and returns a tuple of the (type, subtype,
    params) where 'params' is a dictionary of all the parameters for the media
    range.  For example, the media range 'application/*;q=0.5' would get parsed
    into:

       ('application', '*', {'q', '0.5'})

    In addition this function also guarantees that there is a value for 'q'
    in the params dictionary, filling it in with a proper default if
    necessary.
    """
    (type, subtype, params) = parse_mime_type(range)
    if not params.has_key('q') or not params['q'] or \
            not float(params['q']) or float(params['q']) > 1\
            or float(params['q']) < 0:
        params['q'] = '1'

    return (type, subtype, params)


def fitness_and_quality_parsed(mime_type, parsed_ranges):
    """Find the best match for a mime-type amongst parsed media-ranges.

    Find the best match for a given mime-type against a list of media_ranges
    that have already been parsed by parse_media_range(). Returns a tuple of
    the fitness value and the value of the 'q' quality parameter of the best
    match, or (-1, 0) if no match was found. Just as for quality_parsed(),
    'parsed_ranges' must be a list of parsed media ranges.
    """
    best_fitness = -1
    best_fit_q = 0
    (target_type, target_subtype, target_params) =\
            parse_media_range(mime_type)
    for (type, subtype, params) in parsed_ranges:
        type_match = (type == target_type or\
                      type == '*' or\
                      target_type == '*')
        subtype_match = (subtype == target_subtype or\
                         subtype == '*' or\
                         target_subtype == '*')
        if type_match and subtype_match:
            param_matches = reduce(lambda x, y: x + y, [1 for (key, value) in \
                    target_params.iteritems() if key != 'q' and \
                    params.has_key(key) and value == params[key]], 0)
            fitness = (type == target_type) and 100 or 0
            fitness += (subtype == target_subtype) and 10 or 0
            fitness += param_matches
            if fitness > best_fitness:
                best_fitness = fitness
                best_fit_q = params['q']

    return best_fitness, float(best_fit_q)


def quality_parsed(mime_type, parsed_ranges):
    """Find the best match for a mime-type amongst parsed media-ranges.

    Find the best match for a given mime-type against a list of media_ranges
    that have already been parsed by parse_media_range(). Returns the 'q'
    quality parameter of the best match, 0 if no match was found. This function
    bahaves the same as quality() except that 'parsed_ranges' must be a list of
    parsed media ranges.
    """

    return fitness_and_quality_parsed(mime_type, parsed_ranges)[1]


def quality(mime_type, ranges):
    """Return the quality ('q') of a mime-type against a list of media-ranges.

    Returns the quality 'q' of a mime-type when compared against the
    media-ranges in ranges. For example:

    >>> quality('text/html','text/*;q=0.3, text/html;q=0.7,
                  text/html;level=1, text/html;level=2;q=0.4, */*;q=0.5')
    0.7

    """
    parsed_ranges = [parse_media_range(r) for r in ranges.split(',')]

    return quality_parsed(mime_type, parsed_ranges)


def best_match(supported, header):
    """Return mime-type with the highest quality ('q') from list of candidates.

    Takes a list of supported mime-types and finds the best match for all the
    media-ranges listed in header. The value of header must be a string that
    conforms to the format of the HTTP Accept: header. The value of 'supported'
    is a list of mime-types. The list of supported mime-types should be sorted
    in order of increasing desirability, in case of a situation where there is
    a tie.

    >>> best_match(['application/xbel+xml', 'text/xml'],
                   'text/*;q=0.5,*/*; q=0.1')
    'text/xml'
    """
    split_header = _filter_blank(header.split(','))
    parsed_header = [parse_media_range(r) for r in split_header]
    weighted_matches = []
    pos = 0
    for mime_type in supported:
        weighted_matches.append((fitness_and_quality_parsed(mime_type,
                                 parsed_header), pos, mime_type))
        pos += 1
    weighted_matches.sort()

    return weighted_matches[-1][0][1] and weighted_matches[-1][2] or ''


def _filter_blank(i):
    for s in i:
        if s.strip():
            yield s

# sql/functions.py
# Copyright (C) 2005-2014 the SQLAlchemy authors and contributors <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php

"""SQL function API, factories, and built-in functions.

"""
from . import sqltypes, schema
from .base import Executable
from .elements import ClauseList, Cast, Extract, _literal_as_binds, \
        literal_column, _type_from_args, ColumnElement, _clone,\
        Over, BindParameter
from .selectable import FromClause, Select

from . import operators
from .visitors import VisitableType
from .. import util
from . import annotation

_registry = util.defaultdict(dict)


def register_function(identifier, fn, package="_default"):
    """Associate a callable with a particular func. name.

    This is normally called by _GenericMeta, but is also
    available by itself so that a non-Function construct
    can be associated with the :data:`.func` accessor (i.e.
    CAST, EXTRACT).

    """
    reg = _registry[package]
    reg[identifier] = fn


class FunctionElement(Executable, ColumnElement, FromClause):
    """Base for SQL function-oriented constructs.

    .. seealso::

        :class:`.Function` - named SQL function.

        :data:`.func` - namespace which produces registered or ad-hoc
        :class:`.Function` instances.

        :class:`.GenericFunction` - allows creation of registered function
        types.

    """

    packagenames = ()

    def __init__(self, *clauses, **kwargs):
        """Construct a :class:`.FunctionElement`.
        """
        args = [_literal_as_binds(c, self.name) for c in clauses]
        self.clause_expr = ClauseList(
                                operator=operators.comma_op,
                                 group_contents=True, *args).\
                                 self_group()

    def _execute_on_connection(self, connection, multiparams, params):
        return connection._execute_function(self, multiparams, params)

    @property
    def columns(self):
        """Fulfill the 'columns' contract of :class:`.ColumnElement`.

        Returns a single-element list consisting of this object.

        """
        return [self]

    @util.memoized_property
    def clauses(self):
        """Return the underlying :class:`.ClauseList` which contains
        the arguments for this :class:`.FunctionElement`.

        """
        return self.clause_expr.element

    def over(self, partition_by=None, order_by=None):
        """Produce an OVER clause against this function.

        Used against aggregate or so-called "window" functions,
        for database backends that support window functions.

        The expression::

            func.row_number().over(order_by='x')

        is shorthand for::

            from sqlalchemy import over
            over(func.row_number(), order_by='x')

        See :func:`~.expression.over` for a full description.

        .. versionadded:: 0.7

        """
        return Over(self, partition_by=partition_by, order_by=order_by)

    @property
    def _from_objects(self):
        return self.clauses._from_objects

    def get_children(self, **kwargs):
        return self.clause_expr,

    def _copy_internals(self, clone=_clone, **kw):
        self.clause_expr = clone(self.clause_expr, **kw)
        self._reset_exported()
        FunctionElement.clauses._reset(self)

    def select(self):
        """Produce a :func:`~.expression.select` construct
        against this :class:`.FunctionElement`.

        This is shorthand for::

            s = select([function_element])

        """
        s = Select([self])
        if self._execution_options:
            s = s.execution_options(**self._execution_options)
        return s

    def scalar(self):
        """Execute this :class:`.FunctionElement` against an embedded
        'bind' and return a scalar value.

        This first calls :meth:`~.FunctionElement.select` to
        produce a SELECT construct.

        Note that :class:`.FunctionElement` can be passed to
        the :meth:`.Connectable.scalar` method of :class:`.Connection`
        or :class:`.Engine`.

        """
        return self.select().execute().scalar()

    def execute(self):
        """Execute this :class:`.FunctionElement` against an embedded
        'bind'.

        This first calls :meth:`~.FunctionElement.select` to
        produce a SELECT construct.

        Note that :class:`.FunctionElement` can be passed to
        the :meth:`.Connectable.execute` method of :class:`.Connection`
        or :class:`.Engine`.

        """
        return self.select().execute()

    def _bind_param(self, operator, obj):
        return BindParameter(None, obj, _compared_to_operator=operator,
                                _compared_to_type=self.type, unique=True)


class _FunctionGenerator(object):
    """Generate :class:`.Function` objects based on getattr calls."""

    def __init__(self, **opts):
        self.__names = []
        self.opts = opts

    def __getattr__(self, name):
        # passthru __ attributes; fixes pydoc
        if name.startswith('__'):
            try:
                return self.__dict__[name]
            except KeyError:
                raise AttributeError(name)

        elif name.endswith('_'):
            name = name[0:-1]
        f = _FunctionGenerator(**self.opts)
        f.__names = list(self.__names) + [name]
        return f

    def __call__(self, *c, **kwargs):
        o = self.opts.copy()
        o.update(kwargs)

        tokens = len(self.__names)

        if tokens == 2:
            package, fname = self.__names
        elif tokens == 1:
            package, fname = "_default", self.__names[0]
        else:
            package = None

        if package is not None:
            func = _registry[package].get(fname)
            if func is not None:
                return func(*c, **o)

        return Function(self.__names[-1],
                        packagenames=self.__names[0:-1], *c, **o)


func = _FunctionGenerator()
"""Generate SQL function expressions.

   :data:`.func` is a special object instance which generates SQL
   functions based on name-based attributes, e.g.::

        >>> print func.count(1)
        count(:param_1)

   The element is a column-oriented SQL element like any other, and is
   used in that way::

        >>> print select([func.count(table.c.id)])
        SELECT count(sometable.id) FROM sometable

   Any name can be given to :data:`.func`. If the function name is unknown to
   SQLAlchemy, it will be rendered exactly as is. For common SQL functions
   which SQLAlchemy is aware of, the name may be interpreted as a *generic
   function* which will be compiled appropriately to the target database::

        >>> print func.current_timestamp()
        CURRENT_TIMESTAMP

   To call functions which are present in dot-separated packages,
   specify them in the same manner::

        >>> print func.stats.yield_curve(5, 10)
        stats.yield_curve(:yield_curve_1, :yield_curve_2)

   SQLAlchemy can be made aware of the return type of functions to enable
   type-specific lexical and result-based behavior. For example, to ensure
   that a string-based function returns a Unicode value and is similarly
   treated as a string in expressions, specify
   :class:`~sqlalchemy.types.Unicode` as the type:

        >>> print func.my_string(u'hi', type_=Unicode) + ' ' + \
        ... func.my_string(u'there', type_=Unicode)
        my_string(:my_string_1) || :my_string_2 || my_string(:my_string_3)

   The object returned by a :data:`.func` call is usually an instance of
   :class:`.Function`.
   This object meets the "column" interface, including comparison and labeling
   functions.  The object can also be passed the :meth:`~.Connectable.execute`
   method of a :class:`.Connection` or :class:`.Engine`, where it will be
   wrapped inside of a SELECT statement first::

        print connection.execute(func.current_timestamp()).scalar()

   In a few exception cases, the :data:`.func` accessor
   will redirect a name to a built-in expression such as :func:`.cast`
   or :func:`.extract`, as these names have well-known meaning
   but are not exactly the same as "functions" from a SQLAlchemy
   perspective.

   .. versionadded:: 0.8 :data:`.func` can return non-function expression
      constructs for common quasi-functional names like :func:`.cast`
      and :func:`.extract`.

   Functions which are interpreted as "generic" functions know how to
   calculate their return type automatically. For a listing of known generic
   functions, see :ref:`generic_functions`.

"""

modifier = _FunctionGenerator(group=False)

class Function(FunctionElement):
    """Describe a named SQL function.

    See the superclass :class:`.FunctionElement` for a description
    of public methods.

    .. seealso::

        :data:`.func` - namespace which produces registered or ad-hoc
        :class:`.Function` instances.

        :class:`.GenericFunction` - allows creation of registered function
        types.

    """

    __visit_name__ = 'function'

    def __init__(self, name, *clauses, **kw):
        """Construct a :class:`.Function`.

        The :data:`.func` construct is normally used to construct
        new :class:`.Function` instances.

        """
        self.packagenames = kw.pop('packagenames', None) or []
        self.name = name
        self._bind = kw.get('bind', None)
        self.type = sqltypes.to_instance(kw.get('type_', None))

        FunctionElement.__init__(self, *clauses, **kw)

    def _bind_param(self, operator, obj):
        return BindParameter(self.name, obj,
                                _compared_to_operator=operator,
                                _compared_to_type=self.type,
                                unique=True)

class _GenericMeta(VisitableType):
    def __init__(cls, clsname, bases, clsdict):
        if annotation.Annotated not in cls.__mro__:
            cls.name = name = clsdict.get('name', clsname)
            cls.identifier = identifier = clsdict.get('identifier', name)
            package = clsdict.pop('package', '_default')
            # legacy
            if '__return_type__' in clsdict:
                cls.type = clsdict['__return_type__']
            register_function(identifier, cls, package)
        super(_GenericMeta, cls).__init__(clsname, bases, clsdict)


class GenericFunction(util.with_metaclass(_GenericMeta, Function)):
    """Define a 'generic' function.

    A generic function is a pre-established :class:`.Function`
    class that is instantiated automatically when called
    by name from the :data:`.func` attribute.    Note that
    calling any name from :data:`.func` has the effect that
    a new :class:`.Function` instance is created automatically,
    given that name.  The primary use case for defining
    a :class:`.GenericFunction` class is so that a function
    of a particular name may be given a fixed return type.
    It can also include custom argument parsing schemes as well
    as additional methods.

    Subclasses of :class:`.GenericFunction` are automatically
    registered under the name of the class.  For
    example, a user-defined function ``as_utc()`` would
    be available immediately::

        from sqlalchemy.sql.functions import GenericFunction
        from sqlalchemy.types import DateTime

        class as_utc(GenericFunction):
            type = DateTime

        print select([func.as_utc()])

    User-defined generic functions can be organized into
    packages by specifying the "package" attribute when defining
    :class:`.GenericFunction`.   Third party libraries
    containing many functions may want to use this in order
    to avoid name conflicts with other systems.   For example,
    if our ``as_utc()`` function were part of a package
    "time"::

        class as_utc(GenericFunction):
            type = DateTime
            package = "time"

    The above function would be available from :data:`.func`
    using the package name ``time``::

        print select([func.time.as_utc()])

    A final option is to allow the function to be accessed
    from one name in :data:`.func` but to render as a different name.
    The ``identifier`` attribute will override the name used to
    access the function as loaded from :data:`.func`, but will retain
    the usage of ``name`` as the rendered name::

        class GeoBuffer(GenericFunction):
            type = Geometry
            package = "geo"
            name = "ST_Buffer"
            identifier = "buffer"

    The above function will render as follows::

        >>> print func.geo.buffer()
        ST_Buffer()

    .. versionadded:: 0.8 :class:`.GenericFunction` now supports
       automatic registration of new functions as well as package
       and custom naming support.

    .. versionchanged:: 0.8 The attribute name ``type`` is used
       to specify the function's return type at the class level.
       Previously, the name ``__return_type__`` was used.  This
       name is still recognized for backwards-compatibility.

    """

    coerce_arguments = True

    def __init__(self, *args, **kwargs):
        parsed_args = kwargs.pop('_parsed_args', None)
        if parsed_args is None:
            parsed_args = [_literal_as_binds(c) for c in args]
        self.packagenames = []
        self._bind = kwargs.get('bind', None)
        self.clause_expr = ClauseList(
                operator=operators.comma_op,
                group_contents=True, *parsed_args).self_group()
        self.type = sqltypes.to_instance(
            kwargs.pop("type_", None) or getattr(self, 'type', None))

register_function("cast", Cast)
register_function("extract", Extract)


class next_value(GenericFunction):
    """Represent the 'next value', given a :class:`.Sequence`
    as it's single argument.

    Compiles into the appropriate function on each backend,
    or will raise NotImplementedError if used on a backend
    that does not provide support for sequences.

    """
    type = sqltypes.Integer()
    name = "next_value"

    def __init__(self, seq, **kw):
        assert isinstance(seq, schema.Sequence), \
                "next_value() accepts a Sequence object as input."
        self._bind = kw.get('bind', None)
        self.sequence = seq

    @property
    def _from_objects(self):
        return []


class AnsiFunction(GenericFunction):
    def __init__(self, **kwargs):
        GenericFunction.__init__(self, **kwargs)


class ReturnTypeFromArgs(GenericFunction):
    """Define a function whose return type is the same as its arguments."""

    def __init__(self, *args, **kwargs):
        args = [_literal_as_binds(c) for c in args]
        kwargs.setdefault('type_', _type_from_args(args))
        kwargs['_parsed_args'] = args
        GenericFunction.__init__(self, *args, **kwargs)


class coalesce(ReturnTypeFromArgs):
    pass


class max(ReturnTypeFromArgs):
    pass


class min(ReturnTypeFromArgs):
    pass


class sum(ReturnTypeFromArgs):
    pass


class now(GenericFunction):
    type = sqltypes.DateTime


class concat(GenericFunction):
    type = sqltypes.String


class char_length(GenericFunction):
    type = sqltypes.Integer

    def __init__(self, arg, **kwargs):
        GenericFunction.__init__(self, arg, **kwargs)


class random(GenericFunction):
    pass


class count(GenericFunction):
    """The ANSI COUNT aggregate function.  With no arguments,
    emits COUNT \*.

    """
    type = sqltypes.Integer

    def __init__(self, expression=None, **kwargs):
        if expression is None:
            expression = literal_column('*')
        GenericFunction.__init__(self, expression, **kwargs)


class current_date(AnsiFunction):
    type = sqltypes.Date


class current_time(AnsiFunction):
    type = sqltypes.Time


class current_timestamp(AnsiFunction):
    type = sqltypes.DateTime


class current_user(AnsiFunction):
    type = sqltypes.String


class localtime(AnsiFunction):
    type = sqltypes.DateTime


class localtimestamp(AnsiFunction):
    type = sqltypes.DateTime


class session_user(AnsiFunction):
    type = sqltypes.String


class sysdate(AnsiFunction):
    type = sqltypes.DateTime


class user(AnsiFunction):
    type = sqltypes.String

# Copyright 2015 Cloudbase Solutions Srl
# All Rights Reserved.
#
#    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.

import abc

import six


@six.add_metaclass(abc.ABCMeta)
class BaseActionManager(object):
    """Get a Action Manager that can handle basic actions.

    :param client:
        A Windows client to send command to the instance.
    :param conf:
        Argus config options.
    """

    def __init__(self, client, conf, os_type):
        self._client = client
        self._os_type = os_type
        self._conf = conf

    @abc.abstractmethod
    def download(self, uri, location):
        """Download the resource locatet at a specific uri in the location.

        :param uri:
            Remote url where the data is found.

        :param location:
            Path from the instance in which we should download the
            remote resouce.
        """
        pass

    @abc.abstractmethod
    def get_installation_script(self):
        """Get instalation script for CloudbaseInit."""
        pass

    @abc.abstractmethod
    def install_cbinit(self, service_type):
        """Install CloudBase-Init.

        :param service_type:
            The metadata service type. It can be:
            http, ec2, configdrive, opennebula, cloudstack and  mass.
            This parameter will dictate what config option is put in
            cloubase-init.conf.
        """
        pass

    @abc.abstractmethod
    def sysprep(self):
        """Run the sysprep."""
        pass

    @abc.abstractmethod
    def wait_cbinit_service(self):
        """Wait if the CloudBase Init Service to stop."""
        pass

    @abc.abstractmethod
    def check_cbinit_service(self, searched_paths=None):
        """Check if the CloudBase Init service started.

        :param searched_paths:
            Paths to files that should exist if the hearbeat patch is
            aplied.
        """
        pass

    @abc.abstractmethod
    def git_clone(self, repo_url, location):
        """Clone from an remote repo to a specific location on the instance.

        :param repo_url:
            The remote repo url.
        :param location:
            Specific location on the instance.
        """
        pass

    @abc.abstractmethod
    def wait_boot_completion(self):
        """Wait for the instance to be booted a resonable period."""
        pass

    @abc.abstractmethod
    def specific_prepare(self):
        """Prepare some OS specific resources."""
        pass

from nose.plugins.attrib import attr
from perfpoint import *

import numpy as np

sample_counters = [
  (4, '00c0', 'instructions'),
]

@docstring_name
def check_data_shape(data, interval):
  '''Check that align produces any data at all'''
  assert len(data.shape)==2, 'Wrong dimensionality in data'
  assert data.shape[0]>5, 'Insufficient rows in data'
  assert data.shape[1]==len(sample_counters)+1, 'Insufficient columns in data'

@docstring_name
def check_data_values(data, interval):
  '''Check for ridiculous values in the data'''
  assert np.all(data>=0), 'Negative values found in data'
  for (c,counter_tuple) in enumerate(sample_counters):#xrange(1,data.shape[1]+1):
    assert np.count_nonzero(data[:,c+1])>5, 'Mostly zero data found in column '+str(c+1)+': '+str(counter_tuple)

@attr('check','align')
def test_alignment_checks():
  interval = 1000000
  align = Alignment(ipoint_interval=interval, argv=[compute])
  for counter in sample_counters:
    align.add_counter(*counter)
  data = align.run()
  # Run several different diagnostics
  yield (check_data_shape, data, interval)
  yield (check_data_values, data, interval)

@attr('check','align')
@docstring_name
def test_ragged_truncate():
  '''Check that we can truncate ragged arrays'''
  data=[ np.vstack([ np.arange(1,100), np.arange(1,100) ]).T,
         np.vstack([ np.arange(1,200), np.arange(1,200) ]).T ]
  new = align.align_truncated(data,1)
  assert new.shape==(99,3), 'align_truncated didnt truncate correctly'
  assert np.all(new[:,1]==new[:,2]), 'align_truncated didnt align the data'

@attr('check','align')
@docstring_name
def test_ragged_scaled():
  '''Check that we can scale ragged arrays'''
  data=[ np.vstack([ np.arange(1,100), np.arange(1,100) ]).T,
         np.vstack([ np.arange(3,300), np.arange(3,300) ]).T ]
  new = align.align_scaled(data,2)
  assert new.shape==(99,3), 'align_scaled didnt scale correctly'
  assert np.all(new[:,1]==new[:,2]), 'align_scaled didnt align the data'

@attr('check','align')
@docstring_name
def test_smoothing():
  '''Check oversample smoothing'''
  trace = np.vstack([ np.arange(1,100), np.arange(1,100) ]).T
  overtrace = np.empty(trace.shape)
  overtrace[:,0] = trace[:,0]
  # "oversample" 8x
  for i in xrange(0,99):
    if i&7:
      overtrace[i,1] = trace[i&(~7),1]
    else:
      overtrace[i,1] = trace[i,1]
  # now correct it back
  overtrace = align.correct_for_oversampling(overtrace)
  recovered = trace[:-10]==overtrace[:-10] # the last bit isn't recovered
  assert np.all(recovered), 'Oversample smoothing didnt recover original samples:\n'+str(np.dstack([trace[~recovered],overtrace[~recovered]]))

#@attr('stats')
#def test_alignment_checks():
#  interval = 1000000
# align = Alignment(ipoint_interval=interval, argv=[compute]
#  for counter in sample_counters:
#    align.add_counter(*counter)
#  data = align.run()
#  # Run several different diagnostics
#  yield (check_data, data, interval)

# The MIT License (MIT)
#
# Copyright (c) 2014 Richard Moore
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

# Why to_bufferable?
# Python 3 is very different from Python 2.x when it comes to strings of text
# and strings of bytes; in Python 3, strings of bytes do not exist, instead to
# represent arbitrary binary data, we must use the "bytes" object. This method
# ensures the object behaves as we need it to.

def to_bufferable(binary):
    return binary

def _get_byte(c):
    return ord(c)

try:
    xrange
except:

    def to_bufferable(binary):
        if isinstance(binary, bytes):
            return binary
        return bytes(ord(b) for b in binary)

    def _get_byte(c):
        return c

def append_PKCS7_padding(data):
    pad = 16 - (len(data) % 16)
    return data + to_bufferable(chr(pad) * pad)

def strip_PKCS7_padding(data):
    if len(data) % 16 != 0:
        raise ValueError("invalid length")

    pad = _get_byte(data[-1])

    if pad > 16:
        raise ValueError("invalid padding byte")

    return data[:-pad]

import os
import unittest
import sys
sys.path.append('../')
import ship
import tempfile


class shipTestCase(unittest.TestCase):

    def setUp(self):
        self.db_fd, ship.app.config['DATABASE'] = tempfile.mkstemp()
        ship.app.config['TESTING'] = True
        self.app = ship.app.test_client()
        ship.init_db()

    def tearDown(self):
        os.close(self.db_fd)
        os.unlink(ship.app.config['DATABASE'])
    
    def test_add_delivery(self):
        """ Test the delivery display """
        body = self.app.post('/add', data={
            'tracking': '10001',
            'carrier': 'UPS',
            'street_address': 'John Doe, Beverly Hills, CA',
            'zipcode': '90069' 
        }, follow_redirects=True)
        assert 'Delivery added' in body.data

        body = self.app.post('/add', data={
            'tracking': '',
            'carrier': 'UPS',
            'street_address': 'John Doe, Beverly Hills, CA',
            'zipcode': '90069' 
        }, follow_redirects=True)
        assert 'Invalid tracking ID' in body.data

        body = self.app.post('/add', data={
            'tracking': '10001',
            'carrier': 'UPS',
            'street_address': '',
            'zipcode': '90069' 
        }, follow_redirects=True)
        assert 'Invalid street address' in body.data

        body = self.app.post('/add', data={
            'tracking': '10001',
            'carrier': 'UPS',
            'street_address': 'John Doe, Beverly Hills, CA',
            'zipcode': '' 
        }, follow_redirects=True)
        assert 'Invalid zipcode' in body.data

        body = self.app.post('/add', data={
            'tracking': '10001',
            'carrier': 'UPS',
            'street_address': 'John Doe, Beverly Hills, CA',
            'zipcode': '9006' 
        }, follow_redirects=True)
        assert 'Invalid zipcode' in body.data

        body = self.app.post('/add', data={
            'tracking': '',
            'carrier': '',
            'street_address': '',
            'zipcode': '' 
        }, follow_redirects=True)
        assert 'Invalid tracking ID, street address, zipcode, carrier' in body.data

    def test_show_deliveries(self):  
        """ Test home page """
        body = self.app.get('/')
        assert 'Shipping Time' in body.data 
        self.app.post('/add', data={
            'tracking': '10001',
            'carrier': 'UPS',
            'street_address': 'John Doe, Beverly Hills, CA',
            'zipcode': '90069' 
        }, follow_redirects=True)
        self.app.post('/add', data={
            'tracking': '10002',
            'carrier': 'FedEx',
            'street_address': 'Jane Doe, West Hollywood, CA',
            'zipcode': '90059' 
        }, follow_redirects=True)
        body = self.app.get('/')
        assert '10001' in body.data 
        assert 'UPS' in body.data 
        assert 'John Doe' in body.data 
        assert '90069' in body.data 
        assert '10002' in body.data 
        assert 'FedEx' in body.data 
        assert 'Jane Doe' in body.data 
        assert '90059' in body.data 


    def test_assert_valid_entries(self):
        result = ship.assert_valid_entries('', 'abc', '90009', 'USPS')
        assert 'tracking ID' in result
        result = ship.assert_valid_entries('10001', '', '90009', 'USPS')
        assert 'street address' in result
        result = ship.assert_valid_entries('10001', 'abc', 'xyz', 'USPS')
        assert 'zipcode' in result
        result = ship.assert_valid_entries('10001', 'abc', '', 'USPS')
        assert 'zipcode' in result
        result = ship.assert_valid_entries('10001', 'abc', 'xyz', '')
        assert 'carrier' in result
        result = ship.assert_valid_entries('', 'abc', 'xyz', '')
        assert 'tracking ID, zipcode, carrier' in result
        result = ship.assert_valid_entries('', '', '', '')
        assert 'tracking ID, street address, zipcode, carrier' in result

if __name__ == '__main__':
    unittest.main()

# Copyright (c) 2012-2015 Netforce Co. Ltd.
# 
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# 
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
# OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
# OR OTHER DEALINGS IN THE SOFTWARE.

from netforce.model import Model, fields


class VariantValue(Model):
    _name = "product.variant.values"
    _transient = True
    _fields = {
        "popup_id": fields.Many2One("prod.create.variants", "Popup", required=True, on_delete="cascade"),
        "attribute_id": fields.Many2One("product.attribute", "Attribute", required=True),
        "values": fields.Many2Many("product.attribute.option", "Values", required=True),
    }

VariantValue.register()

# Copyright 2013 Intel Corp.
#
#    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.


from webob import exc

from nova.api.openstack.compute import pci
from nova.api.openstack import wsgi
from nova import context
from nova import exception
from nova import objects
from nova.objects import fields
from nova.objects import pci_device_pool
from nova import test
from nova.tests.unit.api.openstack import fakes
from nova.tests.unit.objects import test_pci_device
from nova.tests import uuidsentinel as uuids


pci_stats = [{"count": 3,
              "vendor_id": "8086",
              "product_id": "1520",
              "numa_node": 1}]

fake_compute_node = objects.ComputeNode(
    pci_device_pools=pci_device_pool.from_pci_stats(pci_stats))


class FakeResponse(wsgi.ResponseObject):
    pass


class PciServerControllerTestV21(test.NoDBTestCase):
    def setUp(self):
        super(PciServerControllerTestV21, self).setUp()
        self.controller = pci.PciServerController()
        self.fake_obj = {'server': {'addresses': {},
                                    'id': 'fb08',
                                    'name': 'a3',
                                    'status': 'ACTIVE',
                                    'tenant_id': '9a3af784c',
                                    'user_id': 'e992080ac0',
                                    }}
        self.fake_list = {'servers': [{'addresses': {},
                                       'id': 'fb08',
                                       'name': 'a3',
                                       'status': 'ACTIVE',
                                       'tenant_id': '9a3af784c',
                                       'user_id': 'e992080ac',
                                       }]}
        self._create_fake_instance()
        self._create_fake_pci_device()
        self.pci_device.claim(self.inst.uuid)
        self.pci_device.allocate(self.inst)

    def _create_fake_instance(self):
        self.inst = objects.Instance()
        self.inst.uuid = uuids.instance
        self.inst.pci_devices = objects.PciDeviceList()

    def _create_fake_pci_device(self):
        def fake_pci_device_get_by_addr(ctxt, id, addr):
            return test_pci_device.fake_db_dev

        ctxt = context.get_admin_context()
        self.stub_out('nova.db.pci_device_get_by_addr',
                      fake_pci_device_get_by_addr)
        self.pci_device = objects.PciDevice.get_by_dev_addr(ctxt, 1, 'a')

    def test_show(self):
        def fake_get_db_instance(id):
            return self.inst

        resp = FakeResponse(self.fake_obj, '')
        req = fakes.HTTPRequest.blank('/os-pci/1', use_admin_context=True)
        self.stubs.Set(req, 'get_db_instance', fake_get_db_instance)
        self.controller.show(req, resp, '1')
        self.assertEqual([{'id': 1}],
                         resp.obj['server']['os-pci:pci_devices'])

    def test_detail(self):
        def fake_get_db_instance(id):
            return self.inst

        resp = FakeResponse(self.fake_list, '')
        req = fakes.HTTPRequest.blank('/os-pci/detail',
                                        use_admin_context=True)
        self.stubs.Set(req, 'get_db_instance', fake_get_db_instance)
        self.controller.detail(req, resp)
        self.assertEqual([{'id': 1}],
                         resp.obj['servers'][0]['os-pci:pci_devices'])


class PciHypervisorControllerTestV21(test.NoDBTestCase):
    def setUp(self):
        super(PciHypervisorControllerTestV21, self).setUp()
        self.controller = pci.PciHypervisorController()
        self.fake_objs = dict(hypervisors=[
            dict(id=1,
                 service=dict(id=1, host="compute1"),
                 hypervisor_type="xen",
                 hypervisor_version=3,
                 hypervisor_hostname="hyper1")])
        self.fake_obj = dict(hypervisor=dict(
            id=1,
            service=dict(id=1, host="compute1"),
            hypervisor_type="xen",
            hypervisor_version=3,
            hypervisor_hostname="hyper1"))

    def test_show(self):
        def fake_get_db_compute_node(id):
            return fake_compute_node

        req = fakes.HTTPRequest.blank('/os-hypervisors/1',
                                        use_admin_context=True)
        resp = FakeResponse(self.fake_obj, '')
        self.stubs.Set(req, 'get_db_compute_node', fake_get_db_compute_node)
        self.controller.show(req, resp, '1')
        self.assertIn('os-pci:pci_stats', resp.obj['hypervisor'])
        self.assertEqual(pci_stats[0],
                         resp.obj['hypervisor']['os-pci:pci_stats'][0])

    def test_detail(self):
        def fake_get_db_compute_node(id):
            return fake_compute_node

        req = fakes.HTTPRequest.blank('/os-hypervisors/detail',
                                        use_admin_context=True)
        resp = FakeResponse(self.fake_objs, '')
        self.stubs.Set(req, 'get_db_compute_node', fake_get_db_compute_node)
        self.controller.detail(req, resp)
        self.assertIn('os-pci:pci_stats', resp.obj['hypervisors'][0])
        self.assertEqual(pci_stats[0],
                         resp.obj['hypervisors'][0]['os-pci:pci_stats'][0])


class PciControlletestV21(test.NoDBTestCase):
    def setUp(self):
        super(PciControlletestV21, self).setUp()
        self.controller = pci.PciController()

    def test_show(self):
        def fake_pci_device_get_by_id(context, id):
            return test_pci_device.fake_db_dev

        self.stub_out('nova.db.pci_device_get_by_id',
                      fake_pci_device_get_by_id)
        req = fakes.HTTPRequest.blank('/os-pci/1', use_admin_context=True)
        result = self.controller.show(req, '1')
        dist = {'pci_device': {'address': 'a',
                               'compute_node_id': 1,
                               'dev_id': 'i',
                               'extra_info': {},
                               'dev_type': fields.PciDeviceType.STANDARD,
                               'id': 1,
                               'server_uuid': None,
                               'label': 'l',
                               'product_id': 'p',
                               'status': 'available',
                               'vendor_id': 'v'}}
        self.assertEqual(dist, result)

    def test_show_error_id(self):
        def fake_pci_device_get_by_id(context, id):
            raise exception.PciDeviceNotFoundById(id=id)

        self.stub_out('nova.db.pci_device_get_by_id',
                      fake_pci_device_get_by_id)
        req = fakes.HTTPRequest.blank('/os-pci/0', use_admin_context=True)
        self.assertRaises(exc.HTTPNotFound, self.controller.show, req, '0')

    def _fake_compute_node_get_all(self, context):
        return [objects.ComputeNode(id=1,
                                    service_id=1,
                                    host='fake',
                                    cpu_info='cpu_info',
                                    disk_available_least=100)]

    def _fake_pci_device_get_all_by_node(self, context, node):
        return [test_pci_device.fake_db_dev, test_pci_device.fake_db_dev_1]

    def test_index(self):
        self.stubs.Set(self.controller.host_api, 'compute_node_get_all',
                       self._fake_compute_node_get_all)
        self.stub_out('nova.db.pci_device_get_all_by_node',
                      self._fake_pci_device_get_all_by_node)

        req = fakes.HTTPRequest.blank('/os-pci', use_admin_context=True)
        result = self.controller.index(req)
        dist = {'pci_devices': [test_pci_device.fake_db_dev,
                                test_pci_device.fake_db_dev_1]}
        for i in range(len(result['pci_devices'])):
            self.assertEqual(dist['pci_devices'][i]['vendor_id'],
                             result['pci_devices'][i]['vendor_id'])
            self.assertEqual(dist['pci_devices'][i]['id'],
                             result['pci_devices'][i]['id'])
            self.assertEqual(dist['pci_devices'][i]['status'],
                             result['pci_devices'][i]['status'])
            self.assertEqual(dist['pci_devices'][i]['address'],
                             result['pci_devices'][i]['address'])

    def test_detail(self):
        self.stubs.Set(self.controller.host_api, 'compute_node_get_all',
                       self._fake_compute_node_get_all)
        self.stub_out('nova.db.pci_device_get_all_by_node',
                      self._fake_pci_device_get_all_by_node)
        req = fakes.HTTPRequest.blank('/os-pci/detail',
                                        use_admin_context=True)
        result = self.controller.detail(req)
        dist = {'pci_devices': [test_pci_device.fake_db_dev,
                                test_pci_device.fake_db_dev_1]}
        for i in range(len(result['pci_devices'])):
            self.assertEqual(dist['pci_devices'][i]['vendor_id'],
                             result['pci_devices'][i]['vendor_id'])
            self.assertEqual(dist['pci_devices'][i]['id'],
                             result['pci_devices'][i]['id'])
            self.assertEqual(dist['pci_devices'][i]['label'],
                             result['pci_devices'][i]['label'])
            self.assertEqual(dist['pci_devices'][i]['dev_id'],
                             result['pci_devices'][i]['dev_id'])


class PciControllerPolicyEnforcementV21(test.NoDBTestCase):

    def setUp(self):
        super(PciControllerPolicyEnforcementV21, self).setUp()
        self.controller = pci.PciController()
        self.req = fakes.HTTPRequest.blank('')

    def _test_policy_failed(self, action, *args):
        rule_name = "os_compute_api:os-pci:%s" % action
        rule = {rule_name: "project:non_fake"}
        self.policy.set_rules(rule)
        exc = self.assertRaises(
            exception.PolicyNotAuthorized, getattr(self.controller, action),
            self.req, *args)
        self.assertEqual(
            "Policy doesn't allow %s to be performed." % rule_name,
            exc.format_message())

    def test_index_policy_failed(self):
        self._test_policy_failed('index')

    def test_detail_policy_failed(self):
        self._test_policy_failed('detail')

    def test_show_policy_failed(self):
        self._test_policy_failed('show', 1)

# Copyright (c) 2012 Cloudera, Inc. All rights reserved.
#
# 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.
#
# Tests for query expiration.

import pytest
import threading
from tests.common.custom_cluster_test_suite import CustomClusterTestSuite
from tests.common.custom_cluster_test_suite import NUM_SUBSCRIBERS, CLUSTER_SIZE
from time import sleep, time
from tests.beeswax.impala_beeswax import ImpalaBeeswaxException

class TestSessionExpiration(CustomClusterTestSuite):
  """Tests query expiration logic"""

  @pytest.mark.execute_serially
  @CustomClusterTestSuite.with_args("--idle_session_timeout=6")
  def test_session_expiration(self, vector):
    impalad = self.cluster.get_any_impalad()
    # setup_class creates an Impala client to <hostname>:21000 after the cluster starts.
    # The client expires at the same time as the client created below. Since we choose the
    # impalad to connect to randomly, the test becomes flaky, as the metric we expect to
    # be incremented by 1 gets incremented by 2 if both clients are connected to the same
    # Impalad.
    self.client.close()
    num_expired = impalad.service.get_metric_value("impala-server.num-sessions-expired")
    client = impalad.service.create_beeswax_client()
    # Sleep for half the expiration time to confirm that the session is not expired early
    # (see IMPALA-838)
    sleep(3)
    assert num_expired == impalad.service.get_metric_value(
      "impala-server.num-sessions-expired")
    # Wait for session expiration. Session timeout was set for 6 seconds, so Impala
    # will poll the session expiry queue every 3 seconds. So, as long as the sleep in
    # ImpalaSever::ExpireSessions() is not late, the session will expire in at most 9
    # seconds. The test has already waited 3 seconds.
    impalad.service.wait_for_metric_value(
      "impala-server.num-sessions-expired", num_expired + 1, 20)

from .common import *

# Set Roundware API for internal calls to development environment
API_URL = "http://127.0.0.1:8888/roundware/"
# Change banned_timeout limit to better development testing value
BANNED_TIMEOUT_LIMIT = 90

# Remove possibility of demo stream to avoid confusion while testing
DEMO_STREAM_CPU_LIMIT = 0.0

INSTALLED_APPS += (
    'debug_toolbar',
)

DEBUG = True
for TEMPLATE_SETTINGS_BLOCK in TEMPLATES:
    TEMPLATE_SETTINGS_BLOCK['OPTIONS']['debug'] = DEBUG

DEBUG_TOOLBAR_PATCH_SETTINGS = False
CRISPY_FAIL_SILENTLY = not DEBUG


MIDDLEWARE_CLASSES = (
    'debug_toolbar.middleware.DebugToolbarMiddleware',
) + MIDDLEWARE_CLASSES


# Bypass the INTERNAL_IPS check for Debug Toolbar
class internal_list(list):

    def __contains__(self, key):
        return True
INTERNAL_IPS = internal_list()

# PROFILING using django-profiler
PROFILING_SQL_QUERIES = True
LOGGING['handlers'] = {
    # The console handler will display in the manage.py runserver output
    'console': {
        'level': 'DEBUG',
        'class': 'logging.StreamHandler',
        'formatter': 'simple'
    },
    'file': {
        'level': 'DEBUG',
        'class': 'logging.FileHandler',
        'filename': '/var/log/roundware',
        'formatter': 'verbose',
    },
}

LOGGING['loggers'] = {
    # The default logger. Enable to log everything.
    # '': {
    #     'level': 'DEBUG',
    #     'handlers': ['console'],
    # },
    # The Django database logger. Enable to log all SQL queries.
    # 'django.db.backends': {
    #     'level': 'DEBUG',
    #     'handlers': ['console'],
    # },
    # The django-profiler logger. https://github.com/CodeScaleInc/django-profiler
    # 'profiling': {
    #     'level': 'DEBUG',
    #     'handlers': ['console'],
    # },
    # The roundware system logger.
    'roundware': {
        'level': 'DEBUG',
        'handlers': ['console'],
        'propagate': False,
    },
    # The roundwared stream manager logger.
    'roundwared': {
        'level': 'DEBUG',
        'handlers': ['console'],
        'propagate': False,
    },
    # The Roundware API2 logger.
    # 'roundware.api2': {
    #     'level': 'DEBUG',
    #     'handlers': ['console'],
    # },
    # Example logger for single file. Disable parent logger to use.
    # 'roundwared.stream': {
    #    'level': 'DEBUG',
    #    'handlers': ['console'],
    # },
}

try:
    from .local_settings import *
except ImportError:
    pass

# -*- coding: utf-8 -*-
"""

    @author: Fabio Erculiani <lxnay@sabayon.org>
    @contact: lxnay@sabayon.org
    @copyright: Fabio Erculiani
    @license: GPL-2

    B{Entropy Package Manager Client Core Interface}.

"""
import os
import shutil
import threading

from entropy.core import Singleton
from entropy.locks import EntropyResourcesLock
from entropy.fetchers import UrlFetcher, MultipleUrlFetcher
from entropy.output import TextInterface, bold, red, darkred, blue
from entropy.qa import QAInterface
from entropy.security import System, Repository as RepositorySecurity
from entropy.spm.plugins.factory import get_default_instance as get_spm, \
    get_default_class as get_spm_default_class

from entropy.client.interfaces.db import InstalledPackagesRepository
from entropy.client.interfaces.dep import CalculatorsMixin
from entropy.client.interfaces.methods import RepositoryMixin, MiscMixin, \
    MatchMixin
from entropy.client.interfaces.package import PackageActionFactory
from entropy.client.interfaces.repository import Repository

from entropy.client.interfaces.settings import ClientSystemSettingsPlugin
from entropy.client.interfaces.sets import Sets

from entropy.client.misc import sharedinstlock, ConfigurationUpdates

from entropy.client.services.interfaces import \
    ClientWebServiceFactory, RepositoryWebServiceFactory

from entropy.const import etpConst, const_debug_write, \
    const_convert_to_unicode, const_setup_perms
from entropy.core.settings.base import SystemSettings
from entropy.misc import LogFile
from entropy.cache import EntropyCacher
from entropy.i18n import _

import entropy.dump
import entropy.dep
import entropy.tools


class Client(Singleton, TextInterface, CalculatorsMixin,
             RepositoryMixin, MiscMixin, MatchMixin):

    def init_singleton(self, indexing = True, installed_repo = None,
            xcache = True, user_xcache = False, repo_validation = True,
            url_fetcher = None, multiple_url_fetcher = None, **kwargs):
        """
        Entropy Client Singleton interface. Your hitchhikers' guide to the
        Galaxy.

        @keyword indexing: enable metadata indexing (default is True)
        @type indexing: bool
        @keyword installed_repo: open installed packages repository? (default
            is True). Accepted values: True = open, False = open but consider
            it not available, -1 = do not even try to open
        @type installed_repo: bool or int
        @keyword xcache: enable on-disk cache (default is True)
        @type xcache: bool
        @keyword user_xcache: enable on-disk cache even for users not in the
            entropy group (default is False). Dangerous, could lead to cache
            inconsistencies.
        @type user_xcache: bool
        @keyword repo_validation: validate all the available repositories
            and automatically exclude the faulty ones
        @type repo_validation: bool
        @keyword url_fetcher: override default entropy.fetchers.UrlFetcher
            class usage. Provide your own implementation of UrlFetcher using
            this argument.
        @type url_fetcher: class or None
        @keyword multiple_url_fetcher: override default
            entropy.fetchers.MultipleUrlFetcher class usage. Provide your own
            implementation of MultipleUrlFetcher using this argument.
        """
        self.__post_acquire_hook_idx = None
        self.__instance_destroyed = False
        self._repo_error_messages_cache = set()
        self._repodb_cache = {}
        self._repodb_cache_mutex = threading.RLock()
        self._memory_db_instances = {}
        self._real_installed_repository = None
        self._real_installed_repository_lock = threading.RLock()
        self._treeupdates_repos = set()
        self._can_run_sys_set_hooks = False
        const_debug_write(__name__, "debug enabled")

        self.safe_mode = 0
        self._indexing = indexing
        self._repo_validation = repo_validation

        self._real_cacher = None
        self._real_cacher_lock = threading.RLock()

        # setup package settings (masking and other stuff)
        self._real_settings = None
        self._real_settings_lock = threading.RLock()

        self._real_settings_client_plg = None
        self._real_settings_client_plg_lock = threading.RLock()

        self._real_logger = None
        self._real_logger_lock = threading.RLock()

        self._real_enabled_repos = None
        self._real_enabled_repos_lock = threading.RLock()

        self._multiple_url_fetcher = multiple_url_fetcher
        self._url_fetcher = url_fetcher
        if url_fetcher is None:
            self._url_fetcher = UrlFetcher
        if multiple_url_fetcher is None:
            self._multiple_url_fetcher = MultipleUrlFetcher

        self._do_open_installed_repo = True
        self._installed_repo_enable = True
        if installed_repo in (True, None, 1):
            self._installed_repo_enable = True
        elif installed_repo in (False, 0):
            self._installed_repo_enable = False
        elif installed_repo == -1:
            self._installed_repo_enable = False
            self._do_open_installed_repo = False

        self.xcache = xcache
        shell_xcache = os.getenv("ETP_NOCACHE")
        if shell_xcache:
            self.xcache = False

        # now if we are on live, we should disable it
        # are we running on a livecd? (/proc/cmdline has "cdroot")
        if entropy.tools.islive():
            self.xcache = False
        elif (not entropy.tools.is_user_in_entropy_group()) and not user_xcache:
            self.xcache = False

        # Add Entropy Resources Lock post-acquire hook that cleans
        # repository caches.
        hook_ref = EntropyResourcesLock.add_post_acquire_hook(
            self._resources_post_hook)
        self.__post_acquire_hook_idx = hook_ref

        # enable System Settings hooks
        self._can_run_sys_set_hooks = True
        const_debug_write(__name__, "singleton loaded")

    @property
    def _settings(self):
        """
        Return a SystemSettings object instance.
        """
        with self._real_settings_lock:
            if self._real_settings is None:
                self._real_settings = SystemSettings()
                const_debug_write(__name__, "SystemSettings loaded")

                # add our SystemSettings plugin
                # Make sure we connect Entropy Client plugin
                # AFTER client db init
                self._real_settings.add_plugin(
                    self._settings_client_plugin)

        return self._real_settings

    @property
    def _settings_client_plugin(self):
        """
        Return the SystemSettings Entropy Client plugin.
        """
        with self._real_settings_client_plg_lock:
            if self._real_settings_client_plg is None:
                plugin = ClientSystemSettingsPlugin(self)
                self._real_settings_client_plg = plugin

        return self._real_settings_client_plg

    @property
    def _cacher(self):
        """
        Return an EntropyCacher object instance.
        """
        with self._real_cacher_lock:

            if self._real_cacher is None:
                real_cacher = EntropyCacher()
                const_debug_write(__name__, "EntropyCacher loaded")

                # needs to be started here otherwise repository
                # cache will be always dropped
                if self.xcache:
                    real_cacher.start()
                else:
                    # disable STASHING_CACHE or we leak
                    EntropyCacher.STASHING_CACHE = False

                self._real_cacher = real_cacher

        return self._real_cacher

    @property
    def logger(self):
        """
        Return the Entropy Client Logger instance.
        """
        with self._real_logger_lock:
            if self._real_logger is None:
                real_logger = LogFile(
                    level = self._settings['system']['log_level'],
                    filename = etpConst['entropylogfile'],
                    header = "[client]")

                const_debug_write(__name__, "Logger loaded")
                self._real_logger = real_logger

        return self._real_logger

    @property
    def _enabled_repos(self):
        with self._real_enabled_repos_lock:

            if self._real_enabled_repos is None:
                real_enabled_repos = []

                if self._repo_validation:
                    self._validate_repositories(
                        enabled_repos = real_enabled_repos)
                else:
                    real_enabled_repos.extend(
                        self._settings['repositories']['order'])

                self._real_enabled_repos = real_enabled_repos

        return self._real_enabled_repos

    def _resources_post_hook(self):
        """
        Hook running after Entropy Resources Lock acquisition.
        This method takes care of the repository memory caches, by
        invalidating it.
        """
        with self._real_installed_repository_lock:
            if self._real_installed_repository is not None:
                self._real_installed_repository.clearCache()

        with self._repodb_cache_mutex:
            for repo in self._repodb_cache.values():
                repo.clearCache()

    def destroy(self, _from_shutdown = False):
        """
        Destroy this Singleton instance, closing repositories, removing
        SystemSettings plugins added during instance initialization.
        This method should be always called when instance is not used anymore.
        """
        self.__instance_destroyed = True

        if self.__post_acquire_hook_idx is not None:
            EntropyResourcesLock.remove_post_acquire_hook(
                self.__post_acquire_hook_idx)
            self.__post_acquire_hook_idx = None

        if hasattr(self, '_installed_repository'):
            inst_repo = self.installed_repository()
            if inst_repo is not None:
                inst_repo.close(_token = InstalledPackagesRepository.NAME)

        if hasattr(self, '_real_logger_lock'):
            with self._real_logger_lock:
                if self._real_logger is not None:
                    self._real_logger.close()

        if not _from_shutdown:
            if hasattr(self, '_real_settings') and \
                    hasattr(self._real_settings, 'remove_plugin'):

                # shutdown() will terminate the whole process
                # so there is no need to remove plugins from
                # SystemSettings, it wouldn't make any diff.
                if self._real_settings is not None:
                    try:
                        self._real_settings.remove_plugin(
                            ClientSystemSettingsPlugin.ID)
                    except KeyError:
                        pass

        self.close_repositories(mask_clear = False)

    def shutdown(self):
        """
        This method should be called when the whole process is going to be
        killed. It calls destroy() and stops any running thread
        """
        self._cacher.sync()  # enforce, destroy() may kill the current content
        self.destroy(_from_shutdown = True)
        self._cacher.stop()
        entropy.tools.kill_threads()

    @sharedinstlock
    def repository_packages_spm_sync(self, repository_identifier, repo_db,
        force = False):
        """
        Service method used to sync package names with Source Package Manager
        via metadata stored in Repository dbs collected at server-time.
        Source Package Manager can change package names, categories or slot
        and Entropy repositories must be kept in sync.

        In other words, it checks for /usr/portage/profiles/updates changes,
        of course indirectly, since there is no way entropy.client can directly
        depend on Portage.

        @param repository_identifier: repository identifier which repo_db
            parameter is bound
        @type repository_identifier: string
        @param repo_db: repository database instance
        @type repo_db: entropy.db.EntropyRepository
        @return: bool stating if changes have been made
        @rtype: bool
        """
        inst_repo = self.installed_repository()

        if not inst_repo:
            # nothing to do if client db is not availabe
            return False

        self._treeupdates_repos.add(repository_identifier)

        do_rescan = False
        shell_rescan = os.getenv("ETP_TREEUPDATES_RESCAN")
        if shell_rescan:
            do_rescan = True

        # check database digest
        stored_digest = repo_db.retrieveRepositoryUpdatesDigest(
            repository_identifier)
        if stored_digest == -1:
            do_rescan = True

        # check stored value in client database
        client_digest = "0"
        if not do_rescan:
            client_digest = \
                inst_repo.retrieveRepositoryUpdatesDigest(
                    repository_identifier)

        if do_rescan or (str(stored_digest) != str(client_digest)) or force:

            # reset database tables
            inst_repo.clearTreeupdatesEntries(
                repository_identifier)

            # load updates
            update_actions = repo_db.retrieveTreeUpdatesActions(
                repository_identifier)
            # now filter the required actions
            update_actions = inst_repo.filterTreeUpdatesActions(
                update_actions)

            if update_actions:

                mytxt = "%s: %s." % (
                    bold(_("ATTENTION")),
                    red(_("forcing packages metadata update")),
                )
                self.output(
                    mytxt,
                    importance = 1,
                    level = "info",
                    header = darkred(" * ")
                )
                mytxt = "%s %s." % (
                    red(_("Updating system database using repository")),
                    blue(repository_identifier),
                )
                self.output(
                    mytxt,
                    importance = 1,
                    level = "info",
                    header = darkred(" * ")
                )
                # run stuff
                inst_repo.runTreeUpdatesActions(
                    update_actions)

            # store new digest into database
            inst_repo.setRepositoryUpdatesDigest(
                repository_identifier, stored_digest)
            # store new actions
            inst_repo.addRepositoryUpdatesActions(
                InstalledPackagesRepository.NAME, update_actions,
                    self._settings['repositories']['branch'])
            inst_repo.commit()
            # clear client cache
            inst_repo.clearCache()
            return True

    def is_destroyed(self):
        return self.__instance_destroyed

    def clear_cache(self):
        """
        Clear all the Entropy default cache directory. This function is
        fault tolerant and will never return any exception.
        """
        with self._cacher:
            # no data is written while holding self._cacher by the balls
            # drop all the buffers then remove on-disk data
            self._cacher.discard()
            # clear repositories live cache
            inst_repo = self.installed_repository()
            if inst_repo is not None:
                inst_repo.clearCache()
            with self._repodb_cache_mutex:
                for repo in self._repodb_cache.values():
                    repo.clearCache()

            cache_dir = self._cacher.current_directory()
            try:
                shutil.rmtree(cache_dir, True)
            except (shutil.Error, IOError, OSError):
                return
            try:
                os.makedirs(cache_dir, 0o775)
            except (IOError, OSError):
                return
            try:
                const_setup_perms(cache_dir, etpConst['entropygid'])
            except (IOError, OSError):
                return

    def QA(self):
        """
        Load Entropy QA interface object

        @rtype: entropy.qa.QAInterface
        """
        qa_intf = QAInterface()
        qa_intf.output = self.output
        qa_intf.ask_question = self.ask_question
        qa_intf.input_box = self.input_box
        qa_intf.set_title = self.set_title
        return qa_intf

    def Settings(self):
        """
        Return SystemSettings instance object
        """
        return self._settings

    def ClientSettings(self):
        """
        Return SystemSettings Entropy Client plugin metadata dictionary
        """
        p_id = ClientSystemSettingsPlugin.ID
        return self._settings[p_id]

    def Cacher(self):
        """
        Return EntropyCacher instance object

        @return: EntropyCacher instance object
        @rtype: entropy.cache.EntropyCacher
        """
        return self._cacher

    def PackageActionFactory(self):
        """
        Load Entropy PackageActionFactory instance object
        """
        return PackageActionFactory(self)

    def ConfigurationUpdates(self):
        """
        Return Entropy Configuration File Updates management object.
        """
        return ConfigurationUpdates(self)

    def Spm(self):
        """
        Load Source Package Manager instance object
        """
        return get_spm(self)

    def Spm_class(self):
        """
        Load Source Package Manager default plugin class
        """
        return get_spm_default_class()

    def Repositories(self, *args, **kwargs):
        """
        Load Entropy Repositories manager instance object

        @return: Repository instance object
        @rtype: entropy.client.interfaces.repository.Repository
        """
        client_data = self.ClientSettings()['misc']
        kwargs['gpg'] = client_data['gpg']
        return Repository(self, *args, **kwargs)

    def Security(self, *args, **kwargs):
        """
        Load Entropy Security Advisories interface object

        @return: Repository Security instance object
        @rtype: entropy.security.System
        """
        return System(self, *args, **kwargs)

    def RepositorySecurity(self, keystore_dir = None):
        """
        Load Entropy Repository Security interface object

        @return: Repository Repository Security instance object
        @rtype: entropy.security.Repository
        @raise RepositorySecurity.GPGError: GPGError based instances in case
            of problems.
        """
        if keystore_dir is None:
            keystore_dir = etpConst['etpclientgpgdir']
        return RepositorySecurity(keystore_dir = keystore_dir)

    def Sets(self):
        """
        Load Package Sets interface object

        @return: Sets instance object
        @rtype: entropy.client.interfaces.sets.Sets
        """
        return Sets(self)

    def WebServices(self):
        """
        Load the Entropy Web Services Factory interface, that can be used
        to obtain a WebService object that is able to communicate with
        repository remote services, if available.

        @return: WebServicesFactory instance object
        @rtype: entropy.client.services.interfaces.WebServicesFactory
        """
        return ClientWebServiceFactory(self)

    def RepositoryWebServices(self):
        """
        Load the Repository Entropy Web Services Factory interface, that can
        be used to obtain a RepositoryWebService object that is able to
        communicate with repository remote services, querying for package
        metadata and general repository status.

        @return: RepositoryWebServiceFactory instance object
        @rtype: entropy.client.services.interfaces.RepositoryWebServiceFactory
        """
        return RepositoryWebServiceFactory(self)

from hpp.corbaserver.rbprm.rbprmbuilder import Builder
from hpp.corbaserver.rbprm.rbprmfullbody import FullBody
from hpp.gepetto import Viewer

import stair_bauzil_hrp2_path as tp
import time



packageName = "hrp2_14_description"
meshPackageName = "hrp2_14_description"
rootJointType = "freeflyer"
##
#  Information to retrieve urdf and srdf files.
urdfName = "hrp2_14"
urdfSuffix = "_reduced"
srdfSuffix = ""

fullBody = FullBody ()

fullBody.loadFullBodyModel(urdfName, rootJointType, meshPackageName, packageName, urdfSuffix, srdfSuffix)
fullBody.setJointBounds ("base_joint_xyz", [-0.135,2, -1, 1, 0, 2.2])


ps = tp.ProblemSolver( fullBody )
r = tp.Viewer (ps)

#~ AFTER loading obstacles
rLegId = '0rLeg'
rLeg = 'RLEG_JOINT0'
rLegOffset = [0,-0.105,0,]
rLegNormal = [0,1,0]
rLegx = 0.09; rLegy = 0.05
fullBody.addLimb(rLegId,rLeg,'',rLegOffset,rLegNormal, rLegx, rLegy, 10000, "manipulability", 0.1)

lLegId = '1lLeg'
lLeg = 'LLEG_JOINT0'
lLegOffset = [0,-0.105,0]
lLegNormal = [0,1,0]
lLegx = 0.09; lLegy = 0.05
fullBody.addLimb(lLegId,lLeg,'',lLegOffset,rLegNormal, lLegx, lLegy, 10000, "manipulability", 0.1)

rarmId = '3Rarm'
rarm = 'RARM_JOINT0'
rHand = 'RARM_JOINT5'
rArmOffset = [0,0,-0.1]
rArmNormal = [0,0,1]
rArmx = 0.024; rArmy = 0.024
#disabling collision for hook
fullBody.addLimb(rarmId,rarm,rHand,rArmOffset,rArmNormal, rArmx, rArmy, 10000, "manipulability", 0.05, "_6_DOF", True)


#~ AFTER loading obstacles
larmId = '4Larm'
larm = 'LARM_JOINT0'
lHand = 'LARM_JOINT5'
lArmOffset = [-0.05,-0.050,-0.050]
lArmNormal = [1,0,0]
lArmx = 0.024; lArmy = 0.024
#~ fullBody.addLimb(larmId,larm,lHand,lArmOffset,lArmNormal, lArmx, lArmy, 10000, 0.05)

rKneeId = '0RKnee'
rLeg = 'RLEG_JOINT0'
rKnee = 'RLEG_JOINT3'
rLegOffset = [0.105,0.055,0.017]
rLegNormal = [-1,0,0]
rLegx = 0.05; rLegy = 0.05
#~ fullBody.addLimb(rKneeId, rLeg,rKnee,rLegOffset,rLegNormal, rLegx, rLegy, 10000, 0.01)
#~ 
lKneeId = '1LKnee'
lLeg = 'LLEG_JOINT0'
lKnee = 'LLEG_JOINT3'
lLegOffset = [0.105,0.055,0.017]
lLegNormal = [-1,0,0]
lLegx = 0.05; lLegy = 0.05
#~ fullBody.addLimb(lKneeId,lLeg,lKnee,lLegOffset,lLegNormal, lLegx, lLegy, 10000, 0.01)
 #~ 

#~ fullBody.runLimbSampleAnalysis(rLegId, "jointLimitsDistance", True)
#~ fullBody.runLimbSampleAnalysis(lLegId, "jointLimitsDistance", True)

#~ fullBody.client.basic.robot.setJointConfig('LARM_JOINT0',[1])
#~ fullBody.client.basic.robot.setJointConfig('RARM_JOINT0',[-1])

q_0 = fullBody.getCurrentConfig(); 
#~ fullBody.createOctreeBoxes(r.client.gui, 1, rarmId, q_0,)
q_init = fullBody.getCurrentConfig(); q_init[0:7] = tp.q_init[0:7]
q_goal = fullBody.getCurrentConfig(); q_goal[0:7] = tp.q_goal[0:7]


fullBody.setCurrentConfig (q_init)
q_init =  [
        0.1, -0.82, 0.648702, 1.0, 0.0 , 0.0, 0.0,                         	 # Free flyer 0-6
        0.0, 0.0, 0.0, 0.0,                                                  # CHEST HEAD 7-10
        0.261799388,  0.174532925, 0.0, -0.523598776, 0.0, 0.0, 0.17, 		 # LARM       11-17
        0.261799388, -0.174532925, 0.0, -0.523598776, 0.0, 0.0, 0.17, 		 # RARM       18-24
        0.0, 0.0, -0.453785606, 0.872664626, -0.41887902, 0.0,               # LLEG       25-30
        0.0, 0.0, -0.453785606, 0.872664626, -0.41887902, 0.0,               # RLEG       31-36
        ]; r (q_init)

fullBody.setCurrentConfig (q_goal)
#~ r(q_goal)
q_goal = fullBody.generateContacts(q_goal, [0,0,1])
#~ r(q_goal)

fullBody.setStartState(q_init,[rLegId,lLegId]) #,rarmId,larmId])
fullBody.setEndState(q_goal,[rLegId,lLegId])#,rarmId,larmId])
#~ 
#~ configs = fullBody.interpolate(0.1)
configs = fullBody.interpolate(0.1)
#~ configs = fullBody.interpolate(0.15)
i = 0;
fullBody.draw(configs[i],r); i=i+1; i-1

r.loadObstacleModel ('hpp-rbprm-corba', "stair_bauzil", "contact")
#~ fullBody.exportAll(r, configs, 'stair_bauzil_hrp2_robust_2');
#~ fullBody.client.basic.robot.setJointConfig('LLEG_JOINT0',[-1])
#~ q_0 = fullBody.getCurrentConfig(); 
#~ fullBody.draw(q_0,r);
#~ print(fullBody.client.rbprm.rbprm.getOctreeTransform(rarmId, q_0))
#~ 
#~ 
#~ fullBody.client.basic.robot.setJointConfig('LLEG_JOINT0',[1])
#~ q_0 = fullBody.getCurrentConfig(); 
#~ fullBody.draw(q_0,r);
#~ print(fullBody.client.rbprm.rbprm.getOctreeTransform(rarmId, q_0))
#~ q_init = fullBody.generateContacts(q_init, [0,0,-1]); r (q_init)

#~ f1 = open("secondchoice","w+")
#~ f1 = open("hrp2_stair_not_robust_configs","w+")
#~ f1.write(str(configs))
#~ f1.close()

limbsCOMConstraints = { rLegId : {'file': "hrp2/RL_com.ineq", 'effector' : 'RLEG_JOINT5'},  
						lLegId : {'file': "hrp2/LL_com.ineq", 'effector' : 'LLEG_JOINT5'},
						rarmId : {'file': "hrp2/RA_com.ineq", 'effector' : rHand} }
						#~ larmId : {'file': "hrp2/LA_com.ineq", 'effector' : lHand} }

#~ fullBody.limbRRTFromRootPath(0,len(configs)-1,0,2)
from hpp.corbaserver.rbprm.tools.cwc_trajectory_helper import step, clean,stats, saveAllData, play_traj
from hpp.gepetto import PathPlayer
pp = PathPlayer (fullBody.client.basic, r)

def act(i, numOptim = 0, use_window = 0, friction = 0.5, optim_effectors = True, verbose = False, draw = False):
	return step(fullBody, configs, i, numOptim, pp, limbsCOMConstraints, 0.4, optim_effectors = optim_effectors, time_scale = 20., useCOMConstraints = True, use_window = use_window,
	verbose = verbose, draw = draw)

def play(frame_rate = 1./24.):
	play_traj(fullBody,pp,frame_rate)
	
def saveAll(name):
	saveAllData(fullBody, r, name)
	

def initConfig():
	r.client.gui.setVisibility("hrp2_14", "ON")
	tp.cl.problem.selectProblem("default")
	tp.r.client.gui.setVisibility("toto", "OFF")
	tp.r.client.gui.setVisibility("hrp2_trunk_flexible", "OFF")
	r(q_init)
	
def endConfig():
	r.client.gui.setVisibility("hrp2_14", "ON")
	tp.cl.problem.selectProblem("default")
	tp.r.client.gui.setVisibility("toto", "OFF")
	tp.r.client.gui.setVisibility("hrp2_trunk_flexible", "OFF")
	r(q_goal)
	

def rootPath():
	tp.cl.problem.selectProblem("rbprm_path")
	r.client.gui.setVisibility("hrp2_14", "OFF")
	tp.r.client.gui.setVisibility("toto", "OFF")
	r.client.gui.setVisibility("hyq", "OFF")
	r.client.gui.setVisibility("hrp2_trunk_flexible", "ON")
	tp.pp(0)
	r.client.gui.setVisibility("hrp2_trunk_flexible", "OFF")
	r.client.gui.setVisibility("hyq", "ON")
	tp.cl.problem.selectProblem("default")
	
def genPlan():
	r.client.gui.setVisibility("hrp2_14", "ON")
	tp.cl.problem.selectProblem("default")
	tp.r.client.gui.setVisibility("toto", "OFF")
	tp.r.client.gui.setVisibility("hrp2_trunk_flexible", "OFF")
	global configs
	start = time.clock() 
	configs = configs = fullBody.interpolate(0.1, True)
	end = time.clock() 
	print "Contact plan generated in " + str(end-start) + "seconds"
	
def contactPlan():
	tp.cl.problem.selectProblem("default")
	r.client.gui.setVisibility("hrp2_14", "ON")
	tp.r.client.gui.setVisibility("toto", "OFF")
	tp.r.client.gui.setVisibility("hrp2_trunk_flexible", "OFF")
	for i in range(1,len(configs)):
		r(configs[i]);
		time.sleep(0.5)		
		
def interpolate():
	tp.cl.problem.selectProblem("default")
	r.client.gui.setVisibility("hrp2_14", "ON")
	tp.r.client.gui.setVisibility("toto", "OFF")
	tp.r.client.gui.setVisibility("hrp2_trunk_flexible", "OFF")
	for i in range(7,20):
		act(i,1,optim_effectors=True)
		
def play(frame_rate = 1./24.):
	play_traj(fullBody,pp,frame_rate)
	

		
def a():
	print "initial configuration"
	initConfig()
		
def b():
	print "end configuration"
	endConfig()
		
def c():
	print "displaying root path"
	rootPath()
	
def d():
	print "computing contact plan"
	genPlan()
	
def e():
	print "displaying contact plan"
	contactPlan()

def f():
	print "computing feasible com trajectory"
	interpolate()

def g():
	print "playing feasible trajectory"
	play()
	
print "Root path generated in " + str(tp.t) + " ms."
	



#!/usr/bin/python
#
# Copyright 2008 Google Inc. All Rights Reserved.

"""Test for the rpc proxy class."""

import unittest, os
try:
    import autotest.common as common
except ImportError:
    import common
from autotest_lib.cli import rpc
from autotest_lib.client.common_lib import global_config
from autotest_lib.frontend.afe import rpc_client_lib
from autotest_lib.frontend.afe.json_rpc import proxy

GLOBAL_CONFIG = global_config.global_config


class rpc_unittest(unittest.TestCase):
    def setUp(self):
        self.old_environ = os.environ.copy()
        if 'AUTOTEST_WEB' in os.environ:
            del os.environ['AUTOTEST_WEB']


    def tearDown(self):
        os.environ.clear()
        os.environ.update(self.old_environ)


    def test_get_autotest_server_specific(self):
        self.assertEqual('http://foo', rpc.get_autotest_server('foo'))


    def test_get_autotest_server_none(self):
        GLOBAL_CONFIG.override_config_value('SERVER', 'hostname', 'Prince')
        self.assertEqual('http://Prince', rpc.get_autotest_server(None))


    def test_get_autotest_server_environ(self):
        os.environ['AUTOTEST_WEB'] = 'foo-dev'
        self.assertEqual('http://foo-dev', rpc.get_autotest_server(None))
        del os.environ['AUTOTEST_WEB']


    def test_get_autotest_server_environ_precedence(self):
        os.environ['AUTOTEST_WEB'] = 'foo-dev'
        self.assertEqual('http://foo', rpc.get_autotest_server('foo'))
        del os.environ['AUTOTEST_WEB']


if __name__ == '__main__':
    unittest.main()

# -*- coding: utf-8 -*-
"""
Boolean Nodes
=================================

Commonly used boolean node functions.

"""
#   Copyright (C) 2021 by
#   Alex Gates <ajgates42@gmail.com>
#   Rion Brattig Correia <rionbr@gmail.com>
#   All rights reserved.
#   MIT license.
from .. boolean_network import BooleanNode


def AND():
    """AND boolean node.

    .. code::

        00 : 0
        01 : 0
        10 : 0
        11 : 1

    """
    return BooleanNode.from_output_list(outputs=[0, 0, 0, 1], name="AND")


def OR():
    """OR boolean node.

    .. code::

        00 : 0
        01 : 1
        10 : 1
        11 : 1

    """
    return BooleanNode.from_output_list(outputs=[0, 1, 1, 1], name="OR")


def XOR():
    """XOR boolean node.

    .. code::

        00 : 0
        01 : 1
        10 : 1
        11 : 0

    """
    return BooleanNode.from_output_list(outputs=[0, 1, 1, 0], name="XOR")


def COPYx1():
    """COPY :math:`x_1` boolean node.

    .. code::

        00 : 0
        01 : 0
        10 : 1
        11 : 1

    """
    return BooleanNode.from_output_list(outputs=[0, 0, 1, 1], name="COPY x_1")


def CONTRADICTION():
    """Contradiction boolean node.

    .. code::

        00 : 0
        01 : 0
        10 : 0
        11 : 0

    """
    return BooleanNode.from_output_list(outputs=[0, 0, 0, 0], name="CONTRADICTION")


def RULE90():
    """RULE 90 celular automata node.

    .. code::

        000 : 0
        001 : 1
        010 : 0
        011 : 1
        100 : 1
        101 : 0
        110 : 1
        111 : 0

    """
    return BooleanNode.from_output_list(outputs=[0, 1, 0, 1, 1, 0, 1, 0], name="RULE 90")


def RULE110():
    """RULE 110 celular automata node.

    .. code::

        000 : 0
        001 : 1
        010 : 1
        011 : 1
        100 : 0
        101 : 1
        110 : 1
        111 : 0

    """
    return BooleanNode.from_output_list(outputs=[0, 1, 1, 1, 0, 1, 1, 0], name="RULE 110")

# Author: Nicolas VERDIER
# This file is part of memorpy.
#
# memorpy is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# memorpy is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with memorpy.  If not, see <http://www.gnu.org/licenses/>.

import binascii
import logging
import re
import struct

from LoLVRSpectate.memorpy import utils
from LoLVRSpectate.memorpy.Address import Address
from LoLVRSpectate.memorpy.structures import *

from LoLVRSpectate.memorpy import Process

logger = logging.getLogger('memorpy')

class MemWorker(object):

    def __init__(self, process_name, end_offset = None, start_offset = None):
        logger.info('opening process %s ...' % process_name)
        self.process = Process()
        self.process.open_debug_from_name(process_name)
        si = self.process.GetSystemInfo()
        if end_offset:
            self.end_offset = end_offset
        else:
            self.end_offset = si.lpMaximumApplicationAddress
        if start_offset:
            self.start_offset = start_offset
        else:
            self.start_offset = si.lpMinimumApplicationAddress

    def Address(self, value, default_type = 'uint'):
        """ wrapper to instanciate an Address class for the memworker.process"""
        return Address(value, process=self.process, default_type=default_type)

    def search_address(self, address):
        address = int(address)
        for m in self.process.list_modules():
            for addr in self.mem_search(address, ftype='ulong', start_offset=m.modBaseAddr, end_offset=m.modBaseSize):
                logger.debug('found module %s => addr %s' % (m.szModule, addr))

    def umem_replace(self, regex, replace):
        """ like search_replace_mem but works with unicode strings """
        regex = utils.re_to_unicode(regex)
        replace = replace.encode('utf-16-le')
        return self.mem_replace(re.compile(regex, re.UNICODE), replace)

    def mem_replace(self, regex, replace):
        """ search memory for a pattern and replace all found occurrences """
        allWritesSucceed = True
        for start_offset in self.mem_search(regex, ftype='re'):
            if self.process.write_bytes(start_offset, replace) == 1:
                logger.debug('Write at offset %s succeeded !' % start_offset)
            else:
                allWritesSucceed = False
                logger.debug('Write at offset %s failed !' % start_offset)

        return allWritesSucceed

    def umem_search(self, regex):
        """ like mem_search but works with unicode strings """
        regex = utils.re_to_unicode(regex)
        for i in self.mem_search(str(regex), ftype='re'):
            yield i

    def group_search(self, group, start_offset = None, end_offset = None):
        regex = ''
        for value, type in group:
            if type == 'f' or type == 'float':
                f = struct.pack('<f', float(value))
                regex += '..' + f[2:4]
            else:
                raise NotImplementedError('unknown type %s' % type)

        return self.mem_search(regex, ftype='re', start_offset=start_offset, end_offset=end_offset)

    def search_address(self, addr):
        a = '%08X' % addr
        logger.debug('searching address %s' % a)
        regex = ''
        for i in range(len(a) - 2, -1, -2):
            regex += binascii.unhexlify(a[i:i + 2])

        return self.mem_search(re.escape(regex), ftype='re')

    def mem_search(self, value, ftype = 'match', protec = PAGE_READWRITE | PAGE_READONLY, start_offset = None, end_offset = None):
        """ 
                iterator returning all indexes where the pattern has been found
        """
        ftype = ftype.lower().strip()
        if type(value) is list:
            ftype = 'group'
        if ftype == 're':
            if type(value) is str:
                regex = re.compile(value)
            else:
                regex = value
        if start_offset is None:
            offset = self.start_offset
        else:
            offset = start_offset
        if end_offset is None:
            end_offset = self.end_offset
        if ftype == 'float':
            structtype, structlen = utils.type_unpack(ftype)
        elif ftype != 'match' and ftype != 'group' and ftype != 're':
            structtype, structlen = utils.type_unpack(ftype)
            value = struct.pack(structtype, value)
        while True:
            if offset >= end_offset:
                break
            totalread = 0
            mbi = self.process.VirtualQueryEx(offset)
            offset = mbi.BaseAddress
            chunk = mbi.RegionSize
            protect = mbi.Protect
            state = mbi.State
            if state & MEM_FREE or state & MEM_RESERVE:
                offset += chunk
                continue
            if protec:
                if not protect & protec or protect & PAGE_NOCACHE or protect & PAGE_WRITECOMBINE or protect & PAGE_GUARD:
                    offset += chunk
                    continue
            b = ''
            try:
                b = self.process.read_bytes(offset, chunk)
                totalread = len(b)
            except Exception as e:
                logger.warning(e)
                offset += chunk
                continue

            if b:
                if ftype == 're':
                    duplicates_cache = set()
                    for res in regex.findall(b):
                        index = b.find(res)
                        while index != -1:
                            soffset = offset + index
                            if soffset not in duplicates_cache:
                                duplicates_cache.add(soffset)
                                yield self.Address(soffset, 'bytes')
                            index = b.find(res, index + len(res))

                elif ftype == 'float':
                    for index in range(0, len(b)):
                        try:
                            tmpval = struct.unpack(structtype, b[index:index + 4])[0]
                            if int(value) == int(tmpval):
                                soffset = offset + index
                                yield self.Address(soffset, 'float')
                        except Exception as e:
                            pass

                else:
                    index = b.find(value)
                    while index != -1:
                        soffset = offset + index
                        yield self.Address(soffset, 'bytes')
                        index = b.find(value, index + 1)

            offset += totalread


#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
#
# 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.

from __future__ import print_function

import op_test
import unittest
import numpy


def create_test_class(op_type, typename, callback):
    class Cls(op_test.OpTest):
        def setUp(self):
            a = numpy.random.random(size=(10, 7)).astype(typename)
            b = numpy.random.random(size=(10, 7)).astype(typename)
            c = callback(a, b)
            self.inputs = {'X': a, 'Y': b}
            self.outputs = {'Out': c}
            self.op_type = op_type

        def test_output(self):
            self.check_output()

    cls_name = "{0}_{1}".format(op_type, typename)
    Cls.__name__ = cls_name
    globals()[cls_name] = Cls


for _type_name in {'float32', 'float64', 'int32', 'int64'}:
    create_test_class('less_than', _type_name, lambda _a, _b: _a < _b)
    create_test_class('less_equal', _type_name, lambda _a, _b: _a <= _b)
    create_test_class('greater_than', _type_name, lambda _a, _b: _a > _b)
    create_test_class('greater_equal', _type_name, lambda _a, _b: _a >= _b)
    create_test_class('equal', _type_name, lambda _a, _b: _a == _b)
    create_test_class('not_equal', _type_name, lambda _a, _b: _a != _b)

if __name__ == '__main__':
    unittest.main()

#-*- coding:utf-8 -*-

"""
This file is part of openexp.

openexp is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

openexp is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with openexp.  If not, see <http://www.gnu.org/licenses/>.
"""

from libopensesame.sketchpad_elements._base_element import base_element

class arrow(base_element):

	"""
	desc:
		An arrow element for the sketchpad.
	"""

	def __init__(self, sketchpad, string):

		"""
		desc:
			Constructor.

		arguments:
			sketchpad:		A sketchpad object.
			string:			A definition string.
		"""

		defaults = [
			(u'x1'			, None),
			(u'y1'			, None),
			(u'x2'			, None),
			(u'y2'			, None),
			(u'arrow_size'	, 20),
			(u'color'		, sketchpad.get(u'foreground')),
			(u'penwidth'	, 1),
			]
		super(arrow, self).__init__(sketchpad, string, defaults=defaults)

	def draw(self):

		"""
		desc:
			Draws the element to the canvas of the sketchpad.
		"""

		properties = self.eval_properties()
		return self.canvas.arrow(properties[u'x1'], properties[u'y1'],
			properties[u'x2'], properties[u'y2'],
			color=properties[u'color'],
			penwidth=properties[u'penwidth'],
			arrow_size=properties[u'arrow_size'])


#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.
from typing import List, Optional, Union

from airflow.models import BaseOperator
from airflow.providers.dingding.hooks.dingding import DingdingHook
from airflow.utils.decorators import apply_defaults


class DingdingOperator(BaseOperator):
    """
    This operator allows you send Dingding message using Dingding custom bot.
    Get Dingding token from conn_id.password. And prefer set domain to
    conn_id.host, if not will use default ``https://oapi.dingtalk.com``.

    For more detail message in
    `Dingding custom bot <https://open-doc.dingtalk.com/microapp/serverapi2/qf2nxq>`_

    :param dingding_conn_id: The name of the Dingding connection to use
    :type dingding_conn_id: str
    :param message_type: Message type you want to send to Dingding, support five type so far
        including text, link, markdown, actionCard, feedCard
    :type message_type: str
    :param message: The message send to Dingding chat group
    :type message: str or dict
    :param at_mobiles: Remind specific users with this message
    :type at_mobiles: list[str]
    :param at_all: Remind all people in group or not. If True, will overwrite ``at_mobiles``
    :type at_all: bool
    """

    template_fields = ('message',)
    ui_color = '#4ea4d4'  # Dingding icon color

    @apply_defaults
    def __init__(
        self,
        *,
        dingding_conn_id: str = 'dingding_default',
        message_type: str = 'text',
        message: Union[str, dict, None] = None,
        at_mobiles: Optional[List[str]] = None,
        at_all: bool = False,
        **kwargs,
    ) -> None:
        super().__init__(**kwargs)
        self.dingding_conn_id = dingding_conn_id
        self.message_type = message_type
        self.message = message
        self.at_mobiles = at_mobiles
        self.at_all = at_all

    def execute(self, context) -> None:
        self.log.info('Sending Dingding message.')
        hook = DingdingHook(
            self.dingding_conn_id, self.message_type, self.message, self.at_mobiles, self.at_all
        )
        hook.send()

# ***** BEGIN GPL LICENSE BLOCK *****
#
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.    See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ***** END GPL LICENCE BLOCK *****

import bpy
from bpy.props import *
from bpy.types import Operator, AddonPreferences

import math
# import mifth_tools_cloning


# bpy.mifthTools = dict()

class MFTSceneRender2X(bpy.types.Operator):
    bl_idname = "mft.render_scene_2x"
    bl_label = "Render2X"
    bl_description = "Render2X..."
    bl_options = {'REGISTER', 'UNDO'}

    scale_value : FloatProperty(
        default=2.0,
        min=0.001,
        max=500.0
    )

    def execute(self, context):

        scene = context.scene
        nodes = scene.node_tree.nodes
        mifthTools = context.scene.mifthTools

        crop_nodes_2x(nodes, self.scale_value)

        return {'FINISHED'}


def crop_nodes_2x(nodes, scale_value):
    for node in nodes:
        if node.type == 'GROUP':
            crop_nodes_2x(node.node_tree.nodes, scale_value)
        elif node.type == 'CROP':
            node.min_x *= scale_value
            node.max_x *= scale_value
            node.min_y *= scale_value
            node.max_y *= scale_value


class MFTCropNodeRegion(bpy.types.Operator):
    bl_idname = "mft.cropnoderegion"
    bl_label = "Crop Node Region"
    bl_description = "Crop Node Region"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):

        scene = context.scene
        nodes = scene.node_tree.nodes
        cropNode = nodes.active
        crop_percentage = context.scene.render.resolution_percentage / 100.0


        if cropNode != None:
            if cropNode.type == 'CROP':
                cropNode.min_x = scene.render.border_min_x * scene.render.resolution_x * crop_percentage
                cropNode.max_x = scene.render.border_max_x * scene.render.resolution_x * crop_percentage
                cropNode.min_y = scene.render.border_max_y * scene.render.resolution_y * crop_percentage
                cropNode.max_y = scene.render.border_min_y * scene.render.resolution_y * crop_percentage

            elif cropNode.type == 'GROUP':
                cropGroupNode = cropNode.node_tree.nodes.active

                if cropGroupNode != None and cropGroupNode.type == 'CROP':
                    cropGroupNode.min_x = scene.render.border_min_x * scene.render.resolution_x * crop_percentage
                    cropGroupNode.max_x = scene.render.border_max_x * scene.render.resolution_x * crop_percentage
                    cropGroupNode.min_y = scene.render.border_max_y * scene.render.resolution_y * crop_percentage
                    cropGroupNode.max_y = scene.render.border_min_y * scene.render.resolution_y * crop_percentage
        else:
            self.report({'INFO'}, "Select Crop Node!")

        return {'FINISHED'}

class MFTCropToViewport(bpy.types.Operator):
    bl_idname = "mft.crop_to_viewport"
    bl_label = "Crop To Viewport"
    bl_description = "Crop To Viewport..."
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):

        scene = context.scene
        nodes = scene.node_tree.nodes
        cropNode = nodes.active

        if cropNode != None:
            if cropNode.type == 'CROP':
                scene.render.border_min_x = float(cropNode.min_x / scene.render.resolution_x) / (float(scene.render.resolution_percentage) / 100.0)
                scene.render.border_max_x = float(cropNode.max_x / scene.render.resolution_x) / (float(scene.render.resolution_percentage) / 100.0)
                scene.render.border_max_y = float(cropNode.min_y / scene.render.resolution_y) / (float(scene.render.resolution_percentage) / 100.0)
                scene.render.border_min_y = float(cropNode.max_y / scene.render.resolution_y) / (float(scene.render.resolution_percentage) / 100.0)

            elif cropNode.type == 'GROUP':
                cropGroupNode = cropNode.node_tree.nodes.active

                if cropGroupNode != None and cropGroupNode.type == 'CROP':
                    scene.render.border_min_x = float(cropGroupNode.min_x / scene.render.resolution_x) / (float(scene.render.resolution_percentage) / 100.0)
                    scene.render.border_max_x = float(cropGroupNode.max_x / scene.render.resolution_x) / (float(scene.render.resolution_percentage) / 100.0)
                    scene.render.border_max_y = float(cropGroupNode.min_y / scene.render.resolution_y) / (float(scene.render.resolution_percentage) / 100.0)
                    scene.render.border_min_y = float(cropGroupNode.max_y / scene.render.resolution_y) / (float(scene.render.resolution_percentage) / 100.0)
        else:
            self.report({'INFO'}, "Select Crop Node!")

        return {'FINISHED'}


class MFTOutputCreator(bpy.types.Operator):
    bl_idname = "mft.outputcreator"
    bl_label = "Create Output"
    bl_description = "Output Creator"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):

        scene = context.scene
        nodes = scene.node_tree.nodes
        mifthTools = context.scene.mifthTools

        output_file = nodes.new("CompositorNodeOutputFile")
        output_file.base_path = "//" + mifthTools.outputFolder + "/"

        output_file.file_slots.remove(output_file.inputs[0])
        for i in range(mifthTools.outputSequenceSize):
            idx = str(i + 1)
            if i < 9:
                idx = "0" + idx

            outFile = ""
            if mifthTools.doOutputSubFolder is True:
                outFile = mifthTools.outputSubFolder + "_" + idx + "/"
            outFile += mifthTools.outputSequence + "_" + idx + "_"

            output_file.file_slots.new(outFile)

        return {'FINISHED'}


class MFTCurveAnimator(bpy.types.Operator):
    bl_idname = "mft.curveanimator"
    bl_label = "Curve Animator"
    bl_description = "Curve Animator"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):

        mifthTools = context.scene.mifthTools

        startFrame = context.scene.frame_start
        if mifthTools.doUseSceneFrames is False:
            startFrame = mifthTools.curveAniStartFrame

        endFrame = context.scene.frame_end
        if mifthTools.doUseSceneFrames is False:
            endFrame = mifthTools.curveAniEndFrame

        totalFrames = endFrame - startFrame
        frameSteps = mifthTools.curveAniStepFrame - 1

        for curve in context.selected_objects:
            if curve.type == 'CURVE':

                for frStep in range(frameSteps + 1):
                    aniPos = 1.0 - (float(frStep) / float(frameSteps))
                    goToFrame = int(aniPos * float(totalFrames))
                    goToFrame += startFrame
                    context.scene.frame_current = goToFrame
                    print(goToFrame)

                    for spline in curve.data.splines:
                        # print(spline.points)
                        # if len(spline.bezier_points) >= 2:
                        spline.use_bezier_u = False
                        spline.use_endpoint_u = True
                        # spline.use_cyclic_u = False

                        aniInterpolation = mifthTools.curveAniInterpolation

                        allPoints = None
                        if spline.type == 'BEZIER':
                            allPoints = spline.bezier_points
                        else:
                            allPoints = spline.points

                        splineSize = len(allPoints)
                        iInterpolation = aniPos - aniInterpolation

                        for i in range(splineSize):
                            point = allPoints[i]
                            iPlace = float(i + 1) / float(splineSize)

                            if iPlace >= aniPos and goToFrame != endFrame:
                                point.radius = 0.0

                            elif iPlace < aniPos and iPlace > iInterpolation and goToFrame != endFrame and goToFrame != startFrame:
                                additionalInterpolation = 1.0 - \
                                    ((iPlace - iInterpolation)
                                     / aniInterpolation)
                                point.radius *= additionalInterpolation
                                # print(additionalInterpolation)

                            point.keyframe_insert(
                                data_path="radius", frame=goToFrame)

        return {'FINISHED'}


class MFTMorfCreator(bpy.types.Operator):
    bl_idname = "mft.morfcreator"
    bl_label = "Morfing Creator"
    bl_description = "Morfing Creator from different objects"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):

        scene = bpy.context.scene
        mifthTools = scene.mifthTools

        if len(context.selected_objects):
            objAct = context.active_object
            morfIndex = 1

            # print(objAct.data.shape_keys)
            if objAct.data.shape_keys is None:
                basisKey = objAct.shape_key_add(from_mix=False)
                basisKey.name = 'Basis'

            for obj in context.selected_objects:
                if len(context.selected_objects) > 1 and obj == objAct:
                    pass
                else:
                    if len(obj.data.vertices) == len(objAct.data.vertices):
                        shapeKey = objAct.shape_key_add(from_mix=False)

                        if mifthTools.morfCreatorNames != '':
                            shapeKey.name = mifthTools.morfCreatorNames

                            if len(context.selected_objects) > 2:
                                shapeKey.name += "_" + str(morfIndex)

                            morfIndex += 1
                        else:
                            shapeKey.name = obj.name

                        modifiedMesh = obj.data
                        if mifthTools.morfApplyModifiers is True:
                            #modifiedMesh = obj.to_mesh()
                            depsgraph = bpy.context.evaluated_depsgraph_get()
                            object_eval = obj.evaluated_get(depsgraph)
                            modifiedMesh = bpy.data.meshes.new_from_object(object_eval)

                        for vert in modifiedMesh.vertices:
                            if mifthTools.morfUseWorldMatrix:
                                shapeKey.data[vert.index].co = obj.matrix_world @ vert.co
                            else:
                                shapeKey.data[vert.index].co = vert.co
                            # print(vert.co)  # this is a vertex coord of the
                            # mesh
                    else:
                        self.report(
                            {'INFO'}, "Model " + obj.name + " has different points count")

        return {'FINISHED'}


class MFTCopyBonesTransform(bpy.types.Operator):
    bl_idname = "mft.copy_bones_transform"
    bl_label = "Copy Bones Transform"
    bl_description = "Copy Bones Transform"
    bl_options = {'REGISTER', 'UNDO'}

    bones_transform = []
    mode : EnumProperty(
        items=(('Copy', 'Copy', ''),
               ('Paste', 'Paste', '')
               ),
        default = 'Copy'
    )

    def execute(self, context):

        scene = context.scene
        mifthTools = scene.mifthTools
        obj_act = context.active_object
        all_bones = obj_act.data.bones

        sel_bones = context.selected_pose_bones

        if sel_bones:
            if self.mode == 'Copy':
                del self.bones_transform[:]
                for bone in sel_bones:
                    self.bones_transform.append(bone.matrix.copy())
                    #print(bone.matrix)
            elif self.mode == 'Paste':
                for i in range(len(sel_bones)):
                    sel_bones[i].matrix = self.bones_transform[i].copy()
                    #print(self.bones_transform[i])

        return {'FINISHED'}

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2011 OpenERP S.A (<http://www.openerp.com>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from openerp.osv import fields, osv
from openerp.tools.translate import _
import logging
_logger = logging.getLogger(__name__)

UID_ROOT = 1
SHARED_DOCS_MENU = "Documents"
SHARED_DOCS_CHILD_MENU = "Shared Documents"

class share_wizard_portal(osv.TransientModel):
    """Inherited share wizard to automatically create appropriate
       menus in the selected portal upon sharing with a portal group."""
    _inherit = "share.wizard"

    def _user_type_selection(self, cr, uid, context=None):
        selection = super(share_wizard_portal, self)._user_type_selection(cr, uid, context=context)
        selection.extend([('existing',_('Users you already shared with')),
                          ('groups',_('Existing Groups (e.g Portal Groups)'))])
        return selection

    _columns = {
        'user_ids': fields.many2many('res.users', 'share_wizard_res_user_rel', 'share_id', 'user_id', 'Existing users', domain=[('share', '=', True)]),
        'group_ids': fields.many2many('res.groups', 'share_wizard_res_group_rel', 'share_id', 'group_id', 'Existing groups', domain=[('share', '=', False)]),
    }

    def _check_preconditions(self, cr, uid, wizard_data, context=None):
        if wizard_data.user_type == 'existing':
            self._assert(wizard_data.user_ids,
                     _('Please select at least one user to share with'),
                     context=context)
        elif wizard_data.user_type == 'groups':
            self._assert(wizard_data.group_ids,
                     _('Please select at least one group to share with'),
                     context=context)
        return super(share_wizard_portal, self)._check_preconditions(cr, uid, wizard_data, context=context)

    def _create_or_get_submenu_named(self, cr, uid, parent_menu_id, menu_name, context=None):
        if not parent_menu_id:
            return
        Menus = self.pool.get('ir.ui.menu')
        parent_menu = Menus.browse(cr, uid, parent_menu_id) # No context
        menu_id = None
        max_seq = 10
        for child_menu in parent_menu.child_id:
            max_seq = max(max_seq, child_menu.sequence)
            if child_menu.name == menu_name:
                menu_id = child_menu.id
                break
        if not menu_id:
            # not found, create it
            menu_id = Menus.create(cr, UID_ROOT,
                                    {'name': menu_name,
                                     'parent_id': parent_menu.id,
                                     'sequence': max_seq + 10, # at the bottom
                                    })
        return menu_id

    def _sharing_root_menu_id(self, cr, uid, portal, context=None):
        """Create or retrieve root ID of sharing menu in portal menu

           :param portal: browse_record of portal, constructed with a context WITHOUT language
        """
        parent_menu_id = self._create_or_get_submenu_named(cr, uid, portal.parent_menu_id.id, SHARED_DOCS_MENU, context=context)
        if parent_menu_id:
            child_menu_id = self._create_or_get_submenu_named(cr, uid, parent_menu_id, SHARED_DOCS_CHILD_MENU, context=context)
            return child_menu_id

    def _create_shared_data_menu(self, cr, uid, wizard_data, portal, context=None):
        """Create sharing menus in portal menu according to share wizard options.

           :param wizard_data: browse_record of share.wizard
           :param portal: browse_record of portal, constructed with a context WITHOUT language
        """
        root_menu_id = self._sharing_root_menu_id(cr, uid, portal, context=context)
        if not root_menu_id:
            # no specific parent menu, cannot create the sharing menu at all.
            return
        # Create the shared action and menu
        action_def = self._shared_action_def(cr, uid, wizard_data, context=None)
        action_id = self.pool.get('ir.actions.act_window').create(cr, UID_ROOT, action_def)
        menu_data = {'name': action_def['name'],
                     'sequence': 10,
                     'action': 'ir.actions.act_window,'+str(action_id),
                     'parent_id': root_menu_id,
                     'icon': 'STOCK_JUSTIFY_FILL'}
        menu_id =  self.pool.get('ir.ui.menu').create(cr, UID_ROOT, menu_data)
        return menu_id

    def _create_share_users_group(self, cr, uid, wizard_data, context=None):
        # Override of super() to handle the possibly selected "existing users"
        # and "existing groups".
        # In both cases, we call super() to create the share group, but when
        # sharing with existing groups, we will later delete it, and copy its
        # access rights and rules to the selected groups.
        super_result = super(share_wizard_portal,self)._create_share_users_group(cr, uid, wizard_data, context=context)

        # For sharing with existing groups, we don't create a share group, instead we'll
        # alter the rules of the groups so they can see the shared data
        if wizard_data.group_ids:
            # get the list of portals and the related groups to install their menus.
            res_groups = self.pool.get('res.groups')
            all_portal_group_ids = res_groups.search(cr, UID_ROOT, [('is_portal', '=', True)])

            # populate result lines with the users of each group and
            # setup the menu for portal groups
            for group in wizard_data.group_ids:
                if group.id in all_portal_group_ids:
                    self._create_shared_data_menu(cr, uid, wizard_data, group.id, context=context)

                for user in group.users:
                    new_line = {'user_id': user.id,
                                'newly_created': False}
                    wizard_data.write({'result_line_ids': [(0,0,new_line)]})

        elif wizard_data.user_ids:
            # must take care of existing users, by adding them to the new group, which is super_result[0],
            # and adding the shortcut
            selected_user_ids = [x.id for x in wizard_data.user_ids]
            self.pool.get('res.users').write(cr, UID_ROOT, selected_user_ids, {'groups_id': [(4, super_result[0])]})
            self._setup_action_and_shortcut(cr, uid, wizard_data, selected_user_ids, make_home=False, context=context)
            # populate the result lines for existing users too
            for user in wizard_data.user_ids:
                new_line = { 'user_id': user.id,
                             'newly_created': False}
                wizard_data.write({'result_line_ids': [(0,0,new_line)]})

        return super_result

    def copy_share_group_access_and_delete(self, cr, wizard_data, share_group_id, context=None):
        # In the case of sharing with existing groups, the strategy is to copy
        # access rights and rules from the share group, so that we can
        if not wizard_data.group_ids: return
        Groups = self.pool.get('res.groups')
        Rules = self.pool.get('ir.rule')
        Rights = self.pool.get('ir.model.access')
        share_group = Groups.browse(cr, UID_ROOT, share_group_id)
        share_rule_ids = [r.id for r in share_group.rule_groups]
        for target_group in wizard_data.group_ids:
            # Link the rules to the group. This is appropriate because as of
            # v6.1, the algorithm for combining them will OR the rules, hence
            # extending the visible data.
            Rules.write(cr, UID_ROOT, share_rule_ids, {'groups': [(4,target_group.id)]})
            _logger.debug("Linked sharing rules from temporary sharing group to group %s", target_group)

            # Copy the access rights. This is appropriate too because
            # groups have the UNION of all permissions granted by their
            # access right lines.
            for access_line in share_group.model_access:
                Rights.copy(cr, UID_ROOT, access_line.id, default={'group_id': target_group.id})
            _logger.debug("Copied access rights from temporary sharing group to group %s", target_group)

        # finally, delete it after removing its users
        Groups.write(cr, UID_ROOT, [share_group_id], {'users': [(6,0,[])]})
        Groups.unlink(cr, UID_ROOT, [share_group_id])
        _logger.debug("Deleted temporary sharing group %s", share_group_id)

    def _finish_result_lines(self, cr, uid, wizard_data, share_group_id, context=None):
        super(share_wizard_portal,self)._finish_result_lines(cr, uid, wizard_data, share_group_id, context=context)
        self.copy_share_group_access_and_delete(cr, wizard_data, share_group_id, context=context)



# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

# -*- coding: utf-8 -*-

import collections
from typing import (
    Tuple,
    List,
    Sequence,
    Any,
    Dict,
    Union)


__all__ = [
    'RouteError',
    'Routes',
    'RouteResolved']

# This is a nested structure similar to a linked-list
VariablePartsType = Tuple[tuple, Tuple[str, str]]


class RouteError(Exception):
    """Base error for any exception raised by Kua"""


def depth_of(parts: Sequence[str]) -> int:
    """
    Calculate the depth of URL parts

    :param parts: A list of URL parts
    :return: Depth of the list

    :private:
    """
    return len(parts) - 1


def normalize_url(url: str) -> str:
    """
    Remove leading and trailing slashes from a URL

    :param url: URL
    :return: URL with no leading and trailing slashes

    :private:
    """
    if url.startswith('/'):
        url = url[1:]

    if url.endswith('/'):
        url = url[:-1]

    return url


def _unwrap(variable_parts: VariablePartsType):
    """
    Yield URL parts. The given parts are usually in reverse order.
    """
    curr_parts = variable_parts
    var_any = []

    while curr_parts:
        curr_parts, (var_type, part) = curr_parts

        if var_type == Routes._VAR_ANY_NODE:
            var_any.append(part)
            continue

        if var_type == Routes._VAR_ANY_BREAK:
            if var_any:
                yield tuple(reversed(var_any))
                var_any.clear()

            var_any.append(part)
            continue

        if var_any:
            yield tuple(reversed(var_any))
            var_any.clear()
            yield part
            continue

        yield part

    if var_any:
        yield tuple(reversed(var_any))


def make_params(
        key_parts: Sequence[str],
        variable_parts: VariablePartsType) -> Dict[str, Union[str, Tuple[str]]]:
    """
    Map keys to variables. This map\
    URL-pattern variables to\
    a URL related parts

    :param key_parts: A list of URL parts
    :param variable_parts: A linked-list\
    (ala nested tuples) of URL parts
    :return: The param dict with the values\
    assigned to the keys

    :private:
    """
    # The unwrapped variable parts are in reverse order.
    # Instead of reversing those we reverse the key parts
    # and avoid the O(n) space required for reversing the vars
    return dict(zip(reversed(key_parts), _unwrap(variable_parts)))


_Route = collections.namedtuple(
    '_Route',
    ['key_parts', 'anything'])


RouteResolved = collections.namedtuple(
    'RouteResolved',
    ['params', 'anything'])
RouteResolved.__doc__ = (
    """
    Resolved route

    :param dict params: Pattern variables\
    to URL parts
    :param object anything: Literally anything.\
    This is attached to the URL pattern when\
    registering it
    """)


class Routes:
    """
    Route URLs to registered URL patterns.

    Thread safety: adding routes is not thread-safe,\
    it should be done on import time, everything else is.

    URL matcher supports ``:var`` for matching dynamic\
    path parts and ``:*var`` for matching one or more parts.

    Path parts are matched in the following order: ``static > var > any-var``.

    Usage::

        routes = kua.Routes()
        routes.add('api/:foo', {'GET': my_get_controller})
        route = routes.match('api/hello-world')
        route.params
        # {'foo': 'hello-world'}
        route.anything
        # {'GET': my_get_controller}

        # Matching any path
        routes.add('assets/:*foo', {})
        route = routes.match('assets/user/profile/avatar.jpg')
        route.params
        # {'foo': ('user', 'profile', 'avatar.jpg')}

        # Error handling
        try:
            route = routes.match('bad-url/some')
        except kua.RouteError:
            raise ValueError('Not found 404')
        else:
            # Do something useful here
            pass

    :ivar max_depth: The maximum URL depth\
    (number of parts) willing to match. This only\
    takes effect when one or more URLs matcher\
    make use of any-var (i.e: ``:*var``), otherwise the\
    depth of the deepest URL is taken.
    """

    _VAR_NODE = ':var'
    _VAR_ANY_NODE = ':*var'
    _ROUTE_NODE = ':route'

    _VAR_ANY_BREAK = ':*break'

    def __init__(self, max_depth: int=40) -> None:
        """
        :ivar _routes: \
        Contain a graph with the parts of\
        each URL pattern. This is referred as\
        "partial route" later in the docs.
        :vartype _routes: dict
        :ivar _max_depth: Depth of the deepest\
        registered pattern
        :vartype _max_depth: int

        :private-vars:
        """
        self._max_depth_custom = max_depth
        # Routes graph format for 'foo/:foobar/bar':
        # {
        #   'foo': {
        #       ':var': {
        #           'bar': {
        #               ':route': _Route(),
        #               ...
        #           },
        #           ...
        #        }
        #        ...
        #   },
        #   ...
        # }
        self._routes = {}
        self._max_depth = 0

    def _deconstruct_url(self, url: str) -> List[str]:
        """
        Split a regular URL into parts

        :param url: A normalized URL
        :return: Parts of the URL
        :raises kua.routes.RouteError: \
        If the depth of the URL exceeds\
        the max depth of the deepest\
        registered pattern

        :private:
        """
        parts = url.split('/', self._max_depth + 1)

        if depth_of(parts) > self._max_depth:
            raise RouteError('No match')

        return parts

    def _match(self, parts: Sequence[str]) -> RouteResolved:
        """
        Match URL parts to a registered pattern.

        This function is basically where all\
        the CPU-heavy work is done.

        :param parts: URL parts
        :return: Matched route
        :raises kua.routes.RouteError: If there is no match

        :private:
        """
        route_match = None  # type: RouteResolved
        route_variable_parts = tuple()  # type: VariablePartsType
        # (route_partial, variable_parts, depth)
        to_visit = [(self._routes, tuple(), 0)]  # type: List[Tuple[dict, tuple, int]]

        # Walk through the graph,
        # keep track of all possible
        # matching branches and do
        # backtracking if needed
        while to_visit:
            curr, curr_variable_parts, depth = to_visit.pop()

            try:
                part = parts[depth]
            except IndexError:
                if self._ROUTE_NODE in curr:
                    route_match = curr[self._ROUTE_NODE]
                    route_variable_parts = curr_variable_parts
                    break
                else:
                    continue

            if self._VAR_ANY_NODE in curr:
                to_visit.append((
                    {self._VAR_ANY_NODE: curr[self._VAR_ANY_NODE]},
                    (curr_variable_parts,
                     (self._VAR_ANY_NODE, part)),
                    depth + 1))
                to_visit.append((
                    curr[self._VAR_ANY_NODE],
                    (curr_variable_parts,
                     (self._VAR_ANY_BREAK, part)),
                    depth + 1))

            if self._VAR_NODE in curr:
                to_visit.append((
                    curr[self._VAR_NODE],
                    (curr_variable_parts,
                     (self._VAR_NODE, part)),
                    depth + 1))

            if part in curr:
                to_visit.append((
                    curr[part],
                    curr_variable_parts,
                    depth + 1))

        if not route_match:
            raise RouteError('No match')

        return RouteResolved(
            params=make_params(
                key_parts=route_match.key_parts,
                variable_parts=route_variable_parts),
            anything=route_match.anything)

    def match(self, url: str) -> RouteResolved:
        """
        Match a URL to a registered pattern.

        :param url: URL
        :return: Matched route
        :raises kua.RouteError: If there is no match
        """
        url = normalize_url(url)
        parts = self._deconstruct_url(url)
        return self._match(parts)

    def add(self, url: str, anything: Any) -> None:
        """
        Register a URL pattern into\
        the routes for later matching.

        It's possible to attach any kind of\
        object to the pattern for later\
        retrieving. A dict with methods and callbacks,\
        for example. Anything really.

        Registration order does not matter.\
        Adding a URL first or last makes no difference.

        :param url: URL
        :param anything: Literally anything.
        """
        url = normalize_url(url)
        parts = url.split('/')
        curr_partial_routes = self._routes
        curr_key_parts = []

        for part in parts:
            if part.startswith(':*'):
                curr_key_parts.append(part[2:])
                part = self._VAR_ANY_NODE
                self._max_depth = self._max_depth_custom

            elif part.startswith(':'):
                curr_key_parts.append(part[1:])
                part = self._VAR_NODE

            curr_partial_routes = (curr_partial_routes
                                   .setdefault(part, {}))

        curr_partial_routes[self._ROUTE_NODE] = _Route(
            key_parts=curr_key_parts,
            anything=anything)

        self._max_depth = max(self._max_depth, depth_of(parts))

from __future__ import unicode_literals

import re

from .subtitles import SubtitlesInfoExtractor
from ..utils import (
    parse_duration,
    unified_strdate,
    compat_urllib_parse,
)


class RaiIE(SubtitlesInfoExtractor):
    _VALID_URL = r'(?P<url>http://(?:.+?\.)?(?:rai\.it|rai\.tv|rainews\.it)/dl/.+?-(?P<id>[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12})(?:-.+?)?\.html)'
    _TESTS = [
        {
            'url': 'http://www.rai.tv/dl/RaiTV/programmi/media/ContentItem-cb27157f-9dd0-4aee-b788-b1f67643a391.html',
            'md5': 'c064c0b2d09c278fb293116ef5d0a32d',
            'info_dict': {
                'id': 'cb27157f-9dd0-4aee-b788-b1f67643a391',
                'ext': 'mp4',
                'title': 'Report del 07/04/2014',
                'description': 'md5:f27c544694cacb46a078db84ec35d2d9',
                'upload_date': '20140407',
                'duration': 6160,
            }
        },
        {
            'url': 'http://www.raisport.rai.it/dl/raiSport/media/rassegna-stampa-04a9f4bd-b563-40cf-82a6-aad3529cb4a9.html',
            'md5': '8bb9c151924ce241b74dd52ef29ceafa',
            'info_dict': {
                'id': '04a9f4bd-b563-40cf-82a6-aad3529cb4a9',
                'ext': 'mp4',
                'title': 'TG PRIMO TEMPO',
                'description': '',
                'upload_date': '20140612',
                'duration': 1758,
            },
            'skip': 'Error 404',
        },
        {
            'url': 'http://www.rainews.it/dl/rainews/media/state-of-the-net-Antonella-La-Carpia-regole-virali-7aafdea9-0e5d-49d5-88a6-7e65da67ae13.html',
            'md5': '35cf7c229f22eeef43e48b5cf923bef0',
            'info_dict': {
                'id': '7aafdea9-0e5d-49d5-88a6-7e65da67ae13',
                'ext': 'mp4',
                'title': 'State of the Net, Antonella La Carpia: regole virali',
                'description': 'md5:b0ba04a324126903e3da7763272ae63c',
                'upload_date': '20140613',
            },
            'skip': 'Error 404',
        },
        {
            'url': 'http://www.rai.tv/dl/RaiTV/programmi/media/ContentItem-b4a49761-e0cc-4b14-8736-2729f6f73132-tg2.html',
            'md5': '35694f062977fe6619943f08ed935730',
            'info_dict': {
                'id': 'b4a49761-e0cc-4b14-8736-2729f6f73132',
                'ext': 'mp4',
                'title': 'Alluvione in Sardegna e dissesto idrogeologico',
                'description': 'Edizione delle ore 20:30 ',
            }
        },
    ]

    def _real_extract(self, url):
        mobj = re.match(self._VALID_URL, url)
        video_id = mobj.group('id')

        media = self._download_json('%s?json' % mobj.group('url'), video_id, 'Downloading video JSON')

        title = media.get('name')
        description = media.get('desc')
        thumbnail = media.get('image_300') or media.get('image_medium') or media.get('image')
        duration = parse_duration(media.get('length'))
        uploader = media.get('author')
        upload_date = unified_strdate(media.get('date'))

        formats = []

        for format_id in ['wmv', 'm3u8', 'mediaUri', 'h264']:
            media_url = media.get(format_id)
            if not media_url:
                continue
            formats.append({
                'url': media_url,
                'format_id': format_id,
                'ext': 'mp4',
            })

        if self._downloader.params.get('listsubtitles', False):
            page = self._download_webpage(url, video_id)
            self._list_available_subtitles(video_id, page)
            return

        subtitles = {}
        if self._have_to_download_any_subtitles:
            page = self._download_webpage(url, video_id)
            subtitles = self.extract_subtitles(video_id, page)

        return {
            'id': video_id,
            'title': title,
            'description': description,
            'thumbnail': thumbnail,
            'uploader': uploader,
            'upload_date': upload_date,
            'duration': duration,
            'formats': formats,
            'subtitles': subtitles,
        }

    def _get_available_subtitles(self, video_id, webpage):
        subtitles = {}
        m = re.search(r'<meta name="closedcaption" content="(?P<captions>[^"]+)"', webpage)
        if m:
            captions = m.group('captions')
            STL_EXT = '.stl'
            SRT_EXT = '.srt'
            if captions.endswith(STL_EXT):
                captions = captions[:-len(STL_EXT)] + SRT_EXT
            subtitles['it'] = 'http://www.rai.tv%s' % compat_urllib_parse.quote(captions)
        return subtitles
# encoding: utf-8
"""
attributes.py

Created by Thomas Mangin on 2015-03-31.
Copyright (c) 2009-2015 Exa Networks. All rights reserved.
"""

from struct import pack
from struct import unpack
from struct import calcsize
from exabgp.netlink import NetLinkError


class AttributesError (NetLinkError):
	pass


class Attributes (object):
	class Header (object):
		PACK = 'HH'
		LEN = calcsize(PACK)

	class Type (object):
		IFA_UNSPEC     = 0x00
		IFA_ADDRESS    = 0x01
		IFA_LOCAL      = 0x02
		IFA_LABEL      = 0x03
		IFA_BROADCAST  = 0x04
		IFA_ANYCAST    = 0x05
		IFA_CACHEINFO  = 0x06
		IFA_MULTICAST  = 0x07

	@classmethod
	def decode (cls, data):
		while data:
			length, atype, = unpack(cls.Header.PACK,data[:cls.Header.LEN])
			if len(data) < length:
				raise AttributesError("Buffer underrun %d < %d" % (len(data),length))
			payload = data[cls.Header.LEN:length]
			yield atype, payload
			data = data[int((length + 3) / 4) * 4:]

	@classmethod
	def encode (cls, attributes):
		def _encode (atype, payload):
			def pad (length, to=4):
				return (length+to-1) & ~(to-1)
			length = cls.Header.LEN + len(payload)
			raw = pack(cls.Header.PACK,length,atype) + payload
			pad = pad(length) - len(raw)
			if pad:
				raw += '\0'*pad
			return raw

		return ''.join([_encode(k,v) for (k,v) in attributes.items()])

# Copyright 2010 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# Copyright 2011 Justin Santa Barbara
# Copyright 2014 Red Hat, Inc.
# All Rights Reserved.
#
#    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.

"""Utilities related to SSH connection management."""

import os
import string

from eventlet import pools
from oslo_config import cfg
from oslo_log import log as logging
import paramiko
import six

from cinder import exception
from cinder.i18n import _, _LI

LOG = logging.getLogger(__name__)

ssh_opts = [
    cfg.BoolOpt('strict_ssh_host_key_policy',
                default=False,
                help='Option to enable strict host key checking.  When '
                     'set to "True" Cinder will only connect to systems '
                     'with a host key present in the configured '
                     '"ssh_hosts_key_file".  When set to "False" the host key '
                     'will be saved upon first connection and used for '
                     'subsequent connections.  Default=False'),
    cfg.StrOpt('ssh_hosts_key_file',
               default='$state_path/ssh_known_hosts',
               help='File containing SSH host keys for the systems with which '
                    'Cinder needs to communicate.  OPTIONAL: '
                    'Default=$state_path/ssh_known_hosts'),
]

CONF = cfg.CONF
CONF.register_opts(ssh_opts)


class SSHPool(pools.Pool):
    """A simple eventlet pool to hold ssh connections."""

    def __init__(self, ip, port, conn_timeout, login, password=None,
                 privatekey=None, *args, **kwargs):
        self.ip = ip
        self.port = port
        self.login = login
        self.password = password
        self.conn_timeout = conn_timeout if conn_timeout else None
        self.privatekey = privatekey
        self.hosts_key_file = None

        # Validate good config setting here.
        # Paramiko handles the case where the file is inaccessible.
        if not CONF.ssh_hosts_key_file:
            raise exception.ParameterNotFound(param='ssh_hosts_key_file')
        elif not os.path.isfile(CONF.ssh_hosts_key_file):
            # If using the default path, just create the file.
            if CONF.state_path in CONF.ssh_hosts_key_file:
                open(CONF.ssh_hosts_key_file, 'a').close()
            else:
                msg = (_("Unable to find ssh_hosts_key_file: %s") %
                       CONF.ssh_hosts_key_file)
                raise exception.InvalidInput(reason=msg)

        if 'hosts_key_file' in kwargs.keys():
            self.hosts_key_file = kwargs.pop('hosts_key_file')
            LOG.info(_LI("Secondary ssh hosts key file %(kwargs)s will be "
                         "loaded along with %(conf)s from /etc/cinder.conf."),
                     {'kwargs': self.hosts_key_file,
                      'conf': CONF.ssh_hosts_key_file})

        LOG.debug("Setting strict_ssh_host_key_policy to '%(policy)s' "
                  "using ssh_hosts_key_file '%(key_file)s'.",
                  {'policy': CONF.strict_ssh_host_key_policy,
                   'key_file': CONF.ssh_hosts_key_file})

        self.strict_ssh_host_key_policy = CONF.strict_ssh_host_key_policy

        if not self.hosts_key_file:
            self.hosts_key_file = CONF.ssh_hosts_key_file
        else:
            self.hosts_key_file += ',' + CONF.ssh_hosts_key_file

        super(SSHPool, self).__init__(*args, **kwargs)

    def create(self):
        try:
            ssh = paramiko.SSHClient()
            if ',' in self.hosts_key_file:
                files = string.split(self.hosts_key_file, ',')
                for f in files:
                    ssh.load_host_keys(f)
            else:
                ssh.load_host_keys(self.hosts_key_file)
            # If strict_ssh_host_key_policy is set we want to reject, by
            # default if there is not entry in the known_hosts file.
            # Otherwise we use AutoAddPolicy which accepts on the first
            # Connect but fails if the keys change.  load_host_keys can
            # handle hashed known_host entries.
            if self.strict_ssh_host_key_policy:
                ssh.set_missing_host_key_policy(paramiko.RejectPolicy())
            else:
                ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

            if self.password:
                ssh.connect(self.ip,
                            port=self.port,
                            username=self.login,
                            password=self.password,
                            timeout=self.conn_timeout)
            elif self.privatekey:
                pkfile = os.path.expanduser(self.privatekey)
                privatekey = paramiko.RSAKey.from_private_key_file(pkfile)
                ssh.connect(self.ip,
                            port=self.port,
                            username=self.login,
                            pkey=privatekey,
                            timeout=self.conn_timeout)
            else:
                msg = _("Specify a password or private_key")
                raise exception.CinderException(msg)

            # Paramiko by default sets the socket timeout to 0.1 seconds,
            # ignoring what we set through the sshclient. This doesn't help for
            # keeping long lived connections. Hence we have to bypass it, by
            # overriding it after the transport is initialized. We are setting
            # the sockettimeout to None and setting a keepalive packet so that,
            # the server will keep the connection open. All that does is send
            # a keepalive packet every ssh_conn_timeout seconds.
            if self.conn_timeout:
                transport = ssh.get_transport()
                transport.sock.settimeout(None)
                transport.set_keepalive(self.conn_timeout)
            return ssh
        except Exception as e:
            msg = _("Error connecting via ssh: %s") % six.text_type(e)
            LOG.error(msg)
            raise paramiko.SSHException(msg)

    def get(self):
        """Return an item from the pool, when one is available.

        This may cause the calling greenthread to block. Check if a
        connection is active before returning it.

        For dead connections create and return a new connection.
        """
        conn = super(SSHPool, self).get()
        if conn:
            if conn.get_transport().is_active():
                return conn
            else:
                conn.close()
        return self.create()

    def remove(self, ssh):
        """Close an ssh client and remove it from free_items."""
        ssh.close()
        ssh = None
        if ssh in self.free_items:
            self.free_items.pop(ssh)
        if self.current_size > 0:
            self.current_size -= 1

#!/usr/bin/env python

# Renders a video.
# To generate a 360 panoramic video:
# blender -b photo_360.blend --python odm_video.py -- <project-path> <camera-waypoints.xyz> <number-of-frames>

import sys
import subprocess
import os
import bpy
from common import loadMesh


def main():

    if len(sys.argv) < 7 or sys.argv[-4] != '--':
        sys.exit('Please provide the ODM project path, camera waypoints (xyz format), and number of frames.')

    projectHome = sys.argv[-3]
    waypointFile = sys.argv[-2]
    numFrames = int(sys.argv[-1])

    loadMesh(projectHome +
             '/odm_texturing/odm_textured_model_geo.obj')

    waypoints = loadWaypoints(waypointFile)
    numWaypoints = len(waypoints)

    scene = bpy.data.scenes['Scene']

    # create path thru waypoints
    curve = bpy.data.curves.new(name='CameraPath', type='CURVE')
    curve.dimensions = '3D'
    curve.twist_mode = 'Z_UP'
    nurbs = curve.splines.new('NURBS')
    nurbs.points.add(numWaypoints-1)
    weight = 1
    for i in range(numWaypoints):
       nurbs.points[i].co[0] = waypoints[i][0]
       nurbs.points[i].co[1] = waypoints[i][1]
       nurbs.points[i].co[2] = waypoints[i][2]
       nurbs.points[i].co[3] = weight
    nurbs.use_endpoint_u = True
    path = bpy.data.objects.new(name='CameraPath', object_data=curve)
    scene.objects.link(path)

    camera = bpy.data.objects['Camera']
    camera.location[0] = 0
    camera.location[1] = 0
    camera.location[2] = 0
    followPath = camera.constraints.new(type='FOLLOW_PATH')
    followPath.name = 'CameraFollowPath'
    followPath.target = path
    followPath.use_curve_follow = True
    animateContext = bpy.context.copy()
    animateContext['constraint'] = followPath
    bpy.ops.constraint.followpath_path_animate(animateContext,
                                               constraint='CameraFollowPath',
                                               frame_start=0,
                                               length=numFrames)

    blendName = bpy.path.display_name_from_filepath(bpy.data.filepath)
    fileName = projectHome + '/odm_video/odm_' + blendName.replace('photo', 'video')
    scene.frame_start = 0
    scene.frame_end = numFrames
    render = scene.render
    render.filepath = fileName + '.mp4'
    render.image_settings.file_format = 'FFMPEG'
    if(render.use_multiview):
        render.image_settings.stereo_3d_format.display_mode = 'TOPBOTTOM'
        render.image_settings.views_format = 'STEREO_3D'
        render.views[0].file_suffix = ''
        format3d = 'top-bottom'
    else:
        width = render.resolution_x
        height = render.resolution_y
        format3d = 'none'
    render.resolution_x = 4096
    render.resolution_y = 2048

    render.ffmpeg.audio_codec = 'AAC'
    render.ffmpeg.codec = 'H264'
    render.ffmpeg.format = 'MPEG4'
    render.ffmpeg.video_bitrate = 45000
    bpy.ops.render.render(animation=True)

    writeMetadata(fileName+'.mp4', format3d)


def loadWaypoints(filename):
    waypoints = []
    with open(filename) as f:
        for line in f:
           xyz = line.split()
           waypoints.append((float(xyz[0]), float(xyz[1]), float(xyz[2])))
    return waypoints


def writeMetadata(filename, format3d):
    subprocess.run(['python',
                    'spatialmedia',
                    '-i',
                    '--stereo='+format3d,
                    filename,
                    filename+'.injected'])
    # check metadata injector was succesful
    if os.path.exists(filename+'.injected'):
        os.remove(filename)
        os.rename(filename+'.injected', filename)


if __name__ == '__main__':
    main()

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for tf.bitcast."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import numpy as np

from tensorflow.python.framework import dtypes
from tensorflow.python.ops import array_ops
from tensorflow.python.platform import test


class BitcastTest(test.TestCase):

  def _testBitcast(self, x, datatype, shape):
    with self.test_session(use_gpu=True):
      tf_ans = array_ops.bitcast(x, datatype)
      out = tf_ans.eval()
      buff_after = memoryview(out).tobytes()
      buff_before = memoryview(x).tobytes()
      self.assertEqual(buff_before, buff_after)
      self.assertEqual(tf_ans.get_shape(), shape)
      self.assertEqual(tf_ans.dtype, datatype)

  def testSmaller(self):
    x = np.random.rand(3, 2)
    datatype = dtypes.int8
    shape = [3, 2, 8]
    self._testBitcast(x, datatype, shape)

  def testLarger(self):
    x = np.arange(16, dtype=np.int8).reshape([4, 4])
    datatype = dtypes.int32
    shape = [4]
    self._testBitcast(x, datatype, shape)

  def testSameDtype(self):
    x = np.random.rand(3, 4)
    shape = [3, 4]
    self._testBitcast(x, x.dtype, shape)

  def testSameSize(self):
    x = np.random.rand(3, 4)
    shape = [3, 4]
    self._testBitcast(x, dtypes.int64, shape)

  def testErrors(self):
    x = np.zeros([1, 1], np.int8)
    datatype = dtypes.int32
    with self.assertRaisesRegexp(ValueError, "Cannot bitcast due to shape"):
      array_ops.bitcast(x, datatype, None)

  def testEmpty(self):
    x = np.ones([], np.int32)
    datatype = dtypes.int8
    shape = [4]
    self._testBitcast(x, datatype, shape)

  def testUnknown(self):
    x = array_ops.placeholder(dtypes.float32)
    datatype = dtypes.int8
    array_ops.bitcast(x, datatype, None)

  def testQuantizeType(self):
    shape = [3, 4]
    x = np.zeros(shape, np.uint16)
    datatype = dtypes.quint16
    self._testBitcast(x, datatype, shape)


if __name__ == "__main__":
  test.main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# winapi.py: Windows API-Python interface (removes dependency on pywin32)
#
# Copyright (C) 2007 Thomas Heller <theller@ctypes.org>
# Copyright (C) 2010 Will McGugan <will@willmcgugan.com>
# Copyright (C) 2010 Ryan Kelly <ryan@rfk.id.au>
# Copyright (C) 2010 Yesudeep Mangalapilly <yesudeep@gmail.com>
# Copyright (C) 2014 Thomas Amland
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and / or other materials provided with the distribution.
# * Neither the name of the organization nor the names of its contributors may
#   be used to endorse or promote products derived from this software without
#   specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# Portions of this code were taken from pyfilesystem, which uses the above
# new BSD license.

from __future__ import with_statement

import ctypes.wintypes
import struct
from functools import reduce

try:
    LPVOID = ctypes.wintypes.LPVOID
except AttributeError:
    # LPVOID wasn't defined in Py2.5, guess it was introduced in Py2.6
    LPVOID = ctypes.c_void_p

# Invalid handle value.
INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value

# File notification contants.
FILE_NOTIFY_CHANGE_FILE_NAME = 0x01
FILE_NOTIFY_CHANGE_DIR_NAME = 0x02
FILE_NOTIFY_CHANGE_ATTRIBUTES = 0x04
FILE_NOTIFY_CHANGE_SIZE = 0x08
FILE_NOTIFY_CHANGE_LAST_WRITE = 0x010
FILE_NOTIFY_CHANGE_LAST_ACCESS = 0x020
FILE_NOTIFY_CHANGE_CREATION = 0x040
FILE_NOTIFY_CHANGE_SECURITY = 0x0100

FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
FILE_FLAG_OVERLAPPED = 0x40000000
FILE_LIST_DIRECTORY = 0x01
FILE_SHARE_READ = 0x01
FILE_SHARE_WRITE = 0x02
FILE_SHARE_DELETE = 0x04
OPEN_EXISTING = 3

# File action constants.
FILE_ACTION_CREATED = 1
FILE_ACTION_DELETED = 2
FILE_ACTION_MODIFIED = 3
FILE_ACTION_RENAMED_OLD_NAME = 4
FILE_ACTION_RENAMED_NEW_NAME = 5
FILE_ACTION_OVERFLOW = 0xFFFF

# Aliases
FILE_ACTION_ADDED = FILE_ACTION_CREATED
FILE_ACTION_REMOVED = FILE_ACTION_DELETED

THREAD_TERMINATE = 0x0001

# IO waiting constants.
WAIT_ABANDONED = 0x00000080
WAIT_IO_COMPLETION = 0x000000C0
WAIT_OBJECT_0 = 0x00000000
WAIT_TIMEOUT = 0x00000102

# Error codes
ERROR_OPERATION_ABORTED = 995


class OVERLAPPED(ctypes.Structure):
    _fields_ = [('Internal', LPVOID),
                ('InternalHigh', LPVOID),
                ('Offset', ctypes.wintypes.DWORD),
                ('OffsetHigh', ctypes.wintypes.DWORD),
                ('Pointer', LPVOID),
                ('hEvent', ctypes.wintypes.HANDLE),
                ]


def _errcheck_bool(value, func, args):
    if not value:
        raise ctypes.WinError()
    return args


def _errcheck_handle(value, func, args):
    if not value:
        raise ctypes.WinError()
    if value == INVALID_HANDLE_VALUE:
        raise ctypes.WinError()
    return args


def _errcheck_dword(value, func, args):
    if value == 0xFFFFFFFF:
        raise ctypes.WinError()
    return args


ReadDirectoryChangesW = ctypes.windll.kernel32.ReadDirectoryChangesW
ReadDirectoryChangesW.restype = ctypes.wintypes.BOOL
ReadDirectoryChangesW.errcheck = _errcheck_bool
ReadDirectoryChangesW.argtypes = (
    ctypes.wintypes.HANDLE,  # hDirectory
    LPVOID,  # lpBuffer
    ctypes.wintypes.DWORD,  # nBufferLength
    ctypes.wintypes.BOOL,  # bWatchSubtree
    ctypes.wintypes.DWORD,  # dwNotifyFilter
    ctypes.POINTER(ctypes.wintypes.DWORD),  # lpBytesReturned
    ctypes.POINTER(OVERLAPPED),  # lpOverlapped
    LPVOID  # FileIOCompletionRoutine # lpCompletionRoutine
)

CreateFileW = ctypes.windll.kernel32.CreateFileW
CreateFileW.restype = ctypes.wintypes.HANDLE
CreateFileW.errcheck = _errcheck_handle
CreateFileW.argtypes = (
    ctypes.wintypes.LPCWSTR,  # lpFileName
    ctypes.wintypes.DWORD,  # dwDesiredAccess
    ctypes.wintypes.DWORD,  # dwShareMode
    LPVOID,  # lpSecurityAttributes
    ctypes.wintypes.DWORD,  # dwCreationDisposition
    ctypes.wintypes.DWORD,  # dwFlagsAndAttributes
    ctypes.wintypes.HANDLE  # hTemplateFile
)

CloseHandle = ctypes.windll.kernel32.CloseHandle
CloseHandle.restype = ctypes.wintypes.BOOL
CloseHandle.argtypes = (
    ctypes.wintypes.HANDLE,  # hObject
)

CancelIoEx = ctypes.windll.kernel32.CancelIoEx
CancelIoEx.restype = ctypes.wintypes.BOOL
CancelIoEx.errcheck = _errcheck_bool
CancelIoEx.argtypes = (
    ctypes.wintypes.HANDLE,  # hObject
    ctypes.POINTER(OVERLAPPED)  # lpOverlapped
)

CreateEvent = ctypes.windll.kernel32.CreateEventW
CreateEvent.restype = ctypes.wintypes.HANDLE
CreateEvent.errcheck = _errcheck_handle
CreateEvent.argtypes = (
    LPVOID,  # lpEventAttributes
    ctypes.wintypes.BOOL,  # bManualReset
    ctypes.wintypes.BOOL,  # bInitialState
    ctypes.wintypes.LPCWSTR,  # lpName
)

SetEvent = ctypes.windll.kernel32.SetEvent
SetEvent.restype = ctypes.wintypes.BOOL
SetEvent.errcheck = _errcheck_bool
SetEvent.argtypes = (
    ctypes.wintypes.HANDLE,  # hEvent
)

WaitForSingleObjectEx = ctypes.windll.kernel32.WaitForSingleObjectEx
WaitForSingleObjectEx.restype = ctypes.wintypes.DWORD
WaitForSingleObjectEx.errcheck = _errcheck_dword
WaitForSingleObjectEx.argtypes = (
    ctypes.wintypes.HANDLE,  # hObject
    ctypes.wintypes.DWORD,  # dwMilliseconds
    ctypes.wintypes.BOOL,  # bAlertable
)

CreateIoCompletionPort = ctypes.windll.kernel32.CreateIoCompletionPort
CreateIoCompletionPort.restype = ctypes.wintypes.HANDLE
CreateIoCompletionPort.errcheck = _errcheck_handle
CreateIoCompletionPort.argtypes = (
    ctypes.wintypes.HANDLE,  # FileHandle
    ctypes.wintypes.HANDLE,  # ExistingCompletionPort
    LPVOID,  # CompletionKey
    ctypes.wintypes.DWORD,  # NumberOfConcurrentThreads
)

GetQueuedCompletionStatus = ctypes.windll.kernel32.GetQueuedCompletionStatus
GetQueuedCompletionStatus.restype = ctypes.wintypes.BOOL
GetQueuedCompletionStatus.errcheck = _errcheck_bool
GetQueuedCompletionStatus.argtypes = (
    ctypes.wintypes.HANDLE,  # CompletionPort
    LPVOID,  # lpNumberOfBytesTransferred
    LPVOID,  # lpCompletionKey
    ctypes.POINTER(OVERLAPPED),  # lpOverlapped
    ctypes.wintypes.DWORD,  # dwMilliseconds
)

PostQueuedCompletionStatus = ctypes.windll.kernel32.PostQueuedCompletionStatus
PostQueuedCompletionStatus.restype = ctypes.wintypes.BOOL
PostQueuedCompletionStatus.errcheck = _errcheck_bool
PostQueuedCompletionStatus.argtypes = (
    ctypes.wintypes.HANDLE,  # CompletionPort
    ctypes.wintypes.DWORD,  # lpNumberOfBytesTransferred
    ctypes.wintypes.DWORD,  # lpCompletionKey
    ctypes.POINTER(OVERLAPPED),  # lpOverlapped
)


class FILE_NOTIFY_INFORMATION(ctypes.Structure):
    _fields_ = [("NextEntryOffset", ctypes.wintypes.DWORD),
                ("Action", ctypes.wintypes.DWORD),
                ("FileNameLength", ctypes.wintypes.DWORD),
                #("FileName", (ctypes.wintypes.WCHAR * 1))]
                ("FileName", (ctypes.c_char * 1))]

LPFNI = ctypes.POINTER(FILE_NOTIFY_INFORMATION)


# We don't need to recalculate these flags every time a call is made to
# the win32 API functions.
WATCHDOG_FILE_FLAGS = FILE_FLAG_BACKUP_SEMANTICS
WATCHDOG_FILE_SHARE_FLAGS = reduce(
    lambda x, y: x | y, [
        FILE_SHARE_READ,
        FILE_SHARE_WRITE,
        FILE_SHARE_DELETE,
    ])
WATCHDOG_FILE_NOTIFY_FLAGS = reduce(
    lambda x, y: x | y, [
        FILE_NOTIFY_CHANGE_FILE_NAME,
        FILE_NOTIFY_CHANGE_DIR_NAME,
        FILE_NOTIFY_CHANGE_ATTRIBUTES,
        FILE_NOTIFY_CHANGE_SIZE,
        FILE_NOTIFY_CHANGE_LAST_WRITE,
        FILE_NOTIFY_CHANGE_SECURITY,
        FILE_NOTIFY_CHANGE_LAST_ACCESS,
        FILE_NOTIFY_CHANGE_CREATION,
    ])

BUFFER_SIZE = 2048

    
def _parse_event_buffer(readBuffer, nBytes):
    results = []
    while nBytes > 0:
        fni = ctypes.cast(readBuffer, LPFNI)[0]
        ptr = ctypes.addressof(fni) + FILE_NOTIFY_INFORMATION.FileName.offset
        #filename = ctypes.wstring_at(ptr, fni.FileNameLength)
        filename = ctypes.string_at(ptr, fni.FileNameLength)
        results.append((fni.Action, filename.decode('utf-16')))
        numToSkip = fni.NextEntryOffset
        if numToSkip <= 0:
            break
        readBuffer = readBuffer[numToSkip:]
        nBytes -= numToSkip  # numToSkip is long. nBytes should be long too.
    return results


def get_directory_handle(path):
    """Returns a Windows handle to the specified directory path."""
    return CreateFileW(path, FILE_LIST_DIRECTORY, WATCHDOG_FILE_SHARE_FLAGS,
                       None, OPEN_EXISTING, WATCHDOG_FILE_FLAGS, None)


def close_directory_handle(handle):
    try:
        CancelIoEx(handle, None)  # force ReadDirectoryChangesW to return
        CloseHandle(handle)       # close directory handle
    except WindowsError:
        try:
            CloseHandle(handle)   # close directory handle
        except:
            return


def read_directory_changes(handle, recursive):
    """Read changes to the directory using the specified directory handle.

    http://timgolden.me.uk/pywin32-docs/win32file__ReadDirectoryChangesW_meth.html
    """
    event_buffer = ctypes.create_string_buffer(BUFFER_SIZE)
    nbytes = ctypes.wintypes.DWORD()
    try:
        ReadDirectoryChangesW(handle, ctypes.byref(event_buffer),
                              len(event_buffer), recursive,
                              WATCHDOG_FILE_NOTIFY_FLAGS,
                              ctypes.byref(nbytes), None, None)
    except WindowsError as e:
        if e.winerror == ERROR_OPERATION_ABORTED:
            return [], 0
        raise e

    # Python 2/3 compat
    try:
        int_class = long
    except NameError:
        int_class = int
    return event_buffer.raw, int_class(nbytes.value)


class WinAPINativeEvent(object):
    def __init__(self, action, src_path):
        self.action = action
        self.src_path = src_path
    
    @property
    def is_added(self):
        return self.action == FILE_ACTION_CREATED
    
    @property
    def is_removed(self):
        return self.action == FILE_ACTION_REMOVED
    
    @property
    def is_modified(self):
        return self.action == FILE_ACTION_MODIFIED
    
    @property
    def is_renamed_old(self):
        return self.action == FILE_ACTION_RENAMED_OLD_NAME
    
    @property
    def is_renamed_new(self):
        return self.action == FILE_ACTION_RENAMED_NEW_NAME
    
    def __repr__(self):
        return ("<WinAPINativeEvent: action=%d, src_path=%r>" % (self.action, self.src_path))


def read_events(handle, recursive):
    buf, nbytes = read_directory_changes(handle, recursive)
    events = _parse_event_buffer(buf, nbytes)
    return [WinAPINativeEvent(action, path) for action, path in events]

"""Support for non-delivered packages recorded in AfterShip."""
from __future__ import annotations

import logging
from typing import Any, Final

from pyaftership.tracker import Tracking
import voluptuous as vol

from homeassistant.components.sensor import (
    PLATFORM_SCHEMA as BASE_PLATFORM_SCHEMA,
    SensorEntity,
)
from homeassistant.const import ATTR_ATTRIBUTION, CONF_API_KEY, CONF_NAME, HTTP_OK
from homeassistant.core import HomeAssistant
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.dispatcher import async_dispatcher_send
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.service import ServiceCall
from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
from homeassistant.util import Throttle

from .const import (
    ADD_TRACKING_SERVICE_SCHEMA,
    ATTR_TRACKINGS,
    ATTRIBUTION,
    BASE,
    CONF_SLUG,
    CONF_TITLE,
    CONF_TRACKING_NUMBER,
    DEFAULT_NAME,
    DOMAIN,
    ICON,
    MIN_TIME_BETWEEN_UPDATES,
    REMOVE_TRACKING_SERVICE_SCHEMA,
    SERVICE_ADD_TRACKING,
    SERVICE_REMOVE_TRACKING,
    UPDATE_TOPIC,
)

_LOGGER: Final = logging.getLogger(__name__)

PLATFORM_SCHEMA: Final = BASE_PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_API_KEY): cv.string,
        vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
    }
)


async def async_setup_platform(
    hass: HomeAssistant,
    config: ConfigType,
    async_add_entities: AddEntitiesCallback,
    discovery_info: DiscoveryInfoType | None = None,
) -> None:
    """Set up the AfterShip sensor platform."""
    apikey = config[CONF_API_KEY]
    name = config[CONF_NAME]

    session = async_get_clientsession(hass)
    aftership = Tracking(hass.loop, session, apikey)

    await aftership.get_trackings()

    if not aftership.meta or aftership.meta["code"] != HTTP_OK:
        _LOGGER.error(
            "No tracking data found. Check API key is correct: %s", aftership.meta
        )
        return

    instance = AfterShipSensor(aftership, name)

    async_add_entities([instance], True)

    async def handle_add_tracking(call: ServiceCall) -> None:
        """Call when a user adds a new Aftership tracking from Home Assistant."""
        title = call.data.get(CONF_TITLE)
        slug = call.data.get(CONF_SLUG)
        tracking_number = call.data[CONF_TRACKING_NUMBER]

        await aftership.add_package_tracking(tracking_number, title, slug)
        async_dispatcher_send(hass, UPDATE_TOPIC)

    hass.services.async_register(
        DOMAIN,
        SERVICE_ADD_TRACKING,
        handle_add_tracking,
        schema=ADD_TRACKING_SERVICE_SCHEMA,
    )

    async def handle_remove_tracking(call: ServiceCall) -> None:
        """Call when a user removes an Aftership tracking from Home Assistant."""
        slug = call.data[CONF_SLUG]
        tracking_number = call.data[CONF_TRACKING_NUMBER]

        await aftership.remove_package_tracking(slug, tracking_number)
        async_dispatcher_send(hass, UPDATE_TOPIC)

    hass.services.async_register(
        DOMAIN,
        SERVICE_REMOVE_TRACKING,
        handle_remove_tracking,
        schema=REMOVE_TRACKING_SERVICE_SCHEMA,
    )


class AfterShipSensor(SensorEntity):
    """Representation of a AfterShip sensor."""

    def __init__(self, aftership: Tracking, name: str) -> None:
        """Initialize the sensor."""
        self._attributes: dict[str, Any] = {}
        self._name: str = name
        self._state: int | None = None
        self.aftership = aftership

    @property
    def name(self) -> str:
        """Return the name of the sensor."""
        return self._name

    @property
    def state(self) -> int | None:
        """Return the state of the sensor."""
        return self._state

    @property
    def unit_of_measurement(self) -> str:
        """Return the unit of measurement of this entity, if any."""
        return "packages"

    @property
    def extra_state_attributes(self) -> dict[str, str]:
        """Return attributes for the sensor."""
        return self._attributes

    @property
    def icon(self) -> str:
        """Icon to use in the frontend."""
        return ICON

    async def async_added_to_hass(self) -> None:
        """Register callbacks."""
        self.async_on_remove(
            self.hass.helpers.dispatcher.async_dispatcher_connect(
                UPDATE_TOPIC, self._force_update
            )
        )

    async def _force_update(self) -> None:
        """Force update of data."""
        await self.async_update(no_throttle=True)
        self.async_write_ha_state()

    @Throttle(MIN_TIME_BETWEEN_UPDATES)
    async def async_update(self, **kwargs: Any) -> None:
        """Get the latest data from the AfterShip API."""
        await self.aftership.get_trackings()

        if not self.aftership.meta:
            _LOGGER.error("Unknown errors when querying")
            return
        if self.aftership.meta["code"] != HTTP_OK:
            _LOGGER.error(
                "Errors when querying AfterShip. %s", str(self.aftership.meta)
            )
            return

        status_to_ignore = {"delivered"}
        status_counts: dict[str, int] = {}
        trackings = []
        not_delivered_count = 0

        for track in self.aftership.trackings["trackings"]:
            status = track["tag"].lower()
            name = (
                track["tracking_number"] if track["title"] is None else track["title"]
            )
            last_checkpoint = (
                f"Shipment {track['tag'].lower()}"
                if not track["checkpoints"]
                else track["checkpoints"][-1]
            )
            status_counts[status] = status_counts.get(status, 0) + 1
            trackings.append(
                {
                    "name": name,
                    "tracking_number": track["tracking_number"],
                    "slug": track["slug"],
                    "link": f"{BASE}{track['slug']}/{track['tracking_number']}",
                    "last_update": track["updated_at"],
                    "expected_delivery": track["expected_delivery"],
                    "status": track["tag"],
                    "last_checkpoint": last_checkpoint,
                }
            )

            if status not in status_to_ignore:
                not_delivered_count += 1
            else:
                _LOGGER.debug("Ignoring %s as it has status: %s", name, status)

        self._attributes = {
            ATTR_ATTRIBUTION: ATTRIBUTION,
            **status_counts,
            ATTR_TRACKINGS: trackings,
        }

        self._state = not_delivered_count

# pylint:disable=missing-docstring,no-member
import datetime
import json
import uuid  # pylint:disable=unused-import

from django.contrib.auth.models import User
import factory
from factory.fuzzy import FuzzyText
import pytz

from openedx.core.djangoapps.credit.models import CreditProvider, CreditEligibility, CreditCourse, CreditRequest
from util.date_utils import to_timestamp


class CreditCourseFactory(factory.DjangoModelFactory):
    class Meta(object):
        model = CreditCourse

    course_key = FuzzyText(prefix='fake.org/', suffix='/fake.run')
    enabled = True


class CreditProviderFactory(factory.DjangoModelFactory):
    class Meta(object):
        model = CreditProvider

    provider_id = FuzzyText(length=5)
    provider_url = FuzzyText(prefix='http://')


class CreditEligibilityFactory(factory.DjangoModelFactory):
    class Meta(object):
        model = CreditEligibility

    course = factory.SubFactory(CreditCourseFactory)


class CreditRequestFactory(factory.DjangoModelFactory):
    class Meta(object):
        model = CreditRequest

    uuid = factory.LazyAttribute(lambda o: uuid.uuid4().hex)  # pylint: disable=undefined-variable

    # pylint: disable=access-member-before-definition,attribute-defined-outside-init,no-self-argument,unused-argument
    @factory.post_generation
    def post(obj, create, extracted, **kwargs):
        """
        Post-generation handler.

        Sets up parameters field.
        """
        if not obj.parameters:
            course_key = obj.course.course_key
            user = User.objects.get(username=obj.username)
            user_profile = user.profile

            # pylint:disable=access-member-before-definition
            obj.parameters = json.dumps({
                "request_uuid": obj.uuid,
                "timestamp": to_timestamp(datetime.datetime.now(pytz.UTC)),
                "course_org": course_key.org,
                "course_num": course_key.course,
                "course_run": course_key.run,
                "final_grade": '0.96',
                "user_username": user.username,
                "user_email": user.email,
                "user_full_name": user_profile.name,
                "user_mailing_address": "",
                "user_country": user_profile.country.code or "",
            })

        obj.save()

# -*- coding: utf-8; -*-
#
# This file is part of Superdesk.
#
# Copyright 2013, 2014 Sourcefabric z.u. and contributors.
#
# For the full copyright and license information, please see the
# AUTHORS and LICENSE files distributed with this source code, or
# at https://www.sourcefabric.org/superdesk/license

import logging
from eve.versioning import versioned_id_field

from flask import g, current_app as app

from eve.utils import config, ParsedRequest
from .resource import LEGAL_ARCHIVE_NAME

from superdesk import Service, get_resource_privileges
from superdesk.errors import SuperdeskApiError
from superdesk.metadata.item import ITEM_TYPE, GUID_FIELD, CONTENT_TYPE
from superdesk.metadata.packages import GROUPS, RESIDREF, REFS
from superdesk.utils import ListCursor

logger = logging.getLogger(__name__)


class LegalService(Service):
    """
    Base Service Class for Legal Archive related services
    """

    def on_create(self, docs):
        """
        Overriding to replace the location of each item in the package to legal archive instead of archive,
        if doc is a pacakge.
        """

        super().on_create(docs)
        for doc in docs:
            if ITEM_TYPE in doc:
                doc.setdefault(config.ID_FIELD, doc[GUID_FIELD])
                if doc[ITEM_TYPE] == CONTENT_TYPE.COMPOSITE:
                    self._change_location_of_items_in_package(doc)

    def on_replace(self, document, original):
        """
        Overriding to replace the location of each item in the package to legal archive instead of archive,
        if doc is a pacakge.
        """

        super().on_replace(document, original)
        if document.get(ITEM_TYPE) == CONTENT_TYPE.COMPOSITE:
            self._change_location_of_items_in_package(document)

    def get(self, req, lookup):
        """
        Overriding to check if user is authorized to perform get operation on Legal Archive resources. If authorized
        then request is forwarded otherwise throws forbidden error.

        :return: list of docs matching query in req and lookup
        :raises: SuperdeskApiError.forbiddenError() if user is unauthorized to access the Legal Archive resources.
        """

        self.check_get_access_privilege()
        return super().get(req, lookup)

    def find_one(self, req, **lookup):
        """
        Overriding to check if user is authorized to perform get operation on Legal Archive resources. If authorized
        then request is forwarded otherwise throws forbidden error.

        :return: doc if there is one matching the query in req and lookup
        :raises: SuperdeskApiError.forbiddenError() if user is unauthorized to access the Legal Archive resources.
        """

        self.check_get_access_privilege()
        return super().find_one(req, **lookup)

    def check_get_access_privilege(self):
        """
        Checks if user is authorized to perform get operation on Legal Archive resources. If authorized then request is
        forwarded otherwise throws forbidden error.

        :raises: SuperdeskApiError.forbiddenError() if user is unauthorized to access the Legal Archive resources.
        """

        if not hasattr(g, 'user'):
            return

        privileges = g.user.get('active_privileges', {})
        resource_privileges = get_resource_privileges(self.datasource).get('GET', None)
        if privileges.get(resource_privileges, 0) == 0:
            raise SuperdeskApiError.forbiddenError()

    def enhance(self, legal_archive_docs):
        """
        Enhances the item in Legal Archive Service
        :param legal_archive_docs:
        """

        if isinstance(legal_archive_docs, list):
            for legal_archive_doc in legal_archive_docs:
                legal_archive_doc['_type'] = LEGAL_ARCHIVE_NAME
        else:
            legal_archive_docs['_type'] = LEGAL_ARCHIVE_NAME

    def _change_location_of_items_in_package(self, package):
        """
        Changes location of each item in the package to legal archive instead of archive.
        """

        for group in package.get(GROUPS, []):
            for ref in group.get(REFS, []):
                if RESIDREF in ref:
                    ref['location'] = LEGAL_ARCHIVE_NAME


class LegalArchiveService(LegalService):
    def on_fetched(self, docs):
        """
        Overriding this to enhance the published article with the one in archive collection
        """

        self.enhance(docs[config.ITEMS])

    def on_fetched_item(self, doc):
        """
        Overriding this to enhance the published article with the one in archive collection
        """

        self.enhance(doc)


class LegalPublishQueueService(LegalService):
    def create(self, docs, **kwargs):
        """
        Overriding this from preventing the transmission details again. This happens when an item in a package expires
        at later point of time. In this case, the call to insert transmission details happens twice once when the
        package expires and once when the item expires.
        """

        ids = []
        for doc in docs:
            doc_if_exists = self.find_one(req=None, _id=doc['_id'])
            if doc_if_exists is None:
                ids.extend(super().create([doc]))

        return ids


class LegalArchiveVersionsService(LegalService):
    def create(self, docs, **kwargs):
        """
        Overriding this from preventing the same version again. This happens when an item is published more than once.
        """

        ids = []
        for doc in docs:
            doc_if_exists = None

            if config.ID_FIELD in doc:  # This happens when inserting docs from pre-populate command
                doc_if_exists = self.find_one(req=None, _id=doc['_id'])

            if doc_if_exists is None:
                ids.extend(super().create([doc]))

        return ids

    def get(self, req, lookup):
        """
        Version of an article in Legal Archive isn't maintained by Eve. Overriding this to fetch the version history.
        """

        resource_def = app.config['DOMAIN'][LEGAL_ARCHIVE_NAME]
        id_field = versioned_id_field(resource_def)

        if req and req.args and req.args.get(config.ID_FIELD):
            version_history = list(super().get_from_mongo(req=ParsedRequest(),
                                                          lookup={id_field: req.args.get(config.ID_FIELD)}))
        else:
            version_history = list(super().get_from_mongo(req=req, lookup=lookup))

        for doc in version_history:
            doc[config.ID_FIELD] = doc[id_field]
            self.enhance(doc)

        return ListCursor(version_history)

from django import forms
from django.utils.translation import ugettext_lazy as _

# While this couples the geographic forms to the GEOS library,
# it decouples from database (by not importing SpatialBackend).
from django.contrib.gis.geos import GEOSGeometry

class GeometryField(forms.Field):
    """
    This is the basic form field for a Geometry.  Any textual input that is
    accepted by GEOSGeometry is accepted by this form.  By default,
    this includes WKT, HEXEWKB, WKB (in a buffer), and GeoJSON.
    """
    widget = forms.Textarea

    default_error_messages = {
        'no_geom' : _(u'No geometry value provided.'),
        'invalid_geom' : _(u'Invalid geometry value.'),
        'invalid_geom_type' : _(u'Invalid geometry type.'),
        'transform_error' : _(u'An error occurred when transforming the geometry '
                              'to the SRID of the geometry form field.'),
        }

    def __init__(self, **kwargs):
        # Pop out attributes from the database field, or use sensible
        # defaults (e.g., allow None).
        self.srid = kwargs.pop('srid', None)
        self.geom_type = kwargs.pop('geom_type', 'GEOMETRY')
        self.null = kwargs.pop('null', True)
        super(GeometryField, self).__init__(**kwargs)

    def clean(self, value):
        """
        Validates that the input value can be converted to a Geometry
        object (which is returned).  A ValidationError is raised if
        the value cannot be instantiated as a Geometry.
        """
        if not value:
            if self.null and not self.required:
                # The geometry column allows NULL and is not required.
                return None
            else:
                raise forms.ValidationError(self.error_messages['no_geom'])

        # Trying to create a Geometry object from the form value.
        try:
            geom = GEOSGeometry(value)
        except:
            raise forms.ValidationError(self.error_messages['invalid_geom'])

        # Ensuring that the geometry is of the correct type (indicated
        # using the OGC string label).
        if str(geom.geom_type).upper() != self.geom_type and not self.geom_type == 'GEOMETRY':
            raise forms.ValidationError(self.error_messages['invalid_geom_type'])

        # Transforming the geometry if the SRID was set.
        if self.srid:
            if not geom.srid:
                # Should match that of the field if not given.
                geom.srid = self.srid
            elif self.srid != -1 and self.srid != geom.srid:
                try:
                    geom.transform(self.srid)
                except:
                    raise forms.ValidationError(self.error_messages['transform_error'])

        return geom

"""
South Africa-specific Form helpers
"""

from django.core.validators import EMPTY_VALUES
from django.forms import ValidationError
from django.forms.fields import Field, RegexField
from django.utils.checksums import luhn
from django.utils.translation import gettext as _
import re
from datetime import date

id_re = re.compile(r'^(?P<yy>\d\d)(?P<mm>\d\d)(?P<dd>\d\d)(?P<mid>\d{4})(?P<end>\d{3})')

class ZAIDField(Field):
    """A form field for South African ID numbers -- the checksum is validated
    using the Luhn checksum, and uses a simlistic (read: not entirely accurate)
    check for the birthdate
    """
    default_error_messages = {
        'invalid': _(u'Enter a valid South African ID number'),
    }

    def clean(self, value):
        super(ZAIDField, self).clean(value)

        if value in EMPTY_VALUES:
            return u''

        # strip spaces and dashes
        value = value.strip().replace(' ', '').replace('-', '')

        match = re.match(id_re, value)

        if not match:
            raise ValidationError(self.error_messages['invalid'])

        g = match.groupdict()

        try:
            # The year 2000 is conveniently a leapyear.
            # This algorithm will break in xx00 years which aren't leap years
            # There is no way to guess the century of a ZA ID number
            d = date(int(g['yy']) + 2000, int(g['mm']), int(g['dd']))
        except ValueError:
            raise ValidationError(self.error_messages['invalid'])

        if not luhn(value):
            raise ValidationError(self.error_messages['invalid'])

        return value

class ZAPostCodeField(RegexField):
    default_error_messages = {
        'invalid': _(u'Enter a valid South African postal code'),
    }

    def __init__(self, *args, **kwargs):
        super(ZAPostCodeField, self).__init__(r'^\d{4}$',
            max_length=None, min_length=None, *args, **kwargs)

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.

# coding: utf-8
# pylint: disable= arguments-differ
"""Alexnet, implemented in Gluon."""
__all__ = ['AlexNet', 'alexnet']

import os

from ....context import cpu
from ...block import HybridBlock
from ... import nn
from .... import base

# Net
class AlexNet(HybridBlock):
    r"""AlexNet model from the `"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.

    Parameters
    ----------
    classes : int, default 1000
        Number of classes for the output layer.
    """
    def __init__(self, classes=1000, **kwargs):
        super(AlexNet, self).__init__(**kwargs)
        with self.name_scope():
            self.features = nn.HybridSequential(prefix='')
            with self.features.name_scope():
                self.features.add(nn.Conv2D(64, kernel_size=11, strides=4,
                                            padding=2, activation='relu'))
                self.features.add(nn.MaxPool2D(pool_size=3, strides=2))
                self.features.add(nn.Conv2D(192, kernel_size=5, padding=2,
                                            activation='relu'))
                self.features.add(nn.MaxPool2D(pool_size=3, strides=2))
                self.features.add(nn.Conv2D(384, kernel_size=3, padding=1,
                                            activation='relu'))
                self.features.add(nn.Conv2D(256, kernel_size=3, padding=1,
                                            activation='relu'))
                self.features.add(nn.Conv2D(256, kernel_size=3, padding=1,
                                            activation='relu'))
                self.features.add(nn.MaxPool2D(pool_size=3, strides=2))
                self.features.add(nn.Flatten())
                self.features.add(nn.Dense(4096, activation='relu'))
                self.features.add(nn.Dropout(0.5))
                self.features.add(nn.Dense(4096, activation='relu'))
                self.features.add(nn.Dropout(0.5))

            self.output = nn.Dense(classes)

    def hybrid_forward(self, F, x):
        x = self.features(x)
        x = self.output(x)
        return x

# Constructor
def alexnet(pretrained=False, ctx=cpu(),
            root=os.path.join(base.data_dir(), 'models'), **kwargs):
    r"""AlexNet model from the `"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.

    Parameters
    ----------
    pretrained : bool, default False
        Whether to load the pretrained weights for model.
    ctx : Context, default CPU
        The context in which to load the pretrained weights.
    root : str, default $MXNET_HOME/models
        Location for keeping the model parameters.
    """
    net = AlexNet(**kwargs)
    if pretrained:
        from ..model_store import get_model_file
        net.load_parameters(get_model_file('alexnet', root=root), ctx=ctx)
    return net

#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
    Copyright (c) 2016, Kersten Doering <kersten.doering@gmail.com>
"""

# import modules
# to connect to Xapian
import xappy
# debug: sys.exit(0)
import sys
# path options
import os
# runtime
import time
# to connect to PostgreSQL
import psycopg2
from psycopg2 import extras

# log start time
start = time.asctime()

# set options verbose, output and whether PostgreSQL should be used to display results
output = True
verbose = True
debug = False
use_psql = True

# get path to this script
root = os.getcwd()

# search connection to Xapian full text index
xapianPath   =  os.path.join( root, "xapian_PMC_complete" )
searchConn = xappy.SearchConnection(xapianPath)
searchConn.reopen()

# get PMC texts from PostgreSQL
def get_text(pmcid):
    stmt = """
    SELECT 
        text
    FROM 
        public.tbl_pmcid_text
    WHERE
        pmcid = %s
    ;
    """ 
    cursor.execute(stmt, (pmcid,))
    output = cursor.fetchone()
    return output[0]

# settings PostgreSQL connection with user parser
postgres_user       = "parser"
postgres_password   = "parser"
postgres_host       = "localhost" 
postgres_port       = "5432"
postgres_db         = "pancreatic_cancer_db"
connection          = psycopg2.connect("dbname='"+postgres_db+"' user='"+postgres_user+"' host='"+postgres_host+"' password='"+postgres_password+"' port='"+postgres_port+"'")
cursor              = connection.cursor(cursor_factory=psycopg2.extras.DictCursor)

# get search terms (synonyms)
synonyms = []
infile = open("synonyms/synonyms.txt","r")
for line in infile:
    synonyms.append(line.strip())
infile.close()

# write results to file with PMC ID and identified synonym if option output
if output:
    outfile = open("results/results.csv","w")
# search synonyms
for term in synonyms:
    # use exact search with quotations
    text = '"'+term + '"'
    # build query
    query = searchConn.query_field('text', text )
    # show query syntax if option verbose:
    if verbose:
        print query
    # search and get results
    results=searchConn.search(query, 0, searchConn.get_doccount())
    # iterate over results
    for r in results:
        # write to file if option output:
        if output:
            outfile.write(r.id + "\t" + term + "\n")
        # option verbose:
        if verbose and not use_psql:
            print "################"
            print r.id
            print r.data['text'][0][0:90] + "..."
            print "################"
        if verbose and use_psql:
            print "################"
            print r.id
            print get_text(r.id)[0:90] + "..."
            print "################"
        # terminate here to have a look at the first result if option debug:
        if debug:
            sys.exit(0)
    # show number of results if option verbose
    if verbose:
        print "#results: ", len(results)
# close file if option output
if output:
    outfile.close()

# log end time
end = time.asctime()

# show runtime
print "programme started - " + start
print "programme ended - " + end


'''
Challenge 3.2
Queue To Do
===========

You're almost ready to make your move to destroy the LAMBCHOP doomsday device, but the security checkpoints that guard the underlying systems of the LAMBCHOP are going to be a problem. You were able to take one down without tripping any alarms, which is great! Except that as Commander Lambda's assistant, you've learned that the checkpoints are about to come under automated review, which means that your sabotage will be discovered and your cover blown - unless you can trick the automated review system.

To trick the system, you'll need to write a program to return the same security checksum that the guards would have after they would have checked all the workers through. Fortunately, Commander Lambda's desire for efficiency won't allow for hours-long lines, so the checkpoint guards have found ways to quicken the pass-through rate. Instead of checking each and every worker coming through, the guards instead go over everyone in line while noting their security IDs, then allow the line to fill back up. Once they've done that they go over the line again, this time leaving off the last worker. They continue doing this, leaving off one more worker from the line each time but recording the security IDs of those they do check, until they skip the entire line, at which point they XOR the IDs of all the workers they noted into a checksum and then take off for lunch. Fortunately, the workers' orderly nature causes them to always line up in numerical order without any gaps.

For example, if the first worker in line has ID 0 and the security checkpoint line holds three workers, the process would look like this:
0 1 2 /
3 4 / 5
6 / 7 8
where the guards' XOR (^) checksum is 0^1^2^3^4^6 == 2.

Likewise, if the first worker has ID 17 and the checkpoint holds four workers, the process would look like:
17 18 19 20 /
21 22 23 / 24
25 26 / 27 28
29 / 30 31 32
which produces the checksum 17^18^19^20^21^22^23^25^26^29 == 14.

All worker IDs (including the first worker) are between 0 and 2000000000 inclusive, and the checkpoint line will always be at least 1 worker long.

With this information, write a function answer(start, length) that will cover for the missing security checkpoint by outputting the same checksum the guards would normally submit before lunch. You have just enough time to find out the ID of the first worker to be checked (start) and the length of the line (length) before the automatic review occurs, so your program must generate the proper checksum with just those two values.

Languages
=========

To provide a Python solution, edit solution.py
To provide a Java solution, edit solution.java

Test cases
==========

Inputs:
    (int) start = 0
    (int) length = 3
Output:
    (int) 2

Inputs:
    (int) start = 17
    (int) length = 4
Output:
    (int) 14
'''

def getXOR(start, end):

    if (end - start) == 0:
        return 0
    if (end - start) == 1:
        return start
    if (end - start) <= 4:
        return reduce(lambda x, y: x ^ y, range(start, end))
    else:
        begin_range = (start, start / 4 * 4 + 4)
        end_range = (end / 4 * 4, end)
        return getXOR(*begin_range) ^ getXOR(*end_range)


def answer(start, length):
    worker_list = [(start + (length - l) * length, start + (length - l) * length + l) for l in range(length, 0, -1)]
    
    new_xor = [getXOR(start, end) for start, end in worker_list]
    
    return reduce(lambda x, y: x ^ y, new_xor)

#print(answer(0, 3))
print(answer(17, 4))
#print(answer(200000, 25000))

# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt

"""Python source expertise for coverage.py"""

import os.path
import types
import zipimport

from coverage import env, files
from coverage.misc import contract, expensive, isolate_module, join_regex
from coverage.misc import CoverageException, NoSource
from coverage.parser import PythonParser
from coverage.phystokens import source_token_lines, source_encoding
from coverage.plugin import FileReporter

os = isolate_module(os)


@contract(returns='bytes')
def read_python_source(filename):
    """Read the Python source text from `filename`.

    Returns bytes.

    """
    with open(filename, "rb") as f:
        source = f.read()

    if env.IRONPYTHON:
        # IronPython reads Unicode strings even for "rb" files.
        source = bytes(source)

    return source.replace(b"\r\n", b"\n").replace(b"\r", b"\n")


@contract(returns='unicode')
def get_python_source(filename):
    """Return the source code, as unicode."""
    base, ext = os.path.splitext(filename)
    if ext == ".py" and env.WINDOWS:
        exts = [".py", ".pyw"]
    else:
        exts = [ext]

    for ext in exts:
        try_filename = base + ext
        if os.path.exists(try_filename):
            # A regular text file: open it.
            source = read_python_source(try_filename)
            break

        # Maybe it's in a zip file?
        source = get_zip_bytes(try_filename)
        if source is not None:
            break
    else:
        # Couldn't find source.
        exc_msg = "No source for code: '%s'.\n" % (filename,)
        exc_msg += "Aborting report output, consider using -i."
        raise NoSource(exc_msg)

    # Replace \f because of http://bugs.python.org/issue19035
    source = source.replace(b'\f', b' ')
    source = source.decode(source_encoding(source), "replace")

    # Python code should always end with a line with a newline.
    if source and source[-1] != '\n':
        source += '\n'

    return source


@contract(returns='bytes|None')
def get_zip_bytes(filename):
    """Get data from `filename` if it is a zip file path.

    Returns the bytestring data read from the zip file, or None if no zip file
    could be found or `filename` isn't in it.  The data returned will be
    an empty string if the file is empty.

    """
    markers = ['.zip'+os.sep, '.egg'+os.sep, '.pex'+os.sep]
    for marker in markers:
        if marker in filename:
            parts = filename.split(marker)
            try:
                zi = zipimport.zipimporter(parts[0]+marker[:-1])
            except zipimport.ZipImportError:
                continue
            try:
                data = zi.get_data(parts[1])
            except IOError:
                continue
            return data
    return None


def source_for_file(filename):
    """Return the source file for `filename`.

    Given a file name being traced, return the best guess as to the source
    file to attribute it to.

    """
    if filename.endswith(".py"):
        # .py files are themselves source files.
        return filename

    elif filename.endswith((".pyc", ".pyo")):
        # Bytecode files probably have source files near them.
        py_filename = filename[:-1]
        if os.path.exists(py_filename):
            # Found a .py file, use that.
            return py_filename
        if env.WINDOWS:
            # On Windows, it could be a .pyw file.
            pyw_filename = py_filename + "w"
            if os.path.exists(pyw_filename):
                return pyw_filename
        # Didn't find source, but it's probably the .py file we want.
        return py_filename

    elif filename.endswith("$py.class"):
        # Jython is easy to guess.
        return filename[:-9] + ".py"

    # No idea, just use the file name as-is.
    return filename


class PythonFileReporter(FileReporter):
    """Report support for a Python file."""

    def __init__(self, morf, coverage=None):
        self.coverage = coverage

        if hasattr(morf, '__file__'):
            filename = morf.__file__
        elif isinstance(morf, types.ModuleType):
            # A module should have had .__file__, otherwise we can't use it.
            # This could be a PEP-420 namespace package.
            raise CoverageException("Module {0} has no file".format(morf))
        else:
            filename = morf

        filename = source_for_file(files.unicode_filename(filename))

        super(PythonFileReporter, self).__init__(files.canonical_filename(filename))

        if hasattr(morf, '__name__'):
            name = morf.__name__.replace(".", os.sep)
            if os.path.basename(filename).startswith('__init__.'):
                name += os.sep + "__init__"
            name += ".py"
            name = files.unicode_filename(name)
        else:
            name = files.relative_filename(filename)
        self.relname = name

        self._source = None
        self._parser = None
        self._statements = None
        self._excluded = None

    def __repr__(self):
        return "<PythonFileReporter {0!r}>".format(self.filename)

    @contract(returns='unicode')
    def relative_filename(self):
        return self.relname

    @property
    def parser(self):
        """Lazily create a :class:`PythonParser`."""
        if self._parser is None:
            self._parser = PythonParser(
                filename=self.filename,
                exclude=self.coverage._exclude_regex('exclude'),
            )
            self._parser.parse_source()
        return self._parser

    def lines(self):
        """Return the line numbers of statements in the file."""
        return self.parser.statements

    def excluded_lines(self):
        """Return the line numbers of statements in the file."""
        return self.parser.excluded

    def translate_lines(self, lines):
        return self.parser.translate_lines(lines)

    def translate_arcs(self, arcs):
        return self.parser.translate_arcs(arcs)

    @expensive
    def no_branch_lines(self):
        no_branch = self.parser.lines_matching(
            join_regex(self.coverage.config.partial_list),
            join_regex(self.coverage.config.partial_always_list)
            )
        return no_branch

    @expensive
    def arcs(self):
        return self.parser.arcs()

    @expensive
    def exit_counts(self):
        return self.parser.exit_counts()

    def missing_arc_description(self, start, end, executed_arcs=None):
        return self.parser.missing_arc_description(start, end, executed_arcs)

    @contract(returns='unicode')
    def source(self):
        if self._source is None:
            self._source = get_python_source(self.filename)
        return self._source

    def should_be_python(self):
        """Does it seem like this file should contain Python?

        This is used to decide if a file reported as part of the execution of
        a program was really likely to have contained Python in the first
        place.

        """
        # Get the file extension.
        _, ext = os.path.splitext(self.filename)

        # Anything named *.py* should be Python.
        if ext.startswith('.py'):
            return True
        # A file with no extension should be Python.
        if not ext:
            return True
        # Everything else is probably not Python.
        return False

    def source_token_lines(self):
        return source_token_lines(self.source())

#!/usr/bin/python
#
#  Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.

import zookeeper, zktestbase, unittest, threading
ZOO_OPEN_ACL_UNSAFE = {"perms":0x1f, "scheme":"world", "id" :"anyone"}

class GetSetTest(zktestbase.TestBase):
    def setUp( self ):
        zktestbase.TestBase.setUp(self)
        try:
            zookeeper.create(self.handle, "/zk-python-getsettest", "on",[ZOO_OPEN_ACL_UNSAFE], zookeeper.EPHEMERAL)
            zookeeper.create(self.handle, "/zk-python-agetsettest",
                             "on",[ZOO_OPEN_ACL_UNSAFE], zookeeper.EPHEMERAL)
        except:
            pass

    def test_sync_getset(self):
        self.assertEqual(self.connected, True, "Not connected!")
        (data,stat) = zookeeper.get(self.handle, "/zk-python-getsettest", None)
        self.assertEqual(data, "on", "Data is not 'on' as expected: " + data)
        ret = zookeeper.set(self.handle, "/zk-python-getsettest",
                            "off", stat["version"])
        (data,stat) = zookeeper.get(self.handle, "/zk-python-getsettest", None)
        self.assertEqual(data, "off", "Data is not 'off' as expected: " + data)
        self.assertRaises(zookeeper.BadVersionException,
                          zookeeper.set,
                          self.handle,
                          "/zk-python-getsettest",
                          "test",
                          stat["version"]+1)

    def test_stat_deleted_node(self):
        """
        Test for a bug that surfaced when trying to build a
        stat object from a non-existant node.

        """
        self.ensureDeleted("/zk-python-test-deleteme")
        self.assertRaises(zookeeper.NoNodeException,
                          zookeeper.get,
                          self.handle,
                          "/zk-python-test-deleteme")
        self.cv = threading.Condition()
        def callback(handle, rc, value, stat):
            self.cv.acquire()
            self.stat = stat
            self.rc = rc
            self.value = value
            self.callback_flag = True
            self.cv.notify()
            self.cv.release()
        self.cv.acquire()
        zookeeper.aget(self.handle, "/zk-python-test-deleteme", None, callback)
        self.cv.wait(15)
        self.assertEqual(self.callback_flag, True, "aget timed out!")
        self.assertEqual(self.stat, None, "Stat should be none!")
        self.assertEqual(self.value, None, "Value should be none!")

    def test_sync_get_large_datanode(self):
        """
        Test that we can retrieve datanode sizes up to
        1Mb with default parameters (depends on ZooKeeper server).
        """

        data = ''.join(["A" for x in xrange(1024*1023)])
        self.ensureDeleted("/zk-python-test-large-datanode")
        zookeeper.create(self.handle, "/zk-python-test-large-datanode", data,
                         [{"perms":0x1f, "scheme":"world", "id" :"anyone"}])
        (ret,stat) = zookeeper.get(self.handle, "/zk-python-test-large-datanode")
        self.assertEqual(len(ret), 1024*1023,
                         "Should have got 1Mb returned, instead got %s" % len(ret))
        (ret,stat) = zookeeper.get(self.handle, "/zk-python-test-large-datanode",None,500)
        self.assertEqual(len(ret), 500,
                         "Should have got 500 bytes returned, instead got %s" % len(ret))



    def test_async_getset(self):
        self.cv = threading.Condition()
        def get_callback(handle, rc, value, stat):
            self.cv.acquire()
            self.callback_flag = True
            self.rc = rc
            self.value = (value,stat)
            self.cv.notify()
            self.cv.release()

        def set_callback(handle, rc, stat):
            self.cv.acquire()
            self.callback_flag = True
            self.rc = rc
            self.value = stat
            self.cv.notify()
            self.cv.release()

        self.assertEqual(self.connected, True, "Not connected!")

        self.cv.acquire()
        self.callback_flag = False
        ret = zookeeper.aset(self.handle, "/zk-python-agetsettest", "off", -1, set_callback)
        self.assertEqual(ret, zookeeper.OK, "aset failed")
        while not self.callback_flag:
            self.cv.wait(15)
        self.cv.release()
        self.assertEqual(self.callback_flag, True, "aset timed out")

        self.cv.acquire()
        self.callback_flag = False
        ret = zookeeper.aget(self.handle, "/zk-python-agetsettest", None, get_callback)
        self.assertEqual(ret, zookeeper.OK, "aget failed")
        self.cv.wait(15)
        self.cv.release()
        self.assertEqual(self.callback_flag, True, "aget timed out")
        self.assertEqual(self.value[0], "off", "Data is not 'off' as expected: " + self.value[0])

    def test_sync_getchildren(self):
        self.ensureCreated("/zk-python-getchildrentest", flags=0)
        self.ensureCreated("/zk-python-getchildrentest/child")
        children = zookeeper.get_children(self.handle, "/zk-python-getchildrentest")
        self.assertEqual(len(children), 1, "Expected to find 1 child, got " + str(len(children)))

    def test_async_getchildren(self):
        self.ensureCreated("/zk-python-getchildrentest", flags=0)
        self.ensureCreated("/zk-python-getchildrentest/child")

        def gc_callback(handle, rc, children):
            self.cv.acquire()
            self.rc = rc
            self.children = children
            self.callback_flag = True
            self.cv.notify()
            self.cv.release()

        self.cv.acquire()
        self.callback_flag = False
        zookeeper.aget_children(self.handle, "/zk-python-getchildrentest", None, gc_callback)
        self.cv.wait(15)
        self.assertEqual(self.callback_flag, True, "aget_children timed out")
        self.assertEqual(self.rc, zookeeper.OK, "Return code for aget_children was not OK - %s" % zookeeper.zerror(self.rc))
        self.assertEqual(len(self.children), 1, "Expected to find 1 child, got " + str(len(self.children)))


    def test_async_getchildren_with_watcher(self):
        self.ensureCreated("/zk-python-getchildrentest", flags=0)
        self.ensureCreated("/zk-python-getchildrentest/child")

        watched = []

        def watcher(*args):
            self.cv.acquire()
            watched.append(args)
            self.cv.notify()
            self.cv.release()

        def children_callback(*args):
            self.cv.acquire()
            self.cv.notify()
            self.cv.release()

        zookeeper.aget_children(
            self.handle, "/zk-python-getchildrentest", watcher, children_callback)

        self.cv.acquire()
        self.cv.wait()
        self.cv.release()

        self.cv.acquire()
        self.ensureCreated("/zk-python-getchildrentest/child2")
        self.cv.wait(15)
        self.assertTrue(watched)

if __name__ == '__main__':
    unittest.main()

import os
import unittest

import torch
import torchvision
from torch.utils.data import Subset

from src.datasets.load_cifar10 import CIFAR10_TRAIN_MEAN, CIFAR10_TRAIN_STD, DATA_DIRPATH, SPLIT_DIRPATH
from src.misc.utils import read_lines


class TestCifar10(unittest.TestCase):
    def setUp(self) -> None:
        transform = torchvision.transforms.ToTensor()
        dataset = torchvision.datasets.CIFAR10(DATA_DIRPATH, train=True, transform=transform, download=True)

        train_indices = read_lines(os.path.join(SPLIT_DIRPATH, "train.txt"), int)
        self.train_dataset = Subset(dataset, train_indices)
        self.images = torch.stack([image for image, label in self.train_dataset], dim=0)

    def test_mean(self) -> None:
        expected_mean = torch.mean(self.images, dim=(0, 2, 3))
        for c in range(3):
            self.assertAlmostEqual(expected_mean[c].item(), CIFAR10_TRAIN_MEAN[c], 4)

    def test_std(self) -> None:
        expected_std = torch.std(self.images, dim=(0, 2, 3))
        for c in range(3):
            self.assertAlmostEqual(expected_std[c].item(), CIFAR10_TRAIN_STD[c], 4)

#  Copyright 2008-2015 Nokia Solutions and Networks
#
#  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.

from collections import Mapping
from UserDict import UserDict
from UserString import UserString
try:
    from java.lang import String
except ImportError:
    String = ()


def is_integer(item):
    return isinstance(item, (int, long))


def is_number(item):
    return isinstance(item, (int, long, float))


def is_bytes(item):
    return isinstance(item, str)


def is_string(item):
    return isinstance(item, basestring)


def is_unicode(item):
    return isinstance(item, unicode)


def is_list_like(item):
    if isinstance(item, (basestring, UserString, String)):
        return False
    try:
        iter(item)
    except TypeError:
        return False
    else:
        return True


def is_dict_like(item):
    return isinstance(item, (Mapping, UserDict))


def is_truthy(item):
    if isinstance(item, basestring):
        return item.upper() not in ('FALSE', 'NO', '')
    return bool(item)


def is_falsy(item):
    return not is_truthy(item)


def type_name(item):
    cls = item.__class__ if hasattr(item, '__class__') else type(item)
    named_types = {str: 'string', unicode: 'string', bool: 'boolean',
                   int: 'integer', long: 'integer', type(None): 'None',
                   dict: 'dictionary'}
    return named_types.get(cls, cls.__name__)

## This file is part of Scapy
## See http://www.secdev.org/projects/scapy for more informations
## Copyright (C) Philippe Biondi <phil@secdev.org>
## This program is published under a GPLv2 license

"""
PPP (Point to Point Protocol)

[RFC 1661]
"""

import struct
from scapy.packet import Packet, bind_layers
from scapy.layers.l2 import Ether, CookedLinux
from scapy.layers.inet import IP
from scapy.layers.inet6 import IPv6
from scapy.fields import BitField, ByteEnumField, ByteField, \
    ConditionalField, FieldLenField, IPField, PacketListField, \
    ShortEnumField, ShortField, StrFixedLenField, StrLenField, XByteField, \
    XShortField


class PPPoE(Packet):
    name = "PPP over Ethernet"
    fields_desc = [ BitField("version", 1, 4),
                    BitField("type", 1, 4),
                    ByteEnumField("code", 0, {0:"Session"}),
                    XShortField("sessionid", 0x0),
                    ShortField("len", None) ]

    def post_build(self, p, pay):
        p += pay
        if self.len is None:
            l = len(p)-6
            p = p[:4]+struct.pack("!H", l)+p[6:]
        return p

class PPPoED(PPPoE):
    name = "PPP over Ethernet Discovery"
    fields_desc = [ BitField("version", 1, 4),
                    BitField("type", 1, 4),
                    ByteEnumField("code", 0x09, {0x09:"PADI",0x07:"PADO",0x19:"PADR",0x65:"PADS",0xa7:"PADT"}),
                    XShortField("sessionid", 0x0),
                    ShortField("len", None) ]


_PPP_proto = { 0x0001: "Padding Protocol",
               0x0003: "ROHC small-CID [RFC3095]",
               0x0005: "ROHC large-CID [RFC3095]",
               0x0021: "Internet Protocol version 4",
               0x0023: "OSI Network Layer",
               0x0025: "Xerox NS IDP",
               0x0027: "DECnet Phase IV",
               0x0029: "Appletalk",
               0x002b: "Novell IPX",
               0x002d: "Van Jacobson Compressed TCP/IP",
               0x002f: "Van Jacobson Uncompressed TCP/IP",
               0x0031: "Bridging PDU",
               0x0033: "Stream Protocol (ST-II)",
               0x0035: "Banyan Vines",
               0x0037: "reserved (until 1993) [Typo in RFC1172]",
               0x0039: "AppleTalk EDDP",
               0x003b: "AppleTalk SmartBuffered",
               0x003d: "Multi-Link [RFC1717]",
               0x003f: "NETBIOS Framing",
               0x0041: "Cisco Systems",
               0x0043: "Ascom Timeplex",
               0x0045: "Fujitsu Link Backup and Load Balancing (LBLB)",
               0x0047: "DCA Remote Lan",
               0x0049: "Serial Data Transport Protocol (PPP-SDTP)",
               0x004b: "SNA over 802.2",
               0x004d: "SNA",
               0x004f: "IPv6 Header Compression",
               0x0051: "KNX Bridging Data [ianp]",
               0x0053: "Encryption [Meyer]",
               0x0055: "Individual Link Encryption [Meyer]",
               0x0057: "Internet Protocol version 6 [Hinden]",
               0x0059: "PPP Muxing [RFC3153]",
               0x005b: "Vendor-Specific Network Protocol (VSNP) [RFC3772]",
               0x0061: "RTP IPHC Full Header [RFC3544]",
               0x0063: "RTP IPHC Compressed TCP [RFC3544]",
               0x0065: "RTP IPHC Compressed Non TCP [RFC3544]",
               0x0067: "RTP IPHC Compressed UDP 8 [RFC3544]",
               0x0069: "RTP IPHC Compressed RTP 8 [RFC3544]",
               0x006f: "Stampede Bridging",
               0x0071: "Reserved [Fox]",
               0x0073: "MP+ Protocol [Smith]",
               0x007d: "reserved (Control Escape) [RFC1661]",
               0x007f: "reserved (compression inefficient [RFC1662]",
               0x0081: "Reserved Until 20-Oct-2000 [IANA]",
               0x0083: "Reserved Until 20-Oct-2000 [IANA]",
               0x00c1: "NTCITS IPI [Ungar]",
               0x00cf: "reserved (PPP NLID)",
               0x00fb: "single link compression in multilink [RFC1962]",
               0x00fd: "compressed datagram [RFC1962]",
               0x00ff: "reserved (compression inefficient)",
               0x0201: "802.1d Hello Packets",
               0x0203: "IBM Source Routing BPDU",
               0x0205: "DEC LANBridge100 Spanning Tree",
               0x0207: "Cisco Discovery Protocol [Sastry]",
               0x0209: "Netcs Twin Routing [Korfmacher]",
               0x020b: "STP - Scheduled Transfer Protocol [Segal]",
               0x020d: "EDP - Extreme Discovery Protocol [Grosser]",
               0x0211: "Optical Supervisory Channel Protocol (OSCP)[Prasad]",
               0x0213: "Optical Supervisory Channel Protocol (OSCP)[Prasad]",
               0x0231: "Luxcom",
               0x0233: "Sigma Network Systems",
               0x0235: "Apple Client Server Protocol [Ridenour]",
               0x0281: "MPLS Unicast [RFC3032]  ",
               0x0283: "MPLS Multicast [RFC3032]",
               0x0285: "IEEE p1284.4 standard - data packets [Batchelder]",
               0x0287: "ETSI TETRA Network Protocol Type 1 [Nieminen]",
               0x0289: "Multichannel Flow Treatment Protocol [McCann]",
               0x2063: "RTP IPHC Compressed TCP No Delta [RFC3544]",
               0x2065: "RTP IPHC Context State [RFC3544]",
               0x2067: "RTP IPHC Compressed UDP 16 [RFC3544]",
               0x2069: "RTP IPHC Compressed RTP 16 [RFC3544]",
               0x4001: "Cray Communications Control Protocol [Stage]",
               0x4003: "CDPD Mobile Network Registration Protocol [Quick]",
               0x4005: "Expand accelerator protocol [Rachmani]",
               0x4007: "ODSICP NCP [Arvind]",
               0x4009: "DOCSIS DLL [Gaedtke]",
               0x400B: "Cetacean Network Detection Protocol [Siller]",
               0x4021: "Stacker LZS [Simpson]",
               0x4023: "RefTek Protocol [Banfill]",
               0x4025: "Fibre Channel [Rajagopal]",
               0x4027: "EMIT Protocols [Eastham]",
               0x405b: "Vendor-Specific Protocol (VSP) [RFC3772]",
               0x8021: "Internet Protocol Control Protocol",
               0x8023: "OSI Network Layer Control Protocol",
               0x8025: "Xerox NS IDP Control Protocol",
               0x8027: "DECnet Phase IV Control Protocol",
               0x8029: "Appletalk Control Protocol",
               0x802b: "Novell IPX Control Protocol",
               0x802d: "reserved",
               0x802f: "reserved",
               0x8031: "Bridging NCP",
               0x8033: "Stream Protocol Control Protocol",
               0x8035: "Banyan Vines Control Protocol",
               0x8037: "reserved (until 1993)",
               0x8039: "reserved",
               0x803b: "reserved",
               0x803d: "Multi-Link Control Protocol",
               0x803f: "NETBIOS Framing Control Protocol",
               0x8041: "Cisco Systems Control Protocol",
               0x8043: "Ascom Timeplex",
               0x8045: "Fujitsu LBLB Control Protocol",
               0x8047: "DCA Remote Lan Network Control Protocol (RLNCP)",
               0x8049: "Serial Data Control Protocol (PPP-SDCP)",
               0x804b: "SNA over 802.2 Control Protocol",
               0x804d: "SNA Control Protocol",
               0x804f: "IP6 Header Compression Control Protocol",
               0x8051: "KNX Bridging Control Protocol [ianp]",
               0x8053: "Encryption Control Protocol [Meyer]",
               0x8055: "Individual Link Encryption Control Protocol [Meyer]",
               0x8057: "IPv6 Control Protovol [Hinden]",
               0x8059: "PPP Muxing Control Protocol [RFC3153]",
               0x805b: "Vendor-Specific Network Control Protocol (VSNCP) [RFC3772]",
               0x806f: "Stampede Bridging Control Protocol",
               0x8073: "MP+ Control Protocol [Smith]",
               0x8071: "Reserved [Fox]",
               0x807d: "Not Used - reserved [RFC1661]",
               0x8081: "Reserved Until 20-Oct-2000 [IANA]",
               0x8083: "Reserved Until 20-Oct-2000 [IANA]",
               0x80c1: "NTCITS IPI Control Protocol [Ungar]",
               0x80cf: "Not Used - reserved [RFC1661]",
               0x80fb: "single link compression in multilink control [RFC1962]",
               0x80fd: "Compression Control Protocol [RFC1962]",
               0x80ff: "Not Used - reserved [RFC1661]",
               0x8207: "Cisco Discovery Protocol Control [Sastry]",
               0x8209: "Netcs Twin Routing [Korfmacher]",
               0x820b: "STP - Control Protocol [Segal]",
               0x820d: "EDPCP - Extreme Discovery Protocol Ctrl Prtcl [Grosser]",
               0x8235: "Apple Client Server Protocol Control [Ridenour]",
               0x8281: "MPLSCP [RFC3032]",
               0x8285: "IEEE p1284.4 standard - Protocol Control [Batchelder]",
               0x8287: "ETSI TETRA TNP1 Control Protocol [Nieminen]",
               0x8289: "Multichannel Flow Treatment Protocol [McCann]",
               0xc021: "Link Control Protocol",
               0xc023: "Password Authentication Protocol",
               0xc025: "Link Quality Report",
               0xc027: "Shiva Password Authentication Protocol",
               0xc029: "CallBack Control Protocol (CBCP)",
               0xc02b: "BACP Bandwidth Allocation Control Protocol [RFC2125]",
               0xc02d: "BAP [RFC2125]",
               0xc05b: "Vendor-Specific Authentication Protocol (VSAP) [RFC3772]",
               0xc081: "Container Control Protocol [KEN]",
               0xc223: "Challenge Handshake Authentication Protocol",
               0xc225: "RSA Authentication Protocol [Narayana]",
               0xc227: "Extensible Authentication Protocol [RFC2284]",
               0xc229: "Mitsubishi Security Info Exch Ptcl (SIEP) [Seno]",
               0xc26f: "Stampede Bridging Authorization Protocol",
               0xc281: "Proprietary Authentication Protocol [KEN]",
               0xc283: "Proprietary Authentication Protocol [Tackabury]",
               0xc481: "Proprietary Node ID Authentication Protocol [KEN]"}


class HDLC(Packet):
    fields_desc = [ XByteField("address",0xff),
                    XByteField("control",0x03)  ]

class PPP(Packet):
    name = "PPP Link Layer"
    fields_desc = [ ShortEnumField("proto", 0x0021, _PPP_proto) ]
    @classmethod
    def dispatch_hook(cls, _pkt=None, *args, **kargs):
        if _pkt and _pkt[0] == '\xff':
            cls = HDLC
        return cls

_PPP_conftypes = { 1:"Configure-Request",
                   2:"Configure-Ack",
                   3:"Configure-Nak",
                   4:"Configure-Reject",
                   5:"Terminate-Request",
                   6:"Terminate-Ack",
                   7:"Code-Reject",
                   8:"Protocol-Reject",
                   9:"Echo-Request",
                   10:"Echo-Reply",
                   11:"Discard-Request",
                   14:"Reset-Request",
                   15:"Reset-Ack",
                   }


### PPP IPCP stuff (RFC 1332)

# All IPCP options are defined below (names and associated classes) 
_PPP_ipcpopttypes = {     1:"IP-Addresses (Deprecated)",
                          2:"IP-Compression-Protocol",
                          3:"IP-Address",
                          4:"Mobile-IPv4", # not implemented, present for completeness
                          129:"Primary-DNS-Address",
                          130:"Primary-NBNS-Address",
                          131:"Secondary-DNS-Address",
                          132:"Secondary-NBNS-Address"}


class PPP_IPCP_Option(Packet):
    name = "PPP IPCP Option"
    fields_desc = [ ByteEnumField("type" , None , _PPP_ipcpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2),
                    StrLenField("data", "", length_from=lambda p:max(0,p.len-2)) ]
    def extract_padding(self, pay):
        return "",pay

    registered_options = {}
    @classmethod
    def register_variant(cls):
        cls.registered_options[cls.type.default] = cls
    @classmethod
    def dispatch_hook(cls, _pkt=None, *args, **kargs):
        if _pkt:
            o = ord(_pkt[0])
            return cls.registered_options.get(o, cls)
        return cls


class PPP_IPCP_Option_IPAddress(PPP_IPCP_Option):
    name = "PPP IPCP Option: IP Address"
    fields_desc = [ ByteEnumField("type" , 3 , _PPP_ipcpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2),
                    IPField("data","0.0.0.0"),
                    ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ]

class PPP_IPCP_Option_DNS1(PPP_IPCP_Option):
    name = "PPP IPCP Option: DNS1 Address"
    fields_desc = [ ByteEnumField("type" , 129 , _PPP_ipcpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2),
                    IPField("data","0.0.0.0"),
                    ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ]

class PPP_IPCP_Option_DNS2(PPP_IPCP_Option):
    name = "PPP IPCP Option: DNS2 Address"
    fields_desc = [ ByteEnumField("type" , 131 , _PPP_ipcpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2),
                    IPField("data","0.0.0.0"),
                    ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ]

class PPP_IPCP_Option_NBNS1(PPP_IPCP_Option):
    name = "PPP IPCP Option: NBNS1 Address"
    fields_desc = [ ByteEnumField("type" , 130 , _PPP_ipcpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2),
                    IPField("data","0.0.0.0"),
                    ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ]

class PPP_IPCP_Option_NBNS2(PPP_IPCP_Option):
    name = "PPP IPCP Option: NBNS2 Address"
    fields_desc = [ ByteEnumField("type" , 132 , _PPP_ipcpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2),
                    IPField("data","0.0.0.0"),
                    ConditionalField(StrLenField("garbage","", length_from=lambda pkt:pkt.len-6), lambda p:p.len!=6) ]


class PPP_IPCP(Packet):
    fields_desc = [ ByteEnumField("code" , 1, _PPP_conftypes),
		    XByteField("id", 0 ),
                    FieldLenField("len" , None, fmt="H", length_of="options", adjust=lambda p,x:x+4 ),
                    PacketListField("options", [],  PPP_IPCP_Option, length_from=lambda p:p.len-4,) ]


### ECP

_PPP_ecpopttypes = { 0:"OUI",
                     1:"DESE", }

class PPP_ECP_Option(Packet):
    name = "PPP ECP Option"
    fields_desc = [ ByteEnumField("type" , None , _PPP_ecpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+2),
                    StrLenField("data", "", length_from=lambda p:max(0,p.len-2)) ]
    def extract_padding(self, pay):
        return "",pay

    registered_options = {}
    @classmethod
    def register_variant(cls):
        cls.registered_options[cls.type.default] = cls
    @classmethod
    def dispatch_hook(cls, _pkt=None, *args, **kargs):
        if _pkt:
            o = ord(_pkt[0])
            return cls.registered_options.get(o, cls)
        return cls

class PPP_ECP_Option_OUI(PPP_ECP_Option):
    fields_desc = [ ByteEnumField("type" , 0 , _PPP_ecpopttypes),
                    FieldLenField("len", None, length_of="data", fmt="B", adjust=lambda p,x:x+6),
                    StrFixedLenField("oui","",3),
                    ByteField("subtype",0),
                    StrLenField("data", "", length_from=lambda p:p.len-6) ]
                    


class PPP_ECP(Packet):
    fields_desc = [ ByteEnumField("code" , 1, _PPP_conftypes),
		    XByteField("id", 0 ),
                    FieldLenField("len" , None, fmt="H", length_of="options", adjust=lambda p,x:x+4 ),
                    PacketListField("options", [],  PPP_ECP_Option, length_from=lambda p:p.len-4,) ]

bind_layers( Ether,         PPPoED,        type=0x8863)
bind_layers( Ether,         PPPoE,         type=0x8864)
bind_layers( CookedLinux,   PPPoED,        proto=0x8863)
bind_layers( CookedLinux,   PPPoE,         proto=0x8864)
bind_layers( PPPoE,         PPP,           code=0)
bind_layers( HDLC,          PPP,           )
bind_layers( PPP,           IP,            proto=0x0021)
bind_layers( PPP,           IPv6,          proto=0x0057)
bind_layers( PPP,           PPP_IPCP,      proto=0x8021)
bind_layers( PPP,           PPP_ECP,       proto=0x8053)
bind_layers( Ether,         PPP_IPCP,      type=0x8021)
bind_layers( Ether,         PPP_ECP,       type=0x8053)

from __future__ import unicode_literals

from .common import InfoExtractor
from .zdf import extract_from_xml_url


class PhoenixIE(InfoExtractor):
    _VALID_URL = r'https?://(?:www\.)?phoenix\.de/content/(?P<id>[0-9]+)'
    _TEST = {
        'url': 'http://www.phoenix.de/content/884301',
        'md5': 'ed249f045256150c92e72dbb70eadec6',
        'info_dict': {
            'id': '884301',
            'ext': 'mp4',
            'title': 'Michael Krons mit Hans-Werner Sinn',
            'description': 'Im Dialog - Sa. 25.10.14, 00.00 - 00.35 Uhr',
            'upload_date': '20141025',
            'uploader': 'Im Dialog',
        }
    }

    def _real_extract(self, url):
        video_id = self._match_id(url)
        webpage = self._download_webpage(url, video_id)

        internal_id = self._search_regex(
            r'<div class="phx_vod" id="phx_vod_([0-9]+)"',
            webpage, 'internal video ID')

        api_url = 'http://www.phoenix.de/php/zdfplayer-v1.3/data/beitragsDetails.php?ak=web&id=%s' % internal_id
        return extract_from_xml_url(self, video_id, api_url)

"""
@copyright Copyright (c) 2011 - 2016, Intel Corporation.

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.

@file test_pfc_samples.py

@summary   Samples for PFC configuration.

@details
Following test cases are tested:
1. Verify that device doesn't flood received pause frames when flow control
    mode is configured.
2. Verify that "RxTx" flow control manages traffic correctly.
"""
import time

import pytest

from testlib import helpers


@pytest.mark.flow_control
@pytest.mark.simplified
class TestPFCSamples(object):
    """
    @description Suite for PFC testing
    """

# Attributes and Properties

    def rate_decreasing(self, pf_rate=None, quanta=None, pause_frame_size=64,
                        full_rate=None, actual_rate=None):
        """
        @brief Calculated expected line rate during stream of pause frames is sending.
        @param pf_rate:  PFC rate
        @type  pf_rate:  int
        @param quanta:  PFC quanta
        @type  quanta:  int
        @param pause_frame_size:  PFC frame size
        @type  pause_frame_size:  int
        @param full_rate:  full rate
        @type  full_rate:  int
        @param actual_rate:  actual rate
        @type  actual_rate:  int
        @rtype:  bool
        @return:  True if actual rate is equal to the calculated expected line rate
        """
        x = pf_rate // 10
        ptime = quanta * 96
        frame_rate = (x * 1000000000) // (pause_frame_size + 20) // 8
        sweeper_p = frame_rate * ptime
        delay_sent = (sweeper_p * 100.) / 1000000000
        delay_received = 100 - delay_sent
        expected_rate = (full_rate * delay_received) / 100
        if expected_rate <= 0:
            expected_rate = 0
            if not actual_rate - expected_rate == 0:
                return False
            else:
                return True
        else:
            if abs(actual_rate - expected_rate) <= 10:
                return True
            else:
                return False

    def full_rate(self, sw_instance=None, tested_port=None, frame_size=None):
        """
        @brief Calculation of full line rate for tested ports.
        @param sw_instance:  switch instance
        @type  sw_instance:  SwitchGeneral
        @param tested_port:  switch port ID
        @type  tested_port:  int
        @param frame_size:  frame size
        @type  frame_size:  int
        @rtype:  int
        @return:  full line rate
        """
        speed_value = sw_instance.ui.get_table_ports([tested_port], True)[0]['speed']
        full_line_rate = (speed_value * 1000000.) / ((frame_size + 20) / 8)
        return full_line_rate

# Test Cases
    @pytest.mark.skip("Pypacker does not support Pause frames")
    def test_sent_pause_frames(self, env):
        """
        @brief  Verify that device doesn't flood received pause frames when flow control mode is configured.
        @steps
            -# Configure FlowControl on switch ports.
            -# Send PFC frames to the switch.
            -# Verify PFC frames are not flooded.
        @endsteps
        """
        # Define active ports
        ports = env.get_ports([['tg1', 'sw1', 3], ])

        # Disable all ports and enabling only necessary ones:
        helpers.set_all_ports_admin_disabled(env.switch)
        helpers.set_ports_admin_enabled(env.switch, ports)

        # Wait until ports will be in forwarding state.
        helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP",
                                              state="Forwarding",
                                              port=ports[('sw1', 'tg1')][1],
                                              timeout=120)
        helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP",
                                              state="Forwarding",
                                              port=ports[('sw1', 'tg1')][2],
                                              timeout=120)
        helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP",
                                              state="Forwarding",
                                              port=ports[('sw1', 'tg1')][3],
                                              timeout=120)

        # Configure stream of pause frame.
        pause_frame = ({"Ethernet": {"dst": "01:80:C2:00:00:01",
                                  "src": "00:00:00:00:01:44",
                                  "type": 0x8808}},
                       {"Pause": {"opcode": 0x0001, "ptime": 1}})
        stream = env.tg[1].set_stream(pause_frame,
                                      count=10,
                                      iface=ports[('tg1', 'sw1')][1])

        sniff_ports = list(ports[('tg1', 'sw1')].values())

        # Configure flow control values for all active ports.
        env.switch[1].ui.set_flow_control_type([ports[('sw1', 'tg1')][1],
                                                ports[('sw1', 'tg1')][2],
                                                ports[('sw1', 'tg1')][3]],
                                               control_type='RxTx')

        # Start capture
        env.tg[1].start_sniff(sniff_ports, sniffing_time=5)
        # Send pause frame from the TG port 1.
        env.tg[1].send_stream(stream)

        data = env.tg[1].stop_sniff(sniff_ports)
        helpers.print_sniffed_data_brief(data)
        # Verify that Pause Frames are not forwarded from tested ports.
        params = ({'layer': "Ethernet",
                   'field': "dst",
                   'value': "01:80:C2:00:00:01".lower()}, )
        assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0],
                                                    params=params,
                                                    sniff_data=data,
                                                    tg=env.tg[1])) == 0, \
            "Pause Frames are forwarded from port 1 when PF traffic is sent"
        assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1],
                                                    params=params,
                                                    sniff_data=data,
                                                    tg=env.tg[1])) == 0, \
            "Pause Frames are forwarded from port 2 when PF traffic is sent"
        assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2],
                                                    params=params,
                                                    sniff_data=data,
                                                    tg=env.tg[1])) == 0, \
            "Pause Frames are forwarded from port 3 when PF traffic is sent"

    @pytest.mark.skip("Pypacker does not support Pause frames")
    def test_rxtx_flow_control(self, env):
        """
        @brief Verify that "RxTx" flow control manages traffic correctly.
        @steps
            -# Configure FlowControl on switch ports in 'RxTx' mode.
            -# Send stream of unicast packets with 50% rate to the port 1.
            -# Send stream of unicast packets with 50% rate to the port 2.
            -# Send PFC frames to the port 3.
            -# Verify that line rate on TG port 3 decreases after pause frames with middle quanta are sending
        @endsteps
        """
        self.suite_logger.info("Define variables for test execution")
        pause_frame_rate = 30
        quanta_value = 4096

        # Define active ports
        ports = env.get_ports([['tg1', 'sw1', 3], ])

        # Disable all ports and enabling only necessary ones:
        helpers.set_all_ports_admin_disabled(env.switch)
        helpers.set_ports_admin_enabled(env.switch, ports)

        # Wait until ports will be in forwarding state.
        helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP",
                                              state="Forwarding",
                                              port=ports[('sw1', 'tg1')][1],
                                              timeout=120)
        helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP",
                                              state="Forwarding",
                                              port=ports[('sw1', 'tg1')][2],
                                              timeout=120)
        helpers.wait_until_stp_state(switch_instance=env.switch[1], mode="RSTP",
                                              state="Forwarding",
                                              port=ports[('sw1', 'tg1')][3],
                                              timeout=120)

        # Configure two streams of unicast packets.
        packet_1 = ({"Ethernet": {"dst": "00:00:00:00:00:33",
                               "src": "00:00:00:00:00:11",
                               "type": 0x0800}},
                    {"IP": {}})
        packet_2 = ({"Ethernet": {"dst": "00:00:00:00:00:33",
                               "src": "00:00:00:00:00:22",
                               "type": 0x0800}},
                    {"IP": {}})
        stream_1 = env.tg[1].set_stream(packet_1,
                                        iface=ports[('tg1', 'sw1')][1],
                                        rate=50,
                                        continuous=True)
        stream_2 = env.tg[1].set_stream(packet_2,
                                        iface=ports[('tg1', 'sw1')][2],
                                        rate=50,
                                        continuous=True)

        sniff_ports = list(ports[('tg1', 'sw1')].values())

        # Configure flow control values for all active ports.
        env.switch[1].ui.set_flow_control_type([ports[('sw1', 'tg1')][1],
                                                ports[('sw1', 'tg1')][2],
                                                ports[('sw1', 'tg1')][3]],
                                               control_type='RxTx')

        # Enable Flow Control on TG port 1 and port 2
        env.tg[1].set_flow_control(ports[('tg1', 'sw1')][1], True)
        env.tg[1].set_flow_control(ports[('tg1', 'sw1')][2], True)

        # Send stream of unicast packets from TG port 1.
        env.tg[1].start_streams([stream_1, stream_2, ])
        time.sleep(3)

        # Configure stream of pause frames
        pause_frame = ({"Ethernet": {"dst": "01:80:C2:00:00:01",
                                  "src": "00:00:00:00:01:44",
                                  "type": 0x8808}},
                       {"Pause": {"opcode": 0x0001,
                                  "ptime": quanta_value}})
        stream = env.tg[1].set_stream(pause_frame,
                                      iface=ports[('tg1', 'sw1')][3],
                                      rate=pause_frame_rate,
                                      continuous=True)

        # Send stream of pause frames from TG port 2.
        env.tg[1].start_streams([stream, ])
        time.sleep(3)

        self.suite_logger.debug("Start sniffer for detecting pause frames")
        env.tg[1].start_sniff(sniff_ports, sniffing_time=5, filter_layer='PAUSE')
        time.sleep(5)

        # Define transmit rate limits on TG port 1 and port 2 after sending pause frames to "RxTx" flow control port.
        tx_test_rate1 = env.tg[1].get_port_txrate(ports[('tg1', 'sw1')][1])
        tx_test_rate2 = env.tg[1].get_port_txrate(ports[('tg1', 'sw1')][2])
        # Define receive rate limit on TG port 3 after sending pause frames to "RxTx" flow control port.
        rx_test_rate3 = env.tg[1].get_port_rxrate(ports[('tg1', 'sw1')][3])

        self.suite_logger.debug("Stop sniffer")
        data = env.tg[1].stop_sniff(sniff_ports)
        # Stop streams of unicast packets and pause frames.
        env.tg[1].stop_streams([stream_1, stream_2, stream, ])

        # Verify that pause frames are not forwarded from tested ports.
        params = ({'layer': "Ethernet", 'field': "src", 'value': "00:00:00:00:01:44"}, )
        assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[0],
                                                    params=params,
                                                    sniff_data=data,
                                                    tg=env.tg[1])) == 0, \
            "Pause Frames are forwarded from port 1 when 'RxTx' is configured on all tested ports."
        assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[1],
                                                    params=params,
                                                    sniff_data=data,
                                                    tg=env.tg[1])) == 0, \
            "Pause Frames are forwarded from port 2 when 'RxTx' is configured on all tested ports."
        assert len(helpers.get_packet_from_the_port(sniff_port=sniff_ports[2],
                                                    params=params,
                                                    sniff_data=data,
                                                    tg=env.tg[1])) == 0, \
            "Pause Frames are forwarded from port 3 when 'RxTx' is configured on all tested ports."

        # Verify that line rate on TG port 3 decreases after pause frames with middle quanta are sending.
        if self.rate_decreasing(pf_rate=pause_frame_rate,
                                quanta=quanta_value,
                                pause_frame_size=64,
                                full_rate=self.full_rate(sw_instance=env.switch[1],
                                                         tested_port=ports[('sw1', 'tg1')][3],
                                                         frame_size=64),
                                actual_rate=rx_test_rate3):
            self.suite_logger.debug("Line rate decreases properly when stream of pause frames with middle quanta is sent to 'RxTx' port.")
        else:
            pytest.fail("Line rate is not decreased properly when stream of pause frames with middle quanta is sent to 'RxTx' port.")

        # Verify that transmit line rate on TG port 1 is decreased according to configured "RxTx" flow control on all tested ports.
        if not abs(tx_test_rate1 - (rx_test_rate3 // 2)) <= rx_test_rate3 // 2 * 101 // 100:
            pytest.fail("Transmit line rate is not decreased accordingly to detected overflow on 'RxTx' egress port.")

        # Verify that transmit line rate on TG port 2 is decreased according to configured "RxTx" flow control on all tested ports.
        if not abs(tx_test_rate2 - (rx_test_rate3 // 2)) <= rx_test_rate3 / 2 * 101 // 100:
            pytest.fail("Transmit line rate is not decreased accordingly to detected overflow on 'RxTx' egress port.")

from _pydevd_bundle.pydevd_constants import dict_contains
import sys
from _pydevd_bundle import pydevd_xml
from os.path import basename
import traceback
try:
    from urllib import quote, quote_plus, unquote, unquote_plus
except:
    from urllib.parse import quote, quote_plus, unquote, unquote_plus  #@Reimport @UnresolvedImport

#===================================================================================================
# print_var_node
#===================================================================================================
def print_var_node(xml_node, stream):
    name = xml_node.getAttribute('name')
    value = xml_node.getAttribute('value')
    val_type = xml_node.getAttribute('type')

    found_as = xml_node.getAttribute('found_as')
    stream.write('Name: ')
    stream.write(unquote_plus(name))
    stream.write(', Value: ')
    stream.write(unquote_plus(value))
    stream.write(', Type: ')
    stream.write(unquote_plus(val_type))
    if found_as:
        stream.write(', Found as: %s' % (unquote_plus(found_as),))
    stream.write('\n')

#===================================================================================================
# print_referrers
#===================================================================================================
def print_referrers(obj, stream=None):
    if stream is None:
        stream = sys.stdout
    result = get_referrer_info(obj)
    from xml.dom.minidom import parseString
    dom = parseString(result)

    xml = dom.getElementsByTagName('xml')[0]
    for node in xml.childNodes:
        if node.nodeType == node.TEXT_NODE:
            continue

        if node.localName == 'for':
            stream.write('Searching references for: ')
            for child in node.childNodes:
                if child.nodeType == node.TEXT_NODE:
                    continue
                print_var_node(child, stream)

        elif node.localName == 'var':
            stream.write('Referrer found: ')
            print_var_node(node, stream)

        else:
            sys.stderr.write('Unhandled node: %s\n' % (node,))

    return result


#===================================================================================================
# get_referrer_info
#===================================================================================================
def get_referrer_info(searched_obj):
    DEBUG = 0
    if DEBUG:
        sys.stderr.write('Getting referrers info.\n')
    try:
        try:
            if searched_obj is None:
                ret = ['<xml>\n']

                ret.append('<for>\n')
                ret.append(pydevd_xml.var_to_xml(
                    searched_obj,
                    'Skipping getting referrers for None',
                    additionalInXml=' id="%s"' % (id(searched_obj),)))
                ret.append('</for>\n')
                ret.append('</xml>')
                ret = ''.join(ret)
                return ret

            obj_id = id(searched_obj)

            try:
                if DEBUG:
                    sys.stderr.write('Getting referrers...\n')
                import gc
                referrers = gc.get_referrers(searched_obj)
            except:
                traceback.print_exc()
                ret = ['<xml>\n']

                ret.append('<for>\n')
                ret.append(pydevd_xml.var_to_xml(
                    searched_obj,
                    'Exception raised while trying to get_referrers.',
                    additionalInXml=' id="%s"' % (id(searched_obj),)))
                ret.append('</for>\n')
                ret.append('</xml>')
                ret = ''.join(ret)
                return ret

            if DEBUG:
                sys.stderr.write('Found %s referrers.\n' % (len(referrers),))

            curr_frame = sys._getframe()
            frame_type = type(curr_frame)

            #Ignore this frame and any caller frame of this frame

            ignore_frames = {}  #Should be a set, but it's not available on all python versions.
            while curr_frame is not None:
                if basename(curr_frame.f_code.co_filename).startswith('pydev'):
                    ignore_frames[curr_frame] = 1
                curr_frame = curr_frame.f_back


            ret = ['<xml>\n']

            ret.append('<for>\n')
            if DEBUG:
                sys.stderr.write('Searching Referrers of obj with id="%s"\n' % (obj_id,))

            ret.append(pydevd_xml.var_to_xml(
                searched_obj,
                'Referrers of obj with id="%s"' % (obj_id,)))
            ret.append('</for>\n')

            all_objects = None

            for r in referrers:
                try:
                    if dict_contains(ignore_frames, r):
                        continue  #Skip the references we may add ourselves
                except:
                    pass  #Ok: unhashable type checked...

                if r is referrers:
                    continue

                r_type = type(r)
                r_id = str(id(r))

                representation = str(r_type)

                found_as = ''
                if r_type == frame_type:
                    if DEBUG:
                        sys.stderr.write('Found frame referrer: %r\n' % (r,))
                    for key, val in r.f_locals.items():
                        if val is searched_obj:
                            found_as = key
                            break

                elif r_type == dict:
                    if DEBUG:
                        sys.stderr.write('Found dict referrer: %r\n' % (r,))

                    # Try to check if it's a value in the dict (and under which key it was found)
                    for key, val in r.items():
                        if val is searched_obj:
                            found_as = key
                            if DEBUG:
                                sys.stderr.write('    Found as %r in dict\n' % (found_as,))
                            break

                    #Ok, there's one annoying thing: many times we find it in a dict from an instance,
                    #but with this we don't directly have the class, only the dict, so, to workaround that
                    #we iterate over all reachable objects ad check if one of those has the given dict.
                    if all_objects is None:
                        all_objects = gc.get_objects()

                    for x in all_objects:
                        try:
                            if getattr(x, '__dict__', None) is r:
                                r = x
                                r_type = type(x)
                                r_id = str(id(r))
                                representation = str(r_type)
                                break
                        except:
                            pass  #Just ignore any error here (i.e.: ReferenceError, etc.)

                elif r_type in (tuple, list):
                    if DEBUG:
                        sys.stderr.write('Found tuple referrer: %r\n' % (r,))

                    #Don't use enumerate() because not all Python versions have it.
                    i = 0
                    for x in r:
                        if x is searched_obj:
                            found_as = '%s[%s]' % (r_type.__name__, i)
                            if DEBUG:
                                sys.stderr.write('    Found as %s in tuple: \n' % (found_as,))
                            break
                        i += 1

                if found_as:
                    if not isinstance(found_as, str):
                        found_as = str(found_as)
                    found_as = ' found_as="%s"' % (pydevd_xml.make_valid_xml_value(found_as),)

                ret.append(pydevd_xml.var_to_xml(
                    r,
                    representation,
                    additionalInXml=' id="%s"%s' % (r_id, found_as)))
        finally:
            if DEBUG:
                sys.stderr.write('Done searching for references.\n')

            #If we have any exceptions, don't keep dangling references from this frame to any of our objects.
            all_objects = None
            referrers = None
            searched_obj = None
            r = None
            x = None
            key = None
            val = None
            curr_frame = None
            ignore_frames = None
    except:
        traceback.print_exc()
        ret = ['<xml>\n']

        ret.append('<for>\n')
        ret.append(pydevd_xml.var_to_xml(
            searched_obj,
            'Error getting referrers for:',
            additionalInXml=' id="%s"' % (id(searched_obj),)))
        ret.append('</for>\n')
        ret.append('</xml>')
        ret = ''.join(ret)
        return ret

    ret.append('</xml>')
    ret = ''.join(ret)
    return ret


import mock

from django.test import TestCase
from django.utils import timezone

from myvoice.clinics.models import Visit
from myvoice.core.tests import factories

from .. import tasks
from .. import models
from ..textit import TextItException


@mock.patch('myvoice.survey.tasks.importer.import_responses')
class TestImportResponses(TestCase):

    def test_active_survey(self, import_responses):
        """We should call the import_responses utility for active surveys."""
        self.survey = factories.Survey(active=True)
        tasks.import_responses()
        self.assertEqual(import_responses.call_count, 1)
        self.assertEqual(import_responses.call_args, ((self.survey.flow_id,),))

    def test_inactive_survey(self, import_responses):
        """We should not try to import responses for inactive surveys."""
        self.survey = factories.Survey(active=False)
        tasks.import_responses()
        self.assertEqual(import_responses.call_count, 0)


@mock.patch.object(tasks.TextItApi, 'start_flow')
class TestStartFeedbackSurvey(TestCase):

    def setUp(self):
        super(TestStartFeedbackSurvey, self).setUp()
        self.survey = factories.Survey(role=models.Survey.PATIENT_FEEDBACK)
        self.visit = factories.Visit(mobile='01234567890')

    def test_no_such_survey(self, start_flow):
        """No flow should be started if there is no patient feedback survey."""
        self.survey.delete()
        self.assertRaises(models.Survey.DoesNotExist,
                          tasks.start_feedback_survey,
                          self.visit.pk)
        self.assertEqual(start_flow.call_count, 0)
        self.visit = Visit.objects.get(pk=self.visit.pk)
        self.assertIsNone(self.visit.survey_sent)

    def test_no_such_visit(self, start_flow):
        """No flow should be started if there is no associated visit."""
        self.assertRaises(Visit.DoesNotExist,
                          tasks.start_feedback_survey,
                          12345)
        self.assertEqual(start_flow.call_count, 0)
        self.visit = Visit.objects.get(pk=self.visit.pk)
        self.assertIsNone(self.visit.survey_sent)

    def test_start_flow(self, start_flow):
        """When survey is sent, survey_sent field should be updated."""
        tasks.start_feedback_survey(self.visit.pk)
        self.assertEqual(start_flow.call_count, 1)
        expected = ((self.survey.flow_id, self.visit.mobile),)
        self.assertEqual(start_flow.call_args, expected)
        self.visit = Visit.objects.get(pk=self.visit.pk)
        self.assertIsNotNone(self.visit.survey_sent)

    def test_error(self, start_flow):
        """If error occurs during start_flow, survey_sent should be null."""
        start_flow.side_effect = TextItException
        self.assertRaises(start_flow.side_effect,
                          tasks.start_feedback_survey,
                          self.visit.pk)
        self.assertEqual(start_flow.call_count, 1)
        expected = ((self.survey.flow_id, self.visit.mobile),)
        self.assertEqual(start_flow.call_args, expected)
        self.visit = Visit.objects.get(pk=self.visit.pk)
        self.assertIsNone(self.visit.survey_sent)


@mock.patch.object(tasks.TextItApi, 'send_message')
@mock.patch('myvoice.survey.tasks.start_feedback_survey.apply_async')
class TestHandleNewVisits(TestCase):

    def setUp(self):
        super(TestHandleNewVisits, self).setUp()
        self.survey = factories.Survey(role=models.Survey.PATIENT_FEEDBACK)

    def test_new_visit(self, start_feedback_survey, send_message):
        """
        We should send a welcome message and schedule the survey to be started
        for a new visit.
        """
        visit = factories.Visit(welcome_sent=None, mobile='01234567890')
        tasks.handle_new_visits()
        self.assertEqual(send_message.call_count, 0)
        visit = Visit.objects.get(pk=visit.pk)
        self.assertIsNotNone(visit.welcome_sent)
        self.assertEqual(start_feedback_survey.call_count, 1)

    def test_only_invalid(self, start_feedback_survey, send_message):
        """Nothing should happen if all phone numbers are invalid."""
        visit = factories.Visit(welcome_sent=None, mobile='invalid')
        tasks.handle_new_visits()
        self.assertEqual(send_message.call_count, 0)
        visit = Visit.objects.get(pk=visit.pk)
        self.assertIsNone(visit.welcome_sent)
        self.assertEqual(start_feedback_survey.call_count, 0)

    def test_mixed_valid_invalid_phones(self, start_feedback_survey, send_message):
        """
        We should send a welcome message and schedule the survey to be started
        for a new visit.
        """
        visit1 = factories.Visit(welcome_sent=None, mobile='invalid')
        visit2 = factories.Visit(welcome_sent=None, mobile='01234567890')
        tasks.handle_new_visits()

        # No welcome message sent so send_message.call_count = 0
        self.assertEqual(send_message.call_count, 0)
        visit1 = Visit.objects.get(pk=visit1.pk)
        self.assertIsNone(visit1.welcome_sent)
        visit2 = Visit.objects.get(pk=visit2.pk)
        self.assertIsNotNone(visit2.welcome_sent)
        self.assertEqual(start_feedback_survey.call_count, 1)

    def test_past_visit(self, start_feedback_survey, send_message):
        """
        We should not do anything for visits that have already had the
        welcome message sent.
        """
        welcome_sent = timezone.now()
        visit = factories.Visit(welcome_sent=welcome_sent, mobile='01234567890')
        tasks.handle_new_visits()

        # No welcome message sent so send_message.call_count = 0
        self.assertEqual(send_message.call_count, 0)
        self.assertEqual(start_feedback_survey.call_count, 0)
        visit = Visit.objects.get(pk=visit.pk)
        self.assertEqual(visit.welcome_sent, welcome_sent)
        self.assertIsNone(visit.survey_sent)

    def test_blocked_number(self, start_feedback_survey, send_message):
        """
        We don't start surveys for blocked numbers which are those that are senders
        in one or more Visits.
        """
        factories.Visit(welcome_sent=None, mobile='01234567890', sender='09876543210')
        visit2 = factories.Visit(welcome_sent=None, mobile='09876543210')
        tasks.handle_new_visits()

        # No welcome message sent so send_message.call_count = 0
        self.assertEqual(send_message.call_count, 0)
        visit2 = Visit.objects.get(pk=visit2.pk)
        self.assertIsNone(visit2.welcome_sent)
        self.assertEqual(start_feedback_survey.call_count, 1)


@mock.patch('myvoice.survey.tasks.settings')
class TestGetSurveyStartTime(TestCase):

    def setUp(self):
        self.t1 = timezone.make_aware(
            timezone.datetime(2014, 07, 21, 10, 0, 0, 0), timezone.utc)

    def test_get_start_time(self, settings):
        settings.DEFAULT_SURVEY_DELAY = timezone.timedelta(minutes=5)
        settings.SURVEY_TIME_WINDOW = (7, 20)
        eta = tasks._get_survey_start_time(self.t1)
        self.assertEqual(eta, self.t1.replace(minute=5))

    def test_get_eta_early(self, settings):
        settings.DEFAULT_SURVEY_DELAY = timezone.timedelta(minutes=5)
        settings.SURVEY_TIME_WINDOW = (7, 20)
        tm = self.t1.replace(hour=4)
        eta = tasks._get_survey_start_time(tm)
        self.assertEqual(eta, self.t1.replace(hour=7))

    def test_get_eta_late(self, settings):
        settings.DEFAULT_SURVEY_DELAY = timezone.timedelta(minutes=5)
        settings.SURVEY_TIME_WINDOW = (7, 20)
        tm = self.t1.replace(hour=23)
        eta = tasks._get_survey_start_time(tm)
        self.assertEqual(eta, self.t1.replace(hour=7, day=22))

#!/usr/bin/env python

from __future__ import print_function
from __future__ import absolute_import
import os
import sys
import tct

params = tct.readjson(sys.argv[1])
facts = tct.readjson(params['factsfile'])
milestones = tct.readjson(params['milestonesfile'])
reason = ''
resultfile = params['resultfile']
result = tct.readjson(resultfile)
toolname = params['toolname']
toolname_pure = params['toolname_pure']
toolchain_name = facts['toolchain_name']
workdir = params['workdir']
loglist = result['loglist'] = result.get('loglist', [])
exitcode = CONTINUE = 0


# ==================================================
# Make a copy of milestones for later inspection?
# --------------------------------------------------

if 0 or milestones.get('debug_always_make_milestones_snapshot'):
    tct.make_snapshot_of_milestones(params['milestonesfile'], sys.argv[1])


# ==================================================
# Helper functions
# --------------------------------------------------

deepget = tct.deepget

def lookup(D, *keys, **kwdargs):
    result = deepget(D, *keys, **kwdargs)
    loglist.append((keys, result))
    return result


# ==================================================
# define
# --------------------------------------------------

TheProjectLog = None
TheProjectBuild = None
TheProjectWebroot = None


# ==================================================
# Check params
# --------------------------------------------------

if exitcode == CONTINUE:
    loglist.append('CHECK PARAMS')

    TheProject = lookup(milestones, 'TheProject', default=None)

    if not TheProject:
        exitcode = 22
        reason = 'Bad PARAMS or nothing to do'

if exitcode == CONTINUE:
    loglist.append('PARAMS are ok')
else:
    loglist.append('Bad PARAMS or nothing to do')


# ==================================================
# work
# --------------------------------------------------

if exitcode == CONTINUE:

    resultdir = lookup(milestones, 'resultdir', default=None)

    TheProjectLog = TheProject + 'Log'
    if not os.path.exists(TheProjectLog):
        os.makedirs(TheProjectLog)

    TheProjectBuild = TheProject + 'Build'
    if not os.path.exists(TheProjectBuild):
        os.makedirs(TheProjectBuild)

    if resultdir:
        TheProjectWebroot = os.path.join(resultdir, 'Result')
    else:
        TheProjectWebroot = TheProject + 'Webroot'

    if not os.path.exists(TheProjectWebroot):
        os.makedirs(TheProjectWebroot)


# ==================================================
# Set MILESTONE
# --------------------------------------------------

if TheProjectBuild:
    result['MILESTONES'].append({'TheProjectBuild': TheProjectBuild})

if TheProjectLog:
    result['MILESTONES'].append({'TheProjectLog': TheProjectLog})

if TheProjectWebroot:
    result['MILESTONES'].append({'TheProjectWebroot': TheProjectWebroot})


# ==================================================
# save result
# --------------------------------------------------

tct.save_the_result(result, resultfile, params, facts, milestones, exitcode, CONTINUE, reason)

# ==================================================
# Return with proper exitcode
# --------------------------------------------------

sys.exit(exitcode)

from django.conf import settings
from django.core.cache import caches
from django.core.cache.backends.db import BaseDatabaseCache
from django.core.management.base import BaseCommand, CommandError
from django.db import (
    DEFAULT_DB_ALIAS, connections, models, router, transaction,
)
from django.db.utils import DatabaseError
from django.utils.encoding import force_text


class Command(BaseCommand):
    help = "Creates the tables needed to use the SQL cache backend."

    requires_system_checks = False

    def add_arguments(self, parser):
        parser.add_argument(
            'args', metavar='table_name', nargs='*',
            help='Optional table names. Otherwise, settings.CACHES is used to find cache tables.',
        )
        parser.add_argument(
            '--database', action='store', dest='database',
            default=DEFAULT_DB_ALIAS,
            help='Nominates a database onto which the cache tables will be '
                 'installed. Defaults to the "default" database.',
        )
        parser.add_argument(
            '--dry-run', action='store_true', dest='dry_run',
            help='Does not create the table, just prints the SQL that would be run.',
        )

    def handle(self, *tablenames, **options):
        db = options['database']
        self.verbosity = options['verbosity']
        dry_run = options['dry_run']
        if len(tablenames):
            # Legacy behavior, tablename specified as argument
            for tablename in tablenames:
                self.create_table(db, tablename, dry_run)
        else:
            for cache_alias in settings.CACHES:
                cache = caches[cache_alias]
                if isinstance(cache, BaseDatabaseCache):
                    self.create_table(db, cache._table, dry_run)

    def create_table(self, database, tablename, dry_run):
        cache = BaseDatabaseCache(tablename, {})
        if not router.allow_migrate_model(database, cache.cache_model_class):
            return
        connection = connections[database]

        if tablename in connection.introspection.table_names():
            if self.verbosity > 0:
                self.stdout.write("Cache table '%s' already exists." % tablename)
            return

        fields = (
            # "key" is a reserved word in MySQL, so use "cache_key" instead.
            models.CharField(name='cache_key', max_length=255, unique=True, primary_key=True),
            models.TextField(name='value'),
            models.DateTimeField(name='expires', db_index=True),
        )
        table_output = []
        index_output = []
        qn = connection.ops.quote_name
        for f in fields:
            field_output = [
                qn(f.name),
                f.db_type(connection=connection),
                '%sNULL' % ('NOT ' if not f.null else ''),
            ]
            if f.primary_key:
                field_output.append("PRIMARY KEY")
            elif f.unique:
                field_output.append("UNIQUE")
            if f.db_index:
                unique = "UNIQUE " if f.unique else ""
                index_output.append(
                    "CREATE %sINDEX %s ON %s (%s);" %
                    (unique, qn('%s_%s' % (tablename, f.name)), qn(tablename), qn(f.name))
                )
            table_output.append(" ".join(field_output))
        full_statement = ["CREATE TABLE %s (" % qn(tablename)]
        for i, line in enumerate(table_output):
            full_statement.append('    %s%s' % (line, ',' if i < len(table_output) - 1 else ''))
        full_statement.append(');')

        full_statement = "\n".join(full_statement)

        if dry_run:
            self.stdout.write(full_statement)
            for statement in index_output:
                self.stdout.write(statement)
            return

        with transaction.atomic(using=database, savepoint=connection.features.can_rollback_ddl):
            with connection.cursor() as curs:
                try:
                    curs.execute(full_statement)
                except DatabaseError as e:
                    raise CommandError(
                        "Cache table '%s' could not be created.\nThe error was: %s." %
                        (tablename, force_text(e)))
                for statement in index_output:
                    curs.execute(statement)

        if self.verbosity > 1:
            self.stdout.write("Cache table '%s' created." % tablename)

"""Generic linux daemon base class"""

# Adapted from http://www.jejik.com/files/examples/daemon3x.py
# thanks to the original author

import sys
import os
import time
import atexit
import signal
import syslog
import psutil
import traceback
import gc

class Daemon(object):
    """A generic daemon class.

    Usage: subclass the daemon class and override the run() method."""

    def __init__(self, pidfile):
        self.pidfile = pidfile

    def daemonize(self):
        """Deamonize class. UNIX double fork mechanism."""

        try:
            pid = os.fork()
            if pid > 0:
                # exit first parent
                sys.exit(0)
        except OSError as err:
            sys.stderr.write('fork #1 failed: {0}\n'.format(err))
            sys.exit(1)

        # decouple from parent environment
        os.chdir('/')
        os.setsid()
        os.umask(0)

        # do second fork
        try:
            pid = os.fork()
            if pid > 0:

                # exit from second parent
                sys.exit(0)
        except OSError as err:
            sys.stderr.write('fork #2 failed: {0}\n'.format(err))
            sys.exit(1)

        # redirect standard file descriptors
        sys.stdout.flush()
        sys.stderr.flush()
        stdi = open(os.devnull, 'r')
        stdo = open(os.devnull, 'a+')
        stde = open(os.devnull, 'a+')

        os.dup2(stdi.fileno(), sys.stdin.fileno())
        os.dup2(stdo.fileno(), sys.stdout.fileno())
        os.dup2(stde.fileno(), sys.stderr.fileno())

        # write pidfile
        atexit.register(self.delpid)

        pid = str(os.getpid())
        with open(self.pidfile, 'w+') as fd:
            fd.write(pid + '\n')

    def delpid(self):
        """Delete pid file"""
        os.remove(self.pidfile)

    def start(self):
        """Start the daemon."""

        # Check for a pidfile to see if the daemon already runs
        try:
            with open(self.pidfile, 'r') as pidf:

                pid = int(pidf.read().strip())
        except IOError:
            pid = None

        if pid:
            message = "pidfile {0} already exist. " + \
                    "Daemon already running?\n"
            sys.stderr.write(message.format(self.pidfile))
            sys.exit(1)

        # Start the daemon
        self.daemonize()
        syslog.syslog(syslog.LOG_INFO, '{}: started'.format(os.path.basename(sys.argv[0])))
        while True:
            # look if steam is running
            if len([p for p in psutil.process_iter() if p.name() == 'steam']) == 0:
                try:
                    self.run()
                except Exception as e: # pylint: disable=W0703
                    syslog.syslog(syslog.LOG_ERR, '{}: {!s}'.format(os.path.basename(sys.argv[0]), e))
                    syslog.syslog(syslog.LOG_ERR, traceback.format_exc())
                    gc.collect()
            else:
                syslog.syslog(syslog.LOG_INFO, '{}: steam client is runing'.format(os.path.basename(sys.argv[0])))
            time.sleep(2)

    def stop(self):
        """Stop the daemon."""

        # Get the pid from the pidfile
        try:
            with open(self.pidfile, 'r') as pidf:
                pid = int(pidf.read().strip())
        except IOError:
            pid = None

        if not pid:
            message = "pidfile {0} does not exist. " + \
                    "Daemon not running?\n"
            sys.stderr.write(message.format(self.pidfile))
            return # not an error in a restart

        # Try killing the daemon process
        try:
            while True:
                os.kill(pid, signal.SIGTERM)
                time.sleep(0.1)
        except OSError as err:
            e = str(err.args)
            if e.find("No such process") > 0:
                if os.path.exists(self.pidfile):
                    os.remove(self.pidfile)
            else:
                print(str(err.args))
                sys.exit(1)
        syslog.syslog(syslog.LOG_INFO, '{}: stopped'.format(os.path.basename(sys.argv[0])))

    def restart(self):
        """Restart the daemon."""
        self.stop()
        self.start()

    def run(self):
        """You should override this method when you subclass Daemon.

        It will be called after the process has been daemonized by
        start() or restart()."""

# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for utility functions."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import math
import numpy as np
from scipy import special
import tensorflow as tf

from tensorflow.contrib.distributions.python.ops import distribution_util
from tensorflow.python.framework import tensor_util


class AssertCloseTest(tf.test.TestCase):

  def testAssertCloseIntegerDtype(self):
    x = [1, 5, 10, 15, 20]
    y = x
    z = [2, 5, 10, 15, 20]
    with self.test_session():
      with tf.control_dependencies([distribution_util.assert_close(x, y)]):
        tf.identity(x).eval()

      with tf.control_dependencies([distribution_util.assert_close(y, x)]):
        tf.identity(x).eval()

      with self.assertRaisesOpError("Condition x ~= y"):
        with tf.control_dependencies([distribution_util.assert_close(x, z)]):
          tf.identity(x).eval()

      with self.assertRaisesOpError("Condition x ~= y"):
        with tf.control_dependencies([distribution_util.assert_close(y, z)]):
          tf.identity(y).eval()

  def testAssertCloseNonIntegerDtype(self):
    x = np.array([1., 5, 10, 15, 20], dtype=np.float32)
    y = x + 1e-8
    z = [2., 5, 10, 15, 20]
    with self.test_session():
      with tf.control_dependencies([distribution_util.assert_close(x, y)]):
        tf.identity(x).eval()

      with tf.control_dependencies([distribution_util.assert_close(y, x)]):
        tf.identity(x).eval()

      with self.assertRaisesOpError("Condition x ~= y"):
        with tf.control_dependencies([distribution_util.assert_close(x, z)]):
          tf.identity(x).eval()

      with self.assertRaisesOpError("Condition x ~= y"):
        with tf.control_dependencies([distribution_util.assert_close(y, z)]):
          tf.identity(y).eval()

  def testAssertCloseEpsilon(self):
    x = [0., 5, 10, 15, 20]
    # x != y
    y = [0.1, 5, 10, 15, 20]
    # x = z
    z = [1e-8, 5, 10, 15, 20]
    with self.test_session():
      with tf.control_dependencies([distribution_util.assert_close(x, z)]):
        tf.identity(x).eval()

      with self.assertRaisesOpError("Condition x ~= y"):
        with tf.control_dependencies([distribution_util.assert_close(x, y)]):
          tf.identity(x).eval()

      with self.assertRaisesOpError("Condition x ~= y"):
        with tf.control_dependencies([distribution_util.assert_close(y, z)]):
          tf.identity(y).eval()

  def testAssertIntegerForm(self):
    # This should only be detected as an integer.
    x = [1., 5, 10, 15, 20]
    y = [1.1, 5, 10, 15, 20]
    # First component isn't less than float32.eps = 1e-7
    z = [1.0001, 5, 10, 15, 20]
    # This shouldn"t be detected as an integer.
    w = [1e-8, 5, 10, 15, 20]
    with self.test_session():
      with tf.control_dependencies([distribution_util.assert_integer_form(x)]):
        tf.identity(x).eval()

      with self.assertRaisesOpError("x has non-integer components"):
        with tf.control_dependencies([
            distribution_util.assert_integer_form(y)]):
          tf.identity(y).eval()

      with self.assertRaisesOpError("x has non-integer components"):
        with tf.control_dependencies([
            distribution_util.assert_integer_form(z)]):
          tf.identity(z).eval()

      with self.assertRaisesOpError("x has non-integer components"):
        with tf.control_dependencies([
            distribution_util.assert_integer_form(w)]):
          tf.identity(w).eval()


class GetLogitsAndProbTest(tf.test.TestCase):

  def testGetLogitsAndProbImproperArguments(self):
    with self.test_session():
      with self.assertRaises(ValueError):
        distribution_util.get_logits_and_prob(logits=None, p=None)

      with self.assertRaises(ValueError):
        distribution_util.get_logits_and_prob(logits=[0.1], p=[0.1])

  def testGetLogitsAndProbLogits(self):
    p = np.array([0.01, 0.2, 0.5, 0.7, .99], dtype=np.float32)
    logits = special.logit(p)

    with self.test_session():
      new_logits, new_p = distribution_util.get_logits_and_prob(
          logits=logits, validate_args=True)

      self.assertAllClose(p, new_p.eval())
      self.assertAllClose(logits, new_logits.eval())

  def testGetLogitsAndProbLogitsMultidimensional(self):
    p = np.array([0.2, 0.3, 0.5], dtype=np.float32)
    logits = np.log(p)

    with self.test_session():
      new_logits, new_p = distribution_util.get_logits_and_prob(
          logits=logits, multidimensional=True, validate_args=True)

      self.assertAllClose(new_p.eval(), p)
      self.assertAllClose(new_logits.eval(), logits)

  def testGetLogitsAndProbProbability(self):
    p = np.array([0.01, 0.2, 0.5, 0.7, .99], dtype=np.float32)

    with self.test_session():
      new_logits, new_p = distribution_util.get_logits_and_prob(
          p=p, validate_args=True)

      self.assertAllClose(special.logit(p), new_logits.eval())
      self.assertAllClose(p, new_p.eval())

  def testGetLogitsAndProbProbabilityMultidimensional(self):
    p = np.array([[0.3, 0.4, 0.3], [0.1, 0.5, 0.4]], dtype=np.float32)

    with self.test_session():
      new_logits, new_p = distribution_util.get_logits_and_prob(
          p=p, multidimensional=True, validate_args=True)

      self.assertAllClose(np.log(p), new_logits.eval())
      self.assertAllClose(p, new_p.eval())

  def testGetLogitsAndProbProbabilityValidateArgs(self):
    p = [0.01, 0.2, 0.5, 0.7, .99]
    # Component less than 0.
    p2 = [-1, 0.2, 0.5, 0.3, .2]
    # Component greater than 1.
    p3 = [2, 0.2, 0.5, 0.3, .2]

    with self.test_session():
      _, prob = distribution_util.get_logits_and_prob(p=p, validate_args=True)
      prob.eval()

      with self.assertRaisesOpError("Condition x >= 0"):
        _, prob = distribution_util.get_logits_and_prob(
            p=p2, validate_args=True)
        prob.eval()

      _, prob = distribution_util.get_logits_and_prob(p=p2, validate_args=False)
      prob.eval()

      with self.assertRaisesOpError("p has components greater than 1"):
        _, prob = distribution_util.get_logits_and_prob(
            p=p3, validate_args=True)
        prob.eval()

      _, prob = distribution_util.get_logits_and_prob(p=p3, validate_args=False)
      prob.eval()

  def testGetLogitsAndProbProbabilityValidateArgsMultidimensional(self):
    p = np.array([[0.3, 0.4, 0.3], [0.1, 0.5, 0.4]], dtype=np.float32)
    # Component less than 0. Still sums to 1.
    p2 = np.array([[-.3, 0.4, 0.9], [0.1, 0.5, 0.4]], dtype=np.float32)
    # Component greater than 1. Does not sum to 1.
    p3 = np.array([[1.3, 0.0, 0.0], [0.1, 0.5, 0.4]], dtype=np.float32)
    # Does not sum to 1.
    p4 = np.array([[1.1, 0.3, 0.4], [0.1, 0.5, 0.4]], dtype=np.float32)

    with self.test_session():
      _, prob = distribution_util.get_logits_and_prob(
          p=p, multidimensional=True)
      prob.eval()

      with self.assertRaisesOpError("Condition x >= 0"):
        _, prob = distribution_util.get_logits_and_prob(
            p=p2, multidimensional=True, validate_args=True)
        prob.eval()

      _, prob = distribution_util.get_logits_and_prob(
          p=p2, multidimensional=True, validate_args=False)
      prob.eval()

      with self.assertRaisesOpError(
          "(p has components greater than 1|p does not sum to 1)"):
        _, prob = distribution_util.get_logits_and_prob(
            p=p3, multidimensional=True, validate_args=True)
        prob.eval()

      _, prob = distribution_util.get_logits_and_prob(
          p=p3, multidimensional=True, validate_args=False)
      prob.eval()

      with self.assertRaisesOpError("p does not sum to 1"):
        _, prob = distribution_util.get_logits_and_prob(
            p=p4, multidimensional=True, validate_args=True)
        prob.eval()

      _, prob = distribution_util.get_logits_and_prob(
          p=p4, multidimensional=True, validate_args=False)
      prob.eval()


class LogCombinationsTest(tf.test.TestCase):

  def testLogCombinationsBinomial(self):
    n = [2, 5, 12, 15]
    k = [1, 2, 4, 11]
    log_combs = np.log(special.binom(n, k))

    with self.test_session():
      n = np.array(n, dtype=np.float32)
      counts = [[1., 1], [2., 3], [4., 8], [11, 4]]
      log_binom = distribution_util.log_combinations(n, counts)
      self.assertEqual([4], log_binom.get_shape())
      self.assertAllClose(log_combs, log_binom.eval())

  def testLogCombinationsShape(self):
    # Shape [2, 2]
    n = [[2, 5], [12, 15]]

    with self.test_session():
      n = np.array(n, dtype=np.float32)
      # Shape [2, 2, 4]
      counts = [[[1., 1, 0, 0], [2., 2, 1, 0]], [[4., 4, 1, 3], [10, 1, 1, 4]]]
      log_binom = distribution_util.log_combinations(n, counts)
      self.assertEqual([2, 2], log_binom.get_shape())


class DynamicShapeTest(tf.test.TestCase):

  def testSameDynamicShape(self):
    with self.test_session():
      scalar = tf.constant(2.0)
      scalar1 = tf.placeholder(dtype=tf.float32)

      vector = [0.3, 0.4, 0.5]
      vector1 = tf.placeholder(dtype=tf.float32, shape=[None])
      vector2 = tf.placeholder(dtype=tf.float32, shape=[None])

      multidimensional = [[0.3, 0.4], [0.2, 0.6]]
      multidimensional1 = tf.placeholder(dtype=tf.float32, shape=[None, None])
      multidimensional2 = tf.placeholder(dtype=tf.float32, shape=[None, None])

      # Scalar
      self.assertTrue(distribution_util.same_dynamic_shape(
          scalar, scalar1).eval({
              scalar1: 2.0}))

      # Vector

      self.assertTrue(distribution_util.same_dynamic_shape(
          vector, vector1).eval({
              vector1: [2.0, 3.0, 4.0]}))
      self.assertTrue(distribution_util.same_dynamic_shape(
          vector1, vector2).eval({
              vector1: [2.0, 3.0, 4.0],
              vector2: [2.0, 3.5, 6.0]}))

      # Multidimensional
      self.assertTrue(distribution_util.same_dynamic_shape(
          multidimensional, multidimensional1).eval({
              multidimensional1: [[2.0, 3.0], [3.0, 4.0]]}))
      self.assertTrue(distribution_util.same_dynamic_shape(
          multidimensional1, multidimensional2).eval({
              multidimensional1: [[2.0, 3.0], [3.0, 4.0]],
              multidimensional2: [[1.0, 3.5], [6.3, 2.3]]}))


      # Scalar, X
      self.assertFalse(distribution_util.same_dynamic_shape(
          scalar, vector1).eval({
              vector1: [2.0, 3.0, 4.0]}))
      self.assertFalse(distribution_util.same_dynamic_shape(
          scalar1, vector1).eval({
              scalar1: 2.0,
              vector1: [2.0, 3.0, 4.0]}))
      self.assertFalse(distribution_util.same_dynamic_shape(
          scalar, multidimensional1).eval({
              multidimensional1: [[2.0, 3.0], [3.0, 4.0]]}))
      self.assertFalse(distribution_util.same_dynamic_shape(
          scalar1, multidimensional1).eval({
              scalar1: 2.0,
              multidimensional1: [[2.0, 3.0], [3.0, 4.0]]}))

      # Vector, X
      self.assertFalse(distribution_util.same_dynamic_shape(
          vector, vector1).eval({
              vector1: [2.0, 3.0]}))
      self.assertFalse(distribution_util.same_dynamic_shape(
          vector1, vector2).eval({
              vector1: [2.0, 3.0, 4.0],
              vector2: [6.0]}))
      self.assertFalse(distribution_util.same_dynamic_shape(
          vector, multidimensional1).eval({
              multidimensional1: [[2.0, 3.0], [3.0, 4.0]]}))
      self.assertFalse(distribution_util.same_dynamic_shape(
          vector1, multidimensional1).eval({
              vector1: [2.0, 3.0, 4.0],
              multidimensional1: [[2.0, 3.0], [3.0, 4.0]]}))

      # Multidimensional, X
      self.assertFalse(distribution_util.same_dynamic_shape(
          multidimensional, multidimensional1).eval({
              multidimensional1: [[1.0, 3.5, 5.0], [6.3, 2.3, 7.1]]}))
      self.assertFalse(distribution_util.same_dynamic_shape(
          multidimensional1, multidimensional2).eval({
              multidimensional1: [[2.0, 3.0], [3.0, 4.0]],
              multidimensional2: [[1.0, 3.5, 5.0], [6.3, 2.3, 7.1]]}))



class RotateTransposeTest(tf.test.TestCase):

  def _np_rotate_transpose(self, x, shift):
    if not isinstance(x, np.ndarray):
      x = np.array(x)
    return np.transpose(x, np.roll(np.arange(len(x.shape)), shift))

  def testRollStatic(self):
    with self.test_session():
      with self.assertRaisesRegexp(
          ValueError, "None values not supported."):
        distribution_util.rotate_transpose(None, 1)
      for x in (np.ones(1), np.ones((2, 1)), np.ones((3, 2, 1))):
        for shift in np.arange(-5, 5):
          y = distribution_util.rotate_transpose(x, shift)
          self.assertAllEqual(self._np_rotate_transpose(x, shift),
                              y.eval())
          self.assertAllEqual(np.roll(x.shape, shift),
                              y.get_shape().as_list())

  def testRollDynamic(self):
    with self.test_session() as sess:
      x = tf.placeholder(tf.float32)
      shift = tf.placeholder(tf.int32)
      for x_value in (np.ones(1, dtype=x.dtype.as_numpy_dtype()),
                      np.ones((2, 1), dtype=x.dtype.as_numpy_dtype()),
                      np.ones((3, 2, 1), dtype=x.dtype.as_numpy_dtype())):
        for shift_value in np.arange(-5, 5):
          self.assertAllEqual(
              self._np_rotate_transpose(x_value, shift_value),
              sess.run(distribution_util.rotate_transpose(x, shift),
                       feed_dict={x: x_value, shift: shift_value}))


class PickVectorTest(tf.test.TestCase):

  def testCorrectlyPicksVector(self):
    with self.test_session():
      x = np.arange(10, 12)
      y = np.arange(15, 18)
      self.assertAllEqual(
          x, distribution_util.pick_vector(
              tf.less(0, 5), x, y).eval())
      self.assertAllEqual(
          y, distribution_util.pick_vector(
              tf.less(5, 0), x, y).eval())
      self.assertAllEqual(
          x, distribution_util.pick_vector(
              tf.constant(True), x, y))  # No eval.
      self.assertAllEqual(
          y, distribution_util.pick_vector(
              tf.constant(False), x, y))  # No eval.


class FillLowerTriangularTest(tf.test.TestCase):

  def setUp(self):
    self._rng = np.random.RandomState(42)

  def _fill_lower_triangular(self, x):
    """Numpy implementation of `fill_lower_triangular`."""
    x = np.asarray(x)
    d = x.shape[-1]
    # d = n(n+1)/2 implies n is:
    n = int(0.5 * (math.sqrt(1. + 8. * d) - 1.))
    ids = np.tril_indices(n)
    y = np.zeros(list(x.shape[:-1]) + [n, n], dtype=x.dtype)
    y[..., ids[0], ids[1]] = x
    return y

  def testCorrectlyMakes1x1LowerTril(self):
    with self.test_session():
      x = tf.convert_to_tensor(self._rng.randn(3, 1))
      expected = self._fill_lower_triangular(tensor_util.constant_value(x))
      actual = distribution_util.fill_lower_triangular(x, validate_args=True)
      self.assertAllEqual(expected.shape, actual.get_shape())
      self.assertAllEqual(expected, actual.eval())

  def testCorrectlyMakesNoBatchLowerTril(self):
    with self.test_session():
      x = tf.convert_to_tensor(self._rng.randn(10))
      expected = self._fill_lower_triangular(tensor_util.constant_value(x))
      actual = distribution_util.fill_lower_triangular(x, validate_args=True)
      self.assertAllEqual(expected.shape, actual.get_shape())
      self.assertAllEqual(expected, actual.eval())
      g = tf.gradients(distribution_util.fill_lower_triangular(x), x)
      self.assertAllEqual(np.tri(4).reshape(-1), g[0].values.eval())

  def testCorrectlyMakesBatchLowerTril(self):
    with self.test_session():
      x = tf.convert_to_tensor(self._rng.randn(2, 2, 6))
      expected = self._fill_lower_triangular(tensor_util.constant_value(x))
      actual = distribution_util.fill_lower_triangular(x, validate_args=True)
      self.assertAllEqual(expected.shape, actual.get_shape())
      self.assertAllEqual(expected, actual.eval())
      self.assertAllEqual(
          np.ones((2, 2, 6)),
          tf.gradients(distribution_util.fill_lower_triangular(
              x), x)[0].eval())


class GenNewSeedTest(tf.test.TestCase):

  def testOnlyNoneReturnsNone(self):
    self.assertFalse(distribution_util.gen_new_seed(0, "salt") is None)
    self.assertTrue(distribution_util.gen_new_seed(None, "salt") is None)


if __name__ == "__main__":
  tf.test.main()

import os
import tempfile
import numpy
import math
import random
import time

from weka_utilities import test_file_creation, feature_selection, Test_result
from data_mining.PrintOutput import PrintOutput

#loads system variables                                                                                  
path = os.environ.get('OPUS_HOME')
path = os.path.join(path, "src", "data_mining", "SYSTEM_VARIABLES.py")
execfile(path) 

class Num_model :

    def __init__(self, xml_elem, MAKE_ALL_PREDS, logCB = None, progressCB = None) :

        #For reporting results
        self.printOut = PrintOutput(logCB, progressCB, PROFILING) 

        #Test specific information
        self.test_attribute = xml_elem.attributes["test_attribute"].value
        
        self.test_classifier = "weka.classifiers.lazy.IBk"
        if xml_elem.hasAttribute("test_classifier") :
            self.test_classifier = xml_elem.attributes["classifier"].value

        self.test_options = "-I -K 20 -X -A weka.core.neighboursearch.KDTree"
        if xml_elem.hasAttribute("options") :
            self.test_options = xml_elem.attributes["options"].value

        #Feature selection information
        self.use_feature_selection = False
        self.using_pca = False
        self.search_class = ""
        self.evaluation_class = ""
        if xml_elem.hasAttribute('fs_evaluation_class'):
            self.use_feature_selection = True

            self.search_class = xml_elem.attributes["fs_search_class"].value
            self.evaluation_class = xml_elem.attributes["fs_evaluation_class"].value
            
            #Checking for pca
            if self.evaluation_class.find("PrincipalComponents") > -1 :
                self.using_pca = True
                
            #Attributes that the search class starts with (Not used with PCA)
            self.start_attributes = []
            if xml_elem.hasAttribute('fs_start_attributes') :
                self.start_attributes = util_get_attribute_list(xml_elem.attributes['fs_start_attributes'].value)  
            
        #Attributes that are used to make the prediction        
        attributes_string = xml_elem.attributes["train_attributes"].value
        self.attributes = util_get_attribute_list(attributes_string)

        #Values that are considered null for the target attribute
        self.null_value_list = []
        elements = xml_elem.getElementsByTagName('null_values')
        if len(elements) > 0 :
            null_val_element = elements[0]
            for element in null_val_element.getElementsByTagName('v') :
    
                attribute = element.attributes['attribute'].value
                type = element.attributes['type'].value
                value = element.attributes['value'].value
                vt = element.attributes['vt'].value
    
                null_dict = {"attribute" : attribute, "type" : type}
    
                if vt == "int" :
                    null_dict["value"] = int(value)
                elif vt == "string" :
                    null_dict["value"] = str(value)
            
                self.null_value_list.append(null_dict)

        #Simply defined null values
        if xml_elem.hasAttribute("null_value") :
            null_value = xml_elem.attributes["null_value"].value
            null_dict = {"attribute" : self.test_attribute, "type" : "E", "value" : int(null_value)}
            self.null_value_list.append(null_dict)

        #Random information
        self.test_type = "Num"
        self.MAKE_ALL_PREDS = MAKE_ALL_PREDS           
        
    def get_predictions(self, query_manager) :

        #Filenames
        test_filename = "test" + str(int(time.time())) + ".arff"
        train_filename = "train" + str(int(time.time())) + ".arff"
        train_log = "train_log" + str(int(time.time())) + ".arff"
        result_filename = "results" + str(int(time.time())) + ".txt"


        #Creates (or clears) files that are used by the binary 
        IS_NUM_TEST = True
        file_creation_info = test_file_creation(IS_NUM_TEST, self.using_pca, test_filename, train_filename, query_manager, self)
        target_values = file_creation_info["target_values"]
        target_value_null = file_creation_info["target_value_null"]
        attribute_indexes = file_creation_info["attribute_indexes"]

        #If there are no null values in the test set
        #And the run is only replacing null values then terminate if no null values
        if not self.MAKE_ALL_PREDS and target_value_null.count(True) == 0 :
            os.remove(test_filename)
            os.remove(train_filename)            
            return None


        #Running feature selection process if needed
        acc_est = {}
        if self.use_feature_selection :
            (test_filename, train_filename, selected_attributes) = feature_selection(test_filename, train_filename, query_manager, file_creation_info, self, IS_NUM_TEST)
            acc_est["selected attributes"] = selected_attributes
                      
        #Running tests
        model_name = "saved_model" + str(int(time.time()))
        path_spef_weka = os.path.join( path, "models", "weka.jar")
        train_string = "java -Xmx1024m -cp " + path_spef_weka + " " + self.test_classifier + " -d " + model_name  + " " + self.test_options + " -t " + train_filename + " >> " + train_log
        test_string = "java -Xmx1024m -cp " +  path_spef_weka + " " + self.test_classifier + " -l " + model_name + " -T " + test_filename + " -p 0 >> " + result_filename

        self.printOut.pLog( "PRED- Training model")
        os.system(train_string)
        self.printOut.pLog( "PRED- Making predictions")
        os.system(test_string)
                    
        #Gathering results for each test instance
        self.printOut.pLog( "PRED- Getting results")
        f = open(result_filename)
        
        prediction_list = []
        confidence_list = []
        
        #For stat keeping
        absolute_diff_list = [] 
        relative_diff_list = []
        
        index = 0
        collect_results = False
        for line in f.readlines() :
            line_list = line.split()
            
            #Getting results
            if collect_results and len(line_list) > 1:
                prediction = float(line_list[2])
                prediction_list.append(prediction)
                confidence_list.append(0.0)
                
                #Getting difference between predicted and actuall results 
                #For non null values
                if not target_value_null[index] :
                    actual = float(target_values[index])
                    diff = math.fabs(actual - prediction)
                    
                    absolute_diff_list.append(diff)
                    if actual > 0 :
                        relative_diff_list.append(diff / actual)
                    else :
                        relative_diff_list.append(-1)
                index += 1
            
            #Seeing if you are at the results portion of the file
            if line.find("inst#") > -1 :
                collect_results = True            
        
        f.close()

        #Gathering accuracy estimations
        f = open(train_log)

        cross_val_info = False
        get_k_value = False
        for line in f.readlines() :
        
            #Getting all performance related metrics
            if cross_val_info :
                line = line.rstrip('\n')
                line = line.rstrip('\t')
                line = line.rstrip('\b')
                line = line.rstrip(' %')
        
                list = line.split('  ')
                if len(list) > 1:
                    attribute = list[0]
                    value = list[len(list) - 1]
                    value = float(value)
                    acc_est[attribute] = value
        
            #Getting parameter search results
            if get_k_value and line.find('using') > -1:
                list = line.split(' ')
                k = int(list[1])
                acc_est["1 Parameter: k value"] = k
                get_k_value = False
        
            #Finding cross validation info                                                                   
            if line.find('Cross-validation') > -1 :
                cross_val_info = True

            #Finding k value info
            if line.find('IB1 instance-based classifier') > -1 :
                get_k_value = True

        f.close()

        #Adding actual performance statistics
        absolute_diff_array = numpy.array(absolute_diff_list)
        relative_diff_array = numpy.array(relative_diff_list)

        absolute_mean = numpy.mean(absolute_diff_array)
        absolute_std = numpy.std(absolute_diff_array)

        relative_mean = numpy.mean(relative_diff_array)
        relative_std = numpy.std(relative_diff_array)
        
        acc_est["2 On test data: mean absolute diff"] = absolute_mean
        acc_est["2 On test data: std absolute diff"] = absolute_std
        acc_est["2 On test data: mean relative diff"] = relative_mean
        acc_est["2 On test data: std relative diff"] = relative_std
        

        #Add number of test instances to the accuracy estimation
        current_test_num = query_manager.current_test_block.parcel_count
        acc_est["test instance count"] = current_test_num / query_manager.group_max
        acc_est["block number"] = (len(query_manager.used_blocks) - 1)*query_manager.group_max + query_manager.group_count
         
        #Removing files
        os.remove(test_filename)
        os.remove(train_filename)
        os.remove(train_log)
        os.remove(result_filename)
        os.remove(model_name)                  
                    
        return Test_result("Num", self.test_attribute, prediction_list, confidence_list, acc_est)

    

#Gets attributes from a string        
def util_get_attribute_list(string):
    initial_list = string.split(",")
    
    list = []
    for attribute in initial_list :
        new = attribute.rstrip(" ")
        new = new.lstrip(" ")
        list.append(str(new))

    return list
        

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Copyright (C) 2014 The ProteinDF development team.
# see also AUTHORS and README if provided.
#
# This file is a part of the ProteinDF software package.
#
# The ProteinDF is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# The ProteinDF is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with ProteinDF.  If not, see <http://www.gnu.org/licenses/>.

"""
output xyz
"""

import os
import sys
import argparse
try:
    import msgpack
except:
    import msgpack_pure as msgpack

import proteindf_tools as pdf

ANG2AU = 0.52917721067

def main():
    # parse args
    parser = argparse.ArgumentParser(description='output XYZ file')
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument('-d', '--db',
                       nargs='?',
                       action='store',
                       const='pdfresults.db',
                       help='ProteinDF results file')
    group.add_argument('-p', '--param',
                       nargs='?',
                       action='store',
                       const='pdfparam.mpac',
                       help='ProteinDF parameter file')
    parser.add_argument("-v", "--verbose",
                        action="store_true",
                        default=False)
    parser.add_argument('-D', '--debug',
                        action='store_true',
                        default=False)
    args = parser.parse_args()

    # setting
    verbose = args.verbose
    if args.debug:
        logging.basicConfig(level=logging.DEBUG)

    #
    atomgroup = None
    if args.db:
        entry = pdf.PdfArchive(args.db)
        atomgroup = entry.get_molecule()
    elif args.param:
        pdfparam = pdf.load_pdfparam(args.param)
        atomgroup = pdfparam.molecule

    # a.u, to angstroam
    atomgroup *= ANG2AU
    print(atomgroup.get_xyz())

if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-
#
# Copyright 2012-2015 Spotify AB
#
# 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.
#

import getpass
import os

import luigi.contrib.hadoop
import luigi.contrib.hdfs
from nose.plugins.attrib import attr

import unittest

try:
    from snakebite.minicluster import MiniCluster
except ImportError:
    raise unittest.SkipTest('Snakebite not installed')


@attr('minicluster')
class MiniClusterTestCase(unittest.TestCase):

    """ Base class for test cases that rely on Hadoop's minicluster functionality. This
    in turn depends on Snakebite's minicluster setup:

    http://hadoop.apache.org/docs/r2.5.1/hadoop-project-dist/hadoop-common/CLIMiniCluster.html
    https://github.com/spotify/snakebite"""
    cluster = None

    @classmethod
    def setupClass(cls):
        if not cls.cluster:
            cls.cluster = MiniCluster(None, nnport=50030)
        cls.cluster.mkdir("/tmp")

    @classmethod
    def tearDownClass(cls):
        if cls.cluster:
            cls.cluster.terminate()

    def setUp(self):
        self.fs = luigi.contrib.hdfs.get_autoconfig_client()
        cfg_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "testconfig")
        hadoop_bin = os.path.join(os.environ['HADOOP_HOME'], 'bin/hadoop')
        cmd = "{} --config {}".format(hadoop_bin, cfg_path)
        self.stashed_hdfs_client = luigi.configuration.get_config().get('hadoop', 'command', None)
        luigi.configuration.get_config().set('hadoop', 'command', cmd)

    def tearDown(self):
        if self.fs.exists(self._test_dir()):
            self.fs.remove(self._test_dir(), skip_trash=True)
        if self.stashed_hdfs_client:
            luigi.configuration.get_config().set('hadoop', 'command', self.stashed_hdfs_client)

    @staticmethod
    def _test_dir():
        return '/tmp/luigi_tmp_testdir_%s' % getpass.getuser()

    @staticmethod
    def _test_file(suffix=""):
        return '%s/luigi_tmp_testfile%s' % (MiniClusterTestCase._test_dir(), suffix)


class MiniClusterHadoopJobRunner(luigi.contrib.hadoop.HadoopJobRunner):

    ''' The default job runner just reads from config and sets stuff '''

    def __init__(self):
        # Locate the hadoop streaming jar in the hadoop directory
        hadoop_tools_lib = os.path.join(os.environ['HADOOP_HOME'], 'share/hadoop/tools/lib')

        for path in os.listdir(hadoop_tools_lib):
            if path.startswith('hadoop-streaming') and path.endswith('.jar'):
                streaming_jar = os.path.join(hadoop_tools_lib, path)
                break
        else:
            raise Exception('Could not locate streaming jar in ' + hadoop_tools_lib)

        super(MiniClusterHadoopJobRunner, self).__init__(streaming_jar=streaming_jar)

#
# Newfies-Dialer License
# http://www.newfies-dialer.org
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.
#
# Copyright (C) 2011-2012 Star2Billing S.L.
#
# The Initial Developer of the Original Code is
# Arezqui Belaid <info@star2billing.com>
#

from django.template.defaultfilters import register
from django.utils.translation import ugettext as _
from mod_sms.constants import SMS_CAMPAIGN_STATUS, SMS_CAMPAIGN_STATUS_COLOR
from mod_utils.function_def import get_common_campaign_status_url, get_common_campaign_status,\
    get_status_value


@register.filter(name='sms_campaign_status')
def sms_campaign_status(value):
    """SMS Campaign Status

    >>> sms_campaign_status(1)
    'START'

    >>> sms_campaign_status(2)
    'PAUSE'

    >>> sms_campaign_status(3)
    'ABORT'

    >>> sms_campaign_status(4)
    'END'

    >>> sms_campaign_status(0)
    ''
    """
    return get_status_value(value, SMS_CAMPAIGN_STATUS)


@register.filter(name='get_sms_campaign_status')
def get_sms_campaign_status(id):
    return get_common_campaign_status(id, SMS_CAMPAIGN_STATUS, SMS_CAMPAIGN_STATUS_COLOR)


@register.simple_tag(name='get_sms_campaign_status_url')
def get_sms_campaign_status_url(id, status):
    return get_common_campaign_status_url(
        id, status, 'update_sms_campaign_status_cust/', SMS_CAMPAIGN_STATUS)


@register.filter(name='create_duplicate_sms_campaign')
def create_duplicate_sms_campaign(sms_campaign_id):
    """Create link to make duplicate campaign"""
    link = '<a href="#sms-campaign-duplicate"  url="/sms_campaign/duplicate/%s/" class="sms-campaign-duplicate" data-toggle="modal" data-controls-modal="sms-campaign-duplicate" title="%s"><i class="fa fa-copy"></i></a>' \
           % (sms_campaign_id, _('duplicate this sms campaign').capitalize())
    return link


@register.filter(name='get_sms_campaign_textmessage')
def get_sms_campaign_textmessage(sms_campaign_id):
    """Create link to get sms campaign's text-message"""
    link = '<a href="#sms-campaign-textmessage"  url="/sms_campaign/text_message/%s/" class="sms-campaign-textmessage" data-toggle="modal" data-controls-modal="sms-campaign-textmessage" title="%s"><i class="fa fa-search"></i></a>' \
           % (sms_campaign_id, _('get text-message of this sms campaign').capitalize())
    return link

import hashlib
import simplejson

from django.contrib.auth.models import User
from django.db import models
from django.shortcuts import get_object_or_404
from django.template.defaultfilters import slugify
from django.utils.translation import ugettext_lazy as _
from django.utils import timezone

from guardian.shortcuts import *

from agora_site.misc.utils import JSONField
from agora_site.agora_core.models.election import Election
from agora_site.agora_core.models.castvote import CastVote


class DelegateElectionCount(models.Model):
    '''
    Stores how many people delegated into a delegate in a given election
    '''
    delegate = models.ForeignKey(User, related_name='delegate_election_counts',
        verbose_name=_('Delegate'), null=False)

    election = models.ForeignKey(Election, related_name='delegate_election_counts',
        verbose_name=_('Election'), null=False)

    # number of effective vote delegations
    count = models.IntegerField(null=False)

    # number of effective vote delegations / number of valid votes in the election
    # 0 if number of valid votes is zero
    count_percentage = models.FloatField(null=False, default=0)

    # position in the rank of delegates with more effective vote delegations
    # None if the delegate did not get any effective vote delegation
    rank = models.IntegerField(null=True, blank=True)

    created_at_date = models.DateTimeField(_(u'Created at date'),
        auto_now_add=True, editable=True, default=timezone.now())

    delegate_vote = models.ForeignKey(CastVote, related_name='delegate_election_count',
        verbose_name=_('Delegate vote'), null=True, blank=True)

    class Meta:
        app_label = 'agora_core'
        unique_together = (('election', 'delegate'),)

# Copyright 2006--2010 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
# Authors:
#     Jan Pazdziora jpazdziora at redhat dot com
#     Daniel Benamy <dbenamy@redhat.com>

import sys
sys.path.append("/usr/share/rhn")
from up2date_client import rhnreg
from up2date_client import rhnregGui

import gtk
from gtk import glade

import gettext
_ = lambda x: gettext.ldgettext("rhn-client-tools", x)

gtk.glade.bindtextdomain("rhn-client-tools")

from firstboot.module import Module
from firstboot.constants import *

class moduleClass(Module):
    def __init__(self):
        Module.__init__(self)
        self.priority = 107.5
        self.sidebarTitle = _("Provide Certificate")
        self.title = _("Provide Certificate")

    def needsNetwork(self):
        return True

    def apply(self, interface, testing=False):
        if testing:
            return RESULT_SUCCESS

        status = self.provideCertificatePage.provideCertificatePageApply()
        if status == 0: # cert was installed
            return RESULT_SUCCESS
        elif status == 1: # the user doesn't want to provide a cert right now
            # TODO write a message to disk like the other cases? need to decide
            # how we want to do error handling in general.
            interface.moveToPage(moduleTitle=_("Finish Updates Setup"))
            return RESULT_JUMP
        else: # an error occurred and the user was notified
            assert status == 2
            return RESULT_FAILURE

    def createScreen(self):
        self.provideCertificatePage = rhnregGui.ProvideCertificatePage()
        self.vbox = gtk.VBox(spacing=5)
        self.vbox.pack_start(self.provideCertificatePage.provideCertificatePageVbox(), True, True)

    def initializeUI(self):
        self.provideCertificatePage.setUrlInWidget()

    def shouldAppear(self):
        if rhnreg.registered():
            return False
        return True


#!/usr/bin/env python
# ----------------------------------------------------------------------------
# pyglet
# Copyright (c) 2006-2008 Alex Holkner
# All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions 
# are met:
#
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright 
#    notice, this list of conditions and the following disclaimer in
#    the documentation and/or other materials provided with the
#    distribution.
#  * Neither the name of pyglet nor the names of its
#    contributors may be used to endorse or promote products
#    derived from this software without specific prior written
#    permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------

# An example setup.py that can be used to create both standalone Windows
# executables (requires py2exe) and Mac OS X applications (requires py2app).
#
# On Windows::
#
#     python setup.py py2exe
#
# On Mac OS X::
#
#     python setup.py py2app
#

from distutils.core import setup

import os

# The main entry point of the program
script_file = 'astraea.py'

# Create a list of data files.  Add everything in the 'res/' directory.
data_files = []
for file in os.listdir('res'):
    file = os.path.join('res', file)
    if os.path.isfile(file):
        data_files.append(file)

# Setup args that apply to all setups, including ordinary distutils.
setup_args = dict(
    data_files=[('res', data_files)]
)

# py2exe options
try:
    import py2exe
    setup_args.update(dict(
        windows=[dict(
            script=script_file,
            icon_resources=[(1, 'assets/app.ico')],
        )],
    ))
except ImportError:
    pass

# py2app options
try:
    import py2app
    setup_args.update(dict(
        app=[script_file],
        options=dict(py2app=dict(
            argv_emulation=True,
            iconfile='assets/app.icns',
        )),
    ))
except ImportError:
    pass

setup(**setup_args)

# Copyright (c) 2013 NTT DOCOMO, INC.
# Copyright 2014 IBM Corporation.
# All Rights Reserved.
#
#    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.

"""The bare-metal admin extension."""

from oslo_config import cfg
from oslo_utils import importutils
import webob

from nova.api.openstack import common
from nova.api.openstack import extensions
from nova.api.openstack import wsgi
from nova.i18n import _

ironic_client = importutils.try_import('ironicclient.client')
ironic_exc = importutils.try_import('ironicclient.exc')

CONF = cfg.CONF
ALIAS = "os-baremetal-nodes"
authorize = extensions.os_compute_authorizer(ALIAS)

node_fields = ['id', 'cpus', 'local_gb', 'memory_mb', 'pm_address',
               'pm_user', 'service_host', 'terminal_port', 'instance_uuid']

node_ext_fields = ['uuid', 'task_state', 'updated_at', 'pxe_config_path']

interface_fields = ['id', 'address', 'datapath_id', 'port_no']

CONF.import_opt('api_version',
                'nova.virt.ironic.driver',
                group='ironic')
CONF.import_opt('api_endpoint',
                'nova.virt.ironic.driver',
                group='ironic')
CONF.import_opt('admin_username',
                'nova.virt.ironic.driver',
                group='ironic')
CONF.import_opt('admin_password',
                'nova.virt.ironic.driver',
                group='ironic')
CONF.import_opt('admin_tenant_name',
                'nova.virt.ironic.driver',
                group='ironic')
CONF.import_opt('compute_driver', 'nova.virt.driver')


def _check_ironic_client_enabled():
    """Check whether Ironic is installed or not."""
    if ironic_client is None:
        common.raise_feature_not_supported()


def _get_ironic_client():
    """return an Ironic client."""
    # TODO(NobodyCam): Fix insecure setting
    kwargs = {'os_username': CONF.ironic.admin_username,
              'os_password': CONF.ironic.admin_password,
              'os_auth_url': CONF.ironic.admin_url,
              'os_tenant_name': CONF.ironic.admin_tenant_name,
              'os_service_type': 'baremetal',
              'os_endpoint_type': 'public',
              'insecure': 'true',
              'ironic_url': CONF.ironic.api_endpoint}
    icli = ironic_client.get_client(CONF.ironic.api_version, **kwargs)
    return icli


def _no_ironic_proxy(cmd):
    raise webob.exc.HTTPBadRequest(
                    explanation=_("Command Not supported. Please use Ironic "
                                  "command %(cmd)s to perform this "
                                  "action.") % {'cmd': cmd})


class BareMetalNodeController(wsgi.Controller):
    """The Bare-Metal Node API controller for the OpenStack API."""

    def _node_dict(self, node_ref):
        d = {}
        for f in node_fields:
            d[f] = node_ref.get(f)
        for f in node_ext_fields:
            d[f] = node_ref.get(f)
        return d

    @extensions.expected_errors((404, 501))
    def index(self, req):
        context = req.environ['nova.context']
        authorize(context)
        nodes = []
        # proxy command to Ironic
        _check_ironic_client_enabled()
        icli = _get_ironic_client()
        ironic_nodes = icli.node.list(detail=True)
        for inode in ironic_nodes:
            node = {'id': inode.uuid,
                    'interfaces': [],
                    'host': 'IRONIC MANAGED',
                    'task_state': inode.provision_state,
                    'cpus': inode.properties.get('cpus', 0),
                    'memory_mb': inode.properties.get('memory_mb', 0),
                    'disk_gb': inode.properties.get('local_gb', 0)}
            nodes.append(node)
        return {'nodes': nodes}

    @extensions.expected_errors((404, 501))
    def show(self, req, id):
        context = req.environ['nova.context']
        authorize(context)
        # proxy command to Ironic
        _check_ironic_client_enabled()
        icli = _get_ironic_client()
        try:
            inode = icli.node.get(id)
        except ironic_exc.NotFound:
            msg = _("Node %s could not be found.") % id
            raise webob.exc.HTTPNotFound(explanation=msg)
        iports = icli.node.list_ports(id)
        node = {'id': inode.uuid,
                'interfaces': [],
                'host': 'IRONIC MANAGED',
                'task_state': inode.provision_state,
                'cpus': inode.properties.get('cpus', 0),
                'memory_mb': inode.properties.get('memory_mb', 0),
                'disk_gb': inode.properties.get('local_gb', 0),
                'instance_uuid': inode.instance_uuid}
        for port in iports:
            node['interfaces'].append({'address': port.address})
        return {'node': node}

    @extensions.expected_errors(400)
    def create(self, req, body):
        _no_ironic_proxy("port-create")

    @extensions.expected_errors(400)
    def delete(self, req, id):
        _no_ironic_proxy("port-create")

    @wsgi.action('add_interface')
    @extensions.expected_errors(400)
    def _add_interface(self, req, id, body):
        _no_ironic_proxy("port-create")

    @wsgi.action('remove_interface')
    @extensions.expected_errors(400)
    def _remove_interface(self, req, id, body):
        _no_ironic_proxy("port-delete")


class BareMetalNodes(extensions.V3APIExtensionBase):
    """Admin-only bare-metal node administration."""

    name = "BareMetalNodes"
    alias = ALIAS
    version = 1

    def get_resources(self):
        resource = [extensions.ResourceExtension(ALIAS,
                BareMetalNodeController(),
                member_actions={"action": "POST"})]
        return resource

    def get_controller_extensions(self):
        """It's an abstract function V3APIExtensionBase and the extension
        will not be loaded without it.
        """
        return []

#!/usr/bin/env python
# Copyright 2017 gRPC authors.
#
# 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.

import yaml
import argparse
import datetime
import csv

argp = argparse.ArgumentParser(description='Convert cloc yaml to bigquery csv')
argp.add_argument('-i', '--input', type=str)
argp.add_argument(
    '-d',
    '--date',
    type=str,
    default=datetime.date.today().strftime('%Y-%m-%d'))
argp.add_argument('-o', '--output', type=str, default='out.csv')
args = argp.parse_args()

data = yaml.load(open(args.input).read())
with open(args.output, 'w') as outf:
    writer = csv.DictWriter(
        outf, ['date', 'name', 'language', 'code', 'comment', 'blank'])
    for key, value in data.iteritems():
        if key == 'header': continue
        if key == 'SUM': continue
        if key.startswith('third_party/'): continue
        row = {'name': key, 'date': args.date}
        row.update(value)
        writer.writerow(row)

#    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.

import os.path

from oslo_log import log as logging
from tempest_lib.common.utils import data_utils
from tempest_lib import exceptions as lib_exc
import yaml

from tempest import config
import tempest.test

CONF = config.CONF

LOG = logging.getLogger(__name__)


class BaseOrchestrationTest(tempest.test.BaseTestCase):
    """Base test case class for all Orchestration API tests."""

    credentials = ['primary']

    @classmethod
    def skip_checks(cls):
        super(BaseOrchestrationTest, cls).skip_checks()
        if not CONF.service_available.heat:
            raise cls.skipException("Heat support is required")

    @classmethod
    def setup_credentials(cls):
        super(BaseOrchestrationTest, cls).setup_credentials()
        stack_owner_role = CONF.orchestration.stack_owner_role
        cls.os = cls.get_client_manager(roles=[stack_owner_role])

    @classmethod
    def setup_clients(cls):
        super(BaseOrchestrationTest, cls).setup_clients()
        cls.orchestration_client = cls.os.orchestration_client
        cls.client = cls.orchestration_client
        cls.servers_client = cls.os.servers_client
        cls.keypairs_client = cls.os.keypairs_client
        cls.network_client = cls.os.network_client
        cls.volumes_client = cls.os.volumes_client
        cls.images_v2_client = cls.os.image_client_v2

    @classmethod
    def resource_setup(cls):
        super(BaseOrchestrationTest, cls).resource_setup()
        cls.build_timeout = CONF.orchestration.build_timeout
        cls.build_interval = CONF.orchestration.build_interval
        cls.stacks = []
        cls.keypairs = []
        cls.images = []

    @classmethod
    def create_stack(cls, stack_name, template_data, parameters=None,
                     environment=None, files=None):
        if parameters is None:
            parameters = {}
        body = cls.client.create_stack(
            stack_name,
            template=template_data,
            parameters=parameters,
            environment=environment,
            files=files)
        stack_id = body.response['location'].split('/')[-1]
        stack_identifier = '%s/%s' % (stack_name, stack_id)
        cls.stacks.append(stack_identifier)
        return stack_identifier

    @classmethod
    def _clear_stacks(cls):
        for stack_identifier in cls.stacks:
            try:
                cls.client.delete_stack(stack_identifier)
            except lib_exc.NotFound:
                pass

        for stack_identifier in cls.stacks:
            try:
                cls.client.wait_for_stack_status(
                    stack_identifier, 'DELETE_COMPLETE')
            except lib_exc.NotFound:
                pass

    @classmethod
    def _create_keypair(cls, name_start='keypair-heat-'):
        kp_name = data_utils.rand_name(name_start)
        body = cls.keypairs_client.create_keypair(kp_name)
        cls.keypairs.append(kp_name)
        return body

    @classmethod
    def _clear_keypairs(cls):
        for kp_name in cls.keypairs:
            try:
                cls.keypairs_client.delete_keypair(kp_name)
            except Exception:
                pass

    @classmethod
    def _create_image(cls, name_start='image-heat-', container_format='bare',
                      disk_format='iso'):
        image_name = data_utils.rand_name(name_start)
        body = cls.images_v2_client.create_image(image_name,
                                                 container_format,
                                                 disk_format)
        image_id = body['id']
        cls.images.append(image_id)
        return body

    @classmethod
    def _clear_images(cls):
        for image_id in cls.images:
            try:
                cls.images_v2_client.delete_image(image_id)
            except lib_exc.NotFound:
                pass

    @classmethod
    def read_template(cls, name, ext='yaml'):
        loc = ["stacks", "templates", "%s.%s" % (name, ext)]
        fullpath = os.path.join(os.path.dirname(__file__), *loc)

        with open(fullpath, "r") as f:
            content = f.read()
            return content

    @classmethod
    def load_template(cls, name, ext='yaml'):
        loc = ["stacks", "templates", "%s.%s" % (name, ext)]
        fullpath = os.path.join(os.path.dirname(__file__), *loc)

        with open(fullpath, "r") as f:
            return yaml.safe_load(f)

    @classmethod
    def resource_cleanup(cls):
        cls._clear_stacks()
        cls._clear_keypairs()
        cls._clear_images()
        super(BaseOrchestrationTest, cls).resource_cleanup()

    @staticmethod
    def stack_output(stack, output_key):
        """Return a stack output value for a given key."""
        return next((o['output_value'] for o in stack['outputs']
                    if o['output_key'] == output_key), None)

    def assert_fields_in_dict(self, obj, *fields):
        for field in fields:
            self.assertIn(field, obj)

    def list_resources(self, stack_identifier):
        """Get a dict mapping of resource names to types."""
        resources = self.client.list_resources(stack_identifier)
        self.assertIsInstance(resources, list)
        for res in resources:
            self.assert_fields_in_dict(res, 'logical_resource_id',
                                       'resource_type', 'resource_status',
                                       'updated_time')

        return dict((r['resource_name'], r['resource_type'])
                    for r in resources)

    def get_stack_output(self, stack_identifier, output_key):
        body = self.client.show_stack(stack_identifier)
        return self.stack_output(body, output_key)

# Copyright (c) 2005 The Regents of The University of Michigan
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Nathan Binkert


from __future__ import print_function
import os, sys
from time import time

if sys.version_info >= (3, 0):
    import tkinter as tk
else:
    import Tkinter as tk

# import rospkg as rp

__all__ = ['InteractiveCostTuning']

class InteractiveCostTuning(object):
    
    def __init__(self, problem):

        # Initial setup
        self.master = tk.Tk()
        self.problem = problem

        # Set title
        self.master.winfo_toplevel().title("Interactive Cost Tuning")

        # Set icon
        # icon = rp.RosStack().get_path('exotica') + '/doc/images/EXOTica_icon.png'
        # img = tk.PhotoImage(file=icon)
        # self.master.tk.call('wm', 'iconphoto', self.master._w, img)

        # Grab current rhos and cost task map names
        self.rho = {}
        self.original_rho = {}
        self.cost_task_map_names = []
        for k in list(problem.get_task_maps().keys()):
            try:
                r = problem.get_rho(k)
                self.rho[k] = r
                self.original_rho[k] = r
                self.cost_task_map_names.append(k)
            except:
                continue

        # Setup labels and entries
        self.entries = {}
        for i, k in enumerate(self.cost_task_map_names):
            tk.Label(self.master, text=k).grid(row=i, column=0)
            self.entries[k] = tk.Entry(self.master)
            self.entries[k].grid(row=i, column=1, pady=4)
            self.entries[k].insert(0, self.rho[k])

        n_cost_task_maps = len(self.cost_task_map_names)
        tk.Label(self.master, text='Filename').grid(row=n_cost_task_maps, column=0, pady=4)
        self.entries['filename'] = tk.Entry(self.master)
        self.entries['filename'].grid(row=n_cost_task_maps, column=1, pady=4)
        self.entries['filename'].insert(0, 'FilenameHere')

        # Setup buttons
        tk.Button(self.master, text="Set", command=self.set_button).grid(row=n_cost_task_maps+1, column=0, pady=4)
        tk.Button(self.master, text="Save", command=self.save_button).grid(row=n_cost_task_maps+1, column=1, pady=4)
        tk.Button(self.master, text="Reset", command=self.reset_button).grid(row=n_cost_task_maps+2, column=0, pady=4)
        tk.Button(self.master, text="Quit", command=self.quit_button).grid(row=n_cost_task_maps+2, column=1, pady=4)

    def set_button(self):
        """Sets rho parameters in entries into Exotica problem."""
        print("Setting cost parameters:")
        for k in self.cost_task_map_names:
            userin = self.entries[k].get() # is a str
            rho = float(eval(userin))
            self.entries[k].delete(0, 'end')
            self.entries[k].insert(0, rho)
            self.problem.set_rho(k, rho)
            print("  {}\t{}".format(k, rho))

    def save_button(self):
        """Saves current rho parameters in entries to file in home dir."""

        # Generate filename, filename structure is FILENAMEINENTRY_TIMEINMS.costparams
        # Use time to avoid overwriting errors
        t = int(round(time() * 1000)) # time in ms (int)
        filename = "%s/%s_%d.costparams" % (os.environ['HOME'], self.entries['filename'].get(), t)

        # Save parameters
        with open(filename, 'w') as fout:
            fout.write('<Cost>\n')
            for k in self.cost_task_map_names:
                fout.write('  <Task Task="{}" Rho="{}"/>\n'.format(k, float(eval(self.entries[k].get()))))
            fout.write('</Cost>\n')
        print("Saved cost parameters to %s" % filename)

    def reset_button(self):
        """Resets entries/exotica to original cost terms as specified in xml."""
        print("Resetting cost parameters:")
        for k in self.cost_task_map_names:
            rho = self.original_rho[k]

            # Reset entries
            self.entries[k].delete(0, 'end')
            self.entries[k].insert(0, rho)

            # Reset exotica problem
            self.problem.set_rho(k, rho)

            print("  {}\t{}".format(k, rho))

    def quit_button(self):
        """Quits interactive cost tuning."""
        print("Quitting interactive cost tuning...")
        self.master.quit()

    def mainloop(self):
        """Starts tk mainloop."""
        tk.mainloop()

#!/usr/bin/python
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

# This is a DOCUMENTATION stub specific to this module, it extends
# a documentation fragment located in ansible.utils.module_docs_fragments
DOCUMENTATION = '''
---
module: rax_cbs
short_description: Manipulate Rackspace Cloud Block Storage Volumes
description:
     - Manipulate Rackspace Cloud Block Storage Volumes
version_added: 1.6
options:
  description:
    description:
      - Description to give the volume being created
    default: null
  image:
    description:
      - image to use for bootable volumes. Can be an C(id), C(human_id) or
        C(name). This option requires C(pyrax>=1.9.3)
    default: null
    version_added: 1.9
  meta:
    description:
      - A hash of metadata to associate with the volume
    default: null
  name:
    description:
      - Name to give the volume being created
    default: null
    required: true
  size:
    description:
      - Size of the volume to create in Gigabytes
    default: 100
    required: true
  snapshot_id:
    description:
      - The id of the snapshot to create the volume from
    default: null
  state:
    description:
      - Indicate desired state of the resource
    choices:
      - present
      - absent
    default: present
    required: true
  volume_type:
    description:
      - Type of the volume being created
    choices:
      - SATA
      - SSD
    default: SATA
    required: true
  wait:
    description:
      - wait for the volume to be in state 'available' before returning
    default: "no"
    choices:
      - "yes"
      - "no"
  wait_timeout:
    description:
      - how long before wait gives up, in seconds
    default: 300
author: 
    - "Christopher H. Laco (@claco)"
    - "Matt Martz (@sivel)"
extends_documentation_fragment: rackspace.openstack
'''

EXAMPLES = '''
- name: Build a Block Storage Volume
  gather_facts: False
  hosts: local
  connection: local
  tasks:
    - name: Storage volume create request
      local_action:
        module: rax_cbs
        credentials: ~/.raxpub
        name: my-volume
        description: My Volume
        volume_type: SSD
        size: 150
        region: DFW
        wait: yes
        state: present
        meta:
          app: my-cool-app
      register: my_volume
'''

from distutils.version import LooseVersion

try:
    import pyrax
    HAS_PYRAX = True
except ImportError:
    HAS_PYRAX = False


def cloud_block_storage(module, state, name, description, meta, size,
                        snapshot_id, volume_type, wait, wait_timeout,
                        image):
    changed = False
    volume = None
    instance = {}

    cbs = pyrax.cloud_blockstorage

    if cbs is None:
        module.fail_json(msg='Failed to instantiate client. This '
                             'typically indicates an invalid region or an '
                             'incorrectly capitalized region name.')

    if image:
        # pyrax<1.9.3 did not have support for specifying an image when
        # creating a volume which is required for bootable volumes
        if LooseVersion(pyrax.version.version) < LooseVersion('1.9.3'):
            module.fail_json(msg='Creating a bootable volume requires '
                                 'pyrax>=1.9.3')
        image = rax_find_image(module, pyrax, image)

    volume = rax_find_volume(module, pyrax, name)

    if state == 'present':
        if not volume:
            kwargs = dict()
            if image:
                kwargs['image'] = image
            try:
                volume = cbs.create(name, size=size, volume_type=volume_type,
                                    description=description,
                                    metadata=meta,
                                    snapshot_id=snapshot_id, **kwargs)
                changed = True
            except Exception, e:
                module.fail_json(msg='%s' % e.message)
            else:
                if wait:
                    attempts = wait_timeout / 5
                    pyrax.utils.wait_for_build(volume, interval=5,
                                               attempts=attempts)

        volume.get()
        instance = rax_to_dict(volume)

        result = dict(changed=changed, volume=instance)

        if volume.status == 'error':
            result['msg'] = '%s failed to build' % volume.id
        elif wait and volume.status not in VOLUME_STATUS:
            result['msg'] = 'Timeout waiting on %s' % volume.id

        if 'msg' in result:
            module.fail_json(**result)
        else:
            module.exit_json(**result)

    elif state == 'absent':
        if volume:
            instance = rax_to_dict(volume)
            try:
                volume.delete()
                changed = True
            except Exception, e:
                module.fail_json(msg='%s' % e.message)

    module.exit_json(changed=changed, volume=instance)


def main():
    argument_spec = rax_argument_spec()
    argument_spec.update(
        dict(
            description=dict(type='str'),
            image=dict(type='str'),
            meta=dict(type='dict', default={}),
            name=dict(required=True),
            size=dict(type='int', default=100),
            snapshot_id=dict(),
            state=dict(default='present', choices=['present', 'absent']),
            volume_type=dict(choices=['SSD', 'SATA'], default='SATA'),
            wait=dict(type='bool', default=False),
            wait_timeout=dict(type='int', default=300)
        )
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_together=rax_required_together()
    )

    if not HAS_PYRAX:
        module.fail_json(msg='pyrax is required for this module')

    description = module.params.get('description')
    image = module.params.get('image')
    meta = module.params.get('meta')
    name = module.params.get('name')
    size = module.params.get('size')
    snapshot_id = module.params.get('snapshot_id')
    state = module.params.get('state')
    volume_type = module.params.get('volume_type')
    wait = module.params.get('wait')
    wait_timeout = module.params.get('wait_timeout')

    setup_rax_module(module, pyrax)

    cloud_block_storage(module, state, name, description, meta, size,
                        snapshot_id, volume_type, wait, wait_timeout,
                        image)

# import module snippets
from ansible.module_utils.basic import *
from ansible.module_utils.rax import *

# invoke the module
main()

# -*- coding: utf-8 -*-
"""
    longboxed.frontend.admin
    ~~~~~~~~~~~~~~~~~~~~~~~~~

    Administrative interface

"""
from datetime import datetime

from flask import flash
from flask.ext.security import current_user
from flask.ext.admin import Admin, AdminIndexView
from flask.ext.admin.actions import action
from flask.ext.admin.babel import gettext, lazy_gettext
from flask.ext.admin.contrib.sqla import ModelView
from flask.ext.admin.contrib.sqla.ajax import QueryAjaxModelLoader

from ..core import db
from ..helpers import current_wednesday, last_wednesday, next_wednesday
from ..models import (Creator, Issue, Publisher, Title, User, Role,
                      Bundle, DiamondList)


class LongboxedAdminIndexView(AdminIndexView):
    def is_accessible(self):
        return current_user.has_role('admin')

class AdministratorBase(ModelView):
    def is_accessible(self):
        return current_user.has_role('admin')

class SuperUserBase(ModelView):
    def is_accessible(self):
        return (current_user.has_role('admin') and
                current_user.has_role('super'))


class IssueAdmin(AdministratorBase):
    edit_template = 'edit_issue_model.html'
    # List of columns that can be sorted
    column_sortable_list = ('issue_number', 'complete_title', 'on_sale_date',
                            ('title',Title.name), ('publisher', Publisher.name))
    column_searchable_list = ('complete_title', 'diamond_id')
    column_list = ('on_sale_date', 'prospective_release_date', 'diamond_id',
                   'old_diamond_id', 'issue_number', 'issues', 'complete_title',
                   'title', 'publisher')
    form_excluded_columns = ('cover_image', 'bundles')

    form_ajax_refs = {
            'title': QueryAjaxModelLoader(
                'title',
                db.session,
                Title,
                fields=['name'],
                page_size=10),
            'publisher': QueryAjaxModelLoader(
                'publisher',
                db.session,
                Publisher,
                fields=['name'],
                page_size=10),
            'creators': QueryAjaxModelLoader(
                'creators',
                db.session,
                Creator,
                fields=['name'],
                page_size=10)
    }

    def __init__(self, session):
        # Just call parent class with predefined model.
        super(IssueAdmin, self).__init__(Issue, session)

    def on_model_change(self, form, model):
        """Sets last_updated attribute of issue object"""
        model.last_updated = datetime.now()
        return

    def set_on_sale_date(self, ids, date):
        try:
            issues = Issue.query.filter(Issue.id.in_(*ids)).all()
            for issue in issues:
                issue.update(**{'on_sale_date': date})
        except Exception, ex:
            flash(gettext('Failed to set date %(error)s', error=str(ex)), 'error')
        return

    @action('set_cover_image', lazy_gettext('Set Cover Image'), lazy_gettext('Are you sure you want to set the cover image?'))
    def set_cover_image(self, ids):
        try:
            issues = Issue.query.filter(Issue.id.in_(ids)).all()
            for issue in issues:
                issue.set_cover_image_from_url(issue.big_image, True)
                issue.find_or_create_thumbnail(width=250)
        except Exception, ex:
            flash(gettext('Failed to set cover image %(errors)s', error=str(ex)), 'error')
        return

    @action('current_wednesday', lazy_gettext('This Wed | %(date)s', date=current_wednesday()), lazy_gettext('Are you sure? | %(date)s', date=current_wednesday()))
    def action_current_wednesday(self, ids):
        self.set_on_sale_date(ids, current_wednesday())

    @action('next_wednesday', lazy_gettext('Next Wed | %(date)s', date=next_wednesday()), lazy_gettext('Are you sure? | %(date)s', date=next_wednesday()))
    def action_next_wednesday(self, ids):
        self.set_on_sale_date(ids, next_wednesday())

    @action('last_wednesday', lazy_gettext('Last Wed | %(date)s', date=last_wednesday()), lazy_gettext('Are you sure? | %(date)s', date=last_wednesday()))
    def action_last_wednesday(self, ids):
        self.set_on_sale_date(ids, last_wednesday())

    @action('no_date', lazy_gettext('No Date'), lazy_gettext('Are you sure? | No Date'))
    def action_no_date(self, ids):
        self.set_on_sale_date(ids, None)

class PublisherAdmin(AdministratorBase):
    def __init__(self, session):
        # Just call parent class with predefined model.
        super(PublisherAdmin, self).__init__(Publisher, session)

    form_excluded_columns = ('titles', 'comics')
    form_ajax_refs = {
        'users': QueryAjaxModelLoader(
            'users',
            db.session,
            User,
            fields=['email'],
            page_size=10),
    }


class TitleAdmin(AdministratorBase):
    column_sortable_list= ('name', ('publisher', Publisher.name))
    def __init__(self, session):
        # Just call parent class with predefined model.
        super(TitleAdmin, self).__init__(Title, session)

    form_ajax_refs = {
        'users': QueryAjaxModelLoader(
            'users',
            db.session,
            User,
            fields=['email'],
            page_size=10),
        'issues': QueryAjaxModelLoader(
            'issues',
            db.session,
            Issue,
            fields=['complete_title'],
            page_size=10),
        'publisher': QueryAjaxModelLoader(
            'publisher',
            db.session,
            Publisher,
            fields=['name'],
            page_size=10)
    }


class CreatorAdmin(AdministratorBase):
    def __init__(self, session):
        # Just call parent class with predefined model.
        super(CreatorAdmin, self).__init__(Creator, session)

    form_excluded_columns = ('issues')


class BundleAdmin(AdministratorBase):
    def __init__(self, session):
        # Just call parent class with predefined model.
        super(BundleAdmin, self).__init__(Bundle, session)

    form_ajax_refs = {
        'issues': QueryAjaxModelLoader(
            'issues',
            db.session,
            Issue,
            fields=['complete_title'],
            page_size=10),
        'user': QueryAjaxModelLoader(
            'user',
            db.session,
            User,
            fields=['email'],
            page_size=10)
    }


class UserAdmin(SuperUserBase):
    column_list = ('email', 'last_seen', 'login_count', 'pull_list', 'roles')
    column_searchable_list = ('email',)

    form_excluded_columns = ('bundles',)
    form_ajax_refs = {
        'pull_list': QueryAjaxModelLoader(
            'pull_list',
            db.session,
            Title,
            fields=['name'],
            page_size=10)
    }

    def __init__(self, session):
        # Just call parent class with predefined model.
        super(UserAdmin, self).__init__(User, session)


class RoleAdmin(SuperUserBase):
    def __init__(self, session):
        # Just call parent class with predefined model.
        super(RoleAdmin, self).__init__(Role, session)

    form_ajax_refs = {
        'users': QueryAjaxModelLoader(
            'users',
            db.session,
            User,
            fields=['email'],
            page_size=10)
    }


class DiamondListAdmin(SuperUserBase):
    def __init__(self, session):
        super(DiamondListAdmin, self).__init__(DiamondList, session)

    form_ajax_refs = {'issues': QueryAjaxModelLoader('issues', db.session,
        Issue, fields=['complete_title'], page_size=10)}
    column_list = ('date_created', 'date', 'revision', 'hash_string',)
    form_ajax_refs = {
        'issues': QueryAjaxModelLoader(
            'issues',
            db.session,
            Issue,
            fields=['complete_title'],
            page_size=10),
    }

def init_app(app):
    admin = Admin(app, index_view=LongboxedAdminIndexView())
    admin.add_view(UserAdmin(db.session))
    admin.add_view(IssueAdmin(db.session))
    admin.add_view(PublisherAdmin(db.session))
    admin.add_view(TitleAdmin(db.session))
    admin.add_view(CreatorAdmin(db.session))
    admin.add_view(RoleAdmin(db.session))
    admin.add_view(BundleAdmin(db.session))
    admin.add_view(DiamondListAdmin(db.session))

#!/usr/bin/env python

import os
import logging
from aatest.check import State, OK
from aatest.events import EV_CONDITION
from aatest.result import Result, safe_path
from aatest.verify import Verify
from future.backports.urllib.parse import quote_plus
from future.backports.urllib.parse import parse_qs

from aatest.summation import store_test_state
from aatest.session import SessionHandler, Done

from saml2.httputil import BadRequest
from saml2.httputil import get_post
from saml2.httputil import Response
from saml2test.idp_test.webio import WebIO
from saml2test.idp_test.setup import setup
from saml2test.idp_test.wb_tool import Tester

SERVER_LOG_FOLDER = "server_log"

if not os.path.isdir(SERVER_LOG_FOLDER):
    os.makedirs(SERVER_LOG_FOLDER)

try:
    from mako.lookup import TemplateLookup
except Exception as ex:
    raise ex

LOGGER = logging.getLogger("")


def pick_args(args, kwargs):
    return dict([(k, kwargs[k]) for k in args])


def do_next(tester, resp, sh, webio, filename, path):
    tester.conv = tester.sh['conv']
    tester.handle_response(resp, {})

    store_test_state(sh, sh['conv'].events)
    tester.webio.store_test_info()

    tester.conv.index += 1
    lix = len(tester.conv.sequence)
    while tester.conv.sequence[tester.conv.index] != Done:
        resp = tester.run_flow(tester.conv.test_id, index=tester.conv.index)
        store_test_state(sh, sh['conv'].events)
        if isinstance(resp, Response):
            webio.print_info(path, filename)
            return resp
        if tester.conv.index >= lix:
            break

    if tester.conv.events.last_item(EV_CONDITION).test_id == 'Done':
        pass
    else:
        if 'assert' in tester.conv.flow:
            _ver = Verify(tester.chk_factory, tester.conv)
            _ver.test_sequence(tester.conv.flow["assert"])
        tester.conv.events.store(EV_CONDITION, State('Done', status=OK))

    store_test_state(sh, sh['conv'].events)
    tester.webio.store_test_info()
    return webio.flow_list(filename)


class Application(object):
    def __init__(self, webenv):
        self.webenv = webenv

    def application(self, environ, start_response):
        LOGGER.info("Connection from: %s" % environ["REMOTE_ADDR"])
        session = environ['beaker.session']

        path = environ.get('PATH_INFO', '').lstrip('/')
        LOGGER.info("path: %s" % path)

        try:
            sh = session['session_info']
        except KeyError:
            sh = SessionHandler(**self.webenv)
            sh.session_init()
            session['session_info'] = sh

        webio = WebIO(session=sh, **self.webenv)
        webio.environ = environ
        webio.start_response = start_response

        tester = Tester(webio, sh, **self.webenv)

        if path == "robots.txt":
            return webio.static("static/robots.txt")
        elif path == "favicon.ico":
            return webio.static("static/favicon.ico")
        elif path.startswith('acs/site/static'):
            path = path[4:]
            return webio.static(path)
        elif path.startswith("site/static/") or path.startswith('static/'):
            return webio.static(path)
        elif path.startswith("export/"):
            return webio.static(path)

        if path == "" or path == "/":  # list
            return tester.display_test_list()
        elif "flow_names" not in sh:
            sh.session_init()

        if path == "logs":
            return webio.display_log("log", issuer="", profile="", testid="")
        elif path.startswith("log"):
            if path == "log" or path == "log/":
                _cc = webio.conf.CLIENT
                try:
                    _iss = _cc["srv_discovery_url"]
                except KeyError:
                    _iss = _cc["provider_info"]["issuer"]
                parts = [quote_plus(_iss)]
            else:
                parts = []
                while path != "log":
                    head, tail = os.path.split(path)
                    # tail = tail.replace(":", "%3A")
                    # if tail.endswith("%2F"):
                    #     tail = tail[:-3]
                    parts.insert(0, tail)
                    path = head

            return webio.display_log("log", *parts)
        elif path.startswith("tar"):
            path = path.replace(":", "%3A")
            return webio.static(path)

        elif path.startswith("test_info"):
            p = path.split("/")
            try:
                return webio.test_info(p[1])
            except KeyError:
                return webio.not_found()
        elif path == "continue":
            return tester.cont(environ, self.webenv)
        elif path == 'reset':
            for param in ['flow', 'flow_names', 'index', 'node', 'profile',
                          'sequence', 'test_info', 'test_id', 'tests']:
                del sh[param]
            return tester.display_test_list()
        elif path == "opresult":
            if tester.conv is None:
                return webio.sorry_response("", "No result to report")

            return webio.opresult(tester.conv, sh)
        # expected path format: /<testid>[/<endpoint>]
        elif path in sh["flow_names"]:
            resp = tester.run(path, **self.webenv)
            store_test_state(sh, sh['conv'].events)
            filename = self.webenv['profile_handler'](sh).log_path(path)
            if isinstance(resp, Response):
                res = Result(sh, self.webenv['profile_handler'])
                res.store_test_info()
                res.print_info(path, tester.fname(path))
                return webio.respond(resp)
            else:
                return webio.flow_list(filename)
        elif path == "acs/post":
            qs = get_post(environ).decode('utf8')
            resp = dict([(k, v[0]) for k, v in parse_qs(qs).items()])
            filename = self.webenv['profile_handler'](sh).log_path(tester.conv.test_id)

            return do_next(tester, resp, sh, webio, filename, path)
        elif path == "acs/redirect":
            qs = environ['QUERY_STRING']
            resp = dict([(k, v[0]) for k, v in parse_qs(qs).items()])
            filename = self.webenv['profile_handler'](sh).log_path(tester.conv.test_id)

            return do_next(tester, resp, sh, webio, filename, path)
        elif path == "acs/artifact":
            pass
        elif path == "ecp":
            pass
        elif path == "disco":
            pass
        elif path == "slo":
            pass
        else:
            resp = BadRequest()
            return resp(environ, start_response)


if __name__ == '__main__':
    from beaker.middleware import SessionMiddleware
    from cherrypy import wsgiserver
    from mako.lookup import TemplateLookup

    cargs, kwargs = setup('wb')

    session_opts = {
        'session.type': 'memory',
        'session.cookie_expires': True,
        'session.auto': True,
        'session.timeout': 900
    }

    LOOKUP = TemplateLookup(directories=['./' + 'templates', './' + 'htdocs'],
                            module_directory='./' + 'modules',
                            input_encoding='utf-8',
                            output_encoding='utf-8')

    kwargs['lookup'] = LOOKUP
    _conf = kwargs['conf']

    _app = Application(webenv=kwargs)

    SRV = wsgiserver.CherryPyWSGIServer(('0.0.0.0', _conf.PORT),
                                        SessionMiddleware(_app.application,
                                                          session_opts))

    if _conf.BASE.startswith("https"):
        from cherrypy.wsgiserver.ssl_builtin import BuiltinSSLAdapter

        SRV.ssl_adapter = BuiltinSSLAdapter(_conf.SERVER_CERT, _conf.SERVER_KEY,
                                            _conf.CERT_CHAIN)
        extra = " using SSL/TLS"
    else:
        extra = ""

    txt = "SP listening on port:%s%s" % (_conf.PORT, extra)
    LOGGER.info(txt)
    print(txt)
    try:
        SRV.start()
    except KeyboardInterrupt:
        SRV.stop()

"""Helper functions which doesn't fit anywhere else"""

import re
import hashlib

from importlib import import_module
from pkgutil import iter_modules

from w3lib.html import remove_entities
from scrapy.utils.python import flatten
from scrapy.item import BaseItem

def arg_to_iter(arg):
    """Convert an argument to an iterable. The argument can be a None, single
    value, or an iterable.

    Exception: if arg is a dict, [arg] will be returned
    """
    if arg is None:
        return []
    elif not isinstance(arg, (dict, BaseItem)) and hasattr(arg, '__iter__'):
        return arg
    else:
        return [arg]

def load_object(path):
    """Load an object given its absolute object path, and return it.

    object can be a class, function, variable o instance.
    path ie: 'scrapy.contrib.downloadermiddelware.redirect.RedirectMiddleware'
    """

    try:
        dot = path.rindex('.')
    except ValueError:
        raise ValueError("Error loading object '%s': not a full path" % path)

    module, name = path[:dot], path[dot+1:]
    try:
        mod = import_module(module)
    except ImportError as e:
        raise ImportError("Error loading object '%s': %s" % (path, e))

    try:
        obj = getattr(mod, name)
    except AttributeError:
        raise NameError("Module '%s' doesn't define any object named '%s'" % (module, name))

    return obj

def walk_modules(path, load=False):
    """Loads a module and all its submodules from a the given module path and
    returns them. If *any* module throws an exception while importing, that
    exception is thrown back.

    For example: walk_modules('scrapy.utils')
    """

    mods = []
    mod = import_module(path)
    mods.append(mod)
    if hasattr(mod, '__path__'):
        for _, subpath, ispkg in iter_modules(mod.__path__):
            fullpath = path + '.' + subpath
            if ispkg:
                mods += walk_modules(fullpath)
            else:
                submod = import_module(fullpath)
                mods.append(submod)
    return mods

def extract_regex(regex, text, encoding='utf-8'):
    """Extract a list of unicode strings from the given text/encoding using the following policies:

    * if the regex contains a named group called "extract" that will be returned
    * if the regex contains multiple numbered groups, all those will be returned (flattened)
    * if the regex doesn't contain any group the entire regex matching is returned
    """

    if isinstance(regex, basestring):
        regex = re.compile(regex, re.UNICODE)

    try:
        strings = [regex.search(text).group('extract')]   # named group
    except:
        strings = regex.findall(text)    # full regex or numbered groups
    strings = flatten(strings)

    if isinstance(text, unicode):
        return [remove_entities(s, keep=['lt', 'amp']) for s in strings]
    else:
        return [remove_entities(unicode(s, encoding), keep=['lt', 'amp']) for s in strings]

def md5sum(file):
    """Calculate the md5 checksum of a file-like object without reading its
    whole content in memory.

    >>> from StringIO import StringIO
    >>> md5sum(StringIO('file content to hash'))
    '784406af91dd5a54fbb9c84c2236595a'
    """
    m = hashlib.md5()
    while 1:
        d = file.read(8096)
        if not d:
            break
        m.update(d)
    return m.hexdigest()

"""Constants for the ozw integration."""
from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
from homeassistant.components.cover import DOMAIN as COVER_DOMAIN
from homeassistant.components.fan import DOMAIN as FAN_DOMAIN
from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN

DOMAIN = "ozw"
DATA_UNSUBSCRIBE = "unsubscribe"

CONF_INTEGRATION_CREATED_ADDON = "integration_created_addon"
CONF_USE_ADDON = "use_addon"

PLATFORMS = [
    BINARY_SENSOR_DOMAIN,
    COVER_DOMAIN,
    CLIMATE_DOMAIN,
    FAN_DOMAIN,
    LIGHT_DOMAIN,
    LOCK_DOMAIN,
    SENSOR_DOMAIN,
    SWITCH_DOMAIN,
]
MANAGER = "manager"
NODES_VALUES = "nodes_values"

# MQTT Topics
TOPIC_OPENZWAVE = "OpenZWave"

# Common Attributes
ATTR_CONFIG_PARAMETER = "parameter"
ATTR_CONFIG_VALUE = "value"
ATTR_INSTANCE_ID = "instance_id"
ATTR_SECURE = "secure"
ATTR_NODE_ID = "node_id"
ATTR_SCENE_ID = "scene_id"
ATTR_SCENE_LABEL = "scene_label"
ATTR_SCENE_VALUE_ID = "scene_value_id"
ATTR_SCENE_VALUE_LABEL = "scene_value_label"

# Config entry data and options
MIGRATED = "migrated"

# Service specific
SERVICE_ADD_NODE = "add_node"
SERVICE_REMOVE_NODE = "remove_node"
SERVICE_CANCEL_COMMAND = "cancel_command"
SERVICE_SET_CONFIG_PARAMETER = "set_config_parameter"

# Home Assistant Events
EVENT_SCENE_ACTIVATED = f"{DOMAIN}.scene_activated"

# Signals
SIGNAL_DELETE_ENTITY = f"{DOMAIN}_delete_entity"

# Discovery Information
DISC_COMMAND_CLASS = "command_class"
DISC_COMPONENT = "component"
DISC_GENERIC_DEVICE_CLASS = "generic_device_class"
DISC_GENRE = "genre"
DISC_INDEX = "index"
DISC_INSTANCE = "instance"
DISC_NODE_ID = "node_id"
DISC_OPTIONAL = "optional"
DISC_PRIMARY = "primary"
DISC_SPECIFIC_DEVICE_CLASS = "specific_device_class"
DISC_TYPE = "type"
DISC_VALUES = "values"

#!/usr/bin/python
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

# This is a DOCUMENTATION stub specific to this module, it extends
# a documentation fragment located in ansible.utils.module_docs_fragments
ANSIBLE_METADATA = {'metadata_version': '1.0',
                    'status': ['preview'],
                    'supported_by': 'community'}


DOCUMENTATION = '''
---
module: rax_identity
short_description: Load Rackspace Cloud Identity
description:
     - Verifies Rackspace Cloud credentials and returns identity information
version_added: "1.5"
options:
  state:
    description:
      - Indicate desired state of the resource
    choices: ['present', 'absent']
    default: present
    required: false
author:
    - "Christopher H. Laco (@claco)"
    - "Matt Martz (@sivel)"
extends_documentation_fragment: rackspace.openstack
'''

EXAMPLES = '''
- name: Load Rackspace Cloud Identity
  gather_facts: False
  hosts: local
  connection: local
  tasks:
    - name: Load Identity
      local_action:
        module: rax_identity
        credentials: ~/.raxpub
        region: DFW
      register: rackspace_identity
'''

try:
    import pyrax
    HAS_PYRAX = True
except ImportError:
    HAS_PYRAX = False


def cloud_identity(module, state, identity):
    instance = dict(
        authenticated=identity.authenticated,
        credentials=identity._creds_file
    )
    changed = False

    instance.update(rax_to_dict(identity))
    instance['services'] = instance.get('services', {}).keys()

    if state == 'present':
        if not identity.authenticated:
            module.fail_json(msg='Credentials could not be verified!')

    module.exit_json(changed=changed, identity=instance)


def main():
    argument_spec = rax_argument_spec()
    argument_spec.update(
        dict(
            state=dict(default='present', choices=['present'])
        )
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_together=rax_required_together()
    )

    if not HAS_PYRAX:
        module.fail_json(msg='pyrax is required for this module')

    state = module.params.get('state')

    setup_rax_module(module, pyrax)

    if not pyrax.identity:
        module.fail_json(msg='Failed to instantiate client. This '
                             'typically indicates an invalid region or an '
                             'incorrectly capitalized region name.')

    cloud_identity(module, state, pyrax.identity)

# import module snippets
from ansible.module_utils.basic import *
from ansible.module_utils.rax import *

# invoke the module

if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

import unittest
import unicodedata

import epitran


class TestBengaliGeneral(unittest.TestCase):
    def setUp(self):
        self.epi = epitran.Epitran(u'ben-Beng')

    def _assert_trans(self, src, tar):
        trans = self.epi.transliterate(src)
        trans = unicodedata.normalize('NFD', trans)
        src = unicodedata.normalize('NFD', trans)
        # print('{}\t{}\t{}'.format(trans, tar, zip(trans, tar)))
        self.assertEqual(trans, tar)

    def test_somosto(self):
        self._assert_trans('সমস্ত', 's̪ɔmɔs̪t̪ɔ')

    def test_manush(self):
        self._assert_trans('মানুষ', 'man̪uʂ')

    def test_sbadinbabe(self):
        self._assert_trans('স্বাধীনভাবে', 's̪bad̪̤in̪b̤abe')

    def test_shoman(self):
        self._assert_trans('সমান', 's̪ɔman̪')

    def test_morjada(self):
        self._assert_trans('মর্যাদা', 'mɔrd͡zad̪a')

    def test_ebong(self):
        self._assert_trans('এবং', 'ebɔŋ')

    def test_odikar(self):
        self._assert_trans('অধিকার', 'od̪̤ikar')

    def test_niye(self):
        self._assert_trans('নিয়ে', 'n̪ie̯e')

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from openerp.osv import fields, osv
from openerp import tools
from openerp.addons.crm import crm

MONTHS = [
    ('01', 'January'),
    ('02', 'February'),
    ('03', 'March'),
    ('04', 'April'),
    ('05', 'May'),
    ('06', 'June'),
    ('07', 'July'),
    ('08', 'August'),
    ('09', 'September'),
    ('10', 'October'),
    ('11', 'November'),
    ('12', 'December')
]

class crm_lead_report(osv.osv):
    """ CRM Lead Analysis """
    _name = "crm.lead.report"
    _auto = False
    _description = "CRM Lead Analysis"
    _rec_name = 'date_deadline'

    _columns = {
        'date_deadline': fields.date('Exp. Closing', size=10, readonly=True, help="Expected Closing"),
        'create_date': fields.datetime('Creation Date', readonly=True),
        'opening_date': fields.date('Assignation Date', readonly=True),
        'date_closed': fields.date('Close Date', readonly=True),
        'date_last_stage_update': fields.datetime('Last Stage Update', readonly=True),

        # durations
        'delay_open': fields.float('Delay to Assign',digits=(16,2),readonly=True, group_operator="avg",help="Number of Days to open the case"),
        'delay_close': fields.float('Delay to Close',digits=(16,2),readonly=True, group_operator="avg",help="Number of Days to close the case"),
        'delay_expected': fields.float('Overpassed Deadline',digits=(16,2),readonly=True, group_operator="avg"),

        'user_id':fields.many2one('res.users', 'User', readonly=True),
        'country_id':fields.many2one('res.country', 'Country', readonly=True),
        'section_id':fields.many2one('crm.case.section', 'Sales Team', readonly=True),
        'channel_id':fields.many2one('crm.case.channel', 'Channel', readonly=True),
        'type_id':fields.many2one('crm.case.resource.type', 'Campaign', readonly=True),
        'company_id': fields.many2one('res.company', 'Company', readonly=True),
        'probability': fields.float('Probability',digits=(16,2),readonly=True, group_operator="avg"),
        'planned_revenue': fields.float('Planned Revenue',digits=(16,2),readonly=True),
        'probable_revenue': fields.float('Probable Revenue', digits=(16,2),readonly=True),
        'stage_id': fields.many2one ('crm.case.stage', 'Stage', readonly=True, domain="[('section_ids', '=', section_id)]"),
        'partner_id': fields.many2one('res.partner', 'Partner' , readonly=True),
        'company_id': fields.many2one('res.company', 'Company', readonly=True),
        'priority': fields.selection(crm.AVAILABLE_PRIORITIES, 'Priority'),
        'type':fields.selection([
            ('lead','Lead'),
            ('opportunity','Opportunity'),
        ],'Type', help="Type is used to separate Leads and Opportunities"),
    }

    def init(self, cr):

        """
            CRM Lead Report
            @param cr: the current row, from the database cursor
        """
        tools.drop_view_if_exists(cr, 'crm_lead_report')
        cr.execute("""
            CREATE OR REPLACE VIEW crm_lead_report AS (
                SELECT
                    id,
                    c.date_deadline,

                    to_char(c.date_open, 'YYYY-MM-DD') as opening_date,
                    to_char(c.date_closed, 'YYYY-mm-dd') as date_closed,

                    date_trunc('day',c.date_last_stage_update) as date_last_stage_update,

                    c.user_id,
                    c.probability,
                    c.stage_id,
                    c.type,
                    c.company_id,
                    c.priority,
                    c.section_id,
                    c.channel_id,
                    c.type_id,
                    c.partner_id,
                    c.country_id,
                    c.planned_revenue,
                    c.planned_revenue*(c.probability/100) as probable_revenue,
                    date_trunc('day',c.create_date) as create_date,
                    extract('epoch' from (c.date_closed-c.create_date))/(3600*24) as  delay_close,
                    abs(extract('epoch' from (c.date_deadline - c.date_closed))/(3600*24)) as  delay_expected,
                    extract('epoch' from (c.date_open-c.create_date))/(3600*24) as  delay_open
                FROM
                    crm_lead c
                WHERE c.active = 'true'
            )""")


# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

# 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.

from django.core.urlresolvers import reverse
from django import http

from mox import IsA  # noqa

from openstack_dashboard import api
from openstack_dashboard.test import helpers as test


INDEX_URL = reverse(
    'horizon:project:data_processing.data_image_registry:index')
REGISTER_URL = reverse(
    'horizon:project:data_processing.data_image_registry:register')


class DataProcessingImageRegistryTests(test.TestCase):
    @test.create_stubs({api.sahara: ('image_list',)})
    def test_index(self):
        api.sahara.image_list(IsA(http.HttpRequest)) \
            .AndReturn(self.images.list())
        self.mox.ReplayAll()

        res = self.client.get(INDEX_URL)

        self.assertTemplateUsed(
            res,
            'project/data_processing.data_image_registry/image_registry.html')
        self.assertContains(res, 'Image Registry')
        self.assertContains(res, 'Image')
        self.assertContains(res, 'Tags')

    @test.create_stubs({api.sahara: ('image_update',
                                     'image_tags_update',
                                     'image_list'),
                        api.glance: ('image_list_detailed',)})
    def test_register(self):
        image_id = self.images.first().id
        test_username = 'myusername'
        test_description = 'mydescription'
        api.glance.image_list_detailed(IsA(http.HttpRequest),
                                       filters={'owner': self.user.id,
                                                'status': 'active'}) \
            .AndReturn((self.images.list(), False, False))
        api.sahara.image_update(IsA(http.HttpRequest),
                                image_id,
                                test_username,
                                test_description) \
            .AndReturn(True)
        api.sahara.image_tags_update(IsA(http.HttpRequest),
                                     image_id,
                                     {}) \
            .AndReturn(True)
        api.sahara.image_list(IsA(http.HttpRequest)) \
            .AndReturn([])
        self.mox.ReplayAll()

        res = self.client.post(
            REGISTER_URL,
            {'image_id': image_id,
             'user_name': test_username,
             'description': test_description,
             'tags_list': '{}'})

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)
        self.assertMessageCount(success=1)

    @test.create_stubs({api.sahara: ('image_list',
                                     'image_unregister')})
    def test_unregister(self):
        image = self.images.first()
        api.sahara.image_list(IsA(http.HttpRequest)) \
            .AndReturn(self.images.list())
        api.sahara.image_unregister(IsA(http.HttpRequest), image.id)
        self.mox.ReplayAll()

        form_data = {'action': 'image_registry__delete__%s' % image.id}
        res = self.client.post(INDEX_URL, form_data)

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)
        self.assertMessageCount(success=1)

    @test.create_stubs({api.sahara: ('image_get',
                                     'image_update',
                                     'image_tags_update')})
    def test_edit_tags(self):
        image = self.registered_images.first()
        api.sahara.image_get(IsA(http.HttpRequest),
                             image.id) \
            .AndReturn(image)
        api.sahara.image_update(IsA(http.HttpRequest),
                                image.id,
                                image.username,
                                image.description) \
            .AndReturn(True)
        api.sahara.image_tags_update(IsA(http.HttpRequest),
                                     image.id,
                                     {"0": "mytag"}) \
            .AndReturn(True)
        self.mox.ReplayAll()

        edit_tags_url = reverse(
            'horizon:project:data_processing.data_image_registry:edit_tags',
            args=[image.id])
        res = self.client.post(
            edit_tags_url,
            {'image_id': image.id,
             'user_name': image.username,
             'description': image.description,
             'tags_list': '{"0": "mytag"}'})

        self.assertNoFormErrors(res)
        self.assertRedirectsNoFollow(res, INDEX_URL)
        self.assertMessageCount(success=1)

"""
Django settings for k666 project.

Generated by 'django-admin startproject' using Django 1.8.3.

For more information on this file, see
https://docs.djangoproject.com/en/1.8/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.8/ref/settings/
"""

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.8/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '^_bk5wj9el+un48)*jyeva_482cky7ap1p)djrk6a8qr7v()@$'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = os.environ['DEBUG']

ALLOWED_HOSTS = []


# Application definition

INSTALLED_APPS = (
    'comments',
    'freek666',
    'django.contrib.sites',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'django_messages',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
)

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'django.middleware.security.SecurityMiddleware',
)

ROOT_URLCONF = 'k666.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                ],
        },
    },
]

WSGI_APPLICATION = 'k666.wsgi.application'

# Database
# https://docs.djangoproject.com/en/1.8/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

DATABASE_CHOICES = {
    'sqlite3': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    },
    'postgresql': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'postgres',
        'USER': 'postgres',
        'PASSWORD': 'postgres',
        'HOST': 'postgres',
        # 'PORT': '5432',
    }
}

DATABASES = {
    'default': DATABASE_CHOICES[os.environ['DEFAULT_DATABASE']],
}


# Internationalization
# https://docs.djangoproject.com/en/1.8/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.8/howto/static-files/

STATIC_URL = '/static/'

SITE_ID = 1

LOGIN_REDIRECT_URL = '/'

AUTHENTICATION_BACKENDS = (
    
    # Needed to login by username in Django admin, regardless of `allauth`
    'django.contrib.auth.backends.ModelBackend',

    # `allauth` specific authentication methods, such as login by e-mail
    'allauth.account.auth_backends.AuthenticationBackend',
    
)
if DEBUG:
    EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

#@+leo-ver=4-thin
#@+node:Zoomq.20051028115650:@thin dict4ini.py
#@verbatim
#@ignore
#@verbatim
#@language python
#@<< dict4ini declarations >>
#@+node:Zoomq.20051028115650.1:<< dict4ini declarations >>
#coding=utf-8
# dump python dict to ini format file
# Author: limodou (limodou@gmail.com)
# Copyleft GPL
# $Revision$
# you can see http://wiki.woodpecker.org.cn/moin/Dict4Ini for more details
# 
# Updates:
#   2005/10/16
#     Saving the order of the items
#     Adding float format
#

__version__ = '0.2'

import sys
import locale
import os.path
import re

r_float = re.compile('\d*\.\d+')
section_delimeter = '/'

#@-node:Zoomq.20051028115650.1:<< dict4ini declarations >>
#@nl
#@+others
#@+node:Zoomq.20051028115650.3:class DictNode
class DictNode(object):
    #@	@+others
    #@+node:Zoomq.20051028115650.4:__init__
    def __init__(self, values, encoding=None, root=None, section=[], orders=[]):
        self._items = values
        self._orders = orders
        self._encoding = encoding
        self._root = root
        self._section = section
    #@-node:Zoomq.20051028115650.4:__init__
    #@+node:Zoomq.20051028115650.5:__getitem__
    def __getitem__(self, name):
        if self._items.has_key(name):
            value = self._items[name]
            if isinstance(value, dict):
                return DictNode(value, self._encoding, self._root, self._section + [name])
            else:
                return value
        else:
            self._items[name] = {}
            self._root.setorder(self.get_full_keyname(name))
            return DictNode(self._items[name], self._encoding, self._root, self._section + [name])
    #@-node:Zoomq.20051028115650.5:__getitem__
    #@+node:Zoomq.20051028115650.6:__setitem__
    def __setitem__(self, name, value):
        if section_delimeter in name:
            sec = name.split(section_delimeter)
            obj = self._items
            
            _s = self._section[:]
            for i in sec[:-1]:
                _s.append(i)
                if obj.has_key(i):
                    if isinstance(obj[i], dict):
                        obj = obj[i]
                    else:
                        obj[i] = {} #may lost some data
                        obj = obj[i]
                else:
                    obj[i] = {}
                    self._root.setorder(section_delimeter.join(_s))
                    obj = obj[i]
            obj[sec[-1]] = value
            self._root.setorder(section_delimeter.join(_s + [sec[-1]]))
        else:
            self._items[name] = value
            self._root.setorder(self.get_full_keyname(name))
    #@-node:Zoomq.20051028115650.6:__setitem__
    #@+node:Zoomq.20051028115650.7:__delitem__
    def __delitem__(self, name):
        if self._items.has_key(name):
            del self._items[name]
    #@-node:Zoomq.20051028115650.7:__delitem__
    #@+node:Zoomq.20051028115650.8:__repr__
    def __repr__(self):
        return repr(self._items)
    #@-node:Zoomq.20051028115650.8:__repr__
    #@+node:Zoomq.20051028115650.9:__getattr__
    def __getattr__(self, name):
        return self.__getitem__(name)
    #@-node:Zoomq.20051028115650.9:__getattr__
    #@+node:Zoomq.20051028115650.10:__setattr__
    def __setattr__(self, name, value):
        if name.startswith('_'):
            if name == '_comment':
                self._root._comments[section_delimeter.join(self._section)] = value
            else:
                self.__dict__[name] = value
        else:
            self.__setitem__(name, value)
    #@-node:Zoomq.20051028115650.10:__setattr__
    #@+node:Zoomq.20051028115650.11:comment
    def comment(self, name, comment):
        if name:
            self._root._comments[section_delimeter.join(self._section + [name])] = comment
        else:
            self._root._comments[section_delimeter.join(self._section)] = comment
    #@-node:Zoomq.20051028115650.11:comment
    #@+node:Zoomq.20051028115650.12:__delattr__
    def __delattr__(self, name):
        if self._items.has_key(name):
            del self._items[name]
    #@-node:Zoomq.20051028115650.12:__delattr__
    #@+node:Zoomq.20051028115650.13:__str__
    def __str__(self):
        return repr(self._items)
    #@-node:Zoomq.20051028115650.13:__str__
    #@+node:Zoomq.20051028115650.14:__len__
    def __len__(self):
        return len(self._items)
    #@-node:Zoomq.20051028115650.14:__len__
    #@+node:Zoomq.20051028115650.15:has_key
    def has_key(self, name):
        return self._items.has_key(name)
    #@-node:Zoomq.20051028115650.15:has_key
    #@+node:Zoomq.20051028115650.16:items
    def items(self):
        return self._items.items()
    #@-node:Zoomq.20051028115650.16:items
    #@+node:Zoomq.20051028115650.17:setdefault
    def setdefault(self, name, value):
        return self._items.setdefault(name, value)
    #@-node:Zoomq.20051028115650.17:setdefault
    #@+node:Zoomq.20051028115650.18:get
    def get(self, name, default=None):
        return self._items.get(name, default)
    #@-node:Zoomq.20051028115650.18:get
    #@+node:Zoomq.20051028115650.19:keys
    def keys(self):
        return self._items.keys()
    #@-node:Zoomq.20051028115650.19:keys
    #@+node:Zoomq.20051028115650.20:values
    def values(self):
        return self._items.values()
    #@-node:Zoomq.20051028115650.20:values
    #@+node:Zoomq.20051028115650.21:get_full_keyname
    def get_full_keyname(self, key):
        return section_delimeter.join(self._section + [key])
    #@-node:Zoomq.20051028115650.21:get_full_keyname
    #@-others
#@-node:Zoomq.20051028115650.3:class DictNode
#@+node:Zoomq.20051028115650.22:class DictIni
    
class DictIni(DictNode):
    #@	@+others
    #@+node:Zoomq.20051028115650.23:__init__
    def __init__(self, inifile=None, values=None, encoding=None, commentdelimeter='#'):
        self._items = {}
        self._inifile = inifile
        self._root = self
        self._section = []
        self._commentdelimeter = commentdelimeter
        if values is not None:
            self._items = values
        self._comments = {}
        self._orders = {}
        self._ID = 1
        self._encoding = getdefaultencoding(encoding)
        
        if self._inifile and os.path.exists(self._inifile):
            self.read(self._inifile, self._encoding)
    #@-node:Zoomq.20051028115650.23:__init__
    #@+node:Zoomq.20051028115650.24:setfilename
    def setfilename(self, filename):
        self._inifile = filename
    #@-node:Zoomq.20051028115650.24:setfilename
    #@+node:Zoomq.20051028115650.25:getfilename
    def getfilename(self):
        return self._inifile
    #@-node:Zoomq.20051028115650.25:getfilename
    #@+node:Zoomq.20051028115650.26:save
    def save(self, inifile=None, encoding=None):
        if inifile is None:
            inifile = self._inifile
            
        if isinstance(inifile, (str, unicode)):
            f = file(inifile, 'w')
        elif isinstance(inifile, file):
            f = inifile
        else:
            f = inifile
            
        if not f:
            f = sys.stdout
            
        if encoding is None:
            encoding = self._encoding
            
        f.write(self._savedict([], self._items, encoding))
        if isinstance(inifile, (str, unicode)):
            f.close()
    #@-node:Zoomq.20051028115650.26:save
    #@+node:Zoomq.20051028115650.27:_savedict
    def _savedict(self, section, values, encoding):
        if values:
            buf = []
            default = []
            for key, value in self._getorderitems(values.items()):
                if isinstance(value, dict):
                    sec = section[:]
                    sec.append(key)
                    buf.append(self._savedict(sec, value, encoding))
                else:
                    c = self._comments.get(section_delimeter.join(section + [key]), '')
                    if c:
                        lines = c.splitlines()
                        default.append('\n'.join(['%s %s' % (self._commentdelimeter, x) for x in lines]))
                        
                    default.append("%s = %s" % (key, uni_prt(value, encoding)))
            if default:
                buf.insert(0, '\n'.join(default))
                buf.insert(0, '[%s]' % section_delimeter.join(section))
                c = self._comments.get(section_delimeter.join(section), '')
                if c:
                    lines = c.splitlines()
                    buf.insert(0, '\n'.join(['%s %s' % (self._commentdelimeter, x) for x in lines]))
            return '\n'.join(buf + [''])
        else:
            return ''
    #@-node:Zoomq.20051028115650.27:_savedict
    #@+node:Zoomq.20051028115650.28:read
    def read(self, inifile=None, encoding=None):
        if inifile is None:
            inifile = self._inifile
            
        if isinstance(inifile, (str, unicode)):
            try:
                f = file(inifile, 'r')
            except:
                return  #may raise Exception is better
        elif isinstance(inifile, file):
            f = inifile
        else:
            f = inifile
            
        if not f:
            f = sys.stdin
            
        if encoding is None:
            encoding = self._encoding
            
        comments = []
        section = ''
        for line in f.readlines():
            line = line.strip()
            if not line: continue
            if line.startswith(self._commentdelimeter):
                comments.append(line[1:].lstrip())
                continue
            if line.startswith('['):    #section
                section = line[1:-1]
                #if comment then set it
                if comments:
                    self.comment(section, '\n'.join(comments))
                    comments = []
                continue
            key, value = line.split('=', 1)
            key = key.strip()
            value = process_value(value.strip(), encoding)
            if section:
                self.__setitem__(section + section_delimeter + key, value)
                #if comment then set it
                if comments:
                    self.__getitem__(section).comment(key, '\n'.join(comments))
                    comments = []
            else:
                self.__setitem__(key, value)
                #if comment then set it
                if comments:
                    self.comment(key, '\n'.join(comments))
                    comments = []
        if isinstance(inifile, (str, unicode)):
            f.close()
    #@-node:Zoomq.20051028115650.28:read
    #@+node:Zoomq.20051028115650.29:setorder
    def setorder(self, key):
        if not self._orders.has_key(key):
            self._orders[key] = self._ID
            self._ID += 1
    #@-node:Zoomq.20051028115650.29:setorder
    #@+node:Zoomq.20051028115650.30:_getorderitems
    def _getorderitems(self, values):
        s = []
        for key, value in values:
            s.append((self._orders.get(key, 99999), key, value))
        s.sort()
        return [(x, y) for z, x, y in s]
    #@-node:Zoomq.20051028115650.30:_getorderitems
    #@-others
#@-node:Zoomq.20051028115650.22:class DictIni
#@+node:Zoomq.20051028115650.31:process_value
def process_value(value, encoding=None):
    length = len(value)
    t = value
    i = 0
    r = []
    buf = []
    listflag = False
    while i < length:
        if t[i] == '"': #string quote
            buf.append(t[i])
            i += 1
            while t[i] != '"' or (t[i] == '"' and t[i-1] == '\\'):
                buf.append(t[i])
                i += 1
            buf.append(t[i])
            i += 1
        elif t[i] == ',':
            r.append(''.join(buf))
            buf = []
            i += 1
            listflag = True
        elif t[i] == 'u':
            buf.append(t[i])
            i += 1
        else:
            buf.append(t[i])
            i += 1
            while i < length and t[i] != ',':
                buf.append(t[i])
                i += 1
    if buf:
        r.append(''.join(buf))
    result = []
    for i in r:
        if i.isdigit():
            result.append(int(i))
        elif i and i.startswith('u"'):
            result.append(unicode(unescstr(i[1:]), encoding))
        else:
            b = r_float.match(i)
            if b:
                result.append(float(b.group()))
            else:
                result.append(unescstr(i))
            
    if listflag:
        return result
    elif result:
        return result[0]
    else:
        return ''
#@-node:Zoomq.20051028115650.31:process_value
#@+node:Zoomq.20051028115650.32:unescstr
def unescstr(value):
    if value.startswith('"') and value.endswith('"'):
        value = value[1:-1]
        escapechars = [("\\", "\\\\"), ("'", r"\'"), ('\"', r'\"'), ('\b', r'\b'), 
            ('\t', r"\t"), ('\r', r"\r"), ('\n', r"\n")]
        for item in escapechars:
            k, v = item
            value = value.replace(v, k)
    return value
#@-node:Zoomq.20051028115650.32:unescstr
#@+node:Zoomq.20051028115650.33:getdefaultencoding
def getdefaultencoding(encoding):
    if not encoding:
        encoding = locale.getdefaultlocale()[1]
    if not encoding:
        encoding = sys.getfilesystemencoding()
    if not encoding:
        encoding = 'utf-8'
    return encoding
#@-node:Zoomq.20051028115650.33:getdefaultencoding
#@+node:Zoomq.20051028115650.34:uni_prt
def uni_prt(a, encoding=None):
    escapechars = [("\\", "\\\\"), ("'", r"\'"), ('\"', r'\"'), ('\b', r'\b'), 
        ('\t', r"\t"), ('\r', r"\r"), ('\n', r"\n")]
    s = []
    if isinstance(a, (list, tuple)):
        for i, k in enumerate(a):
            s.append(uni_prt(k, encoding))
            s.append(',')
    elif isinstance(a, str):
        t = a
        for i in escapechars:
            t = t.replace(i[0], i[1])
        if ' ' in t or ',' in t or t.isdigit():
            s.append('"%s"' % t)
        else:
            s.append("%s" % t)
    elif isinstance(a, unicode):
        t = a
        for i in escapechars:
            t = t.replace(i[0], i[1])
        s.append('u"%s"' % t.encode(encoding))
    else:
        s.append(str(a))
    return ''.join(s)
#@-node:Zoomq.20051028115650.34:uni_prt
#@-others
        
if __name__ == '__main__':
    #@    << try >>
    #@+node:Zoomq.20051028115650.2:<< try >>
    
    d = DictIni('test.ini')
    #    d._comment = 'Test\nTest2'
    #    d.a = 'b'
    #    d['b'] = 3
    #    d.c.d = (1,2,'b asf aaa')
    #    d['s']['t'] = u'涓�浗'
    #    d['s'].a = 1
    #    d['m/m'] = 'testing'
    #    d.t.m.p = '3'
    
    print d
    #    d.setfilename('test.ini')
    #    d.t.m.comment('p', 'PTesting')
    #    print d.getfilename()
    #    print '---------------------'
    #    
    #    d.save('test.ini')
    #    
    #    a = process_value('1,abc,"aa cc",,"  ,\\"sdf",u"aaa"', 'ascii')
    #    print a
    #    print uni_prt(a, 'utf-8')
    #    
    #    t = DictIni(inifile='test.ini')
    #    print t
    #
    #    t.setfilename('test1.ini')
    #    t.save()
    
    #    t.setfilename('test2.ini')
    #    t.save()
    
    #@-node:Zoomq.20051028115650.2:<< try >>
    #@nl
#@nonl
#@-node:Zoomq.20051028115650:@thin dict4ini.py
#@-leo

# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors
# MIT License. See license.txt 

import webnotes
import webnotes.model
from webnotes.model.doc import Document
from webnotes import _

class DocList(list):
	"""DocList object as a wrapper around a list"""
	def get(self, filters, limit=0):
		"""pass filters as:
			{"key": "val", "key": ["!=", "val"],
			"key": ["in", "val"], "key": ["not in", "val"], "key": "^val",
			"key" : True (exists), "key": False (does not exist) }"""

		out = []
		
		for doc in self:
			d = isinstance(getattr(doc, "fields", None), dict) and doc.fields or doc
			add = True
			for f in filters:
				fval = filters[f]
				
				if fval is True:
					fval = ["not None", fval]
				elif fval is False:
					fval = ["None", fval]
				elif not isinstance(fval, list):
					if isinstance(fval, basestring) and fval.startswith("^"):
						fval = ["^", fval[1:]]
					else:
						fval = ["=", fval]
				
				if not webnotes.compare(d.get(f), fval[0], fval[1]):
					add = False
					break

			if add:
				out.append(doc)
				if limit and (len(out)-1)==limit:
					break
		
		return DocList(out)
		
	def get_distinct_values(self, fieldname):
		return filter(None, list(set(map(lambda d: d.fields.get(fieldname), self))))

	def remove_items(self, filters):
		for d in self.get(filters):
			self.remove(d)

	def getone(self, filters):
		return self.get(filters, limit=1)[0]

	def copy(self):
		out = []
		for d in self:
			if isinstance(d, dict):
				fielddata = d
			else:
				fielddata = d.fields
			fielddata.update({"name": None})
			out.append(Document(fielddata=fielddata))
		return DocList(out)
		
	def get_item_value(self, d, name):
		if isinstance(d, dict):
			return d.get(name)
		else:
			return d.fields.get(name)
		
	def filter_valid_fields(self):
		import webnotes.model
		fieldnames = {}
		for d in self:
			remove = []
			for f in d:
				if f not in fieldnames.setdefault(d.doctype,
						webnotes.model.get_fieldnames(d.doctype)):
					remove.append(f)
			for f in remove:
				del d[f]
				
	def append(self, doc):
		if not isinstance(doc, Document):
			doc = Document(fielddata=doc)
			
		self._prepare_doc(doc)

		super(DocList, self).append(doc)
		
	def extend(self, doclist):
		doclist = objectify(doclist)
		for doc in doclist:
			self._prepare_doc(doc)
		
		super(DocList, self).extend(doclist)
		
		return self
		
	def _prepare_doc(self, doc):
		if not doc.name:
			doc.fields["__islocal"] = 1
			doc.docstatus = 0
		if doc.parentfield:
			if not doc.parenttype:
				doc.parenttype = self[0].doctype
			if not doc.parent:
				doc.parent = self[0].name
			if not doc.idx:
				siblings = [int(self.get_item_value(d, "idx") or 0) for d in self.get({"parentfield": doc.parentfield})]
				doc.idx = (max(siblings) + 1) if siblings else 1
	
	def update(self, doclist):
		for i, d in enumerate(self):
			if d.get("parent") and d.get("name") not in [t.get("name") for t in doclist]:
				del self[i]
				
		for d in doclist:
			if not d["name"]:
				d["__islocal"] = 1
				self.append(d)
			else:
				# child
				found_in_existing = False

				for ref in self:				
					if d["name"] and ref.name and ref.name == d["name"]:
						ref.fields.update(d)
						found_in_existing = True
						break
						
				if not found_in_existing:
					d["__islocal"] = 1
					d["name"] = None
					self.append(d)
					
		return self
		
def objectify(doclist):
	from webnotes.model.doc import Document
	return map(lambda d: isinstance(d, Document) and d or Document(d), doclist)

# ----------------------------------------------------------------------
# Numenta Platform for Intelligent Computing (NuPIC)
# Copyright (C) 2013, Numenta, Inc.  Unless you have an agreement
# with Numenta, Inc., for a separate license for this software code, the
# following terms and conditions apply:
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 3 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see http://www.gnu.org/licenses.
#
# http://numenta.org/licenses/
# ----------------------------------------------------------------------

"""
Template file used by the OPF Experiment Generator to generate the actual
description.py file by replacing $XXXXXXXX tokens with desired values.

This description.py file was generated by:
'/Users/ronmarianetti/nta/eng/lib/python2.6/site-packages/nupic/frameworks/opf/expGenerator/ExpGenerator.py'
"""

from nupic.frameworks.opf.expdescriptionapi import ExperimentDescriptionAPI

from nupic.frameworks.opf.expdescriptionhelpers import (
  updateConfigFromSubConfig,
  applyValueGettersToContainer,
  DeferredDictLookup)

from nupic.frameworks.opf.clamodelcallbacks import *
from nupic.frameworks.opf.metrics import MetricSpec
from nupic.frameworks.opf.opfutils import (InferenceType,
                                           InferenceElement)
from nupic.support import aggregationDivide

from nupic.frameworks.opf.opftaskdriver import (
                                            IterationPhaseSpecLearnOnly,
                                            IterationPhaseSpecInferOnly,
                                            IterationPhaseSpecLearnAndInfer)


# Model Configuration Dictionary:
#
# Define the model parameters and adjust for any modifications if imported
# from a sub-experiment.
#
# These fields might be modified by a sub-experiment; this dict is passed
# between the sub-experiment and base experiment
#
#
# NOTE: Use of DEFERRED VALUE-GETTERs: dictionary fields and list elements
#   within the config dictionary may be assigned futures derived from the
#   ValueGetterBase class, such as DeferredDictLookup.
#   This facility is particularly handy for enabling substitution of values in
#   the config dictionary from other values in the config dictionary, which is
#   needed by permutation.py-based experiments. These values will be resolved
#   during the call to applyValueGettersToContainer(),
#   which we call after the base experiment's config dictionary is updated from
#   the sub-experiment. See ValueGetterBase and
#   DeferredDictLookup for more details about value-getters.
#
#   For each custom encoder parameter to be exposed to the sub-experiment/
#   permutation overrides, define a variable in this section, using key names
#   beginning with a single underscore character to avoid collisions with
#   pre-defined keys (e.g., _dsEncoderFieldName2_N).
#
#   Example:
#      config = dict(
#        _dsEncoderFieldName2_N = 70,
#        _dsEncoderFieldName2_W = 5,
#        dsEncoderSchema = [
#          base=dict(
#            fieldname='Name2', type='ScalarEncoder',
#            name='Name2', minval=0, maxval=270, clipInput=True,
#            n=DeferredDictLookup('_dsEncoderFieldName2_N'),
#            w=DeferredDictLookup('_dsEncoderFieldName2_W')),
#        ],
#      )
#      updateConfigFromSubConfig(config)
#      applyValueGettersToContainer(config)
config = {
    # Type of model that the rest of these parameters apply to.
    'model': "CLA",

    # Version that specifies the format of the config.
    'version': 1,

    # Intermediate variables used to compute fields in modelParams and also
    # referenced from the control section.
    'aggregationInfo': {   'days': 0,
        'fields': [],
        'hours': 0,
        'microseconds': 0,
        'milliseconds': 0,
        'minutes': 0,
        'months': 0,
        'seconds': 0,
        'weeks': 0,
        'years': 0},
    
    'predictAheadTime': None,

    # Model parameter dictionary.
    'modelParams': {
        # The type of inference that this model will perform
        'inferenceType': 'NontemporalClassification',

        'sensorParams': {
            # Sensor diagnostic output verbosity control;
            # if > 0: sensor region will print out on screen what it's sensing
            # at each step 0: silent; >=1: some info; >=2: more info;
            # >=3: even more info (see compute() in py/regions/RecordSensor.py)
            'verbosity' : 0,

            # Example:
            #     dsEncoderSchema = [
            #       DeferredDictLookup('__field_name_encoder'),
            #     ],
            #
            # (value generated from DS_ENCODER_SCHEMA)
            'encoders': {   u'A': {   'fieldname': u'daynight',
                          'n': 300,
                          'name': u'daynight',
                          'type': 'SDRCategoryEncoder',
                          'w': 21},
                u'B': {   'fieldname': u'daynight',
                          'n': 300,
                          'name': u'daynight',
                          'type': 'SDRCategoryEncoder',
                          'w': 21},
                u'C': {   'fieldname': u'precip',
                          'n': 300,
                          'name': u'precip',
                          'type': 'SDRCategoryEncoder',
                          'w': 21},
                u'D': {   'clipInput': True,
                          'fieldname': u'visitor_winloss',
                          'maxval': 0.78600000000000003,
                          'minval': 0.0,
                          'n': 150,
                          'name': u'visitor_winloss',
                          'type': 'AdaptiveScalarEncoder',
                          'w': 21},
                u'E': {   'clipInput': True,
                          'fieldname': u'home_winloss',
                          'maxval': 0.69999999999999996,
                          'minval': 0.0,
                          'n': 150,
                          'name': u'home_winloss',
                          'type': 'AdaptiveScalarEncoder',
                          'w': 21},
                u'F': {   'dayOfWeek': (7, 1),
                          'fieldname': u'timestamp',
                          'name': u'timestamp_dayOfWeek',
                          'type': 'DateEncoder'},
                u'G': {   'fieldname': u'timestamp',
                          'name': u'timestamp_timeOfDay',
                          'timeOfDay': (7, 1),
                          'type': 'DateEncoder'},
                u'_classifierInput': {   'clipInput': True,
                             'fieldname': u'attendance',
                             'classifierOnly': True,
                             'maxval': 36067,
                             'minval': 0,
                             'n': 150,
                             'name': u'attendance',
                             'type': 'AdaptiveScalarEncoder',
                             'w': 21}},

            # A dictionary specifying the period for automatically-generated
            # resets from a RecordSensor;
            #
            # None = disable automatically-generated resets (also disabled if
            # all of the specified values evaluate to 0).
            # Valid keys is the desired combination of the following:
            #   days, hours, minutes, seconds, milliseconds, microseconds, weeks
            #
            # Example for 1.5 days: sensorAutoReset = dict(days=1,hours=12),
            #
            # (value generated from SENSOR_AUTO_RESET)
            'sensorAutoReset' : None,
        },

        'spEnable': True,

        'spParams': {
            # SP diagnostic output verbosity control;
            # 0: silent; >=1: some info; >=2: more info;
            'spVerbosity' : 0,

            'globalInhibition': 1,

            # Number of cell columns in the cortical region (same number for
            # SP and TP)
            # (see also tpNCellsPerCol)
            'columnCount': 2048,

            'inputWidth': 0,

            # SP inhibition control (absolute value);
            # Maximum number of active columns in the SP region's output (when
            # there are more, the weaker ones are suppressed)
            'numActivePerInhArea': 40,

            'seed': 1956,

            # coincInputPoolPct
            # What percent of the columns's receptive field is available
            # for potential synapses. At initialization time, we will
            # choose coincInputPoolPct * (2*coincInputRadius+1)^2
            'coincInputPoolPct': 1.0,

            # The default connected threshold. Any synapse whose
            # permanence value is above the connected threshold is
            # a "connected synapse", meaning it can contribute to the
            # cell's firing. Typical value is 0.10. Cells whose activity
            # level before inhibition falls below minDutyCycleBeforeInh
            # will have their own internal synPermConnectedCell
            # threshold set below this default value.
            # (This concept applies to both SP and TP and so 'cells'
            # is correct here as opposed to 'columns')
            'synPermConnected': 0.1,

            'synPermActiveInc': 0.1,

            'synPermInactiveDec': 0.01,
        },

        # Controls whether TP is enabled or disabled;
        # TP is necessary for making temporal predictions, such as predicting
        # the next inputs.  Without TP, the model is only capable of
        # reconstructing missing sensor inputs (via SP).
        'tpEnable' : True,

        'tpParams': {
            # TP diagnostic output verbosity control;
            # 0: silent; [1..6]: increasing levels of verbosity
            # (see verbosity in nta/trunk/py/nupic/research/TP.py and TP10X*.py)
            'verbosity': 0,

            # Number of cell columns in the cortical region (same number for
            # SP and TP)
            # (see also tpNCellsPerCol)
            'columnCount': 2048,

            # The number of cells (i.e., states), allocated per column.
            'cellsPerColumn': 32,

            'inputWidth': 2048,

            'seed': 1960,

            # Temporal Pooler implementation selector (see _getTPClass in
            # CLARegion.py).
            'temporalImp': 'cpp',

            # New Synapse formation count
            # NOTE: If None, use spNumActivePerInhArea
            #
            # TODO: need better explanation
            'newSynapseCount': 15,

            # Maximum number of synapses per segment
            #  > 0 for fixed-size CLA
            # -1 for non-fixed-size CLA
            #
            # TODO: for Ron: once the appropriate value is placed in TP
            # constructor, see if we should eliminate this parameter from
            # description.py.
            'maxSynapsesPerSegment': 32,

            # Maximum number of segments per cell
            #  > 0 for fixed-size CLA
            # -1 for non-fixed-size CLA
            #
            # TODO: for Ron: once the appropriate value is placed in TP
            # constructor, see if we should eliminate this parameter from
            # description.py.
            'maxSegmentsPerCell': 128,

            # Initial Permanence
            # TODO: need better explanation
            'initialPerm': 0.21,

            # Permanence Increment
            'permanenceInc': 0.1,

            # Permanence Decrement
            # If set to None, will automatically default to tpPermanenceInc
            # value.
            'permanenceDec' : 0.1,

            'globalDecay': 0.0,

            'maxAge': 0,

            # Minimum number of active synapses for a segment to be considered
            # during search for the best-matching segments.
            # None=use default
            # Replaces: tpMinThreshold
            'minThreshold': 12,

            # Segment activation threshold.
            # A segment is active if it has >= tpSegmentActivationThreshold
            # connected synapses that are active due to infActiveState
            # None=use default
            # Replaces: tpActivationThreshold
            'activationThreshold': 16,

            'outputType': 'normal',

            # "Pay Attention Mode" length. This tells the TP how many new
            # elements to append to the end of a learned sequence at a time.
            # Smaller values are better for datasets with short sequences,
            # higher values are better for datasets with long sequences.
            'pamLength': 1,
        },

        'clParams': {
            'regionName' : 'CLAClassifierRegion',

            # Classifier diagnostic output verbosity control;
            # 0: silent; [1..6]: increasing levels of verbosity
            'clVerbosity' : 0,

            # This controls how fast the classifier learns/forgets. Higher values
            # make it adapt faster and forget older patterns faster.
            'alpha': 0.001,

            # This is set after the call to updateConfigFromSubConfig and is
            # computed from the aggregationInfo and predictAheadTime.
            'steps': '1',
            
            
        },

        'trainSPNetOnlyIfRequested': False,
    },
          
  
}
# end of config dictionary


# Adjust base config dictionary for any modifications if imported from a
# sub-experiment
updateConfigFromSubConfig(config)


# Compute predictionSteps based on the predictAheadTime and the aggregation
# period, which may be permuted over.
if config['predictAheadTime'] is not None:
  predictionSteps = int(round(aggregationDivide(
      config['predictAheadTime'], config['aggregationInfo'])))
  assert (predictionSteps >= 1)
  config['modelParams']['clParams']['steps'] = str(predictionSteps)


# Adjust config by applying ValueGetterBase-derived
# futures. NOTE: this MUST be called after updateConfigFromSubConfig() in order
# to support value-getter-based substitutions from the sub-experiment (if any)
applyValueGettersToContainer(config)




################################################################################
control = {
  # The environment that the current model is being run in
  "environment": 'nupic',

  # Input stream specification per py/nupicengine/cluster/database/StreamDef.json.
  #
  'dataset' : {   u'info': u'baseball benchmark test',
      u'streams': [   {   u'columns': [   u'daynight',
                                          u'precip',
                                          u'home_winloss',
                                          u'visitor_winloss',
                                          u'attendance',
                                          u'timestamp'],
                          u'info': u'OAK01.csv',
                          u'source': u'file://extra/baseball_stadium/OAK01reformatted.csv'}],
      u'version': 1},

  # Iteration count: maximum number of iterations.  Each iteration corresponds
  # to one record from the (possibly aggregated) dataset.  The task is
  # terminated when either number of iterations reaches iterationCount or
  # all records in the (possibly aggregated) database have been processed,
  # whichever occurs first.
  #
  # iterationCount of -1 = iterate over the entire dataset
  #'iterationCount' : ITERATION_COUNT,

  # Metrics: A list of MetricSpecs that instantiate the metrics that are
  # computed for this experiment
  'metrics':[
    MetricSpec(field=u'attendance', metric='multiStep', 
               inferenceElement='multiStepBestPredictions', 
               params={'window': 1000, 'steps': [0], 'errorMetric': 'aae'}),
  ],

  # Logged Metrics: A sequence of regular expressions that specify which of
  # the metrics from the Inference Specifications section MUST be logged for
  # every prediction. The regex's correspond to the automatically generated
  # metric labels. This is similar to the way the optimization metric is
  # specified in permutations.py.
  'loggedMetrics': ['.*'],
}


################################################################################
################################################################################
descriptionInterface = ExperimentDescriptionAPI(modelConfig=config,
                                                control=control)

###
# Copyright (c) 2004-2005, Jeremiah Fincher
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
#   * Redistributions of source code must retain the above copyright notice,
#     this list of conditions, and the following disclaimer.
#   * Redistributions in binary form must reproduce the above copyright notice,
#     this list of conditions, and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#   * Neither the name of the author of this software nor the name of
#     contributors to this software may be used to endorse or promote products
#     derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

import supybot.conf as conf
import supybot.registry as registry

def configure(advanced):
    # This will be called by supybot to configure this module.  advanced is
    # a bool that specifies whether the user identified himself as an advanced
    # user or not.  You should effect your configuration by manipulating the
    # registry as appropriate.
    from supybot.questions import expect, anything, something, yn
    conf.registerPlugin('Misc', True)

Misc = conf.registerPlugin('Misc')
conf.registerGlobalValue(Misc, 'listPrivatePlugins',
    registry.Boolean(True, """Determines whether the bot will list private
    plugins with the list command if given the --private switch.  If this is
    disabled, non-owner users should be unable to see what private plugins
    are loaded."""))
conf.registerGlobalValue(Misc, 'timestampFormat',
    registry.String('[%H:%M:%S]', """Determines the format string for
    timestamps in the Misc.last command.  Refer to the Python documentation
    for the time module to see what formats are accepted. If you set this
    variable to the empty string, the timestamp will not be shown."""))
conf.registerGroup(Misc, 'last')
conf.registerGroup(Misc.last, 'nested')
conf.registerChannelValue(Misc.last.nested,
    'includeTimestamp', registry.Boolean(False, """Determines whether or not
    the timestamp will be included in the output of last when it is part of a
    nested command"""))
conf.registerChannelValue(Misc.last.nested,
    'includeNick', registry.Boolean(False, """Determines whether or not the
    nick will be included in the output of last when it is part of a nested
    command"""))

# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:

# -*- coding: utf-8 -*-
#
# Copyright (c) 2017 F5 Networks Inc.
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os
import json
import pytest
import sys

from nose.plugins.skip import SkipTest
if sys.version_info < (2, 7):
    raise SkipTest("F5 Ansible modules require Python >= 2.7")

from ansible.compat.tests import unittest
from ansible.compat.tests.mock import Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.basic import AnsibleModule

try:
    from library.bigip_profile_client_ssl import ModuleParameters
    from library.bigip_profile_client_ssl import ApiParameters
    from library.bigip_profile_client_ssl import ModuleManager
    from library.bigip_profile_client_ssl import ArgumentSpec
    from library.module_utils.network.f5.common import F5ModuleError
    from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
    from test.unit.modules.utils import set_module_args
except ImportError:
    try:
        from ansible.modules.network.f5.bigip_profile_client_ssl import ModuleParameters
        from ansible.modules.network.f5.bigip_profile_client_ssl import ApiParameters
        from ansible.modules.network.f5.bigip_profile_client_ssl import ModuleManager
        from ansible.modules.network.f5.bigip_profile_client_ssl import ArgumentSpec
        from ansible.module_utils.network.f5.common import F5ModuleError
        from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
        from units.modules.utils import set_module_args
    except ImportError:
        raise SkipTest("F5 Ansible modules require the f5-sdk Python library")

fixture_path = os.path.join(os.path.dirname(__file__), 'fixtures')
fixture_data = {}


def load_fixture(name):
    path = os.path.join(fixture_path, name)

    if path in fixture_data:
        return fixture_data[path]

    with open(path) as f:
        data = f.read()

    try:
        data = json.loads(data)
    except Exception:
        pass

    fixture_data[path] = data
    return data


class TestParameters(unittest.TestCase):
    def test_module_parameters(self):
        args = dict(
            name='foo',
            parent='bar',
            ciphers='!SSLv3:!SSLv2:ECDHE+AES-GCM+SHA256:ECDHE-RSA-AES128-CBC-SHA',
            cert_key_chain=[
                dict(
                    cert='bigip_ssl_cert1',
                    key='bigip_ssl_key1',
                    chain='bigip_ssl_cert1'
                )
            ]
        )

        p = ModuleParameters(params=args)
        assert p.name == 'foo'
        assert p.parent == '/Common/bar'
        assert p.ciphers == '!SSLv3:!SSLv2:ECDHE+AES-GCM+SHA256:ECDHE-RSA-AES128-CBC-SHA'

    def test_api_parameters(self):
        args = load_fixture('load_ltm_profile_clientssl.json')
        p = ApiParameters(params=args)
        assert p.name == 'foo'
        assert p.ciphers == 'DEFAULT'


class TestManager(unittest.TestCase):

    def setUp(self):
        self.spec = ArgumentSpec()

    def test_create(self, *args):
        # Configure the arguments that would be sent to the Ansible module
        set_module_args(dict(
            name='foo',
            parent='bar',
            ciphers='!SSLv3:!SSLv2:ECDHE+AES-GCM+SHA256:ECDHE-RSA-AES128-CBC-SHA',
            cert_key_chain=[
                dict(
                    cert='bigip_ssl_cert1',
                    key='bigip_ssl_key1',
                    chain='bigip_ssl_cert1'
                )
            ],
            password='passsword',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.exists = Mock(return_value=False)
        mm.create_on_device = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True

"""
This module defines export functions for decision trees.
"""

# Authors: Gilles Louppe <g.louppe@gmail.com>
#          Peter Prettenhofer <peter.prettenhofer@gmail.com>
#          Brian Holt <bdholt1@gmail.com>
#          Noel Dawe <noel@dawe.me>
#          Satrajit Gosh <satrajit.ghosh@gmail.com>
#          Trevor Stephens <trev.stephens@gmail.com>
# Licence: BSD 3 clause

import numpy as np

from ..externals import six

from . import _tree


def _color_brew(n):
    """Generate n colors with equally spaced hues.

    Parameters
    ----------
    n : int
        The number of colors required.

    Returns
    -------
    color_list : list, length n
        List of n tuples of form (R, G, B) being the components of each color.
    """
    color_list = []

    # Initialize saturation & value; calculate chroma & value shift
    s, v = 0.75, 0.9
    c = s * v
    m = v - c

    for h in np.arange(25, 385, 360. / n).astype(int):
        # Calculate some intermediate values
        h_bar = h / 60.
        x = c * (1 - abs((h_bar % 2) - 1))
        # Initialize RGB with same hue & chroma as our color
        rgb = [(c, x, 0),
               (x, c, 0),
               (0, c, x),
               (0, x, c),
               (x, 0, c),
               (c, 0, x),
               (c, x, 0)]
        r, g, b = rgb[int(h_bar)]
        # Shift the initial RGB values to match value and store
        rgb = [(int(255 * (r + m))),
               (int(255 * (g + m))),
               (int(255 * (b + m)))]
        color_list.append(rgb)

    return color_list


def export_graphviz(decision_tree, out_file="tree.dot", max_depth=None,
                    feature_names=None, class_names=None, label='all',
                    filled=False, leaves_parallel=False, impurity=True,
                    node_ids=False, proportion=False, rotate=False,
                    rounded=False, special_characters=False):
    """Export a decision tree in DOT format.

    This function generates a GraphViz representation of the decision tree,
    which is then written into `out_file`. Once exported, graphical renderings
    can be generated using, for example::

        $ dot -Tps tree.dot -o tree.ps      (PostScript format)
        $ dot -Tpng tree.dot -o tree.png    (PNG format)

    The sample counts that are shown are weighted with any sample_weights that
    might be present.

    Read more in the :ref:`User Guide <tree>`.

    Parameters
    ----------
    decision_tree : decision tree classifier
        The decision tree to be exported to GraphViz.

    out_file : file object or string, optional (default="tree.dot")
        Handle or name of the output file.

    max_depth : int, optional (default=None)
        The maximum depth of the representation. If None, the tree is fully
        generated.

    feature_names : list of strings, optional (default=None)
        Names of each of the features.

    class_names : list of strings, bool or None, optional (default=None)
        Names of each of the target classes in ascending numerical order.
        Only relevant for classification and not supported for multi-output.
        If ``True``, shows a symbolic representation of the class name.

    label : {'all', 'root', 'none'}, optional (default='all')
        Whether to show informative labels for impurity, etc.
        Options include 'all' to show at every node, 'root' to show only at
        the top root node, or 'none' to not show at any node.

    filled : bool, optional (default=False)
        When set to ``True``, paint nodes to indicate majority class for
        classification, extremity of values for regression, or purity of node
        for multi-output.

    leaves_parallel : bool, optional (default=False)
        When set to ``True``, draw all leaf nodes at the bottom of the tree.

    impurity : bool, optional (default=True)
        When set to ``True``, show the impurity at each node.

    node_ids : bool, optional (default=False)
        When set to ``True``, show the ID number on each node.

    proportion : bool, optional (default=False)
        When set to ``True``, change the display of 'values' and/or 'samples'
        to be proportions and percentages respectively.

    rotate : bool, optional (default=False)
        When set to ``True``, orient tree left to right rather than top-down.

    rounded : bool, optional (default=False)
        When set to ``True``, draw node boxes with rounded corners and use
        Helvetica fonts instead of Times-Roman.

    special_characters : bool, optional (default=False)
        When set to ``False``, ignore special characters for PostScript
        compatibility.

    Examples
    --------
    >>> from sklearn.datasets import load_iris
    >>> from sklearn import tree

    >>> clf = tree.DecisionTreeClassifier()
    >>> iris = load_iris()

    >>> clf = clf.fit(iris.data, iris.target)
    >>> tree.export_graphviz(clf,
    ...     out_file='tree.dot')                # doctest: +SKIP
    """

    def get_color(value):
        # Find the appropriate color & intensity for a node
        if colors['bounds'] is None:
            # Classification tree
            color = list(colors['rgb'][np.argmax(value)])
            sorted_values = sorted(value, reverse=True)
            alpha = int(255 * (sorted_values[0] - sorted_values[1]) /
                        (1 - sorted_values[1]))
        else:
            # Regression tree or multi-output
            color = list(colors['rgb'][0])
            alpha = int(255 * ((value - colors['bounds'][0]) /
                               (colors['bounds'][1] - colors['bounds'][0])))

        # Return html color code in #RRGGBBAA format
        color.append(alpha)
        hex_codes = [str(i) for i in range(10)]
        hex_codes.extend(['a', 'b', 'c', 'd', 'e', 'f'])
        color = [hex_codes[c // 16] + hex_codes[c % 16] for c in color]

        return '#' + ''.join(color)

    def node_to_str(tree, node_id, criterion):
        # Generate the node content string

        if tree.n_outputs == 1:
            value = tree.value[node_id][0, :]
        else:
            value = tree.value[node_id]

        # Should labels be shown?
        labels = (label == 'root' and node_id == 0) or label == 'all'

        # PostScript compatibility for special characters
        if special_characters:
            characters = ['&#35;', '<SUB>', '</SUB>', '&le;', '<br/>', '>']
            node_string = '<'
        else:
            characters = ['#', '[', ']', '<=', '\\n', '"']
            node_string = '"'

        # Write node ID
        if node_ids:
            if labels:
                node_string += 'node '
            node_string += characters[0] + str(node_id) + characters[4]

        # Write decision criteria
        if tree.children_left[node_id] != _tree.TREE_LEAF:
            # Always write node decision criteria, except for leaves
            if feature_names is not None:
                feature = feature_names[tree.feature[node_id]]
            else:
                feature = "X%s%s%s" % (characters[1],
                                       tree.feature[node_id],
                                       characters[2])
            node_string += '%s %s %s%s' % (feature,
                                           characters[3],
                                           round(tree.threshold[node_id], 4),
                                           characters[4])

        # Write impurity
        if impurity:
            if isinstance(criterion, _tree.FriedmanMSE):
                criterion = "friedman_mse"
            elif not isinstance(criterion, six.string_types):
                criterion = "impurity"
            if labels:
                node_string += '%s = ' % criterion
            node_string += (str(round(tree.impurity[node_id], 4)) +
                            characters[4])

        # Write node sample count
        if labels:
            node_string += 'samples = '
        if proportion:
            percent = (100. * tree.n_node_samples[node_id] /
                       float(tree.n_node_samples[0]))
            node_string += (str(round(percent, 1)) + '%' +
                            characters[4])
        else:
            node_string += (str(tree.n_node_samples[node_id]) +
                            characters[4])

        # Write node class distribution / regression value
        if proportion and tree.n_classes[0] != 1:
            # For classification this will show the proportion of samples
            value = value / tree.weighted_n_node_samples[node_id]
        if labels:
            node_string += 'value = '
        if tree.n_classes[0] == 1:
            # Regression
            value_text = np.around(value, 4)
        elif proportion:
            # Classification
            value_text = np.around(value, 2)
        elif np.all(np.equal(np.mod(value, 1), 0)):
            # Classification without floating-point weights
            value_text = value.astype(int)
        else:
            # Classification with floating-point weights
            value_text = np.around(value, 4)
        # Strip whitespace
        value_text = str(value_text.astype('S32')).replace("b'", "'")
        value_text = value_text.replace("' '", ", ").replace("'", "")
        if tree.n_classes[0] == 1 and tree.n_outputs == 1:
            value_text = value_text.replace("[", "").replace("]", "")
        value_text = value_text.replace("\n ", characters[4])
        node_string += value_text + characters[4]

        # Write node majority class
        if (class_names is not None and
                tree.n_classes[0] != 1 and
                tree.n_outputs == 1):
            # Only done for single-output classification trees
            if labels:
                node_string += 'class = '
            if class_names is not True:
                class_name = class_names[np.argmax(value)]
            else:
                class_name = "y%s%s%s" % (characters[1],
                                          np.argmax(value),
                                          characters[2])
            node_string += class_name

        # Clean up any trailing newlines
        if node_string[-2:] == '\\n':
            node_string = node_string[:-2]
        if node_string[-5:] == '<br/>':
            node_string = node_string[:-5]

        return node_string + characters[5]

    def recurse(tree, node_id, criterion, parent=None, depth=0):
        if node_id == _tree.TREE_LEAF:
            raise ValueError("Invalid node_id %s" % _tree.TREE_LEAF)

        left_child = tree.children_left[node_id]
        right_child = tree.children_right[node_id]

        # Add node with description
        if max_depth is None or depth <= max_depth:

            # Collect ranks for 'leaf' option in plot_options
            if left_child == _tree.TREE_LEAF:
                ranks['leaves'].append(str(node_id))
            elif str(depth) not in ranks:
                ranks[str(depth)] = [str(node_id)]
            else:
                ranks[str(depth)].append(str(node_id))

            out_file.write('%d [label=%s'
                           % (node_id,
                              node_to_str(tree, node_id, criterion)))

            if filled:
                # Fetch appropriate color for node
                if 'rgb' not in colors:
                    # Initialize colors and bounds if required
                    colors['rgb'] = _color_brew(tree.n_classes[0])
                    if tree.n_outputs != 1:
                        # Find max and min impurities for multi-output
                        colors['bounds'] = (np.min(-tree.impurity),
                                            np.max(-tree.impurity))
                    elif tree.n_classes[0] == 1:
                        # Find max and min values in leaf nodes for regression
                        colors['bounds'] = (np.min(tree.value),
                                            np.max(tree.value))
                if tree.n_outputs == 1:
                    node_val = (tree.value[node_id][0, :] /
                                tree.weighted_n_node_samples[node_id])
                    if tree.n_classes[0] == 1:
                        # Regression
                        node_val = tree.value[node_id][0, :]
                else:
                    # If multi-output color node by impurity
                    node_val = -tree.impurity[node_id]
                out_file.write(', fillcolor="%s"' % get_color(node_val))
            out_file.write('] ;\n')

            if parent is not None:
                # Add edge to parent
                out_file.write('%d -> %d' % (parent, node_id))
                if parent == 0:
                    # Draw True/False labels if parent is root node
                    angles = np.array([45, -45]) * ((rotate - .5) * -2)
                    out_file.write(' [labeldistance=2.5, labelangle=')
                    if node_id == 1:
                        out_file.write('%d, headlabel="True"]' % angles[0])
                    else:
                        out_file.write('%d, headlabel="False"]' % angles[1])
                out_file.write(' ;\n')

            if left_child != _tree.TREE_LEAF:
                recurse(tree, left_child, criterion=criterion, parent=node_id,
                        depth=depth + 1)
                recurse(tree, right_child, criterion=criterion, parent=node_id,
                        depth=depth + 1)

        else:
            ranks['leaves'].append(str(node_id))

            out_file.write('%d [label="(...)"' % node_id)
            if filled:
                # color cropped nodes grey
                out_file.write(', fillcolor="#C0C0C0"')
            out_file.write('] ;\n' % node_id)

            if parent is not None:
                # Add edge to parent
                out_file.write('%d -> %d ;\n' % (parent, node_id))

    own_file = False
    try:
        if isinstance(out_file, six.string_types):
            if six.PY3:
                out_file = open(out_file, "w", encoding="utf-8")
            else:
                out_file = open(out_file, "wb")
            own_file = True

        # The depth of each node for plotting with 'leaf' option
        ranks = {'leaves': []}
        # The colors to render each node with
        colors = {'bounds': None}

        out_file.write('digraph Tree {\n')

        # Specify node aesthetics
        out_file.write('node [shape=box')
        rounded_filled = []
        if filled:
            rounded_filled.append('filled')
        if rounded:
            rounded_filled.append('rounded')
        if len(rounded_filled) > 0:
            out_file.write(', style="%s", color="black"'
                           % ", ".join(rounded_filled))
        if rounded:
            out_file.write(', fontname=helvetica')
        out_file.write('] ;\n')

        # Specify graph & edge aesthetics
        if leaves_parallel:
            out_file.write('graph [ranksep=equally, splines=polyline] ;\n')
        if rounded:
            out_file.write('edge [fontname=helvetica] ;\n')
        if rotate:
            out_file.write('rankdir=LR ;\n')

        # Now recurse the tree and add node & edge attributes
        if isinstance(decision_tree, _tree.Tree):
            recurse(decision_tree, 0, criterion="impurity")
        else:
            recurse(decision_tree.tree_, 0, criterion=decision_tree.criterion)

        # If required, draw leaf nodes at same depth as each other
        if leaves_parallel:
            for rank in sorted(ranks):
                out_file.write("{rank=same ; " +
                               "; ".join(r for r in ranks[rank]) + "} ;\n")
        out_file.write("}")

    finally:
        if own_file:
            out_file.close()

class DuplicateArgument(Exception):
    pass


class TooSamllBlockDuration(ValueError):
    """Raised when block_dur results in a block_size smaller than one sample."""

    def __init__(self, message, block_dur, sampling_rate):
        self.block_dur = block_dur
        self.sampling_rate = sampling_rate
        super(TooSamllBlockDuration, self).__init__(message)


class TimeFormatError(Exception):
    """Raised when a duration formatting directive is unknown."""


class EndOfProcessing(Exception):
    """Raised within command line script's main function to jump to
    postprocessing code."""


class AudioIOError(Exception):
    """Raised when a compressed audio file cannot be loaded or when trying
    to read from a not yet open AudioSource"""


class AudioParameterError(AudioIOError):
    """Raised when one audio parameter is missing when loading raw data or
    saving data to a format other than raw. Also raised when an audio
    parameter has a wrong value."""


class AudioEncodingError(Exception):
    """Raised if audio data can not be encoded in the provided format"""


class AudioEncodingWarning(RuntimeWarning):
    """Raised if audio data can not be encoded in the provided format
    but saved as wav.
    """

from __future__ import print_function, division

from sympy.combinatorics.perm_groups import PermutationGroup
from sympy.combinatorics.permutations import Permutation
from sympy.utilities.iterables import uniq
from sympy.core.compatibility import range

_af_new = Permutation._af_new


def DirectProduct(*groups):
    """
    Returns the direct product of several groups as a permutation group.

    This is implemented much like the __mul__ procedure for taking the direct
    product of two permutation groups, but the idea of shifting the
    generators is realized in the case of an arbitrary number of groups.
    A call to DirectProduct(G1, G2, ..., Gn) is generally expected to be faster
    than a call to G1*G2*...*Gn (and thus the need for this algorithm).

    Examples
    ========

    >>> from sympy.combinatorics.group_constructs import DirectProduct
    >>> from sympy.combinatorics.named_groups import CyclicGroup
    >>> C = CyclicGroup(4)
    >>> G = DirectProduct(C, C, C)
    >>> G.order()
    64

    See Also
    ========
    __mul__

    """
    degrees = []
    gens_count = []
    total_degree = 0
    total_gens = 0
    for group in groups:
        current_deg = group.degree
        current_num_gens = len(group.generators)
        degrees.append(current_deg)
        total_degree += current_deg
        gens_count.append(current_num_gens)
        total_gens += current_num_gens
    array_gens = []
    for i in range(total_gens):
        array_gens.append(list(range(total_degree)))
    current_gen = 0
    current_deg = 0
    for i in range(len(gens_count)):
        for j in range(current_gen, current_gen + gens_count[i]):
            gen = ((groups[i].generators)[j - current_gen]).array_form
            array_gens[j][current_deg:current_deg + degrees[i]] = \
                [x + current_deg for x in gen]
        current_gen += gens_count[i]
        current_deg += degrees[i]
    perm_gens = list(uniq([_af_new(list(a)) for a in array_gens]))
    return PermutationGroup(perm_gens, dups=False)

#!/usr/bin/python2.4

# Copyright (c) 2009 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""New implementation of Visual Studio project generation for SCons."""

import common
import os
import random

# hashlib is supplied as of Python 2.5 as the replacement interface for md5
# and other secure hashes.  In 2.6, md5 is deprecated.  Import hashlib if
# available, avoiding a deprecation warning under 2.6.  Import md5 otherwise,
# preserving 2.4 compatibility.
try:
  import hashlib
  _new_md5 = hashlib.md5
except ImportError:
  import md5
  _new_md5 = md5.new


# Initialize random number generator
random.seed()

# GUIDs for project types
ENTRY_TYPE_GUIDS = {
    'project': '{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}',
    'folder': '{2150E333-8FDC-42A3-9474-1A3956D46DE8}',
}

#------------------------------------------------------------------------------
# Helper functions


def MakeGuid(name, seed='msvs_new'):
  """Returns a GUID for the specified target name.

  Args:
    name: Target name.
    seed: Seed for MD5 hash.
  Returns:
    A GUID-line string calculated from the name and seed.

  This generates something which looks like a GUID, but depends only on the
  name and seed.  This means the same name/seed will always generate the same
  GUID, so that projects and solutions which refer to each other can explicitly
  determine the GUID to refer to explicitly.  It also means that the GUID will
  not change when the project for a target is rebuilt.
  """
  # Calculate a MD5 signature for the seed and name.
  d = _new_md5(str(seed) + str(name)).hexdigest().upper()
  # Convert most of the signature to GUID form (discard the rest)
  guid = ('{' + d[:8] + '-' + d[8:12] + '-' + d[12:16] + '-' + d[16:20]
          + '-' + d[20:32] + '}')
  return guid

#------------------------------------------------------------------------------


class MSVSFolder:
  """Folder in a Visual Studio project or solution."""

  def __init__(self, path, name = None, entries = None,
               guid = None, items = None):
    """Initializes the folder.

    Args:
      path: Full path to the folder.
      name: Name of the folder.
      entries: List of folder entries to nest inside this folder.  May contain
          Folder or Project objects.  May be None, if the folder is empty.
      guid: GUID to use for folder, if not None.
      items: List of solution items to include in the folder project.  May be
          None, if the folder does not directly contain items.
    """
    if name:
      self.name = name
    else:
      # Use last layer.
      self.name = os.path.basename(path)

    self.path = path
    self.guid = guid

    # Copy passed lists (or set to empty lists)
    self.entries = list(entries or [])
    self.items = list(items or [])

    self.entry_type_guid = ENTRY_TYPE_GUIDS['folder']

  def get_guid(self):
    if self.guid is None:
      # Use consistent guids for folders (so things don't regenerate).
      self.guid = MakeGuid(self.path, seed='msvs_folder')
    return self.guid


#------------------------------------------------------------------------------


class MSVSProject:
  """Visual Studio project."""

  def __init__(self, path, name = None, dependencies = None, guid = None,
               config_platform_overrides = None):
    """Initializes the project.

    Args:
      path: Relative path to project file.
      name: Name of project.  If None, the name will be the same as the base
          name of the project file.
      dependencies: List of other Project objects this project is dependent
          upon, if not None.
      guid: GUID to use for project, if not None.
      config_platform_overrides: optional dict of configuration platforms to
          used in place of the default for this target.
    """
    self.path = path
    self.guid = guid

    if name:
      self.name = name
    else:
      # Use project filename
      self.name = os.path.splitext(os.path.basename(path))[0]

    # Copy passed lists (or set to empty lists)
    self.dependencies = list(dependencies or [])

    self.entry_type_guid = ENTRY_TYPE_GUIDS['project']

    if config_platform_overrides:
      self.config_platform_overrides = config_platform_overrides
    else:
      self.config_platform_overrides = {}

  def get_guid(self):
    if self.guid is None:
      # Set GUID from path
      # TODO(rspangler): This is fragile.
      # 1. We can't just use the project filename sans path, since there could
      #    be multiple projects with the same base name (for example,
      #    foo/unittest.vcproj and bar/unittest.vcproj).
      # 2. The path needs to be relative to $SOURCE_ROOT, so that the project
      #    GUID is the same whether it's included from base/base.sln or
      #    foo/bar/baz/baz.sln.
      # 3. The GUID needs to be the same each time this builder is invoked, so
      #    that we don't need to rebuild the solution when the project changes.
      # 4. We should be able to handle pre-built project files by reading the
      #    GUID from the files.
      self.guid = MakeGuid(self.name)
    return self.guid

#------------------------------------------------------------------------------


class MSVSSolution:
  """Visual Studio solution."""

  def __init__(self, path, version, entries=None, variants=None,
               websiteProperties=True):
    """Initializes the solution.

    Args:
      path: Path to solution file.
      version: Format version to emit.
      entries: List of entries in solution.  May contain Folder or Project
          objects.  May be None, if the folder is empty.
      variants: List of build variant strings.  If none, a default list will
          be used.
      websiteProperties: Flag to decide if the website properties section
          is generated.
    """
    self.path = path
    self.websiteProperties = websiteProperties
    self.version = version

    # Copy passed lists (or set to empty lists)
    self.entries = list(entries or [])

    if variants:
      # Copy passed list
      self.variants = variants[:]
    else:
      # Use default
      self.variants = ['Debug|Win32', 'Release|Win32']
    # TODO(rspangler): Need to be able to handle a mapping of solution config
    # to project config.  Should we be able to handle variants being a dict,
    # or add a separate variant_map variable?  If it's a dict, we can't
    # guarantee the order of variants since dict keys aren't ordered.


    # TODO(rspangler): Automatically write to disk for now; should delay until
    # node-evaluation time.
    self.Write()


  def Write(self, writer=common.WriteOnDiff):
    """Writes the solution file to disk.

    Raises:
      IndexError: An entry appears multiple times.
    """
    # Walk the entry tree and collect all the folders and projects.
    all_entries = []
    entries_to_check = self.entries[:]
    while entries_to_check:
      # Pop from the beginning of the list to preserve the user's order.
      e = entries_to_check.pop(0)

      # A project or folder can only appear once in the solution's folder tree.
      # This also protects from cycles.
      if e in all_entries:
        #raise IndexError('Entry "%s" appears more than once in solution' %
        #                 e.name)
        continue

      all_entries.append(e)

      # If this is a folder, check its entries too.
      if isinstance(e, MSVSFolder):
        entries_to_check += e.entries

    # Sort by name then guid (so things are in order on vs2008).
    def NameThenGuid(a, b):
      if a.name < b.name: return -1
      if a.name > b.name: return 1
      if a.get_guid() < b.get_guid(): return -1
      if a.get_guid() > b.get_guid(): return 1
      return 0

    all_entries = sorted(all_entries, NameThenGuid)

    # Open file and print header
    f = writer(self.path)
    f.write('Microsoft Visual Studio Solution File, '
            'Format Version %s\r\n' % self.version.SolutionVersion())
    f.write('# %s\r\n' % self.version.Description())

    # Project entries
    for e in all_entries:
      f.write('Project("%s") = "%s", "%s", "%s"\r\n' % (
          e.entry_type_guid,          # Entry type GUID
          e.name,                     # Folder name
          e.path.replace('/', '\\'),  # Folder name (again)
          e.get_guid(),               # Entry GUID
      ))

      # TODO(rspangler): Need a way to configure this stuff
      if self.websiteProperties:
        f.write('\tProjectSection(WebsiteProperties) = preProject\r\n'
                '\t\tDebug.AspNetCompiler.Debug = "True"\r\n'
                '\t\tRelease.AspNetCompiler.Debug = "False"\r\n'
                '\tEndProjectSection\r\n')

      if isinstance(e, MSVSFolder):
        if e.items:
          f.write('\tProjectSection(SolutionItems) = preProject\r\n')
          for i in e.items:
            f.write('\t\t%s = %s\r\n' % (i, i))
          f.write('\tEndProjectSection\r\n')

      if isinstance(e, MSVSProject):
        if e.dependencies:
          f.write('\tProjectSection(ProjectDependencies) = postProject\r\n')
          for d in e.dependencies:
            f.write('\t\t%s = %s\r\n' % (d.get_guid(), d.get_guid()))
          f.write('\tEndProjectSection\r\n')

      f.write('EndProject\r\n')

    # Global section
    f.write('Global\r\n')

    # Configurations (variants)
    f.write('\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n')
    for v in self.variants:
      f.write('\t\t%s = %s\r\n' % (v, v))
    f.write('\tEndGlobalSection\r\n')

    # Sort config guids for easier diffing of solution changes.
    config_guids = []
    config_guids_overrides = {}
    for e in all_entries:
      if isinstance(e, MSVSProject):
        config_guids.append(e.get_guid())
        config_guids_overrides[e.get_guid()] = e.config_platform_overrides
    config_guids.sort()

    f.write('\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n')
    for g in config_guids:
      for v in self.variants:
        nv = config_guids_overrides[g].get(v, v)
        # Pick which project configuration to build for this solution
        # configuration.
        f.write('\t\t%s.%s.ActiveCfg = %s\r\n' % (
            g,              # Project GUID
            v,              # Solution build configuration
            nv,             # Project build config for that solution config
        ))

        # Enable project in this solution configuration.
        f.write('\t\t%s.%s.Build.0 = %s\r\n' % (
            g,              # Project GUID
            v,              # Solution build configuration
            nv,             # Project build config for that solution config
        ))
    f.write('\tEndGlobalSection\r\n')

    # TODO(rspangler): Should be able to configure this stuff too (though I've
    # never seen this be any different)
    f.write('\tGlobalSection(SolutionProperties) = preSolution\r\n')
    f.write('\t\tHideSolutionNode = FALSE\r\n')
    f.write('\tEndGlobalSection\r\n')

    # Folder mappings
    # TODO(rspangler): Should omit this section if there are no folders
    f.write('\tGlobalSection(NestedProjects) = preSolution\r\n')
    for e in all_entries:
      if not isinstance(e, MSVSFolder):
        continue        # Does not apply to projects, only folders
      for subentry in e.entries:
        f.write('\t\t%s = %s\r\n' % (subentry.get_guid(), e.get_guid()))
    f.write('\tEndGlobalSection\r\n')

    f.write('EndGlobal\r\n')

    f.close()

#!/usr/bin/env python2.4
"""static - A stupidly simple WSGI way to serve static (or mixed) content.

(See the docstrings of the various functions and classes.)

Copyright (C) 2006-2009 Luke Arno - http://lukearno.com/

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to:

The Free Software Foundation, Inc., 
51 Franklin Street, Fifth Floor, 
Boston, MA  02110-1301, USA.

Luke Arno can be found at http://lukearno.com/

"""

import mimetypes
import rfc822
import time
import string
import sys
from os import path, stat
from wsgiref import util
from wsgiref.headers import Headers
from wsgiref.simple_server import make_server
from optparse import OptionParser

try: from pkg_resources import resource_filename, Requirement
except: pass

try: import kid
except: pass


class MagicError(Exception): pass


class StatusApp:
    """Used by WSGI apps to return some HTTP status."""
    
    def __init__(self, status, message=None):
        self.status = status
        if message is None:
            self.message = status
        else:
            self.message = message
        
    def __call__(self, environ, start_response, headers=[]):
        if self.message:
            Headers(headers).add_header('Content-type', 'text/plain')
        start_response(self.status, headers)
        if environ['REQUEST_METHOD'] == 'HEAD':
            return [""]
        else:
            return [self.message]


class Cling(object):
    """A stupidly simple way to serve static content via WSGI.
    
    Serve the file of the same path as PATH_INFO in self.datadir.
    
    Look up the Content-type in self.content_types by extension
    or use 'text/plain' if the extension is not found.

    Serve up the contents of the file or delegate to self.not_found.
    """

    block_size = 16 * 4096
    index_file = 'index.html'
    not_found = StatusApp('404 Not Found')
    not_modified = StatusApp('304 Not Modified', "")
    moved_permanently = StatusApp('301 Moved Permanently')
    method_not_allowed = StatusApp('405 Method Not Allowed')

    def __init__(self, root, **kw):
        """Just set the root and any other attribs passes via **kw."""
        self.root = root
        for k, v in kw.iteritems():
            setattr(self, k, v)

    def __call__(self, environ, start_response):
        """Respond to a request when called in the usual WSGI way."""
        if environ['REQUEST_METHOD'] not in ('GET', 'HEAD'):
            headers = [('Allow', 'GET, HEAD')]
            return self.method_not_allowed(environ, start_response, headers)
        path_info = environ.get('PATH_INFO', '')
        full_path = self._full_path(path_info)
        if not self._is_under_root(full_path):
            return self.not_found(environ, start_response)
        if path.isdir(full_path):
            if full_path[-1] <> '/' or full_path == self.root:
                location = util.request_uri(environ, include_query=False) + '/'
                if environ.get('QUERY_STRING'):
                    location += '?' + environ.get('QUERY_STRING')
                headers = [('Location', location)]
                return self.moved_permanently(environ, start_response, headers)
            else:
                full_path = self._full_path(path_info + self.index_file)
        content_type = self._guess_type(full_path)
        try:
            etag, last_modified = self._conditions(full_path, environ)
            headers = [('Date', rfc822.formatdate(time.time())),
                       ('Last-Modified', last_modified),
                       ('ETag', etag)]
            if_modified = environ.get('HTTP_IF_MODIFIED_SINCE')
            if if_modified and (rfc822.parsedate(if_modified)
                                >= rfc822.parsedate(last_modified)):
                return self.not_modified(environ, start_response, headers)
            if_none = environ.get('HTTP_IF_NONE_MATCH')
            if if_none and (if_none == '*' or etag in if_none):
                return self.not_modified(environ, start_response, headers)
            file_like = self._file_like(full_path)
            headers.append(('Content-Type', content_type))
            start_response("200 OK", headers)
            if environ['REQUEST_METHOD'] == 'GET':
                return self._body(full_path, environ, file_like)
            else:
                return ['']
        except (IOError, OSError), e:
            print e
            return self.not_found(environ, start_response)

    def _full_path(self, path_info):
        """Return the full path from which to read."""
        return self.root + path_info

    def _is_under_root(self, full_path):
        """Guard against arbitrary file retrieval."""
        if (path.abspath(full_path) + path.sep)\
            .startswith(path.abspath(self.root) + path.sep):
            return True
        else:
            return False

    def _guess_type(self, full_path):
        """Guess the mime type using the mimetypes module."""
        return mimetypes.guess_type(full_path)[0] or 'text/plain'

    def _conditions(self, full_path, environ):
        """Return a tuple of etag, last_modified by mtime from stat."""
        mtime = stat(full_path).st_mtime
        return str(mtime), rfc822.formatdate(mtime)

    def _file_like(self, full_path):
        """Return the appropriate file object."""
        return open(full_path, 'rb')

    def _body(self, full_path, environ, file_like):
        """Return an iterator over the body of the response."""
        way_to_send = environ.get('wsgi.file_wrapper', iter_and_close)
        return way_to_send(file_like, self.block_size)


def iter_and_close(file_like, block_size):
    """Yield file contents by block then close the file."""
    while 1:
        try:
            block = file_like.read(block_size)
            if block: yield block
            else: raise StopIteration
        except StopIteration, si:
            file_like.close()
            return 


def cling_wrap(package_name, dir_name, **kw):
    """Return a Cling that serves from the given package and dir_name.
    
    This uses pkg_resources.resource_filename which is not the
    recommended way, since it extracts the files. 
    
    I think this works fine unless you have some _very_ serious 
    requirements for static content, in which case you probably 
    shouldn't be serving it through a WSGI app, IMHO. YMMV.
    """
    resource = Requirement.parse(package_name)
    return Cling(resource_filename(resource, dir_name), **kw)
 

class Shock(Cling):
    """A stupidly simple way to serve up mixed content.
    
    Serves static content just like Cling (it's superclass)
    except that it process content with the first matching
    magic from self.magics if any apply.

    See Cling and classes with "Magic" in their names in this module.

    If you are using Shock with the StringMagic class for instance:

    shock = Shock('/data', magics=[StringMagic(food='cheese')])
    
    Let's say you have a file called /data/foo.txt.stp containing one line:

    "I love to eat $food!"
    
    When you do a GET on /foo.txt you will see this in your browser:

    "I love to eat cheese!"

    This is really nice if you have a color variable in your css files or
    something trivial like that. It seems silly to create or change a 
    handful of objects for a couple of dynamic bits of text.
    """

    magics = ()

    def _match_magic(self, full_path):
        """Return the first magic that matches this path or None."""
        for magic in self.magics:
            if magic.matches(full_path):
                return magic

    def _full_path(self, path_info):
        """Return the full path from which to read."""
        full_path = self.root + path_info
        if path.exists(full_path):
            return full_path
        else:
            for magic in self.magics: 
                if path.exists(magic.new_path(full_path)):
                    return magic.new_path(full_path)
            else:
                return full_path

    def _guess_type(self, full_path):
        """Guess the mime type magically or using the mimetypes module."""
        magic = self._match_magic(full_path)
        if magic is not None:
            return (mimetypes.guess_type(magic.old_path(full_path))[0] 
                    or 'text/plain')
        else:
            return mimetypes.guess_type(full_path)[0] or 'text/plain'

    def _conditions(self, full_path, environ):
        """Return Etag and Last-Modified values defaults to now for both."""
        magic = self._match_magic(full_path)
        if magic is not None:
            return magic.conditions(full_path, environ)
        else:
            mtime = stat(full_path).st_mtime
            return str(mtime), rfc822.formatdate(mtime)

    def _file_like(self, full_path):
        """Return the appropriate file object."""
        magic = self._match_magic(full_path)
        if magic is not None:
            return magic.file_like(full_path)
        else:
            return open(full_path, 'rb')

    def _body(self, full_path, environ, file_like):
        """Return an iterator over the body of the response."""
        magic = self._match_magic(full_path)
        if magic is not None:
            return magic.body(environ, file_like)
        else:
            way_to_send = environ.get('wsgi.file_wrapper', iter_and_close)
            return way_to_send(file_like, self.block_size)


class BaseMagic(object):
    """Base class for magic file handling.

    Really a do nothing if you were to use this directly.
    
    In a strait forward case you would just override .extension and body().
    (See StringMagic in this module for a simple example of subclassing.)

    In a more complex case you may need to override many or all methods.
    """

    extension = ''

    def exists(self, full_path):
        """Check that self.new_path(full_path) exists."""
        if path.exists(self.new_path(full_path)):
            return self.new_path(full_path)

    def new_path(self, full_path):
        """Add the self.extension to the path."""
        return full_path + self.extension

    def old_path(self, full_path):
        """Remove self.extension from path or raise MagicError."""
        if self.matches(full_path):
            return full_path[:-len(self.extension)]
        else:
            raise MagicError, "Path does not match this magic."

    def matches(self, full_path):
        """Check that path ends with self.extension."""
        if full_path.endswith(self.extension):
            return full_path

    def conditions(self, full_path, environ):
        """Return Etag and Last-Modified values (based on mtime)."""
        mtime = int(time.time())
        return str(mtime), rfc822.formatdate(mtime)

    def file_like(self, full_path):
        """Return a file object for path."""
        return open(full_path, 'rb')

    def body(self, environ, file_like):
        """Return an iterator over the body of the response."""
        return [file_like.read()]


class StringMagic(BaseMagic):
    """Magic to replace variables in file contents using string.Template.
    
    Using this requires Python2.4.
    """

    extension = '.stp'
    safe = False

    def __init__(self, **variables):
        """Keyword arguments populate self.variables."""
        self.variables = variables

    def body(self, environ, file_like):
        """Pass environ and self.variables in to template.
        
        self.variables overrides environ so that suprises in environ don't
        cause unexpected output if you are passing a value in explicitly.
        """
        variables = environ.copy()
        variables.update(self.variables)
        template = string.Template(file_like.read())
        if self.safe is True:
            return [template.safe_substitute(variables)]
        else:
            return [template.substitute(variables)]


class KidMagic(StringMagic):
    """Like StringMagic only using the Kid templating language.
    
    Using this requires Kid: http://kid.lesscode.org/
    """
    
    extension = '.kid'
    
    def body(self, environ, full_path):
        """Pass environ and **self.variables into the template."""
        template = kid.Template(file=full_path, 
                                environ=environ, 
                                **self.variables)
        return [template.serialize()]


def command():
    parser = OptionParser(usage="%prog DIR [HOST][:][PORT]", 
                          version="static 0.3.6")
    options, args = parser.parse_args()
    if len(args) in (1, 2):
        if len(args) == 2:
            parts = args[1].split(":")
            if len(parts) == 1:
                host = parts[0]
                port = None
            elif len(parts) == 2:
                host, port = parts
            else:
                sys.exit("Invalid host:port specification.")
        elif len(args) == 1:
            host, port = None, None
        if not host:
            host = '0.0.0.0'
        if not port:
            port = 9999
        try:
            port = int(port)
        except:
            sys.exit("Invalid host:port specification.")
        app = Cling(args[0])
        try:
            make_server(host, port, app).serve_forever()
        except KeyboardInterrupt, ki:
            print "Cio, baby!"
        except:
            sys.exit("Problem initializing server.")
    else:
        parser.print_help(sys.stderr)
        sys.exit(1)


def test():
    from wsgiref.validate import validator
    magics = StringMagic(title="String Test"), KidMagic(title="Kid Test")
    app = Shock('testdata/pub', magics=magics)
    try:
        make_server('localhost', 9999, validator(app)).serve_forever()
    except KeyboardInterrupt, ki:
        print "Ciao, baby!"


if __name__ == '__main__':
    test()


#!/bin/python

import pylab as pl
import cPickle
import matplotlib.pyplot as plt
from sklearn import svm, metrics
import numpy as np
import sys

square = 13
imgloc = '../images/v012-penn.10-1hA5D1-cropb.png'
resd={'dot':0,'noise':1,'vein':2}
currimg=plt.imread(imgloc)

pkl_file=open('dots.pkl', 'r')
dots = cPickle.load(pkl_file)
pkl_file.close()
pkl_file=open('noise.pkl', 'r')
noise = cPickle.load(pkl_file)
pkl_file.close()
pkl_file=open('veins.pkl','r')
veins = cPickle.load(pkl_file)
pkl_file.close()

#dots = zip(dots, [0 for i in range(len(dots))])
#noise = zip(noise, [1 for i in range(len(noise))])
#veins = zip(veins, [2 for i in range(len(veins))])

print np.shape(np.asarray(dots))
print np.shape(np.asarray(noise))
print np.shape(np.asarray(veins))

dots_data = np.asarray(dots).reshape((len(dots),-1))
noise_data= np.asarray(noise).reshape((len(noise),-1))
veins_data= np.asarray(veins).reshape((len(veins),-1))

data = np.concatenate((np.concatenate((dots_data,noise_data)),veins_data))

print len(data)

target = [resd['dot'] for i in range(len(dots_data))] + [resd['noise'] for i in range(len(noise_data))] + [resd['vein'] for i in range(len(veins_data))]

print len(target)


classifier = svm.SVC(gamma=0.001)

classifier.fit(data, target)

tmpx, tmpy = len(currimg[0][:]), len(currimg[:][0])

final_image=np.ones((tmpy,tmpx))

blocks=[]
print 'Going through the blocks...'
sys.stdout.flush()

for i in [i+square/2 for i in xrange(tmpy-square)]:
    for j in [j+square/2 for j in xrange(tmpx-square)]:
        currblock=currimg[i-square/2:i+square/2+1,j-square/2:j+square/2+1]
        blocks.append(currblock)

blocks=np.asarray(blocks)
print np.shape(blocks)
blocks = np.asarray(blocks).reshape(len(blocks),-1)
print np.shape(blocks)

print 'About to make predictions...'
sys.stdout.flush()

predicted = classifier.predict(blocks)

voting = np.zeros((tmpy, tmpx, 3))
print 'About to count votes...'
sys.stdout.flush()

for p in xrange(len(predicted)):
    j=p%(tmpx-square)+square/2 
    i=(p-j+square/2)/(tmpx-square)+square/2
    #[i,j] are the coordinates of the center of that box
    #since p=(i-s/2)(X-s)+j-s/2
    for y in range(i-square/2,i+square/2):
        for x in range(j-square/2,j+square/2):
            voting[y,x][predicted[p]]+=1

for i in xrange(tmpy):
    for j in xrange(tmpx):
        if voting[i,j].argmax()==resd['vein']:
            final_image[i,j]=0
            
plt.imshow(final_image, cmap=plt.cm.gray)
plt.show()
#for i in [i+square/2 for i in xrange(tmpx-square)]:
#    for j in [j+square/2 for j in xrange(tmpy-square)]:
#        for k in range(i-square/2,i+square/2+1):
#            for 

__author__ = 'DongMin Kim'

from opencog.atomspace import *
from test_conceptual_blending_base import TestConceptualBlendingBase

# Only run the unit tests if the required dependencies have been installed
# (see: https://github.com/opencog/opencog/issues/337)
try:
    __import__("nose.tools")
except ImportError:
    import unittest

    raise unittest.SkipTest(
        "ImportError exception: " +
        "Can't find Nose. " +
        "make sure the required dependencies are installed."
    )
else:
    # noinspection PyPackageRequirements
    from nose.tools import *

try:
    __import__("opencog.scheme_wrapper")
except ImportError:
    import unittest

    raise unittest.SkipTest(
        "ImportError exception: " +
        "Can't find Scheme wrapper for Python. " +
        "make sure the required dependencies are installed."
    )
else:
    from opencog.scheme_wrapper import *

try:
    __import__("blending.blend")
except ImportError:
    import unittest
    raise unittest.SkipTest(
        "ImportError exception: " +
        "Can't find Python Conceptual Blender. " +
        "make sure the required dependencies are installed."
    )
else:
    from blending.blend import ConceptualBlending

try:
    from blending.util.py_cog_execute import PyCogExecute
    PyCogExecute().load_scheme()
except (ImportError, RuntimeError):
    import unittest

    raise unittest.SkipTest(
        "Can't load Scheme." +
        "make sure the you installed atomspace to /usr/local/share/opencog."
    )


# noinspection PyArgumentList, PyTypeChecker
class TestAtomsChooser(TestConceptualBlendingBase):
    """
    2.1. AtomsChooser tests.
    """

    """
    2.1.1. ChooseNull tests.
    """
    __test__ = True

    def __default_choose_null(self):
        self.a.add_link(
            types.InheritanceLink,
            [
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "default-config")
            ]
        )
        self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:atoms-chooser"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "ChooseNull")
            ]
        )

    def test_choose_null_without_focus_atoms(self):
        self.__default_choose_null()

        # Test blender not makes blend node if we don't give focus atoms.
        result = self.blender.run(
            None,
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 0)

        # Test blender not makes blend node if we don't give focus atoms.
        result = self.blender.run(
            [],
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 0)

    def test_choose_null_with_focus_atoms(self):
        self.__default_choose_null()

        # Test blender makes only one new blend node.
        result = self.blender.run(
            [self.sample_nodes["car"], self.sample_nodes["man"],
             self.sample_nodes["metal"]],
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)

        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_in("car", str(blended_node.name))
        assert_in("man", str(blended_node.name))
        assert_in("metal", str(blended_node.name))
        assert_not_in("move", str(blended_node.name))
        assert_not_in("vehicle", str(blended_node.name))
        assert_not_in("person", str(blended_node.name))

    """
    2.1.2. ChooseAll tests.
    """

    def __default_choose_all(self):
        self.a.add_link(
            types.InheritanceLink,
            [
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "default-config")
            ]
        )
        self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:atoms-chooser"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "ChooseAll")
            ]
        )

    def test_choose_all(self):
        self.__default_choose_all()

        # Test blender doesn't explain if focus atoms was not given,
        # but find all atoms in AtomSpace.
        result = self.blender.run(
            None,
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)

        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_in("car", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("metal", str(blended_node.name))
        assert_in("move", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("person", str(blended_node.name))

        # Test blender doesn't explain if focus atoms was not given,
        # but find all atoms in AtomSpace.
        result = self.blender.run(
            [],
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)

        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_in("car", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("metal", str(blended_node.name))
        assert_in("move", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("person", str(blended_node.name))

        # Test blender makes only one new blend node.
        result = self.blender.run(
            [self.sample_nodes["car"], self.sample_nodes["vehicle"]],
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)

        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_in("car", str(blended_node.name))
        assert_not_in("man", str(blended_node.name))
        assert_not_in("metal", str(blended_node.name))
        assert_not_in("move", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_not_in("person", str(blended_node.name))

    def test_choose_all_with_type_limit(self):
        self.__default_choose_all()

        # Test blender limits node type correctly.
        choose_atom_type_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-atom-type"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "PredicateNode")
            ]
        )
        result = self.blender.run(
            None,
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 0)
        self.a.remove(choose_atom_type_link)

        # Test blender limits node type correctly.
        choose_atom_type_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-atom-type"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "ConceptNode")
            ]
        )
        result = self.blender.run(
            None,
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)

        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_in("car", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("metal", str(blended_node.name))
        assert_in("move", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("person", str(blended_node.name))
        self.a.remove(choose_atom_type_link)

    def test_choose_all_with_count_limit(self):
        self.__default_choose_all()

        # Test blender checks node count correctly.
        choose_least_count_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-least-count"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "1000")
            ]
        )
        result = self.blender.run(
            None,
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 0)
        self.a.remove(choose_least_count_link)

        # Test blender checks node count correctly.
        choose_least_count_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-least-count"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "2")
            ]
        )
        result = self.blender.run(
            None,
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)
        self.a.remove(choose_least_count_link)

    """
    2.1.3. ChooseInSTIRange tests.
    """

    def __default_choose_in_sti_range(self):
        self.a.add_link(
            types.InheritanceLink,
            [
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "default-config")
            ]
        )
        self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:atoms-chooser"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "ChooseInSTIRange")
            ]
        )

    def test_choose_in_sti_range_without_focus_atoms(self):
        self.__default_choose_in_sti_range()

        # Test blender makes only one new blend node.
        result = self.blender.run(
            None,
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 0)

    def test_choose_in_sti_range_with_focus_atoms(self):
        self.__default_choose_in_sti_range()

        # Test blender makes only one new blend node.
        result = self.blender.run(
            self.a.get_atoms_by_type(types.Node),
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)

        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_in("car", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("metal", str(blended_node.name))
        assert_in("move", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("person", str(blended_node.name))

    def test_choose_in_sti_range_with_type_limit(self):
        self.__default_choose_in_sti_range()

        # Test blender limits node type correctly.
        choose_atom_type_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-atom-type"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "PredicateNode")
            ]
        )
        result = self.blender.run(
            self.a.get_atoms_by_type(types.Node),
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 0)
        self.a.remove(choose_atom_type_link)

        # Test blender limits node type correctly.
        choose_atom_type_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-atom-type"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "ConceptNode")
            ]
        )
        result = self.blender.run(
            self.a.get_atoms_by_type(types.Node),
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)

        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_in("car", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("metal", str(blended_node.name))
        assert_in("move", str(blended_node.name))
        assert_in("vehicle", str(blended_node.name))
        assert_in("person", str(blended_node.name))
        self.a.remove(choose_atom_type_link)

    def test_choose_in_sti_range_with_count_limit(self):
        self.__default_choose_in_sti_range()

        # Test blender limits node count correctly.
        choose_least_count_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-least-count"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "1000")
            ]
        )
        result = self.blender.run(
            self.a.get_atoms_by_type(types.Node),
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 0)
        self.a.remove(choose_least_count_link)

        # Test blender limits node count correctly.
        choose_least_count_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-least-count"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, "2")
            ]
        )
        result = self.blender.run(
            self.a.get_atoms_by_type(types.Node),
            self.a.add_node(types.ConceptNode, "my-config")
        )
        assert_equal(len(result), 1)
        self.a.remove(choose_least_count_link)

    def test_choose_in_sti_range_with_min_sti_limit(self):
        self.__default_choose_in_sti_range()
        choose_sti_min = 15

        # Test blender limits sti value correctly.
        choose_sti_min_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-sti-min"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, str(choose_sti_min))
            ]
        )
        result = self.blender.run(
            self.a.get_atoms_by_type(types.Node),
            self.a.add_node(types.ConceptNode, "my-config")
        )

        # Test blender limits sti value correctly.
        blended_node = result[0]
        assert_true(
            str(blended_node.name) == "car-man" or
            str(blended_node.name) == "man-car"
        )
        self.a.remove(choose_sti_min_link)

    def test_choose_in_sti_range_with_max_sti_limit(self):
        self.__default_choose_in_sti_range()
        choose_sti_max = 5

        # Test blender limits sti value correctly.
        choose_sti_max_link = self.a.add_link(
            types.ExecutionLink,
            [
                self.a.add_node(types.SchemaNode, "BLEND:choose-sti-max"),
                self.a.add_node(types.ConceptNode, "my-config"),
                self.a.add_node(types.ConceptNode, str(choose_sti_max))
            ]
        )
        result = self.blender.run(
            self.a.get_atoms_by_type(types.Node),
            self.a.add_node(types.ConceptNode, "my-config")
        )
        # Test blender makes new blend node correctly.
        blended_node = result[0]
        assert_true(
            str(blended_node.name) == "metal-move" or
            str(blended_node.name) == "move-metal"
        )
        self.a.remove(choose_sti_max_link)

from .app import db
from flask.ext.login import UserMixin
from .app import login_manager


class User(db.Model, UserMixin):
	pseudo = db.Column(db.String(100),primary_key=True)
	usermail = db.Column(db.String(100))
	username = db.Column(db.String(50))
	usersurname = db.Column(db.String(50))
	password = db.Column(db.String(64))
	score= db.Column(db.Integer)
	admin = db.Column(db.Boolean, nullable=False, default=False)
	
	def get_id(self):
		return self.pseudo
	
	def __repr__(self):
		return "%s - %s - %s" % (self.pseudo, self.username, self.usermail)


def getUser(pseudo):
	return db.session.query(User).filter(User.pseudo==pseudo).first()

@login_manager.user_loader
def load_user(username):
	return User.query.get(username)

class Ia(db.Model):
	id		=db.Column(db.Integer, primary_key=True)
	user_pseudo =db.Column(db.String(100)) 
	name    =db.Column(db.String(100))  

def removeIa(filename):
	s = db.session()
	m=s.query(Ia).filter(Ia.name==filename).all()
	for c in m:
   		db.session.delete(c)

def removeUser(pseudo):
	s=db.session()
	m=s.query(User).filter(User.pseudo==pseudo).all()
	for c in m:
   		db.session.delete(c)
# -*- coding: utf-8 -*-
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2013  Vassilii Khachaturov
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#

import unittest
import sys

try:
    if sys.version_info < (3,3):
        from mock import Mock
    else:
        from unittest.mock import Mock

    MOCKING = True

except:
    MOCKING = False
    print ("Mocking disabled, some testing skipped", sys.exc_info()[0:2])

class LexGettextTest(unittest.TestCase):
    SRC_WORD = "Inflect-me"
    MSGID = "how-to-use-lexgettext||" + SRC_WORD

    def setUp(self):
        from ..grampslocale import GrampsTranslations
        from ..grampslocale import GrampsLocale as Loc
        self.trans = GrampsTranslations()

    def setup_sgettext_mock(self, msgval_expected):
        if MOCKING:
            mock = Mock(return_value=msgval_expected)
        else:
            mock = lambda msgid: msgval_expected
        self.trans.sgettext = mock

    def tearDown(self):
        if MOCKING:
            try:
                self.trans.sgettext.assert_called_once_with(
                        self.MSGID)
            except AttributeError as e:
                print ("Apparently the test has never set up the mock: ", e)

    def testSrcWordOnlyIfNoTranslation(self):
        self.setup_sgettext_mock(self.SRC_WORD)
        result = self.trans.lexgettext(self.MSGID)
        self.assertEqual(result, self.SRC_WORD)

    def test3InflectionsExtractableByNameThroughForm(self):
        translated = "n=TargetNom|g=TargetGen|d=TargetDat"
        self.setup_sgettext_mock(translated)
        lex = self.trans.lexgettext(self.MSGID)
        formatted = "{lex.f[n]},{lex.f[g]},{lex.f[d]}".format(lex=lex)
        self.assertEqual(formatted, "TargetNom,TargetGen,TargetDat")

    def testFirstLexemeFormExtractableAsDefaultString(self):
        translated = "def=Default|v1=Option1|a=AnotherOption"
        self.setup_sgettext_mock(translated)
        lex = self.trans.lexgettext(self.MSGID)
        formatted = "{}".format(lex)
        self.assertEqual(formatted, "Default")

class LexemeTest(unittest.TestCase):
    def setUp(self):
        from ..grampslocale import Lexeme
        self.lex = Lexeme((('a', 'aaa'), ('b', 'bbb'), ('c', 'ccc')))
        self.zlex = Lexeme({'z' : 'zzz'})
        self.elex = Lexeme({})

    def testIsHashable(self):
        hash(self.lex) # throws if not hashable

    # test delegation to an arbitrary string method pulled in from unicode
    def testDefaultStringStartsWithAA(self):
        self.assertTrue(self.lex.startswith('aa'),
                msg="default string: {} dict: {}".format(
                    self.lex, self.lex.__dict__))

    def testCanConcatenateStringAndLexeme(self):
        moo = "moo"
        self.assertEqual(moo + self.lex, "mooaaa")

    def testCanConcatenateStringAndLexemeInPlace(self):
        moo = "moo"
        moo += self.lex
        self.assertEqual(moo, "mooaaa")

    def testCanConcatenateLexemeAndStringInPlace(self):
        moo = "moo"
        self.lex += moo
        self.assertEqual(self.lex, "aaamoo")

    def testCanConcatenateTwoLexemes(self):
        aaazzz = self.lex + self.zlex
        self.assertEqual(aaazzz, "aaazzz")

    def testCanJoinTwoLexemes(self):
        aaa_zzz = "_".join([self.lex,self.zlex])
        self.assertEqual(aaa_zzz, "aaa_zzz")

    def testEmptyIterableLikeEmptyString(self):
        self.assertEqual(self.elex, "")

if __name__ == "__main__":
    unittest.main()

#  Licensed to the Apache Software Foundation (ASF) under one
#  or more contributor license agreements.  See the NOTICE file
#  distributed with this work for additional information
#  regarding copyright ownership.  The ASF licenses this file
#  to you 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.


import wx
import armid
import ARM
from RiskEnvironmentListCtrl import RiskEnvironmentListCtrl
from DimensionListCtrl import DimensionListCtrl
from MitigateEnvironmentProperties import MitigateEnvironmentProperties


class MitigateEnvironmentPanel(wx.Panel):
  def __init__(self,parent,dp):
    wx.Panel.__init__(self,parent,armid.MITIGATE_PANELENVIRONMENT_ID)
    self.theResponsePanel = parent
    self.dbProxy = dp
    self.theEnvironmentDictionary = {}
    self.theSelectedIdx = -1

    mainSizer = wx.BoxSizer(wx.HORIZONTAL)
    environmentBox = wx.StaticBox(self)
    environmentListSizer = wx.StaticBoxSizer(environmentBox,wx.HORIZONTAL)
    mainSizer.Add(environmentListSizer,0,wx.EXPAND)
    self.environmentList = RiskEnvironmentListCtrl(self,armid.MITIGATE_LISTENVIRONMENTS_ID,self.dbProxy)
    environmentListSizer.Add(self.environmentList,1,wx.EXPAND)
    environmentDimSizer = wx.BoxSizer(wx.VERTICAL)
    mainSizer.Add(environmentDimSizer,1,wx.EXPAND)

    typeBox = wx.StaticBox(self,-1,'Type')
    typeBoxSizer = wx.StaticBoxSizer(typeBox,wx.HORIZONTAL)
    environmentDimSizer.Add(typeBoxSizer,0,wx.EXPAND)
    self.typeCombo = wx.ComboBox(self,armid.MITIGATE_COMBOTYPE_ID,"",choices=['Deter','Prevent','Detect','React'],style=wx.CB_READONLY)
    typeBoxSizer.Add(self.typeCombo,1,wx.EXPAND)
   
    pointBox = wx.StaticBox(self,-1,'Detection Point')
    pointBoxSizer = wx.StaticBoxSizer(pointBox,wx.HORIZONTAL)
    environmentDimSizer.Add(pointBoxSizer,0,wx.EXPAND)
    self.pointCombo = wx.ComboBox(self,armid.MITIGATE_COMBODETECTIONPOINT_ID,"",choices=['Before','At','After'],style=wx.CB_READONLY)
    pointBoxSizer.Add(self.pointCombo,1,wx.EXPAND)


    dmBox = wx.StaticBox(self,-1,)
    dmBoxSizer = wx.StaticBoxSizer(dmBox,wx.HORIZONTAL)
    environmentDimSizer.Add(dmBoxSizer,1,wx.EXPAND)
    self.dmList = DimensionListCtrl(self,armid.MITIGATE_LISTDETMECH_ID,wx.DefaultSize,'Detection Mechanism','detection_mechanism',self.dbProxy,listStyle=wx.LC_REPORT)
    dmBoxSizer.Add(self.dmList,1,wx.EXPAND)

    self.typeCombo.Disable()
    self.pointCombo.Disable() 
    self.dmList.Disable()
    
    self.SetSizer(mainSizer)
    self.typeCombo.Bind(wx.EVT_COMBOBOX,self.onTypeChange)
    self.environmentList.Bind(wx.EVT_LIST_INSERT_ITEM,self.OnAddEnvironment)
    self.environmentList.Bind(wx.EVT_LIST_DELETE_ITEM,self.OnDeleteEnvironment)
    self.environmentList.Bind(wx.EVT_LIST_ITEM_SELECTED,self.OnEnvironmentSelected)
    self.environmentList.Bind(wx.EVT_LIST_ITEM_DESELECTED,self.OnEnvironmentDeselected)

  def onTypeChange(self,evt):
    self.activateTypeCtrls()
    mitType = self.typeCombo.GetValue()
    riskCombo = self.theResponsePanel.FindWindowById(armid.RESPONSE_COMBORISK_ID)
    riskName = riskCombo.GetValue()
    if (riskName != ''):
      riskNameCtrl = self.theResponsePanel.FindWindowById(armid.RESPONSE_TEXTNAME_ID)
      riskNameLabel = mitType + ' ' + riskName
      riskNameCtrl.SetValue(riskNameLabel)

  def activateTypeCtrls(self):
    mitType = self.typeCombo.GetValue()
    if ((mitType == 'Deter') or (mitType == 'Prevent')):
      self.pointCombo.SetValue('')
      self.pointCombo.Disable() 
      self.dmList.DeleteAllItems()
      self.dmList.Disable()
    elif (mitType == 'Detect'):
      self.pointCombo.Enable() 
      self.dmList.Disable()
    elif (mitType == 'React'):
      self.pointCombo.Disable() 
      self.dmList.Enable()
  
  def loadControls(self,accept):
    self.environmentList.Unbind(wx.EVT_LIST_ITEM_SELECTED)
    self.environmentList.Unbind(wx.EVT_LIST_ITEM_DESELECTED)
    environmentNames = []
    for cp in accept.environmentProperties():
      environmentNames.append(cp.name())
    self.environmentList.load(environmentNames)

    for cp in accept.environmentProperties():
      environmentName = cp.name()
      self.theEnvironmentDictionary[environmentName] = cp
      environmentNames.append(environmentName) 
    environmentName = environmentNames[0]
    p = self.theEnvironmentDictionary[environmentName]
    
    self.typeCombo.SetStringSelection(p.type())
    self.pointCombo.SetStringSelection(p.detectionPoint())
    self.dmList.setEnvironment(environmentName)
    self.dmList.load(p.detectionMechanisms())

    self.environmentList.Select(0)

    self.activateTypeCtrls()
    self.environmentList.Bind(wx.EVT_LIST_ITEM_SELECTED,self.OnEnvironmentSelected)
    self.environmentList.Bind(wx.EVT_LIST_ITEM_DESELECTED,self.OnEnvironmentDeselected)
    self.theSelectedIdx = 0

  def OnEnvironmentSelected(self,evt):
    self.theSelectedIdx = evt.GetIndex()
    environmentName = self.environmentList.GetItemText(self.theSelectedIdx)
    p = self.theEnvironmentDictionary[environmentName]

    self.typeCombo.SetStringSelection(p.type())
    self.pointCombo.SetStringSelection(p.detectionPoint())
    self.dmList.setEnvironment(environmentName)
    self.dmList.load(p.detectionMechanisms())
    self.typeCombo.Enable()
    self.activateTypeCtrls()

  def OnEnvironmentDeselected(self,evt):
    self.theSelectedIdx = evt.GetIndex()
    environmentName = self.environmentList.GetItemText(self.theSelectedIdx)
    self.theEnvironmentDictionary[environmentName] = MitigateEnvironmentProperties(environmentName,self.typeCombo.GetValue(),self.pointCombo.GetValue(),self.dmList.dimensions())
    self.typeCombo.SetValue('')
    self.pointCombo.SetValue('')
    self.dmList.setEnvironment('')
    self.dmList.DeleteAllItems()

    self.theSelectedIdx = -1
    self.typeCombo.Disable() 
    self.pointCombo.Disable() 
    self.dmList.Disable() 

  def OnAddEnvironment(self,evt):
    self.theSelectedIdx = evt.GetIndex()
    environmentName = self.environmentList.GetItemText(self.theSelectedIdx)
    self.theEnvironmentDictionary[environmentName] = MitigateEnvironmentProperties(environmentName)
    self.typeCombo.SetValue('')
    self.pointCombo.SetValue('')
    self.dmList.setEnvironment(environmentName)
    self.dmList.DeleteAllItems()
    self.environmentList.Select(self.theSelectedIdx)
    self.typeCombo.Enable() 

  def OnDeleteEnvironment(self,evt):
    selectedIdx = evt.GetIndex()
    environmentName = self.environmentList.GetItemText(selectedIdx)
    del self.theEnvironmentDictionary[environmentName]
    self.theSelectedIdx = -1

  def environmentProperties(self):
    if (self.theSelectedIdx != -1):
      environmentName = self.environmentList.GetItemText(self.theSelectedIdx)
      properties = MitigateEnvironmentProperties(environmentName,self.typeCombo.GetValue(),self.pointCombo.GetValue(),self.dmList.dimensions())
      self.theEnvironmentDictionary[environmentName] = properties
    for cname in self.environmentList.dimensions():
      p = self.theEnvironmentDictionary[cname]
      mitType = p.type()
      if (len(mitType) == 0):
        exceptionText = 'No mitigation type selected for environment ' + p.name()
        raise ARM.EnvironmentValidationError(exceptionText)
      if (mitType == 'Detect') and (len(p.detectionPoint()) == 0):
        exceptionText = 'No detection point selected for environment ' + p.name()
        raise ARM.EnvironmentValidationError(exceptionText)
      if (mitType == 'React') and (len(p.detectionMechanisms()) == 0):
        exceptionText = 'No detection mechanisms selected for environment ' + p.name()
        raise ARM.EnvironmentValidationError(exceptionText)
    return self.theEnvironmentDictionary.values() 

  def setRisk(self,riskName):
    self.environmentList.setRisk(riskName)

# encoding: utf-8

import tornado.ioloop
import tornado.web
import sys
import getopt
import time
import re
import ply.yacc as yacc
from sa_lex import tokens
from treetagger import TreeTagger
from treetagger_wordnet import TreetaggerToWordnet
from sentiwordnet import SentiWordnet
import csv

class MainHandler(tornado.web.RequestHandler):
    """ """

    def initialize(self, to_wordnet, sentiwordnet, tt, rules, stopwords, chunks, language):
        """ """
        self.rules = rules
        self.chunks = chunks
        self.language = language
        self.stopwords = stopwords
        self.sentiwordnet = sentiwordnet
        self.tt = tt
        self.to_wordnet = to_wordnet

    def get(self):
        """ """
        # Start operation time
        time_start = time.time()
        # Prepare the response DS
        response = {}

        # Check input text
        text = self.get_argument("text")
        text = text.replace("\n", "")
        text = text.encode("utf-8")
        response["raw_text"] = text

        # Replace chunks symbols
        for chunk in self.chunks:
            text = text.replace(chunk, " # ")

        # Mapping treetagger postaging to wordnet postagging
        aux = ""
        for tag in self.tt.tag(text):
            lemma = tag[2]
            if lemma == u"<unknown>":
                lemma = tag[0]
            aux += "%s.%s " % (lemma, self.to_wordnet.wordnet_morph_category(self.language, tag[1]))
        text = aux

        # Replace stopwords for the entities
        for stopword in self.stopwords:
            text = text.replace(stopword, " ")

        # Replace postagging for the entities
        aux = ""
        chunks = text.split(" ")
        for chunk in chunks:
            sub_chunks = chunk.split(".")
            if sub_chunks[0].lower() in entities or sub_chunks[0].lower() in inverters:
                aux += "%s " % sub_chunks[0].lower()
            else:
                aux += "%s " % chunk
        text = aux

        # Detecting Words with sentiment (Sentiwordnet)
        aux = ""
        chunks = text.split(" ")
        for chunk in chunks:
            aux += chunk
            sub_chunks = chunk.split(".")
            if len(sub_chunks) > 1:

                # Apply sentiwordnet dictionary
                senti = self.sentiwordnet.get_sentiment(sub_chunks[0], 
                            sub_chunks[1], 
                            language)

                # Calculate score
                score = 0.0
                if senti is not None:
                    score = float(senti["positive"]) + float(senti["negative"])
                if score < 0.0:
                    aux += "%s" % score
                elif score > 0.0:
                    aux += "+%s" % score
            # Return keyword
            aux += " "
        text = aux
        response["text"] = text

        # Split input text
        chunks = text.split('#.None')
        triggered_rule_cont = 0
        response["matches"] = {}

        for chunk in chunks:
            chunk =' '.join(chunk.split())

            # Apply rules and replace matchs
            rule_triggered = False
            while True:

                # Appling all rules over the text
                rule_triggered = False
                for rule in compiled_rules:
                    for match in compiled_rules[rule]["regex"].finditer(chunk):
                        rule_triggered = True
                        response["matches"][triggered_rule_cont] = {}
                        response["matches"][triggered_rule_cont]["rule_triggered"] = rule
                        response["matches"][triggered_rule_cont]["score"] = compiled_rules[rule]["score"]
                        response["matches"][triggered_rule_cont]["match"] = match.group()

                        # Replace chunk with "***"" filling
                        aux = ""
                        for e in match.group().split(" "):
                            aux += "*" * len(e) + " "
                        aux = aux[0:len(aux)-2]

                        # Perfom replace
                        chunk = chunk.replace(match.group(), aux)
                        triggered_rule_cont += 1
                # Break rule matching (precedence behavior)
                if not rule_triggered:
                    break
        # Return response
        response["elipsed_time"] = time.time() - time_start

        # Return result
        self.write(response)

# Variables to manage values in the parser process
start = 'rule'
regex = ''
compiled_rules = {}
adhoc_sentiwords = {}

def p_rule(p):
    'rule : BEGINRULE expression THEN SCORE ENDRULE'
    if p[1] in compiled_rules:
        print("Error: Rule #ID duplicated.")
        sys.exit(0)

    # Replace special character "#" and cast to integer
    # This is main to sort the rules dictionary and to 
    # apply them in order
    rule_id = int(p[1].replace("#", ""))

    # Save rule
    compiled_rules[rule_id] = {}
    compiled_rules[rule_id]["regex"] = regex
    compiled_rules[rule_id]["score"] = float(p[4])
    #print(regex.pattern)


def p_expresion_simple_one(p):
    'expression : QUALIFICATOR ENTITY'
    global regex
    if p[1] == "+":
        regex = re.compile("(\w+\.\w(\%s)(\d+.\d+)+)(\s\S+){0,3}\s%s" % (combined_positives, combined_entities))
    else:
        regex = re.compile("(\w+\.\w(\%s)(\d+.\d+)+)(\s\S+){0,3}\s%s" % (combined_negatives, combined_entities))

def p_expresion_simple_two(p):
    'expression : ENTITY QUALIFICATOR'
    global regex
    if p[2] == "+":
        regex = re.compile("%s(\s\S+){0,3}\s(\w+\.\w(\%s)(\d+.\d+)+)" % (combined_entities, combined_positives))
    else:
        regex = re.compile("%s(\s\S+){0,3}\s(\w+\.\w(\%s)(\d+.\d+)+)" % (combined_entities, combined_negatives))

def p_expresion_simple_swaping_one(p):
    'expression : SWAP QUALIFICATOR ENTITY'
    global regex
    if p[2] == "+":
         regex = re.compile("%s(\s\S+){0,3}\s(\w+\.\w(\%s)(\d+.\d+)+)(\s\S+){0,3}\s%s" % (combined_inverters, combined_positives, combined_entities))
    else:
         regex = re.compile("%s(\s\S+){0,3}\s(\w+\.\w(\%s)(\d+.\d+)+)(\s\S+){0,3}\s%s" % (combined_inverters, combined_negatives, combined_entities))

def p_expresion_simple_swaping_two(p):
    'expression : ENTITY SWAP QUALIFICATOR'
    global regex
    if p[3] == "+":
         regex = re.compile("%s(\s\S+){0,3}\s%s(\s\S+){0,3}\s(\w+\.\w(\%s)(\d+.\d+)+)" % (combined_entities, combined_inverters, combined_positives))
    else:
         regex = re.compile("%s(\s\S+){0,3}\s%s(\s\S+){0,3}\s(\w+\.\w(\%s)(\d+.\d+)+)" % (combined_entities, combined_inverters, combined_negatives))
    # print(regex.pattern)

def p_expresion_adhoc_one(p):
    'expression : ENTITY IDENTIFICATOR'
    global regex
    regex = re.compile("%s(\s\S+){0,3}\s(%s)" % (combined_entities, p[2]))

def p_expresion_adhoc_two(p):
    'expression : IDENTIFICATOR ENTITY'
    global regex
    regex = re.compile("(%s)(\s\S+){0,3}\s%s" % (p[1], combined_entities))



# Error rule for syntax errors
def p_error(p):
    print ">>> %s" % p
    print "Syntax error in input!"
    sys.exit(0)

def load_dict(file_path):
    """
    Load files from disk into variables
    """
    aux = []
    f_in = open(file_path, "r")
    tsv_reader = csv.reader(f_in, delimiter='\t')
    for row in tsv_reader:
        aux.append(row[0])
    return aux



# Check if parameters are valid
try:
    opts, args = getopt.getopt(sys.argv[1:], "l:p:", ["language=","port="])
    assert(len(opts) == 2)
except:
    print 'sentiment_Service.py -l <language> -p <port>'
    sys.exit()


for o, a in opts:
    if o == "-l":
        language = a
        if language not in ["spanish", "english"]:
            print 'Valid languages: spanish, english'
            sys.exit()
    elif o == "-p":
        port = a
    else:
        pass



# Load dicts into global variables
print("Loading Negative and positive constants:")
positive = load_dict("dict/positive.tsv")
assert(len(positive) == 1)
combined_positives = positive[0]
negative = load_dict("dict/negative.tsv")
combined_negatives = negative[0]
assert(len(negative) == 1)
print("...loaded.")
print("\n")


print("Loading dicts:")

entities = load_dict("dict/entities.tsv")
combined_entities = "(%s)" % "|".join(entities)
print("\t%s entities terms loaded" % len(entities))

inverters = load_dict("dict/inverters.tsv")
combined_inverters = "(%s)" % "|".join(inverters)
print("\t%s inverters terms loaded" % len(inverters))

chunks = load_dict("dict/chunks.tsv")
print("\t%s chunks loaded" % len(chunks))

stopwords = load_dict("data/stopwords.tsv")
print("\t%s stopwords loaded" % len(stopwords))

# Read the rules from the file
rules = []
for line in open("dict/rules.tsv", "r"):
        line = line.replace("\n", "")
        line = line.replace("\r", "")
        rules.append(line)

# Build the parser, and parse rules
parser = yacc.yacc()
print ("\nLoading rules:")
for rule in rules:
    result = parser.parse(rule)
    print("\tRule parsed succesfully: %s" % rule)


tt = TreeTagger(encoding='latin-1', language=language)
sentiwordnet = SentiWordnet()
to_wordnet = TreetaggerToWordnet()

# Init Tornado web server
application = tornado.web.Application([
    (r"/", MainHandler, dict(rules = compiled_rules, to_wordnet = to_wordnet, sentiwordnet = sentiwordnet, tt = tt, stopwords = stopwords, chunks = chunks, language = language)),
])

# Listen on specific port and start server
application.listen(port)
tornado.ioloop.IOLoop.instance().start()
# -*- coding: utf-8 -*-
#
# tsodyks_depressing.py
#
# This file is part of NEST.
#
# Copyright (C) 2004 The NEST Initiative
#
# NEST is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# NEST is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with NEST.  If not, see <http://www.gnu.org/licenses/>.

'''
/* BeginDocumentation
Name: tsodyks_depressing - python script for overall test of iaf_neuron model
Derived from tsodyks_depressing.sli.

Description:
Script to test Tsodyks short term plasticity depressing synapses according to
'Neural Networks with Dynamic Synapses'
Misha Tsodyks, Klaus Pawelzik, Henry Markram
Neural computation 10, 821--853 (1998)

reproduces figure 1 A


author:  Birgit Kriener, Moritz Helias, Markus Diesmann
date:	 March 2006

'''

# import nest kernel:
import nest
import nest.voltage_trace
from numpy import exp
import pylab

# set parameters:
h       = 0.1    # simulation step size (ms)
Tau     = 40.    # membrane time constant
Theta   = 15.    # threshold
U0      = 0.     # reset potential of membrane potential
R       = 0.1    # 100 M Ohm
C       = Tau/R  # Tau (ms)/R in NEST units
TauR    = 2.     # refractory time
Tau_psc = 3.     # time constant of PSC (= Tau_inact)
Tau_rec = 800.   # recovery time
Tau_fac = 0.     # facilitation time
U       = 0.5    # facilitation parameter U
A       = 250.   # PSC weight in pA
f       = 20./1000. # frequency in Hz converted to 1/ms
Tend    = 1200.  # simulation time
TIstart = 50.    # start time of dc
TIend   = 1050.  # end time of dc
I0      = Theta*C/Tau/(1-exp(-(1/f-TauR)/Tau)) # dc amplitude

# print I0

# set up simulator:
nest.ResetKernel()
nest.SetKernelStatus({"resolution": h})

# set neuron parameters:
neuron_param = {"tau_m"     :  Tau,
                "t_ref"     :  TauR,
                "tau_syn_ex":  Tau_psc,
                "tau_syn_in":  Tau_psc,
                "C_m"       :  C,
                "V_reset"   :  U0,
                "E_L"       :  U0,
                "V_m"       :  U0,
                "V_th"      :  Theta}

# set defaults of desired neuron type with chosen parameters:
nest.SetDefaults("iaf_psc_exp", neuron_param)

# create two neurons of desired type:
neurons = nest.Create("iaf_psc_exp",2)

# set properties of dc:
nest.SetDefaults("dc_generator",{"amplitude": I0, "start": TIstart, "stop": TIend})

# create dc_generator:
dc_gen = nest.Create("dc_generator")

# create voltmeter
volts=nest.Create("voltmeter")

# set properties of voltmeter
nest.SetStatus(volts,[{"label": "Voltmeter", "withtime": True, "withgid": True,
                         "interval": 1.}])

# connect dc_generator to neuron 1:
nest.Connect(dc_gen,[neurons[0]])

# connect voltmeter to neuron 2:
nest.Connect(volts,[neurons[1]])

# set synapse parameters:
syn_param = {"tau_psc" :  Tau_psc,
            "tau_rec" :  Tau_rec,
            "tau_fac" :  Tau_fac,
            "U"       :  U,
            "delay"   :  0.1,
            "weight"  :  A,
            "u"       :  0.0,
            "x"       :  1.0}

# create desired synapse type with chosen parameters:
nest.CopyModel("tsodyks_synapse","syn",syn_param)

# connect neuron 1 with neuron 2 via synapse model 'syn':
nest.Connect([neurons[0]],[neurons[1]],syn_spec={'model': "syn"})

# simulate:
nest.Simulate(Tend)

# plot membrane potential of neuron
nest.voltage_trace.from_device(volts)

from urlparse import urlparse

from django.contrib.sites.models import Site

import mock
import waffle
from nose.tools import eq_

from kitsune.inproduct.tests import redirect
from kitsune.sumo.tests import TestCase


class RedirectTestCase(TestCase):
    test_urls = (
        ('firefox/3.6.12/WINNT/en-US/', '/en-US/'),
        ('mobile/4.0/Android/en-US/', '/en-US/products/mobile'),
        ('firefox/3.6.12/MACOSX/en-US', '/en-US/'),
        ('firefox/3.6.12/WINNT/fr/', '/fr/'),
        ('firefox/3.6.12/WINNT/fr-FR/', '/fr/'),
        ('firefox-home/1.1/iPhone/en-US/', '/en-US/'),
        ('firefox/4.0/Linux/en-US/prefs-applications',
            '/en-US/kb/Applications'),
        ('firefox/4.0/Linux/en-US/prefs-applications/',
            '/en-US/kb/Applications'),
        ('firefox/5.0/NONE/en-US/', '/en-US/does-not-exist'),
        ('mobile/4.0/MARTIAN/en-US/', 'http://martian.com'),
        ('mobile/4.0/martian/en-US/', 'http://martian.com'),
        ('firefox/4.0/Android/en-US/foo', 404),
        # Make sure Basque doesn't trigger the EU ballot logic.
        ('firefox/29.0/Darwin/eu/', '/eu/'),
        ('firefox/29.0/Darwin/eu', '/eu/'),
    )

    test_eu_urls = (
        ('firefox/3.6.12/WINNT/en-US/eu/', '/en-US/'),
        ('mobile/4.0/Android/en-US/eu/', '/en-US/products/mobile'),
        ('firefox/3.6.12/MACOSX/en-US/eu', '/en-US/'),
        ('firefox/3.6.12/WINNT/fr/eu/', '/fr/'),
        ('firefox/3.6.12/WINNT/fr-FR/eu/', '/fr/'),
        ('firefox-home/1.1/iPhone/en-US/eu/', '/en-US/'),
        ('firefox/4.0/Linux/en-US/eu/prefs-applications',
            '/en-US/kb/Applications'),
        ('firefox/4.0/Linux/en-US/eu/prefs-applications/',
            '/en-US/kb/Applications'),
        ('firefox/5.0/NONE/en-US/eu/', '/en-US/does-not-exist'),
        ('mobile/4.0/MARTIAN/en-US/eu/', 'http://martian.com'),
        ('mobile/4.0/martian/en-US/eu/', 'http://martian.com'),
        ('firefox/4.0/Android/en-US/eu/foo', 404),
        # Basque is awesome.
        ('firefox/30.0/WINNT/eu/eu/', '/eu/'),
        ('firefox/4.0/Linux/eu/eu/prefs-applications',
            '/eu/kb/Applications'),
    )

    def setUp(self):
        super(RedirectTestCase, self).setUp()

        # Create redirects to test with.
        redirect(target='kb/Applications', topic='prefs-applications',
                 save=True)
        redirect(target='', save=True)
        redirect(product='mobile', target='products/mobile', save=True)
        redirect(platform='iPhone', target='', save=True)
        redirect(product='mobile', platform='Android', topic='foo',
                 target='', save=True)
        redirect(version='5.0', target='does-not-exist', save=True)
        redirect(platform='martian', target='http://martian.com', save=True)

    def test_target(self):
        """Test that we can vary on any parameter and targets work."""
        self._targets(self.test_urls, 'as=u&utm_source=inproduct')

    def test_eu_target(self):
        """Test that all URLs work with the extra 'eu'."""
        self._targets(self.test_eu_urls, 'eu=1&as=u&utm_source=inproduct')

    def _targets(self, urls, querystring):
        for input, output in urls:
            response = self.client.get(u'/1/%s' % input, follow=True)
            if output == 404:
                eq_(404, response.status_code)
            elif output.startswith('http'):
                chain = [u[0] for u in response.redirect_chain]
                assert output in chain
            else:
                r = response.redirect_chain
                r.reverse()
                final = urlparse(r[0][0])
                eq_(output, final.path)
                eq_(querystring, final.query)

    @mock.patch.object(Site.objects, 'get_current')
    @mock.patch.object(waffle, 'sample_is_active')
    def test_switch_to_https(self, sample_is_active, get_current):
        """Verify we switch to https when sample is active."""
        get_current.return_value.domain = 'example.com'
        sample_is_active.return_value = True

        response = self.client.get(
            u'/1/firefox/4.0/Linux/en-US/prefs-applications')
        eq_(302, response.status_code)
        assert response['location'].startswith('https://example.com/')

# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.

from six.moves.urllib import parse as urlparse

from st2common.util import isotime
from st2common.util.jsonify import json_encode
from st2common.exceptions import auth as exceptions
from st2common import log as logging
from st2common.util.auth import validate_token
from st2common.constants.auth import QUERY_PARAM_ATTRIBUTE_NAME


LOG = logging.getLogger(__name__)

# HTTP header name format (i.e. 'X-Auth-Token')
# WSGI environment variable name format (ex. 'HTTP_X_AUTH_TOKEN')
HEADERS = ['HTTP_X_AUTH_TOKEN_EXPIRY', 'HTTP_X_USER_NAME']


class AuthMiddleware(object):
    """WSGI middleware to handle authentication"""

    def __init__(self, app):
        self.app = app

    def __call__(self, environ, start_response):
        try:
            self._remove_auth_headers(environ)
            token = self._validate_token(environ)
            self._add_auth_headers(environ, token)
        except exceptions.TokenNotProvidedError:
            LOG.exception('Token is not provided.')
            return self._abort_unauthorized(environ, start_response)
        except exceptions.TokenNotFoundError:
            LOG.exception('Token is not found.')
            return self._abort_unauthorized(environ, start_response)
        except exceptions.TokenExpiredError:
            LOG.exception('Token has expired.')
            return self._abort_unauthorized(environ, start_response)
        except Exception:
            LOG.exception('Unexpected exception.')
            return self._abort_other_errors(environ, start_response)
        else:
            return self.app(environ, start_response)

    def _abort_other_errors(self, environ, start_response):
        body = json_encode({
            'faultstring': 'Internal Server Error'
        })
        headers = [('Content-Type', 'application/json')]

        start_response('500 INTERNAL SERVER ERROR', headers)
        return [body]

    def _abort_unauthorized(self, environ, start_response):
        body = json_encode({
            'faultstring': 'Unauthorized'
        })
        headers = [('Content-Type', 'application/json')]

        start_response('401 UNAUTHORIZED', headers)
        return [body]

    def _remove_auth_headers(self, env):
        """Remove middleware generated auth headers to prevent user from supplying them."""
        headers_found = [k for k in HEADERS if k in env]
        for header in headers_found:
            del env[header]

    def _validate_token(self, env):
        """Validate token"""
        query_string = env.get('QUERY_STRING', '')
        query_params = dict(urlparse.parse_qsl(query_string))

        # Note: This is a WSGI environment variable name
        token_in_headers = env.get('HTTP_X_AUTH_TOKEN', None)
        token_in_query_params = query_params.get(QUERY_PARAM_ATTRIBUTE_NAME, None)

        return validate_token(token_in_headers=token_in_headers,
                              token_in_query_params=token_in_query_params)

    def _add_auth_headers(self, env, token):
        """Write authenticated user data to headers

        Build headers that represent authenticated user:
         * HTTP_X_AUTH_TOKEN_EXPIRY: Token expiration datetime
         * HTTP_X_USER_NAME: Name of confirmed user

        """
        env['HTTP_X_AUTH_TOKEN_EXPIRY'] = isotime.format(token.expiry)
        env['HTTP_X_USER_NAME'] = str(token.user)

import os
from .. import constants, logger
from . import (
    base_classes,
    texture,
    material,
    geometry,
    object as object_,
    utilities,
    io,
    api
)


class Scene(base_classes.BaseScene):
    """Class that handles the contruction of a Three scene"""
    _defaults = {
        constants.METADATA: constants.DEFAULT_METADATA.copy(),
        constants.GEOMETRIES: [],
        constants.MATERIALS: [],
        constants.IMAGES: [],
        constants.TEXTURES: []
    }

    def __init__(self, filepath, options=None):
        logger.debug("Scene().__init__(%s, %s)", filepath, options)
        base_classes.BaseScene.__init__(self, filepath, options or {})

        source_file = api.scene_name()
        if source_file:
            self[constants.METADATA][constants.SOURCE_FILE] = source_file

    @property
    def valid_types(self):
        """

        :return: list of valid node types

        """
        valid_types = [api.constants.MESH]

        if self.options.get(constants.HIERARCHY, False):
            valid_types.append(api.constants.EMPTY)

        if self.options.get(constants.CAMERAS):
            logger.info("Adding cameras to valid object types")
            valid_types.append(api.constants.CAMERA)

        if self.options.get(constants.LIGHTS):
            logger.info("Adding lights to valid object types")
            valid_types.append(api.constants.LAMP)

        return valid_types

    def geometry(self, value):
        """Find a geometry node that matches either a name
        or uuid value.

        :param value: name or uuid
        :type value: str

        """
        logger.debug("Scene().geometry(%s)", value)
        return _find_node(value, self[constants.GEOMETRIES])

    def image(self, value):
        """Find a image node that matches either a name
        or uuid value.

        :param value: name or uuid
        :type value: str

        """
        logger.debug("Scene().image%s)", value)
        return _find_node(value, self[constants.IMAGES])

    def material(self, value):
        """Find a material node that matches either a name
        or uuid value.

        :param value: name or uuid
        :type value: str

        """
        logger.debug("Scene().material(%s)", value)
        return _find_node(value, self[constants.MATERIALS])

    def parse(self):
        """Execute the parsing of the scene"""
        logger.debug("Scene().parse()")
        if self.options.get(constants.MAPS):
            self._parse_textures()

        if self.options.get(constants.MATERIALS):
            self._parse_materials()

        self._parse_geometries()
        self._parse_objects()

    def texture(self, value):
        """Find a texture node that matches either a name
        or uuid value.

        :param value: name or uuid
        :type value: str

        """
        logger.debug("Scene().texture(%s)", value)
        return _find_node(value, self[constants.TEXTURES])

    def write(self):
        """Write the parsed scene to disk."""
        logger.debug("Scene().write()")
        data = {}

        embed_anim = self.options.get(constants.EMBED_ANIMATION, True)
        embed = self.options.get(constants.EMBED_GEOMETRY, True)

        compression = self.options.get(constants.COMPRESSION)
        extension = constants.EXTENSIONS.get(
            compression,
            constants.EXTENSIONS[constants.JSON])

        export_dir = os.path.dirname(self.filepath)
        for key, value in self.items():

            if key == constants.GEOMETRIES:
                geometries = []
                for geom in value:

                    if not embed_anim:
                        geom.write_animation(export_dir)

                    geom_data = geom.copy()
                    if embed:
                        geometries.append(geom_data)
                        continue

                    geo_type = geom_data[constants.TYPE].lower()
                    if geo_type == constants.GEOMETRY.lower():
                        geom_data.pop(constants.DATA)
                    elif geo_type == constants.BUFFER_GEOMETRY.lower():
                        geom_data.pop(constants.ATTRIBUTES)
                        geom_data.pop(constants.METADATA)

                    url = 'geometry.%s%s' % (geom.node, extension)
                    geometry_file = os.path.join(export_dir, url)

                    geom.write(filepath=geometry_file)
                    geom_data[constants.URL] = os.path.basename(url)

                    geometries.append(geom_data)

                data[key] = geometries
            elif isinstance(value, list):
                data[key] = []
                for each in value:
                    data[key].append(each.copy())
            elif isinstance(value, dict):
                data[key] = value.copy()

        io.dump(self.filepath, data, options=self.options)

        if self.options.get(constants.COPY_TEXTURES):
            texture_folder = self.options.get(constants.TEXTURE_FOLDER)
            for geo in self[constants.GEOMETRIES]:
                logger.info("Copying textures from %s", geo.node)
                geo.copy_textures(texture_folder)

    def _parse_geometries(self):
        """Locate all geometry nodes and parse them"""
        logger.debug("Scene()._parse_geometries()")

        # this is an important step. please refer to the doc string
        # on the function for more information
        api.object.prep_meshes(self.options)
        geometries = []

        # now iterate over all the extracted mesh nodes and parse each one
        for mesh in api.object.extracted_meshes():
            logger.info("Parsing geometry %s", mesh)
            geo = geometry.Geometry(mesh, self)
            geo.parse()
            geometries.append(geo)

        logger.info("Added %d geometry nodes", len(geometries))
        self[constants.GEOMETRIES] = geometries

    def _parse_materials(self):
        """Locate all non-orphaned materials and parse them"""
        logger.debug("Scene()._parse_materials()")
        materials = []

        for material_name in api.material.used_materials():
            logger.info("Parsing material %s", material_name)
            materials.append(material.Material(material_name, parent=self))

        logger.info("Added %d material nodes", len(materials))
        self[constants.MATERIALS] = materials

    def _parse_objects(self):
        """Locate all valid objects in the scene and parse them"""
        logger.debug("Scene()._parse_objects()")
        try:
            scene_name = self[constants.METADATA][constants.SOURCE_FILE]
        except KeyError:
            scene_name = constants.SCENE
        self[constants.OBJECT] = object_.Object(None, parent=self)
        self[constants.OBJECT][constants.TYPE] = constants.SCENE.title()
        self[constants.UUID] = utilities.id_from_name(scene_name)

        objects = []
        if self.options.get(constants.HIERARCHY, False):
            nodes = api.object.assemblies(self.valid_types, self.options)
        else:
            nodes = api.object.nodes(self.valid_types, self.options)

        for node in nodes:
            logger.info("Parsing object %s", node)
            obj = object_.Object(node, parent=self[constants.OBJECT])
            objects.append(obj)

        logger.info("Added %d object nodes", len(objects))
        self[constants.OBJECT][constants.CHILDREN] = objects

    def _parse_textures(self):
        """Locate all non-orphaned textures and parse them"""
        logger.debug("Scene()._parse_textures()")
        textures = []

        for texture_name in api.texture.textures():
            logger.info("Parsing texture %s", texture_name)
            tex_inst = texture.Texture(texture_name, self)
            textures.append(tex_inst)

        logger.info("Added %d texture nodes", len(textures))
        self[constants.TEXTURES] = textures


def _find_node(value, manifest):
    """Find a node that matches either a name
    or uuid value.

    :param value: name or uuid
    :param manifest: manifest of nodes to search
    :type value: str
    :type manifest: list

    """
    for index in manifest:
        uuid = index.get(constants.UUID) == value
        name = index.node == value
        if uuid or name:
            return index
    else:
        logger.debug("No matching node for %s", value)


#!/usr/bin/env python3

import os
import json
import sys
from io import open
from time import time
from shutil import rmtree
from collections import OrderedDict

if len(sys.argv) == 1 or not sys.argv[1]:
    raise SystemExit('Build dir missing.')


def mkdirs(path):
    try:
        os.makedirs(path)
    finally:
        return os.path.exists(path)

pj = os.path.join
build_dir = os.path.abspath(sys.argv[1])

description = ''

# locales
locale_dir = pj(build_dir, '_locales')

for alpha2 in sorted(os.listdir(locale_dir)):
    locale_path = pj(locale_dir, alpha2, 'messages.json')
    with open(locale_path, encoding='utf-8') as f:
        string_data = json.load(f, object_pairs_hook=OrderedDict)

    if alpha2 == 'en':
        description = string_data['extShortDesc']['message']

    for string_name in string_data:
        string_data[string_name] = string_data[string_name]['message']

    rmtree(pj(locale_dir, alpha2))

    alpha2 = alpha2.replace('_', '-')
    locale_path = pj(locale_dir, alpha2 + '.json')

    mkdirs(pj(locale_dir))

    with open(locale_path, 'wb') as f:
        f.write(json.dumps(string_data, ensure_ascii=False).encode('utf8'))


# update Info.plist
proj_dir = pj(os.path.split(os.path.abspath(__file__))[0], '..')
chromium_manifest = pj(proj_dir, 'platform', 'chromium', 'manifest.json')

with open(chromium_manifest, encoding='utf-8') as m:
    manifest = json.load(m)

manifest['buildNumber'] = int(time())
manifest['description'] = description

info_plist = pj(build_dir, 'Info.plist')

with open(info_plist, 'r+t', encoding='utf-8', newline='\n') as f:
    info_plist = f.read()
    f.seek(0)

    f.write(info_plist.format(**manifest))

# update Update.plist
update_plist = pj(proj_dir, 'platform', 'safari', 'Update.plist')
update_plist_build = pj(build_dir, '..', os.path.basename(update_plist))

with open(update_plist_build, 'wt', encoding='utf-8', newline='\n') as f:
    with open(update_plist, encoding='utf-8') as u:
        update_plist = u.read()

    f.write(update_plist.format(**manifest))

# -*- coding: utf-8 -*-

"""
***************************************************************************
    ProcessingLog.py
    ---------------------
    Date                 : August 2012
    Copyright            : (C) 2012 by Victor Olaya
    Email                : volayaf at gmail dot com
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""

__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'

import os
import codecs
import datetime
from processing.tools.system import userFolder
from processing.core.ProcessingConfig import ProcessingConfig
from qgis.PyQt.QtCore import QCoreApplication

LOG_SEPARATOR = '|~|'


class ProcessingLog:
    DATE_FORMAT = "%Y-%m-%d %H:%M:%S"

    @staticmethod
    def logFilename():
        logFilename = userFolder() + os.sep + 'processing.log'
        if not os.path.isfile(logFilename):
            with codecs.open(logFilename, 'w', encoding='utf-8') as logfile:
                logfile.write('Started logging at ' +
                              datetime.datetime.now().strftime(ProcessingLog.DATE_FORMAT) + '\n')

        return logFilename

    @staticmethod
    def addToLog(msg):
        try:
            # It seems that this fails sometimes depending on the msg
            # added. To avoid it stopping the normal functioning of the
            # algorithm, we catch all errors, assuming that is better
            # to miss some log info than breaking the algorithm.
            line = 'ALGORITHM' + LOG_SEPARATOR + datetime.datetime.now().strftime(
                ProcessingLog.DATE_FORMAT) + LOG_SEPARATOR \
                + msg + '\n'
            with codecs.open(ProcessingLog.logFilename(), 'a',
                             encoding='utf-8') as logfile:
                logfile.write(line)
        except:
            pass

    @staticmethod
    def getLogEntries():
        entries = []

        with open(ProcessingLog.logFilename(), encoding='utf-8') as f:
            lines = f.readlines()
        for line in lines:
            line = line.strip('\n').strip()
            tokens = line.split(LOG_SEPARATOR)
            if len(tokens) <= 1:
                # try old format log separator
                tokens = line.split('|')

            text = ''.join(
                tokens[i] + LOG_SEPARATOR for i in range(2, len(tokens))
            )
            if line.startswith('ALGORITHM'):
                entries.append(LogEntry(tokens[1], tokens[2]))

        return entries

    @staticmethod
    def clearLog():
        os.unlink(ProcessingLog.logFilename())

    @staticmethod
    def saveLog(fileName):
        entries = ProcessingLog.getLogEntries()
        with codecs.open(fileName, 'w', encoding='utf-8') as f:
            for entry in entries:
                f.write('ALGORITHM{}{}{}{}\n'.format(LOG_SEPARATOR, entry.date, LOG_SEPARATOR, entry.text))

    @staticmethod
    def tr(string, context=''):
        if context == '':
            context = 'ProcessingLog'
        return QCoreApplication.translate(context, string)


class LogEntry:

    def __init__(self, date, text):
        self.date = date
        self.text = text

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Copyright (c) 2009-2014, Mario Vilas
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
#     * Redistributions of source code must retain the above copyright notice,
#       this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above copyright
#       notice,this list of conditions and the following disclaimer in the
#       documentation and/or other materials provided with the distribution.
#     * Neither the name of the copyright holder nor the names of its
#       contributors may be used to endorse or promote products derived from
#       this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

"""
Wrapper for gdi32.dll in ctypes.
"""

__revision__ = "$Id$"

from winappdbg.win32.defines import *
from winappdbg.win32.kernel32 import GetLastError, SetLastError

#==============================================================================
# This is used later on to calculate the list of exported symbols.
_all = None
_all = set(vars().keys())
#==============================================================================

#--- Helpers ------------------------------------------------------------------

#--- Types --------------------------------------------------------------------

#--- Constants ----------------------------------------------------------------

# GDI object types
OBJ_PEN             = 1
OBJ_BRUSH           = 2
OBJ_DC              = 3
OBJ_METADC          = 4
OBJ_PAL             = 5
OBJ_FONT            = 6
OBJ_BITMAP          = 7
OBJ_REGION          = 8
OBJ_METAFILE        = 9
OBJ_MEMDC           = 10
OBJ_EXTPEN          = 11
OBJ_ENHMETADC       = 12
OBJ_ENHMETAFILE     = 13
OBJ_COLORSPACE      = 14
GDI_OBJ_LAST        = OBJ_COLORSPACE

# Ternary raster operations
SRCCOPY         = 0x00CC0020 # dest = source
SRCPAINT        = 0x00EE0086 # dest = source OR dest
SRCAND          = 0x008800C6 # dest = source AND dest
SRCINVERT       = 0x00660046 # dest = source XOR dest
SRCERASE        = 0x00440328 # dest = source AND (NOT dest)
NOTSRCCOPY      = 0x00330008 # dest = (NOT source)
NOTSRCERASE     = 0x001100A6 # dest = (NOT src) AND (NOT dest)
MERGECOPY       = 0x00C000CA # dest = (source AND pattern)
MERGEPAINT      = 0x00BB0226 # dest = (NOT source) OR dest
PATCOPY         = 0x00F00021 # dest = pattern
PATPAINT        = 0x00FB0A09 # dest = DPSnoo
PATINVERT       = 0x005A0049 # dest = pattern XOR dest
DSTINVERT       = 0x00550009 # dest = (NOT dest)
BLACKNESS       = 0x00000042 # dest = BLACK
WHITENESS       = 0x00FF0062 # dest = WHITE
NOMIRRORBITMAP  = 0x80000000 # Do not Mirror the bitmap in this call
CAPTUREBLT      = 0x40000000 # Include layered windows

# Region flags
ERROR               = 0
NULLREGION          = 1
SIMPLEREGION        = 2
COMPLEXREGION       = 3
RGN_ERROR           = ERROR

# CombineRgn() styles
RGN_AND             = 1
RGN_OR              = 2
RGN_XOR             = 3
RGN_DIFF            = 4
RGN_COPY            = 5
RGN_MIN             = RGN_AND
RGN_MAX             = RGN_COPY

# StretchBlt() modes
BLACKONWHITE        = 1
WHITEONBLACK        = 2
COLORONCOLOR        = 3
HALFTONE            = 4
MAXSTRETCHBLTMODE   = 4
STRETCH_ANDSCANS    = BLACKONWHITE
STRETCH_ORSCANS     = WHITEONBLACK
STRETCH_DELETESCANS = COLORONCOLOR
STRETCH_HALFTONE    = HALFTONE

# PolyFill() modes
ALTERNATE       = 1
WINDING         = 2
POLYFILL_LAST   = 2

# Layout orientation options
LAYOUT_RTL                         = 0x00000001 # Right to left
LAYOUT_BTT                         = 0x00000002 # Bottom to top
LAYOUT_VBH                         = 0x00000004 # Vertical before horizontal
LAYOUT_ORIENTATIONMASK             = LAYOUT_RTL + LAYOUT_BTT + LAYOUT_VBH
LAYOUT_BITMAPORIENTATIONPRESERVED  = 0x00000008

# Stock objects
WHITE_BRUSH         = 0
LTGRAY_BRUSH        = 1
GRAY_BRUSH          = 2
DKGRAY_BRUSH        = 3
BLACK_BRUSH         = 4
NULL_BRUSH          = 5
HOLLOW_BRUSH        = NULL_BRUSH
WHITE_PEN           = 6
BLACK_PEN           = 7
NULL_PEN            = 8
OEM_FIXED_FONT      = 10
ANSI_FIXED_FONT     = 11
ANSI_VAR_FONT       = 12
SYSTEM_FONT         = 13
DEVICE_DEFAULT_FONT = 14
DEFAULT_PALETTE     = 15
SYSTEM_FIXED_FONT   = 16

# Metafile functions
META_SETBKCOLOR              = 0x0201
META_SETBKMODE               = 0x0102
META_SETMAPMODE              = 0x0103
META_SETROP2                 = 0x0104
META_SETRELABS               = 0x0105
META_SETPOLYFILLMODE         = 0x0106
META_SETSTRETCHBLTMODE       = 0x0107
META_SETTEXTCHAREXTRA        = 0x0108
META_SETTEXTCOLOR            = 0x0209
META_SETTEXTJUSTIFICATION    = 0x020A
META_SETWINDOWORG            = 0x020B
META_SETWINDOWEXT            = 0x020C
META_SETVIEWPORTORG          = 0x020D
META_SETVIEWPORTEXT          = 0x020E
META_OFFSETWINDOWORG         = 0x020F
META_SCALEWINDOWEXT          = 0x0410
META_OFFSETVIEWPORTORG       = 0x0211
META_SCALEVIEWPORTEXT        = 0x0412
META_LINETO                  = 0x0213
META_MOVETO                  = 0x0214
META_EXCLUDECLIPRECT         = 0x0415
META_INTERSECTCLIPRECT       = 0x0416
META_ARC                     = 0x0817
META_ELLIPSE                 = 0x0418
META_FLOODFILL               = 0x0419
META_PIE                     = 0x081A
META_RECTANGLE               = 0x041B
META_ROUNDRECT               = 0x061C
META_PATBLT                  = 0x061D
META_SAVEDC                  = 0x001E
META_SETPIXEL                = 0x041F
META_OFFSETCLIPRGN           = 0x0220
META_TEXTOUT                 = 0x0521
META_BITBLT                  = 0x0922
META_STRETCHBLT              = 0x0B23
META_POLYGON                 = 0x0324
META_POLYLINE                = 0x0325
META_ESCAPE                  = 0x0626
META_RESTOREDC               = 0x0127
META_FILLREGION              = 0x0228
META_FRAMEREGION             = 0x0429
META_INVERTREGION            = 0x012A
META_PAINTREGION             = 0x012B
META_SELECTCLIPREGION        = 0x012C
META_SELECTOBJECT            = 0x012D
META_SETTEXTALIGN            = 0x012E
META_CHORD                   = 0x0830
META_SETMAPPERFLAGS          = 0x0231
META_EXTTEXTOUT              = 0x0a32
META_SETDIBTODEV             = 0x0d33
META_SELECTPALETTE           = 0x0234
META_REALIZEPALETTE          = 0x0035
META_ANIMATEPALETTE          = 0x0436
META_SETPALENTRIES           = 0x0037
META_POLYPOLYGON             = 0x0538
META_RESIZEPALETTE           = 0x0139
META_DIBBITBLT               = 0x0940
META_DIBSTRETCHBLT           = 0x0b41
META_DIBCREATEPATTERNBRUSH   = 0x0142
META_STRETCHDIB              = 0x0f43
META_EXTFLOODFILL            = 0x0548
META_SETLAYOUT               = 0x0149
META_DELETEOBJECT            = 0x01f0
META_CREATEPALETTE           = 0x00f7
META_CREATEPATTERNBRUSH      = 0x01F9
META_CREATEPENINDIRECT       = 0x02FA
META_CREATEFONTINDIRECT      = 0x02FB
META_CREATEBRUSHINDIRECT     = 0x02FC
META_CREATEREGION            = 0x06FF

# Metafile escape codes
NEWFRAME                     = 1
ABORTDOC                     = 2
NEXTBAND                     = 3
SETCOLORTABLE                = 4
GETCOLORTABLE                = 5
FLUSHOUTPUT                  = 6
DRAFTMODE                    = 7
QUERYESCSUPPORT              = 8
SETABORTPROC                 = 9
STARTDOC                     = 10
ENDDOC                       = 11
GETPHYSPAGESIZE              = 12
GETPRINTINGOFFSET            = 13
GETSCALINGFACTOR             = 14
MFCOMMENT                    = 15
GETPENWIDTH                  = 16
SETCOPYCOUNT                 = 17
SELECTPAPERSOURCE            = 18
DEVICEDATA                   = 19
PASSTHROUGH                  = 19
GETTECHNOLGY                 = 20
GETTECHNOLOGY                = 20
SETLINECAP                   = 21
SETLINEJOIN                  = 22
SETMITERLIMIT                = 23
BANDINFO                     = 24
DRAWPATTERNRECT              = 25
GETVECTORPENSIZE             = 26
GETVECTORBRUSHSIZE           = 27
ENABLEDUPLEX                 = 28
GETSETPAPERBINS              = 29
GETSETPRINTORIENT            = 30
ENUMPAPERBINS                = 31
SETDIBSCALING                = 32
EPSPRINTING                  = 33
ENUMPAPERMETRICS             = 34
GETSETPAPERMETRICS           = 35
POSTSCRIPT_DATA              = 37
POSTSCRIPT_IGNORE            = 38
MOUSETRAILS                  = 39
GETDEVICEUNITS               = 42
GETEXTENDEDTEXTMETRICS       = 256
GETEXTENTTABLE               = 257
GETPAIRKERNTABLE             = 258
GETTRACKKERNTABLE            = 259
EXTTEXTOUT                   = 512
GETFACENAME                  = 513
DOWNLOADFACE                 = 514
ENABLERELATIVEWIDTHS         = 768
ENABLEPAIRKERNING            = 769
SETKERNTRACK                 = 770
SETALLJUSTVALUES             = 771
SETCHARSET                   = 772
STRETCHBLT                   = 2048
METAFILE_DRIVER              = 2049
GETSETSCREENPARAMS           = 3072
QUERYDIBSUPPORT              = 3073
BEGIN_PATH                   = 4096
CLIP_TO_PATH                 = 4097
END_PATH                     = 4098
EXT_DEVICE_CAPS              = 4099
RESTORE_CTM                  = 4100
SAVE_CTM                     = 4101
SET_ARC_DIRECTION            = 4102
SET_BACKGROUND_COLOR         = 4103
SET_POLY_MODE                = 4104
SET_SCREEN_ANGLE             = 4105
SET_SPREAD                   = 4106
TRANSFORM_CTM                = 4107
SET_CLIP_BOX                 = 4108
SET_BOUNDS                   = 4109
SET_MIRROR_MODE              = 4110
OPENCHANNEL                  = 4110
DOWNLOADHEADER               = 4111
CLOSECHANNEL                 = 4112
POSTSCRIPT_PASSTHROUGH       = 4115
ENCAPSULATED_POSTSCRIPT      = 4116
POSTSCRIPT_IDENTIFY          = 4117
POSTSCRIPT_INJECTION         = 4118
CHECKJPEGFORMAT              = 4119
CHECKPNGFORMAT               = 4120
GET_PS_FEATURESETTING        = 4121
GDIPLUS_TS_QUERYVER          = 4122
GDIPLUS_TS_RECORD            = 4123
SPCLPASSTHROUGH2             = 4568

#--- Structures ---------------------------------------------------------------

# typedef struct _RECT {
#   LONG left;
#   LONG top;
#   LONG right;
#   LONG bottom;
# }RECT, *PRECT;
class RECT(Structure):
    _fields_ = [
        ('left',    LONG),
        ('top',     LONG),
        ('right',   LONG),
        ('bottom',  LONG),
    ]
PRECT  = POINTER(RECT)
LPRECT = PRECT

# typedef struct tagPOINT {
#   LONG x;
#   LONG y;
# } POINT;
class POINT(Structure):
    _fields_ = [
        ('x',   LONG),
        ('y',   LONG),
    ]
PPOINT  = POINTER(POINT)
LPPOINT = PPOINT

# typedef struct tagBITMAP {
#   LONG   bmType;
#   LONG   bmWidth;
#   LONG   bmHeight;
#   LONG   bmWidthBytes;
#   WORD   bmPlanes;
#   WORD   bmBitsPixel;
#   LPVOID bmBits;
# } BITMAP, *PBITMAP;
class BITMAP(Structure):
    _fields_ = [
        ("bmType",          LONG),
        ("bmWidth",         LONG),
        ("bmHeight",        LONG),
        ("bmWidthBytes",    LONG),
        ("bmPlanes",        WORD),
        ("bmBitsPixel",     WORD),
        ("bmBits",          LPVOID),
    ]
PBITMAP  = POINTER(BITMAP)
LPBITMAP = PBITMAP

#--- High level classes -------------------------------------------------------

#--- gdi32.dll ----------------------------------------------------------------

# HDC GetDC(
#   __in  HWND hWnd
# );
def GetDC(hWnd):
    _GetDC = windll.gdi32.GetDC
    _GetDC.argtypes = [HWND]
    _GetDC.restype  = HDC
    _GetDC.errcheck = RaiseIfZero
    return _GetDC(hWnd)

# HDC GetWindowDC(
#   __in  HWND hWnd
# );
def GetWindowDC(hWnd):
    _GetWindowDC = windll.gdi32.GetWindowDC
    _GetWindowDC.argtypes = [HWND]
    _GetWindowDC.restype  = HDC
    _GetWindowDC.errcheck = RaiseIfZero
    return _GetWindowDC(hWnd)

# int ReleaseDC(
#   __in  HWND hWnd,
#   __in  HDC hDC
# );
def ReleaseDC(hWnd, hDC):
    _ReleaseDC = windll.gdi32.ReleaseDC
    _ReleaseDC.argtypes = [HWND, HDC]
    _ReleaseDC.restype  = ctypes.c_int
    _ReleaseDC.errcheck = RaiseIfZero
    _ReleaseDC(hWnd, hDC)

# HGDIOBJ SelectObject(
#   __in  HDC hdc,
#   __in  HGDIOBJ hgdiobj
# );
def SelectObject(hdc, hgdiobj):
    _SelectObject = windll.gdi32.SelectObject
    _SelectObject.argtypes = [HDC, HGDIOBJ]
    _SelectObject.restype  = HGDIOBJ
    _SelectObject.errcheck = RaiseIfZero
    return _SelectObject(hdc, hgdiobj)

# HGDIOBJ GetStockObject(
#   __in  int fnObject
# );
def GetStockObject(fnObject):
    _GetStockObject = windll.gdi32.GetStockObject
    _GetStockObject.argtypes = [ctypes.c_int]
    _GetStockObject.restype  = HGDIOBJ
    _GetStockObject.errcheck = RaiseIfZero
    return _GetStockObject(fnObject)

# DWORD GetObjectType(
#   __in  HGDIOBJ h
# );
def GetObjectType(h):
    _GetObjectType = windll.gdi32.GetObjectType
    _GetObjectType.argtypes = [HGDIOBJ]
    _GetObjectType.restype  = DWORD
    _GetObjectType.errcheck = RaiseIfZero
    return _GetObjectType(h)

# int GetObject(
#   __in   HGDIOBJ hgdiobj,
#   __in   int cbBuffer,
#   __out  LPVOID lpvObject
# );
def GetObject(hgdiobj, cbBuffer = None, lpvObject = None):
    _GetObject = windll.gdi32.GetObject
    _GetObject.argtypes = [HGDIOBJ, ctypes.c_int, LPVOID]
    _GetObject.restype  = ctypes.c_int
    _GetObject.errcheck = RaiseIfZero

    # Both cbBuffer and lpvObject can be omitted, the correct
    # size and structure to return are automatically deduced.
    # If lpvObject is given it must be a ctypes object, not a pointer.
    # Always returns a ctypes object.

    if cbBuffer is not None:
        if lpvObject is None:
            lpvObject = ctypes.create_string_buffer("", cbBuffer)
    elif lpvObject is not None:
        cbBuffer = sizeof(lpvObject)
    else: # most likely case, both are None
        t = GetObjectType(hgdiobj)
        if   t == OBJ_PEN:
            cbBuffer  = sizeof(LOGPEN)
            lpvObject = LOGPEN()
        elif t == OBJ_BRUSH:
            cbBuffer  = sizeof(LOGBRUSH)
            lpvObject = LOGBRUSH()
        elif t == OBJ_PAL:
            cbBuffer  = _GetObject(hgdiobj, 0, None)
            lpvObject = (WORD * (cbBuffer // sizeof(WORD)))()
        elif t == OBJ_FONT:
            cbBuffer  = sizeof(LOGFONT)
            lpvObject = LOGFONT()
        elif t == OBJ_BITMAP:  # try the two possible types of bitmap
            cbBuffer  = sizeof(DIBSECTION)
            lpvObject = DIBSECTION()
            try:
                _GetObject(hgdiobj, cbBuffer, byref(lpvObject))
                return lpvObject
            except WindowsError:
                cbBuffer  = sizeof(BITMAP)
                lpvObject = BITMAP()
        elif t == OBJ_EXTPEN:
            cbBuffer  = sizeof(LOGEXTPEN)
            lpvObject = LOGEXTPEN()
        else:
            cbBuffer  = _GetObject(hgdiobj, 0, None)
            lpvObject = ctypes.create_string_buffer("", cbBuffer)
    _GetObject(hgdiobj, cbBuffer, byref(lpvObject))
    return lpvObject

# LONG GetBitmapBits(
#   __in   HBITMAP hbmp,
#   __in   LONG cbBuffer,
#   __out  LPVOID lpvBits
# );
def GetBitmapBits(hbmp):
    _GetBitmapBits = windll.gdi32.GetBitmapBits
    _GetBitmapBits.argtypes = [HBITMAP, LONG, LPVOID]
    _GetBitmapBits.restype  = LONG
    _GetBitmapBits.errcheck = RaiseIfZero

    bitmap   = GetObject(hbmp, lpvObject = BITMAP())
    cbBuffer = bitmap.bmWidthBytes * bitmap.bmHeight
    lpvBits  = ctypes.create_string_buffer("", cbBuffer)
    _GetBitmapBits(hbmp, cbBuffer, byref(lpvBits))
    return lpvBits.raw

# HBITMAP CreateBitmapIndirect(
#   __in  const BITMAP *lpbm
# );
def CreateBitmapIndirect(lpbm):
    _CreateBitmapIndirect = windll.gdi32.CreateBitmapIndirect
    _CreateBitmapIndirect.argtypes = [PBITMAP]
    _CreateBitmapIndirect.restype  = HBITMAP
    _CreateBitmapIndirect.errcheck = RaiseIfZero
    return _CreateBitmapIndirect(lpbm)

#==============================================================================
# This calculates the list of exported symbols.
_all = set(vars().keys()).difference(_all)
__all__ = [_x for _x in _all if not _x.startswith('_')]
__all__.sort()
#==============================================================================

#!/usr/bin/env python
# coding=utf-8

import sys
from datetime import *
import time
from elasticsearch import Elasticsearch

CONST_ES_HOST="http://172.17.0.1:8081"
CONST_TABLE='export_table'
CONST_INDEX='stat-*'

def str2timestamp(str1,formatStr='%Y-%m-%d %H:%M:%S'):
    _t = time.mktime(time.strptime(str1,formatStr))
    return int(_t)



def search_from_es(host,index,query_str,startTime,endTime,scroll=True):
    print('search_from_es startTime:%s,endTime:%s'%(startTime,endTime))
    startTimeStamp = int(str2timestamp(startTime))*1000
    endTimeStamp = int(str2timestamp(endTime))*1000+999
    data_post_search = {"query":{"filtered":{"query":{"query_string":{"query":query_str,"analyze_wildcard":'true'}},"filter":{"bool":{"must":[{"range":{"@timestamp":{"gte":startTimeStamp,"lte":endTimeStamp,"format":"epoch_millis"}}}],"must_not":[]}}}}}
    print('search_from_es,post_data:%s'%(data_post_search))
    es = Elasticsearch(host)
    response={}
    if not scroll:
        response = es.search(index=index, body=data_post_search,size=10000)
    else:
        page_size=10000
        scan_resp = es.search(index=index, body=data_post_search,search_type="scan", scroll="1m",size=page_size,_source=['op','time'])
        scrollId= scan_resp['_scroll_id']
        response={}
        total = scan_resp['hits']['total']
        response_list =[]
        for page_num in range(total/page_size + 1):
            print 'scroll page_num:',page_num
            response_tmp ={}
            response_tmp = es.scroll(scroll_id=scrollId, scroll= "1m")
            scrollId = response_tmp['_scroll_id']
            response_list.append(response_tmp)
            if response.has_key('hits'):
                _hits = response['hits']
                _hits['hits']+=response_tmp['hits']['hits']
                response['hits'] = _hits
            else:
                response['hits'] = response_tmp['hits']
    return response

def fetch_es(startTime,endTime,scroll=True,condition='all'):
    host = CONST_ES_HOST
    index = CONST_INDEX
    query_str='*'
    if condition!='all':
        query_str="op:case_submit_patient_info OR op:case_submit_payee_info OR op:case_submit_treatment_info OR op:case_finish OR op:case_draw_cash_apply OR op:case_submit_for_review OR op:share"
    res = search_from_es(host,index,query_str,startTime,endTime,scroll=scroll)
    return res

if __name__=='__main__':

    startTime='2017-04-13 16:00:00'
    endTime='2017-04-13 17:00:00'
    print '---scroll True--'
    res = fetch_es(startTime,endTime,scroll=True)
    total = res['hits']['total']
    count = len(res['hits']['hits'])
    #print  198704 198704
    print total,count
    print '---scroll False--'
    res = fetch_es(startTime,endTime,scroll=False)
    total = res['hits']['total']
    count = len(res['hits']['hits'])
    #print 198704 198704
    print total,count
    

"""
The CustomPermissionsUser users email as the identifier, but uses the normal
Django permissions model. This allows us to check that the PermissionsMixin
includes everything that is needed to interact with the ModelBackend.
"""
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
from django.contrib.auth.tests.custom_user import (
    CustomUserManager, RemoveGroupsAndPermissions,
)
from django.db import models
from django.utils.encoding import python_2_unicode_compatible


class CustomPermissionsUserManager(CustomUserManager):
    def create_superuser(self, email, password, date_of_birth):
        u = self.create_user(email, password=password, date_of_birth=date_of_birth)
        u.is_superuser = True
        u.save(using=self._db)
        return u


with RemoveGroupsAndPermissions():
    @python_2_unicode_compatible
    class CustomPermissionsUser(AbstractBaseUser, PermissionsMixin):
        email = models.EmailField(verbose_name='email address', max_length=255, unique=True)
        date_of_birth = models.DateField()

        custom_objects = CustomPermissionsUserManager()

        USERNAME_FIELD = 'email'
        REQUIRED_FIELDS = ['date_of_birth']

        class Meta:
            app_label = 'auth'

        def get_full_name(self):
            return self.email

        def get_short_name(self):
            return self.email

        def __str__(self):
            return self.email

# -*- coding: utf-8 -*-

import unittest

from cwpoliticl.extensions.base_parser import BaseParser
from cwpoliticl.items import WDPost


class BaseParseTest(unittest.TestCase):
    def setUp(self):
        self.base_parse = BaseParser()

    # def test_post_page(self):
    #     self.base_parse.get_all_value_response()
    #     pass

    # def test_new_wdpost(self):
    #     self.url_from = 'url_from'
    #     url = 'http://www.google.com'
    #     title = 'title'
    #     image_src = ''
    #     thumbnail_url = 'http://thumbnail/1.jpg'
    #     content = 'content'
    #     tags = []
    #
    #     item = WDPost.get_default(url, self.url_from, title, image_src, thumbnail_url, content, tags)
    #
    #     self.assertEqual(item['url'], url)

    def test_css_background_image_for_dailyo(self):
        image_style = "background-image:url('http://media2.intoday.in/dailyo//story/header/201607/priyankag-sheila-ab_071416102045.jpg')"

        url = self.base_parse.get_image_src_from_style(image_style)
        self.assertEqual(
            'http://media2.intoday.in/dailyo//story/header/201607/priyankag-sheila-ab_071416102045.jpg',
            url)

    def test_css_background_image_for_theindianeconomist(self):
        image_style = 'background-image: url(http://i2.wp.com/theindianeconomist.com/wp-content/uploads/2016/07/16344930632_f89cc36a46_o.jpg?fit=1280%2C850); opacity: 0.3;'
        url = self.base_parse.get_image_src_from_style(image_style)
        self.assertEqual(
            'http://i2.wp.com/theindianeconomist.com/wp-content/uploads/2016/07/16344930632_f89cc36a46_o.jpg?fit=1280%2C850',
            url)

# flake8: noqa
# SKIP this file when reformatting.
# The rest of this file was generated by South.

# encoding: utf-8
import datetime

from django.db import models
from south.db import db
from south.v2 import SchemaMigration


class Migration(SchemaMigration):

    def forwards(self, orm):
        
        # Adding model 'NodeCommissionResult'
        db.create_table('metadataserver_nodecommissionresult', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('node', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['maasserver.Node'])),
            ('name', self.gf('django.db.models.fields.CharField')(max_length=100)),
            ('data', self.gf('django.db.models.fields.CharField')(max_length=1048576)),
        ))
        db.send_create_signal('metadataserver', ['NodeCommissionResult'])

        # Adding unique constraint on 'NodeCommissionResult', fields ['node', 'name']
        db.create_unique('metadataserver_nodecommissionresult', ['node_id', 'name'])


    def backwards(self, orm):
        
        # Removing unique constraint on 'NodeCommissionResult', fields ['node', 'name']
        db.delete_unique('metadataserver_nodecommissionresult', ['node_id', 'name'])

        # Deleting model 'NodeCommissionResult'
        db.delete_table('metadataserver_nodecommissionresult')


    models = {
        'auth.group': {
            'Meta': {'object_name': 'Group'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
        },
        'auth.permission': {
            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        'auth.user': {
            'Meta': {'object_name': 'User'},
            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'email': ('django.db.models.fields.EmailField', [], {'unique': 'True', 'max_length': '75', 'blank': 'True'}),
            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
        },
        'contenttypes.contenttype': {
            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'maasserver.node': {
            'Meta': {'object_name': 'Node'},
            'after_commissioning_action': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
            'architecture': ('django.db.models.fields.CharField', [], {'default': "u'i386'", 'max_length': '10'}),
            'created': ('django.db.models.fields.DateField', [], {}),
            'error': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
            'hostname': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'owner': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'}),
            'power_type': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '10', 'blank': 'True'}),
            'status': ('django.db.models.fields.IntegerField', [], {'default': '0', 'max_length': '10'}),
            'system_id': ('django.db.models.fields.CharField', [], {'default': "u'node-b9edb888-839c-11e1-965e-002215205ce8'", 'unique': 'True', 'max_length': '41'}),
            'token': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['piston.Token']", 'null': 'True'}),
            'updated': ('django.db.models.fields.DateTimeField', [], {})
        },
        'metadataserver.nodecommissionresult': {
            'Meta': {'unique_together': "((u'node', u'name'),)", 'object_name': 'NodeCommissionResult'},
            'data': ('django.db.models.fields.CharField', [], {'max_length': '1048576'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'node': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['maasserver.Node']"})
        },
        'metadataserver.nodekey': {
            'Meta': {'object_name': 'NodeKey'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '18'}),
            'node': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['maasserver.Node']", 'unique': 'True'}),
            'token': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['piston.Token']", 'unique': 'True'})
        },
        'metadataserver.nodeuserdata': {
            'Meta': {'object_name': 'NodeUserData'},
            'data': ('metadataserver.fields.BinaryField', [], {}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'node': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['maasserver.Node']", 'unique': 'True'})
        },
        'piston.consumer': {
            'Meta': {'object_name': 'Consumer'},
            'description': ('django.db.models.fields.TextField', [], {}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'key': ('django.db.models.fields.CharField', [], {'max_length': '18'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'secret': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
            'status': ('django.db.models.fields.CharField', [], {'default': "'pending'", 'max_length': '16'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'consumers'", 'null': 'True', 'to': "orm['auth.User']"})
        },
        'piston.token': {
            'Meta': {'object_name': 'Token'},
            'callback': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'callback_confirmed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'consumer': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['piston.Consumer']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_approved': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'key': ('django.db.models.fields.CharField', [], {'max_length': '18'}),
            'secret': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
            'timestamp': ('django.db.models.fields.IntegerField', [], {'default': '1334124495L'}),
            'token_type': ('django.db.models.fields.IntegerField', [], {}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'tokens'", 'null': 'True', 'to': "orm['auth.User']"}),
            'verifier': ('django.db.models.fields.CharField', [], {'max_length': '10'})
        }
    }

    complete_apps = ['metadataserver']

# coding: utf-8
'''Tests for CrashManager get_auth_token management command

@author:     Jesse Schwartzentruber (:truber)

@license:

This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
'''
import re
from django.contrib.auth.models import User
from django.core.management import call_command, CommandError
from rest_framework.authtoken.models import Token
import pytest


pytestmark = pytest.mark.django_db()  # pylint: disable=invalid-name


def test_args():
    with pytest.raises(CommandError, match=r"Error: Enter at least one label."):
        call_command("get_auth_token")


def test_no_such_user():
    with pytest.raises(User.DoesNotExist):
        call_command("get_auth_token", "user")


def test_one_user(capsys):
    user = User.objects.create_user("test", "test@example.com", "test")
    call_command("get_auth_token", "test")
    out, _ = capsys.readouterr()
    key = out.strip()
    tkn = Token.objects.get(user=user)
    assert tkn.key == key
    assert re.match(r"^[A-Fa-f0-9]+$", key) is not None
    assert len(key) > 32  # just check that it's reasonably long


def test_two_users(capsys):
    users = (User.objects.create_user("test", "test@example.com", "test"),
             User.objects.create_user("test2", "test2@example.com", "test2"))
    call_command("get_auth_token", "test", "test2")
    out, _ = capsys.readouterr()
    keys = set(out.strip().split())
    assert len(keys) == len(users)
    tkns = set(tkn.key for tkn in Token.objects.all())
    assert tkns == keys
    for key in keys:
        assert re.match(r"^[A-Fa-f0-9]+$", key) is not None
        assert len(key) > 32  # just check that it's reasonably long

# TC, 7/25/16

import itertools
import numpy as np
import random
import tqdm
from scipy.misc import logsumexp

#########################
# Bootstrap and Pseudo-R2 Code
#########################

def load_words_to_array(i_f, rare_base='A',
                        discard_base='-', del_as_misinc=False):
    """
    Input a word file object.
    
    Return a KxM {0,1} array representing the M-length words contained in
    one of the word.txt files you've been using
    """
    txt_data = [line.strip() for line in i_f.readlines()
                if discard_base not in line]

    if del_as_misinc:
        rare_base_list = [rare_base, 'd']
    else:
        rare_base_list = [rare_base]
    return np.array([np.where([c in rare_base_list for c in s], 0, 1)
                     for s in txt_data])

def load_controls(A_D_0, A_D_1):
    """
    Given word arrays for the 0 and 1 condition (A_D_0, A_D_1), returns
    an array suitable for use as the control array in likelihood functions.
    """
    p1 = np.sum(A_D_0, axis=0) / float(A_D_0.shape[0])
    p2 = np.sum(A_D_1, axis=0) / float(A_D_1.shape[0])

    return np.array([p1, p2]).T

#########################
# Signal Allocation Code
#########################

def is_monotonic(vec):
    """
    Return True if items in list do not decrease, otherwise return False
    """
    return all([(vec[m+1] - vec[m]) >= 0 for m in range(len(vec) - 1)])

def get_monotonic_allocations(length_d, length_s):
    """
    Return a list of possible ways the strand D could have be written during some signal S.

    Inputs:
        length_d - The length of the DNA analysis strand
        length_s - The number of signal "phases" 
    Output:
        I_L - A list of lists, I. Individual I's are of length D, with each element being
              an index of an element of S, indicating that the nucleotide was written during
              that portion of the signal.
    """

    return [list(I) for I in itertools.product(range(length_s), repeat=length_d)
            if is_monotonic(I)]

#########################
# Single-Sequence Likelihood Code
#########################

def seq_alloc_log_lhood(D, S, I, P):
    """
    Get the likelihood of strand D under signal S, given positional probabilities P. I
    is an "allocation" that indexes D to S.

    Input:
        D - A 1-d M-length array composed of {0,1}, representing errors on a DNA strand
        S - A 1-d N-length array composed of {0,1}, representing the signal delivered at each phase of the signal
        I - An M-length list, providing indexing of each element of D to an element of S
        P - A numpy Nx2 array, each row composed of error rates [p_{m,0}, p_{m,1}]

    Output:
        ll - The log-likelihood of the strand given S, I, and P
    """
    # Get the vector of error rates
    # First get the right S_n index for the d_m's
    # Then use where to get the right probabilities from P
    ers = np.where(S[I], P[:, 1], P[:, 0])

    lhood_components = D*ers + (1-D)*(1-ers)
    return np.sum(np.log(lhood_components))

def seq_log_lhood(D, S, L_I, P, prior=None, method='map'):
    """
    Return the MAP log-likelihood of a sequence over all possible allocations of that
    sequence over the signal.
    
    Input:
        D - A numpy Mx1 array composed of {0,1}, representing errors on a DNA strand
        S - A numpy Nx1 array composed of {0,1}, representing the signal delivered at each phase of the signal
        L_I - A list of M-length lists, providing indexing of each element of D to an element of S
        P - A numpy Nx2 array, each row composed of error rates [p_{m,0}, p_{m,1}]
        prior - A numpy array the length of L_I. The likelihood of each allocation, defaults to a uniform prior

    Output:
        ll - The maximum log-likelihood of the strand given S, I, and P
    """
    if prior is None: # i.e. it's uniform
        prior = np.ones(len(L_I), dtype=float) / len(L_I)

    if method is 'map':
        out = np.max([seq_alloc_log_lhood(D,S,I,P) + np.log(p)
                      for I, p in zip(L_I, prior)])
    elif method is 'sum':
        out = logsumexp([seq_alloc_log_lhood(D,S,I,P) for I in L_I], b=prior)
    else:
        raise ValueError('Unrecognized method `%s`' % method)

    return out

#########################
# Population Likelihood Code
#########################

def pop_log_lhood(A_D, S, P, **kwargs):
    """
    Return the log-likelihood of a population of sequences.
    
    Input:
        A_D - A numpy KxM array composed of {0,1}, representing errors on a M-length DNA strand for K strands
        S - A numpy Nx1 array composed of {0,1}, representing the signal delivered at each phase of the signal
        P - A numpy Nx2 array, each row composed of error rates [p_{m,0}, p_{m,1}]
        
    Output:
        ll - The log-likelihood of the population given S and P
    """
    
    assert A_D.size
    L_I = get_monotonic_allocations(A_D.shape[1], len(S))
    
    return np.sum(np.apply_along_axis(seq_log_lhood, 1, A_D, S, L_I, P, **kwargs))

def all_log_lhood_fast(A_D, S, P, **kwargs):
    """
    Return a 1-d array of the log-likelihoods of the sequences in A_D
    
    Input:
        A_D - A numpy KxM array composed of {0,1}, representing errors on a M-length DNA strand for K strands
        S - A 1-d N-length array composed of {0,1}, representing the signal delivered at each phase of the signal
        P - A numpy Nx2 array, each row composed of error rates [p_{m,0}, p_{m,1}]
        
    Output:
        ll - The log-likelihood of the population given S and P
    """
    assert A_D.size
    L_I = get_monotonic_allocations(A_D.shape[1], len(S))
    
    # Get all possible D's
    possible_Ds = list(itertools.product([0,1], repeat=len(A_D[0])))
    
    prob_Ds = {D: seq_log_lhood(np.array(D), S, L_I, P, **kwargs)
               for D in possible_Ds}
    
    return np.apply_along_axis(lambda x: prob_Ds[tuple(x)], 1, A_D)
    # return [np.apply_along_axis(lambda x: (x == D).all(), 1, A_D) for D in possible_Ds]
    # return np.array([ct * p for ct, p in zip(count_Ds, prob_Ds)])

def pop_log_lhood_fast(A_D, S, P, **kwargs):
    """
    Return the log-likelihood of a population, using a method in kwargs.
    """
    return np.sum(all_log_lhood_fast(A_D, S, P, **kwargs))

def multi_pop_log_lhood_fast(l_A_D, S, P, **kwargs):
    """
    Return the log-likelihood of a multi-sample population.
    """
    return np.sum([np.sum(all_log_lhood_fast(A_D, S, P, **kwargs))
                   for A_D in l_A_D])

#########################
# Bootstrap and Pseudo-R2 Code
#########################

def rel_pseudo_r2_pop(L_D, S1, S2, P1, P2=None, **kwargs):
    """
    Return McFadden's Pseudo-R^2 (1-\frac{logL_S1}{logL_S2} 
    of sequences under signal S1 over signal S2.   
    """
    if not P2:
        P2 = P1
    
    logL_1 = pop_log_lhood_fast(L_D, S1, P1, **kwargs)
    logL_2 = pop_log_lhood_fast(L_D, S2, P2, **kwargs)
    
    return 1 - (logL_1/logL_2)

def multi_rel_pseudo_r2_pop(L_D_list, S1, S2, P1, P2=None, **kwargs):
    """
    Return McFadden's Pseudo-R^2 (1-\frac{logL_S1}{logL_S2} 
    of sequences under signal S1 over signal S2.   
    """
    if not P2:
        P2 = P1
    
    logL_1 = multi_pop_log_lhood_fast(L_D_list, S1, P1, **kwargs)
    logL_2 = multi_pop_log_lhood_fast(L_D_list, S2, P2, **kwargs)
    
    return 1 - (logL_1/logL_2)

def bootstr_ci(func, X, alpha=0.05, args=None, kwargs=None,
               n_iter=1000, samp_size=None, verbose=False):
    if args and kwargs:
        f = lambda data: func(data, *args, **kwargs)
    elif args:
        f = lambda data: func(data, *args)
    elif kwargs:
        f = lambda data: func(data, **kwargs)
    else:
        f = func

    if not samp_size:
        samp_size = len(X)
    
    Fstar_lo, Fstar_hi = np.floor(n_iter * np.array([alpha/2., 1-alpha/2.])).astype(int)

    f_mu = f(X)
    
    bootstrap_stats = np.zeros((n_iter,) + f_mu.shape)
    
    if verbose:
        for i in tqdm.tqdm(range(n_iter)):
            resampled_idx = np.random.randint(X.shape[0], size=(samp_size,1))
            resampled_X = X[resampled_idx,...].squeeze()
            bootstrap_stats[i,...] = f(resampled_X)
    else:
        for i in range(n_iter):
            resampled_idx = np.random.randint(X.shape[0], size=(samp_size,1))
            resampled_X = X[resampled_idx,...].squeeze()
            bootstrap_stats[i,...] = f(resampled_X)

    srt_bootstrap_stats = np.sort(bootstrap_stats, axis=0)
    
    ci = (srt_bootstrap_stats[Fstar_lo], srt_bootstrap_stats[Fstar_hi])
    
    return ci

def bootstr_ci_pseudo_r2(L_D, S1, S2, P1, P2=None,
                         alpha=0.05, n_iter=1000, samp_size=None,
                         verbose=False, **kwargs):
    """
    Does bootstrap for pseudo-r2. Gets significant speedups as we can precompute the 
    log-likelihood of all the sequences first, then just bootstrap over the sum.
    """
    if not P2: # This might be better handled by *args...
        P2 = P1
    if not samp_size:
        samp_size = L_D.shape[0]

    if verbose:
        iterator = tqdm.tqdm(range(n_iter))
    else:
        iterator = range(n_iter)

    Fstar_lo, Fstar_hi = np.floor(n_iter * np.array([alpha/2., 1-alpha/2.])).astype(int)

    # Pre-calculate log-likelihoods
    logLs_1 = all_log_lhood_fast(L_D, S1, P1, **kwargs)
    logLs_2 = all_log_lhood_fast(L_D, S2, P2, **kwargs)

    bootstrap_stats = np.zeros((n_iter))

    for i in iterator:
        resampled_idx = np.random.randint(L_D.shape[0], size=(samp_size,1))
        bootstrap_stats[i] = 1 - (np.sum(logLs_1[resampled_idx].squeeze()) /
                                  np.sum(logLs_2[resampled_idx].squeeze()))

    srt_bootstrap_stats = np.sort(bootstrap_stats.squeeze())

    ci = (srt_bootstrap_stats[Fstar_lo], srt_bootstrap_stats[Fstar_hi])
    return ci

def multi_bootstr_ci_pseudo_r2(L_D_list, S1, S2, P1, P2=None,
                               alpha=0.05, n_iter=1000,
                               verbose=False, **kwargs):
    """
    Does bootstrap for pseudo-r2. Gets significant speedups as we can
    precompute the log-likelihood of all the sequences first, then just
    bootstrap over the sum.

    Inputs:
    - L_D_list: list of arrays denoting errors for each strand in each sample
    - S1: array denoting the first signal
    - S2: array denoting the second signal
    - P1: array denoting the error rates at each site for each condition in S1
            or S2

    Output:
    - ci: a tuple containing the lower and upper pseudo-R2 bound
    """

    if not P2: # This might be better handled by *args...
        P2 = P1

    if verbose:
        iterator = tqdm.tqdm(range(n_iter))
    else:
        iterator = range(n_iter)

    Fstar_lo, Fstar_hi = np.floor(n_iter * np.array([alpha/2., 1-alpha/2.])).astype(int)

    # Pre-calculate log-likelihoods
    logLs_1 = [all_log_lhood_fast(L_D, S1, P1, **kwargs) for L_D in L_D_list]
    logLs_2 = [all_log_lhood_fast(L_D, S2, P2, **kwargs) for L_D in L_D_list]

    bootstrap_stats = np.zeros((n_iter))

    for i in iterator:
        boot_idx = [np.random.randint(L_D.shape[0], size=(L_D.shape[0], 1))
                    for L_D in L_D_list]

        boot_L1 = [np.sum(logL[bix].squeeze())
                   for logL, bix in zip(logLs_1, boot_idx)]
        boot_L2 = [np.sum(logL[bix].squeeze())
                   for logL, bix in zip(logLs_2, boot_idx)]

        bootstrap_stats[i] = 1 - (np.sum(boot_L1) / np.sum(boot_L2))

    srt_bootstrap_stats = np.sort(bootstrap_stats.squeeze())

    ci = (srt_bootstrap_stats[Fstar_lo], srt_bootstrap_stats[Fstar_hi])
    return ci

def model_softmax(L_D, S_list, P1, **kwargs):
    """
    Calculates softmax of models based on model likelihood
    """
    x = np.array([pop_log_lhood_fast(L_D, S, P1, **kwargs) for S in S_List])

    return np.exp(x) / np.sum(np.exp(x), axis=0)
# -*- coding: utf-8 -*-
#
# Copyright (C) 2013 Vinay Sajip.
# Licensed to the Python Software Foundation under a contributor agreement.
# See LICENSE.txt and CONTRIBUTORS.txt.
#
import hashlib
import logging
import os
import shutil
import subprocess
import tempfile
try:
    from threading import Thread
except ImportError:
    from dummy_threading import Thread

from . import DistlibException
from .compat import (HTTPBasicAuthHandler, Request, HTTPPasswordMgr,
                     urlparse, build_opener, string_types)
from .util import cached_property, zip_dir, ServerProxy

logger = logging.getLogger(__name__)

DEFAULT_INDEX = 'https://pypi.python.org/pypi'
DEFAULT_REALM = 'pypi'

class PackageIndex(object):
    """
    This class represents a package index compatible with PyPI, the Python
    Package Index.
    """

    boundary = b'----------ThIs_Is_tHe_distlib_index_bouNdaRY_$'

    def __init__(self, url=None):
        """
        Initialise an instance.

        :param url: The URL of the index. If not specified, the URL for PyPI is
                    used.
        """
        self.url = url or DEFAULT_INDEX
        self.read_configuration()
        scheme, netloc, path, params, query, frag = urlparse(self.url)
        if params or query or frag or scheme not in ('http', 'https'):
            raise DistlibException('invalid repository: %s' % self.url)
        self.password_handler = None
        self.ssl_verifier = None
        self.gpg = None
        self.gpg_home = None
        self.rpc_proxy = None
        with open(os.devnull, 'w') as sink:
            for s in ('gpg2', 'gpg'):
                try:
                    rc = subprocess.check_call([s, '--version'], stdout=sink,
                                               stderr=sink)
                    if rc == 0:
                        self.gpg = s
                        break
                except OSError:
                    pass

    def _get_pypirc_command(self):
        """
        Get the distutils command for interacting with PyPI configurations.
        :return: the command.
        """
        from distutils.core import Distribution
        from distutils.config import PyPIRCCommand
        d = Distribution()
        return PyPIRCCommand(d)

    def read_configuration(self):
        """
        Read the PyPI access configuration as supported by distutils, getting
        PyPI to do the acutal work. This populates ``username``, ``password``,
        ``realm`` and ``url`` attributes from the configuration.
        """
        # get distutils to do the work
        c = self._get_pypirc_command()
        c.repository = self.url
        cfg = c._read_pypirc()
        self.username = cfg.get('username')
        self.password = cfg.get('password')
        self.realm = cfg.get('realm', 'pypi')
        self.url = cfg.get('repository', self.url)

    def save_configuration(self):
        """
        Save the PyPI access configuration. You must have set ``username`` and
        ``password`` attributes before calling this method.

        Again, distutils is used to do the actual work.
        """
        self.check_credentials()
        # get distutils to do the work
        c = self._get_pypirc_command()
        c._store_pypirc(self.username, self.password)

    def check_credentials(self):
        """
        Check that ``username`` and ``password`` have been set, and raise an
        exception if not.
        """
        if self.username is None or self.password is None:
            raise DistlibException('username and password must be set')
        pm = HTTPPasswordMgr()
        _, netloc, _, _, _, _ = urlparse(self.url)
        pm.add_password(self.realm, netloc, self.username, self.password)
        self.password_handler = HTTPBasicAuthHandler(pm)

    def register(self, metadata):
        """
        Register a distribution on PyPI, using the provided metadata.

        :param metadata: A :class:`Metadata` instance defining at least a name
                         and version number for the distribution to be
                         registered.
        :return: The HTTP response received from PyPI upon submission of the
                request.
        """
        self.check_credentials()
        metadata.validate()
        d = metadata.todict()
        d[':action'] = 'verify'
        request = self.encode_request(d.items(), [])
        response = self.send_request(request)
        d[':action'] = 'submit'
        request = self.encode_request(d.items(), [])
        return self.send_request(request)

    def _reader(self, name, stream, outbuf):
        """
        Thread runner for reading lines of from a subprocess into a buffer.

        :param name: The logical name of the stream (used for logging only).
        :param stream: The stream to read from. This will typically a pipe
                       connected to the output stream of a subprocess.
        :param outbuf: The list to append the read lines to.
        """
        while True:
            s = stream.readline()
            if not s:
                break
            s = s.decode('utf-8').rstrip()
            outbuf.append(s)
            logger.debug('%s: %s' % (name, s))
        stream.close()

    def get_sign_command(self, filename, signer, sign_password):
        """
        Return a suitable command for signing a file.

        :param filename: The pathname to the file to be signed.
        :param signer: The identifier of the signer of the file.
        :param sign_password: The passphrase for the signer's
                              private key used for signing.
        :return: The signing command as a list suitable to be
                 passed to :class:`subprocess.Popen`.
        """
        cmd = [self.gpg, '--status-fd', '2', '--no-tty']
        if self.gpg_home:
            cmd.extend(['--homedir', self.gpg_home])
        if sign_password is not None:
            cmd.extend(['--batch', '--passphrase-fd', '0'])
        td = tempfile.mkdtemp()
        sf = os.path.join(td, os.path.basename(filename) + '.asc')
        cmd.extend(['--detach-sign', '--armor', '--local-user',
                    signer, '--output', sf, filename])
        logger.debug('invoking: %s', ' '.join(cmd))
        return cmd, sf

    def run_command(self, cmd, input_data=None):
        """
        Run a command in a child process , passing it any input data specified.

        :param cmd: The command to run.
        :param input_data: If specified, this must be a byte string containing
                           data to be sent to the child process.
        :return: A tuple consisting of the subprocess' exit code, a list of
                 lines read from the subprocess' ``stdout``, and a list of
                 lines read from the subprocess' ``stderr``.
        """
        kwargs = {
            'stdout': subprocess.PIPE,
            'stderr': subprocess.PIPE,
        }
        if input_data is not None:
            kwargs['stdin'] = subprocess.PIPE
        stdout = []
        stderr = []
        p = subprocess.Popen(cmd, **kwargs)
        # We don't use communicate() here because we may need to
        # get clever with interacting with the command
        t1 = Thread(target=self._reader, args=('stdout', p.stdout, stdout))
        t1.start()
        t2 = Thread(target=self._reader, args=('stderr', p.stderr, stderr))
        t2.start()
        if input_data is not None:
            p.stdin.write(input_data)
            p.stdin.close()

        p.wait()
        t1.join()
        t2.join()
        return p.returncode, stdout, stderr

    def sign_file(self, filename, signer, sign_password):
        """
        Sign a file.

        :param filename: The pathname to the file to be signed.
        :param signer: The identifier of the signer of the file.
        :param sign_password: The passphrase for the signer's
                              private key used for signing.
        :return: The absolute pathname of the file where the signature is
                 stored.
        """
        cmd, sig_file = self.get_sign_command(filename, signer, sign_password)
        rc, stdout, stderr = self.run_command(cmd,
                                              sign_password.encode('utf-8'))
        if rc != 0:
            raise DistlibException('sign command failed with error '
                                   'code %s' % rc)
        return sig_file

    def upload_file(self, metadata, filename, signer=None, sign_password=None,
                    filetype='sdist', pyversion='source'):
        """
        Upload a release file to the index.

        :param metadata: A :class:`Metadata` instance defining at least a name
                         and version number for the file to be uploaded.
        :param filename: The pathname of the file to be uploaded.
        :param signer: The identifier of the signer of the file.
        :param sign_password: The passphrase for the signer's
                              private key used for signing.
        :param filetype: The type of the file being uploaded. This is the
                        distutils command which produced that file, e.g.
                        ``sdist`` or ``bdist_wheel``.
        :param pyversion: The version of Python which the release relates
                          to. For code compatible with any Python, this would
                          be ``source``, otherwise it would be e.g. ``3.2``.
        :return: The HTTP response received from PyPI upon submission of the
                request.
        """
        self.check_credentials()
        if not os.path.exists(filename):
            raise DistlibException('not found: %s' % filename)
        metadata.validate()
        d = metadata.todict()
        sig_file = None
        if signer:
            if not self.gpg:
                logger.warning('no signing program available - not signed')
            else:
                sig_file = self.sign_file(filename, signer, sign_password)
        with open(filename, 'rb') as f:
            file_data = f.read()
        md5_digest = hashlib.md5(file_data).hexdigest()
        sha256_digest = hashlib.sha256(file_data).hexdigest()
        d.update({
            ':action': 'file_upload',
            'protcol_version': '1',
            'filetype': filetype,
            'pyversion': pyversion,
            'md5_digest': md5_digest,
            'sha256_digest': sha256_digest,
        })
        files = [('content', os.path.basename(filename), file_data)]
        if sig_file:
            with open(sig_file, 'rb') as f:
                sig_data = f.read()
            files.append(('gpg_signature', os.path.basename(sig_file),
                         sig_data))
            shutil.rmtree(os.path.dirname(sig_file))
        request = self.encode_request(d.items(), files)
        return self.send_request(request)

    def upload_documentation(self, metadata, doc_dir):
        """
        Upload documentation to the index.

        :param metadata: A :class:`Metadata` instance defining at least a name
                         and version number for the documentation to be
                         uploaded.
        :param doc_dir: The pathname of the directory which contains the
                        documentation. This should be the directory that
                        contains the ``index.html`` for the documentation.
        :return: The HTTP response received from PyPI upon submission of the
                request.
        """
        self.check_credentials()
        if not os.path.isdir(doc_dir):
            raise DistlibException('not a directory: %r' % doc_dir)
        fn = os.path.join(doc_dir, 'index.html')
        if not os.path.exists(fn):
            raise DistlibException('not found: %r' % fn)
        metadata.validate()
        name, version = metadata.name, metadata.version
        zip_data = zip_dir(doc_dir).getvalue()
        fields = [(':action', 'doc_upload'),
                  ('name', name), ('version', version)]
        files = [('content', name, zip_data)]
        request = self.encode_request(fields, files)
        return self.send_request(request)

    def get_verify_command(self, signature_filename, data_filename):
        """
        Return a suitable command for verifying a file.

        :param signature_filename: The pathname to the file containing the
                                   signature.
        :param data_filename: The pathname to the file containing the
                              signed data.
        :return: The verifying command as a list suitable to be
                 passed to :class:`subprocess.Popen`.
        """
        cmd = [self.gpg, '--status-fd', '2', '--no-tty']
        if self.gpg_home:
            cmd.extend(['--homedir', self.gpg_home])
        cmd.extend(['--verify', signature_filename, data_filename])
        logger.debug('invoking: %s', ' '.join(cmd))
        return cmd

    def verify_signature(self, signature_filename, data_filename):
        """
        Verify a signature for a file.

        :param signature_filename: The pathname to the file containing the
                                   signature.
        :param data_filename: The pathname to the file containing the
                              signed data.
        :return: True if the signature was verified, else False.
        """
        if not self.gpg:
            raise DistlibException('verification unavailable because gpg '
                                   'unavailable')
        cmd = self.get_verify_command(signature_filename, data_filename)
        rc, stdout, stderr = self.run_command(cmd)
        if rc not in (0, 1):
            raise DistlibException('verify command failed with error '
                             'code %s' % rc)
        return rc == 0

    def download_file(self, url, destfile, digest=None, reporthook=None):
        """
        This is a convenience method for downloading a file from an URL.
        Normally, this will be a file from the index, though currently
        no check is made for this (i.e. a file can be downloaded from
        anywhere).

        The method is just like the :func:`urlretrieve` function in the
        standard library, except that it allows digest computation to be
        done during download and checking that the downloaded data
        matched any expected value.

        :param url: The URL of the file to be downloaded (assumed to be
                    available via an HTTP GET request).
        :param destfile: The pathname where the downloaded file is to be
                         saved.
        :param digest: If specified, this must be a (hasher, value)
                       tuple, where hasher is the algorithm used (e.g.
                       ``'md5'``) and ``value`` is the expected value.
        :param reporthook: The same as for :func:`urlretrieve` in the
                           standard library.
        """
        if digest is None:
            digester = None
            logger.debug('No digest specified')
        else:
            if isinstance(digest, (list, tuple)):
                hasher, digest = digest
            else:
                hasher = 'md5'
            digester = getattr(hashlib, hasher)()
            logger.debug('Digest specified: %s' % digest)
        # The following code is equivalent to urlretrieve.
        # We need to do it this way so that we can compute the
        # digest of the file as we go.
        with open(destfile, 'wb') as dfp:
            # addinfourl is not a context manager on 2.x
            # so we have to use try/finally
            sfp = self.send_request(Request(url))
            try:
                headers = sfp.info()
                blocksize = 8192
                size = -1
                read = 0
                blocknum = 0
                if "content-length" in headers:
                    size = int(headers["Content-Length"])
                if reporthook:
                    reporthook(blocknum, blocksize, size)
                while True:
                    block = sfp.read(blocksize)
                    if not block:
                        break
                    read += len(block)
                    dfp.write(block)
                    if digester:
                        digester.update(block)
                    blocknum += 1
                    if reporthook:
                        reporthook(blocknum, blocksize, size)
            finally:
                sfp.close()

        # check that we got the whole file, if we can
        if size >= 0 and read < size:
            raise DistlibException(
                'retrieval incomplete: got only %d out of %d bytes'
                % (read, size))
        # if we have a digest, it must match.
        if digester:
            actual = digester.hexdigest()
            if digest != actual:
                raise DistlibException('%s digest mismatch for %s: expected '
                                       '%s, got %s' % (hasher, destfile,
                                                       digest, actual))
            logger.debug('Digest verified: %s', digest)

    def send_request(self, req):
        """
        Send a standard library :class:`Request` to PyPI and return its
        response.

        :param req: The request to send.
        :return: The HTTP response from PyPI (a standard library HTTPResponse).
        """
        handlers = []
        if self.password_handler:
            handlers.append(self.password_handler)
        if self.ssl_verifier:
            handlers.append(self.ssl_verifier)
        opener = build_opener(*handlers)
        return opener.open(req)

    def encode_request(self, fields, files):
        """
        Encode fields and files for posting to an HTTP server.

        :param fields: The fields to send as a list of (fieldname, value)
                       tuples.
        :param files: The files to send as a list of (fieldname, filename,
                      file_bytes) tuple.
        """
        # Adapted from packaging, which in turn was adapted from
        # http://code.activestate.com/recipes/146306

        parts = []
        boundary = self.boundary
        for k, values in fields:
            if not isinstance(values, (list, tuple)):
                values = [values]

            for v in values:
                parts.extend((
                    b'--' + boundary,
                    ('Content-Disposition: form-data; name="%s"' %
                     k).encode('utf-8'),
                    b'',
                    v.encode('utf-8')))
        for key, filename, value in files:
            parts.extend((
                b'--' + boundary,
                ('Content-Disposition: form-data; name="%s"; filename="%s"' %
                 (key, filename)).encode('utf-8'),
                b'',
                value))

        parts.extend((b'--' + boundary + b'--', b''))

        body = b'\r\n'.join(parts)
        ct = b'multipart/form-data; boundary=' + boundary
        headers = {
            'Content-type': ct,
            'Content-length': str(len(body))
        }
        return Request(self.url, body, headers)

    def search(self, terms, operator=None):
        if isinstance(terms, string_types):
            terms = {'name': terms}
        if self.rpc_proxy is None:
            self.rpc_proxy = ServerProxy(self.url, timeout=3.0)
        return self.rpc_proxy.search(terms, operator or 'and')

#!/usr/bin/env python2
# Copyright (c) 2014-2015 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.

from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *


class ZapWalletTXesTest (BitcoinTestFramework):

    def setup_chain(self):
        print("Initializing test directory "+self.options.tmpdir)
        initialize_chain_clean(self.options.tmpdir, 3)

    def setup_network(self, split=False):
        self.nodes = start_nodes(3, self.options.tmpdir)
        connect_nodes_bi(self.nodes,0,1)
        connect_nodes_bi(self.nodes,1,2)
        connect_nodes_bi(self.nodes,0,2)
        self.is_network_split=False
        self.sync_all()

    def run_test (self):
        print "Mining blocks..."
        self.nodes[0].generate(1)
        self.sync_all()
        self.nodes[1].generate(101)
        self.sync_all()
        
        assert_equal(self.nodes[0].getbalance(), 500)
        
        txid0 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
        txid1 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
        self.sync_all()
        self.nodes[0].generate(1)
        self.sync_all()
        
        txid2 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 11)
        txid3 = self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10)
        
        tx0 = self.nodes[0].gettransaction(txid0)
        assert_equal(tx0['txid'], txid0) #tx0 must be available (confirmed)
        
        tx1 = self.nodes[0].gettransaction(txid1)
        assert_equal(tx1['txid'], txid1) #tx1 must be available (confirmed)
        
        tx2 = self.nodes[0].gettransaction(txid2)
        assert_equal(tx2['txid'], txid2) #tx2 must be available (unconfirmed)
        
        tx3 = self.nodes[0].gettransaction(txid3)
        assert_equal(tx3['txid'], txid3) #tx3 must be available (unconfirmed)
        
        #restart bitcoind
        self.nodes[0].stop()
        bitcoind_processes[0].wait()
        self.nodes[0] = start_node(0,self.options.tmpdir)
        
        tx3 = self.nodes[0].gettransaction(txid3)
        assert_equal(tx3['txid'], txid3) #tx must be available (unconfirmed)
        
        self.nodes[0].stop()
        bitcoind_processes[0].wait()
        
        #restart bitcoind with zapwallettxes
        self.nodes[0] = start_node(0,self.options.tmpdir, ["-zapwallettxes=1"])
        
        assert_raises(JSONRPCException, self.nodes[0].gettransaction, [txid3])
        #there must be a expection because the unconfirmed wallettx0 must be gone by now

        tx0 = self.nodes[0].gettransaction(txid0)
        assert_equal(tx0['txid'], txid0) #tx0 (confirmed) must still be available because it was confirmed


if __name__ == '__main__':
    ZapWalletTXesTest ().main ()

#-*- coding: utf-8 -*-

###########################################################################
##                                                                       ##
## Copyrights Frederic Rodrigo 2012                                      ##
##                                                                       ##
## This program is free software: you can redistribute it and/or modify  ##
## it under the terms of the GNU General Public License as published by  ##
## the Free Software Foundation, either version 3 of the License, or     ##
## (at your option) any later version.                                   ##
##                                                                       ##
## This program is distributed in the hope that it will be useful,       ##
## but WITHOUT ANY WARRANTY; without even the implied warranty of        ##
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         ##
## GNU General Public License for more details.                          ##
##                                                                       ##
## You should have received a copy of the GNU General Public License     ##
## along with this program.  If not, see <http://www.gnu.org/licenses/>. ##
##                                                                       ##
###########################################################################

from modules.OsmoseTranslation import T_
from plugins.Plugin import Plugin
import sqlite3 as lite


class Wiki(Plugin):

    def init(self, logger):
        Plugin.init(self, logger)
        self.errors[3140] = self.def_class(item = 3140, level = 2, tags = ['tag'],
            title = T_('Object taggin type'))

        # Taginfo wiki extract database
        # http://taginfo.openstreetmap.org/download/taginfo-wiki.db.bz2
        con = lite.connect('taginfo-wiki.db')

        with con:
            cur = con.cursor()
            cur.execute("select tag, on_node, on_way, on_area, on_relation from wikipages where lang='en' and (on_node or on_way or on_area or on_relation)")
            rows = cur.fetchall()

            self.tag_supported = set()
            self.tag_node = set()
            self.tag_way = set()
            self.tag_area = set()
            self.tag_relation = set()
            for row in rows:
                if not "=" in row[0]:
                    self.tag_supported.add(row[0])
                    if row[1]:
                        self.tag_node.add(row[0])
                    if row[2]:
                        self.tag_way.add(row[0])
                    if row[3]:
                        self.tag_area.add(row[0])
                    if row[4]:
                        self.tag_relation.add(row[0])

    def node(self, data, tags):
        ret = []
        for tag in tags:
            if tag in self.tag_supported and tag not in self.tag_node:
                ret.append((3140, 1, {"fr": "Le tag \"{0}\" ne s'applique pas aux nœuds".format(tag), "en": "Tag \"{0}\" not for nodes".format(tag)}))
        return ret

    def way(self, data, tags, nds):
        ret = []
        for tag in tags:
            if tag in self.tag_supported and tag not in self.tag_way and tag not in self.tag_area:
                ret.append((3140, 2, {"fr": "Le tag \"{0}\" ne s'applique pas aux ways".format(tag), "en": "Tag \"{0}\" not for ways".format(tag)}))
        return ret

    def relation(self, data, tags, members):
        ret = []
        for tag in tags:
            if tag in self.tag_supported and tag not in self.tag_relation:
                ret.append((3140, 3, {"fr": "Le tag \"{0}\" ne s'applique pas aux relations".format(tag), "en": "Tag \"{0}\" not for relations".format(tag)}))
        return ret


if __name__ == "__main__":
    a = Wiki(None)
    a.init(None)
    for d in [u"fsdkfjdklsfkleqnhkflerklg", u"sport"]:
        if a.node(None, {d:"a"}):
            print("fail: {0}".format(d))
    for d in [u"building"]:
        if not a.node(None, {d:"a"}):
            print("nofail: {0}".format(d))

import json

from allauth.socialaccount.providers.oauth.client import OAuth
from allauth.socialaccount.providers.oauth.views import (OAuthAdapter,
                                                         OAuthLoginView,
                                                         OAuthCallbackView)
from .provider import VimeoProvider


class VimeoAPI(OAuth):
    url = 'http://vimeo.com/api/rest/v2?method=vimeo.people.getInfo'

    def get_user_info(self):
        url = self.url
        data = json.loads(self.query(url, params=dict(format='json')))
        return data['person']


class VimeoOAuthAdapter(OAuthAdapter):
    provider_id = VimeoProvider.id
    request_token_url = 'https://vimeo.com/oauth/request_token'
    access_token_url = 'https://vimeo.com/oauth/access_token'
    authorize_url = 'https://vimeo.com/oauth/authorize'

    def complete_login(self, request, app, token, response):
        client = VimeoAPI(request, app.client_id, app.secret,
                          self.request_token_url)
        extra_data = client.get_user_info()
        return self.get_provider().sociallogin_from_response(request,
                                                             extra_data)


oauth_login = OAuthLoginView.adapter_view(VimeoOAuthAdapter)
oauth_callback = OAuthCallbackView.adapter_view(VimeoOAuthAdapter)

# Copyright (C) 2014 LiuLang <gsushzhsosgsu@gmail.com>
# Use of this source code is governed by GPLv3 license that can be found
# in http://www.gnu.org/licenses/gpl-3.0.html

import json
import multiprocessing
import os
from queue import Queue
import re
import threading
import time
import traceback

from urllib import request
from gi.repository import GLib
from gi.repository import GObject

from bcloud.const import State, DownloadMode
from bcloud import net
from bcloud import pcs
from bcloud import util
from bcloud.log import logger

CHUNK_SIZE = 131072       # 128K
RETRIES = 3               # 连接失败时的重试次数
DOWNLOAD_RETRIES = 10     # 下载线程的重试次数
THRESHOLD_TO_FLUSH = 500  # 磁盘写入数据次数超过这个值时, 就进行一次同步.
SMALL_FILE_SIZE = 1048576 # 1M, 下载小文件时用单线程下载

(NAME_COL, PATH_COL, FSID_COL, SIZE_COL, CURRSIZE_COL, LINK_COL,
    ISDIR_COL, SAVENAME_COL, SAVEDIR_COL, STATE_COL, STATENAME_COL,
    HUMANSIZE_COL, PERCENT_COL) = list(range(13))

BATCH_FINISISHED, BATCH_ERROR = -1, -2

def get_tmp_filepath(dir_name, save_name):
    '''返回最终路径名及临时路径名'''
    filepath = os.path.join(dir_name, save_name)
    return filepath, filepath + '.part', filepath + '.bcloud-stat'


class DownloadBatch(threading.Thread):

    def __init__(self, id_, queue, url, lock, start_size, end_size, fh,
                 timeout):
        super().__init__()
        self.id_ = id_
        self.queue = queue
        self.url = url
        self.lock = lock
        self.start_size = start_size
        self.end_size = end_size
        self.fh = fh
        self.timeout = timeout
        self.stop_flag = False

    def run(self):
        self.download()

    def stop(self):
        self.stop_flag = True

    def get_req(self, start_size, end_size):
        '''打开socket'''
        logger.debug('DownloadBatch.get_req: %s, %s' % (start_size, end_size))
        opener = request.build_opener()
        content_range = 'bytes={0}-{1}'.format(start_size, end_size)
        opener.addheaders = [('Range', content_range)]
        for i in range(RETRIES):
            try:
                return opener.open(self.url, timeout=self.timeout)
            except OSError:
                logger.error(traceback.format_exc())
        else:
            return None

    def download(self):
        offset = self.start_size
        req = self.get_req(offset, self.end_size)
        if not req:
            self.queue.put((self.id_, BATCH_ERROR), block=False)
            return

        while not self.stop_flag:
            for i in range(DOWNLOAD_RETRIES):
                if not req:
                    req = self.get_req(offset, self.end_size)
                    logger.debug('DownloadBatch.download: socket reconnected')
                try:
                    block = req.read(CHUNK_SIZE)
                    if block:
                        break
                except (OSError, AttributeError):
                    logger.error(traceback.format_exc())
                    req = None
            else:
                logger.error('DownloadBatch, block is empty: %s, %s, %s, %s' %
                             (offset, self.start_size, self.end_size, block))
                self.queue.put((self.id_, BATCH_ERROR), block=False)
                return

            with self.lock:
                if self.fh.closed:
                    return
                self.fh.seek(offset)
                self.fh.write(block)
                self.queue.put((self.id_, len(block)), block=False)
            offset = offset + len(block)
            # 下载完成
            if offset >= self.end_size:
                self.queue.put((self.id_, BATCH_FINISISHED), block=False)
                return


class Downloader(threading.Thread, GObject.GObject):
    '''管理每个下载任务, 使用了多线程下载.

    当程序退出时, 下载线程会保留现场, 以后可以继续下载.
    断点续传功能基于HTTP/1.1 的Range, 百度网盘对它有很好的支持.
    '''

    __gsignals__ = {
        'started': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (str, )),
        'received': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE,
                     (str, GObject.TYPE_INT64, GObject.TYPE_INT64)),
        'downloaded': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (str, )),
        # FSID, tmp-filepath
        'disk-error': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (str, str)),
        'network-error': (GObject.SIGNAL_RUN_LAST, GObject.TYPE_NONE, (str, )),
    }

    def __init__(self, parent, row):
        threading.Thread.__init__(self)
        self.daemon = True
        GObject.GObject.__init__(self)

        self.cookie = parent.app.cookie
        self.tokens = parent.app.tokens
        self.default_threads = int(parent.app.profile['download-segments'])
        self.timeout = int(parent.app.profile['download-timeout'])
        self.download_mode = parent.app.profile['download-mode']
        self.row = row[:]

    def download(self):
        row = self.row
        if not os.path.exists(row[SAVEDIR_COL]):
            os.makedirs(row[SAVEDIR_COL], exist_ok=True)
        filepath, tmp_filepath, conf_filepath = get_tmp_filepath(
                row[SAVEDIR_COL], row[SAVENAME_COL]) 

        if os.path.exists(filepath):
            if self.download_mode == DownloadMode.IGNORE:
                self.emit('downloaded', row[FSID_COL])
                logger.debug('File exists, ignored!')
                return
            elif self.download_mode == DownloadMode.NEWCOPY:
                name, ext = os.path.splitext(filepath)
                filepath = '{0}_{1}{2}'.format(name, util.curr_time(), ext)

        url = pcs.get_download_link(self.cookie, self.tokens, row[PATH_COL])
        if not url:
            row[STATE_COL] = State.ERROR
            self.emit('network-error', row[FSID_COL])
            logger.warn('Failed to get url to download')
            return

        if os.path.exists(conf_filepath) and os.path.exists(tmp_filepath):
            with open(conf_filepath) as conf_fh:
                status = json.load(conf_fh)
            threads = len(status)
            file_exists = True
            fh = open(tmp_filepath, 'rb+')
            fh.seek(0)
        else:
            req = net.urlopen_simple(url)
            if not req:
                logger.warn('Failed to get url to download')
                self.emit('network-error', row[FSID_COL])
                return
            content_length = req.getheader('Content-Length')
            # Fixed: baiduPCS using non iso-8859-1 codec in http headers
            if not content_length:
                match = re.search('\sContent-Length:\s*(\d+)', str(req.headers))
                if not match:
                    logger.warn('Failed to get url to download')
                    self.emit('network-error', row[FSID_COL])
                    return
                content_length = match.group(1)
            size = int(content_length)
            if size == 0:
                open(filepath, 'a').close()
                self.emit('downloaded', row[FSID_COL])
                return
            elif size <= SMALL_FILE_SIZE:
                threads = 1
            else:
                threads = self.default_threads
            average_size, pad_size = divmod(size, threads)
            file_exists = False
            status = []
            fh = open(tmp_filepath, 'wb')
            try:
                fh.truncate(size)
            except (OSError, IOError):
                e = truncate.format_exc()
                logger.error(e)
                self.emit('disk-error', row[FSID_COL], tmp_filepath)
                return

        # task list
        tasks = []
        # message queue
        queue = Queue()
        # threads lock
        lock = threading.RLock()
        for id_ in range(threads):
            if file_exists:
                start_size, end_size, received = status[id_]
                if start_size + received >= end_size:
                    # part of file has been downloaded
                    continue
                start_size += received
            else:
                start_size = id_ * average_size
                end_size = start_size + average_size - 1
                if id_ == threads - 1:
                    end_size = end_size + pad_size + 1
                status.append([start_size, end_size, 0])
            task = DownloadBatch(id_, queue, url, lock, start_size, end_size,
                                 fh, self.timeout)
            tasks.append(task)

        for task in tasks:
            task.start()

        try:
            conf_count = 0
            done = 0
            self.emit('started', row[FSID_COL])
            while row[STATE_COL] == State.DOWNLOADING:
                id_, received = queue.get()
                # FINISHED
                if received == BATCH_FINISISHED:
                    done += 1
                    if done == len(tasks):
                        row[STATE_COL] = State.FINISHED
                        break
                    else:
                        continue
                # error occurs
                elif received == BATCH_ERROR:
                    row[STATE_COL] = State.ERROR
                    break
                status[id_][2] += received
                conf_count += 1
                # flush data and status to disk
                if conf_count > THRESHOLD_TO_FLUSH:
                    with lock:
                        if not fh.closed:
                            fh.flush()
                    with open(conf_filepath, 'w') as fh:
                        json.dump(status, fh)
                    conf_count = 0
                received_total = sum(t[2] for t in status)
                self.emit('received', row[FSID_COL], received, received_total)
        except Exception:
            logger.error(traceback.format_exc())
            row[STATE_COL] = State.ERROR
        with lock:
            if not fh.closed:
                fh.close()
        for task in tasks:
            if task.isAlive():
                task.stop()
        with open(conf_filepath, 'w') as fh:
            json.dump(status, fh)

        if row[STATE_COL] == State.CANCELED:
            os.remove(tmp_filepath)
            if os.path.exists(conf_filepath):
                os.remove(conf_filepath)
        elif row[STATE_COL] == State.ERROR:
            self.emit('network-error', row[FSID_COL])
        elif row[STATE_COL] == State.FINISHED:
            self.emit('downloaded', row[FSID_COL])
            os.rename(tmp_filepath, filepath)
            if os.path.exists(conf_filepath):
                os.remove(conf_filepath)

    def destroy(self):
        '''自毁'''
        self.pause()

    def run(self):
        '''实现了Thread的方法, 线程启动入口'''
        self.download()

    def pause(self):
        '''暂停下载任务'''
        self.row[STATE_COL] = State.PAUSED

    def stop(self):
        '''停止下载, 并删除之前下载的片段'''
        self.row[STATE_COL] = State.CANCELED

GObject.type_register(Downloader)

from bika.lims import enum
from bika.lims import PMF
from bika.lims.browser import ulocalized_time
from bika.lims.interfaces import IJSONReadExtender
from bika.lims.jsonapi import get_include_fields
from bika.lims.utils import changeWorkflowState
from bika.lims.utils import t
from Products.CMFCore.interfaces import IContentish
from Products.CMFCore.utils import getToolByName
from Products.CMFCore.WorkflowCore import WorkflowException
from Products.CMFPlone.interfaces import IWorkflowChain
from Products.CMFPlone.workflow import ToolWorkflowChain
from zope.component import adapts
from zope.interface import implementer
from zope.interface import implements
from zope.interface import Interface


def skip(instance, action, peek=False, unskip=False):
    """Returns True if the transition is to be SKIPPED

        peek - True just checks the value, does not set.
        unskip - remove skip key (for manual overrides).

    called with only (instance, action_id), this will set the request variable preventing the
    cascade's from re-transitioning the object and return None.
    """

    uid = callable(instance.UID) and instance.UID() or instance.UID
    skipkey = "%s_%s" % (uid, action)
    if 'workflow_skiplist' not in instance.REQUEST:
        if not peek and not unskip:
            instance.REQUEST['workflow_skiplist'] = [skipkey, ]
    else:
        if skipkey in instance.REQUEST['workflow_skiplist']:
            if unskip:
                instance.REQUEST['workflow_skiplist'].remove(skipkey)
            else:
                return True
        else:
            if not peek and not unskip:
                instance.REQUEST["workflow_skiplist"].append(skipkey)


def doActionFor(instance, action_id):
    actionperformed = False
    message = ''
    workflow = getToolByName(instance, "portal_workflow")
    if not skip(instance, action_id, peek=True):
        try:
            workflow.doActionFor(instance, action_id)
            actionperformed = True
        except WorkflowException as e:
            message = str(e)
            pass
    return actionperformed, message


def BeforeTransitionEventHandler(instance, event):
    """This will run the workflow_before_* on any
    content type that has one.
    """
    # creation doesn't have a 'transition'
    if not event.transition:
        return
    key = 'workflow_before_' + event.transition.id
    method = getattr(instance, key, False)
    if method:
        method()


def AfterTransitionEventHandler(instance, event):
    """This will run the workflow_script_* on any
    content type that has one.
    """
    # creation doesn't have a 'transition'
    if not event.transition:
        return
    key = 'workflow_script_' + event.transition.id
    method = getattr(instance, key, False)
    if method:
        method()


def get_workflow_actions(obj):
    """ Compile a list of possible workflow transitions for this object
    """

    def translate(id):
        return t(PMF(id + "_transition_title"))

    workflow = getToolByName(obj, 'portal_workflow')
    actions = [{"id": it["id"],
                "title": translate(it["id"])}
               for it in workflow.getTransitionsFor(obj)]

    return actions


def isBasicTransitionAllowed(context, permission=None):
    """Most transition guards need to check the same conditions:

    - Is the object active (cancelled or inactive objects can't transition)
    - Has the user a certain permission, required for transition.  This should
    normally be set in the guard_permission in workflow definition.

    """
    workflow = getToolByName(context, "portal_workflow")
    mtool = getToolByName(context, "portal_membership")
    if workflow.getInfoFor(context, "cancellation_state", "") == "cancelled" \
            or workflow.getInfoFor(context, "inactive_state", "") == "inactive" \
            or (permission and mtool.checkPermission(permission, context)):
        return False
    return True


def getCurrentState(obj, stateflowid):
    """ The current state of the object for the state flow id specified
        Return empty if there's no workflow state for the object and flow id
    """
    wf = getToolByName(obj, 'portal_workflow')
    return wf.getInfoFor(obj, stateflowid, '')

def getTransitionDate(obj, action_id):
    workflow = getToolByName(obj, 'portal_workflow')
    review_history = list(workflow.getInfoFor(obj, 'review_history'))
    # invert the list, so we always see the most recent matching event
    review_history.reverse()
    for event in review_history:
        if event['action'] == action_id:
            value = ulocalized_time(event['time'], long_format=True,
                                    time_only=False, context=obj)
            return value
    return None



# Enumeration of the available status flows
StateFlow = enum(review='review_state',
                 inactive='inactive_state',
                 cancellation='cancellation_state')

# Enumeration of the different available states from the inactive flow
InactiveState = enum(active='active')

# Enumeration of the different states can have a batch
BatchState = enum(open='open',
                  closed='closed',
                  cancelled='cancelled')

BatchTransitions = enum(open='open',
                        close='close')

CancellationState = enum(active='active',
                         cancelled='cancelled')

CancellationTransitions = enum(cancel='cancel',
                               reinstate='reinstate')


class JSONReadExtender(object):

    """- Adds the list of possible transitions to each object, if 'transitions'
    is specified in the include_fields.
    """

    implements(IJSONReadExtender)

    def __init__(self, context):
        self.context = context

    def __call__(self, request, data):
        include_fields = get_include_fields(request)
        if not include_fields or "transitions" in include_fields:
            data['transitions'] = get_workflow_actions(self.context)



@implementer(IWorkflowChain)
def SamplePrepWorkflowChain(ob, wftool):
    """Responsible for inserting the optional sampling preparation workflow
    into the workflow chain for objects with ISamplePrepWorkflow

    This is only done if the object is in 'sample_prep' state in the
    primary workflow (review_state).
    """
    # use catalog to retrieve review_state: getInfoFor causes recursion loop
    chain = list(ToolWorkflowChain(ob, wftool))
    bc = getToolByName(ob, 'bika_catalog')
    proxies = bc(UID=ob.UID())
    if not proxies or proxies[0].review_state != 'sample_prep':
        return chain
    sampleprep_workflow = ob.getPreparationWorkflow()
    if sampleprep_workflow:
        chain.append(sampleprep_workflow)
    return tuple(chain)


def SamplePrepTransitionEventHandler(instance, event):
    """Sample preparation is considered complete when the sampleprep workflow
    reaches a state which has no exit transitions.

    If the stateis state's ID is the same as any AnalysisRequest primary
    workflow ID, then the AnalysisRequest will be sent directly to that state.

    If the final state's ID is not found in the AR workflow, the AR will be
    transitioned to 'sample_received'.
    """
    if not event.transition:
        # creation doesn't have a 'transition'
        return

    if not event.new_state.getTransitions():
        # Is this the final (No exit transitions) state?
        wftool = getToolByName(instance, 'portal_workflow')
        primary_wf_name = list(ToolWorkflowChain(instance, wftool))[0]
        primary_wf = wftool.getWorkflowById(primary_wf_name)
        primary_wf_states = primary_wf.states.keys()
        if event.new_state.id in primary_wf_states:
            # final state name matches review_state in primary workflow:
            dst_state = event.new_state.id
        else:
            # fallback state:
            dst_state = 'sample_received'
        changeWorkflowState(instance, primary_wf_name, dst_state)

#!/usr/bin/env python
"""
Take the test runner log output from the stdin, looking for
the magic line nose runner prints when the test run was successful.

In an ideal world, this should be done directly in runtests.py  using the
nose API, some failure modes are fooling nose to terminate the python process
with zero exit code, see, eg, https://github.com/scipy/scipy/issues/4736
In short, lapack's xerbla can terminate the process with a fortran level STOP
command, which (i) aborts the py process so that runtests.py does not finish,
and (ii) the exit code is implementation-defined.

Also check that the number of tests run is larger than some baseline number
(taken from the state of the master branch at some random point in time.)
This probably could/should be made less brittle.

"""
from __future__ import print_function

import sys
import re


if __name__ == "__main__":
    # full or fast test suite?
    try:
        testmode = sys.argv[1]
        if testmode not in ('fast', 'full'):
            raise IndexError
    except IndexError:
        raise ValueError("Usage: validate.py {full|fast} < logfile.")

    # fetch the expected number of tests
    # these numbers are for 6abad09
    # XXX: this should probably track the commit hash or commit date
    expected_size = {'full': 19055,
                     'fast': 17738}

    # read in the log, parse for the nose printout:
    # Ran NNN tests in MMMs
    # <blank line>
    # OK (SKIP=X, KNOWNFAIL=Y) or FAILED (errors=X, failures=Y)
    r = re.compile("Ran (?P<num_tests>\d+) tests in (?P<time>\d+\S+)")

    status, found_it = False, False
    while True:
        line = sys.stdin.readline()
        if not line:
            break
        m = r.search(line)
        if m:
            found_it = True
            sys.stdin.readline()   # skip the next one
            line = sys.stdin.readline()
            if "OK" in line:
                status = True
            break

    if found_it:
        # did it errored or failed?
        if not status:
            print("*** Looks like some tests failed.")
            sys.exit(-1)

        # now check that the number of tests run is reasonable
        expected = expected_size[testmode]
        actual = int(m.group('num_tests'))
        if actual < expected:
            print("*** Too few tests: expected %s, run %s" % (expected, actual))
            sys.exit(1)
        else:
            sys.exit(0)
    else:
        print('*** Test runner validation errored: did the run really finish?')
        sys.exit(-1)

#!/usr/bin/env python

import sys
def gen_test(n):
    print "CREATE TABLE t (a BINARY(%d));" % (n)
    for v in [ 0, 1, 2, 4, 8, 16, 32, 64, 126, 127 ]:
        print "INSERT INTO t VALUES (%d);" % (v)
    for i in range(2,256):
        if i < n:
            print "--replace_regex /MariaDB/XYZ/ /MySQL/XYZ/"
            print "--error ER_UNSUPPORTED_EXTENSION"
        else:
            print "CREATE TABLE ti LIKE t;"
            print "ALTER TABLE ti ENGINE=myisam;"
            print "INSERT INTO ti SELECT * FROM t;"
            print "ALTER TABLE ti CHANGE COLUMN a a BINARY(%d);" % (i)
        print "ALTER TABLE t CHANGE COLUMN a a BINARY(%d);" % (i)
        if i >= n:
            print "let $diff_tables=test.t, test.ti;"
            print "source include/diff_tables.inc;"
            print "DROP TABLE ti;"
    print "DROP TABLE t;"

def main():
    print "# this test is generated by change_bin.py"
    print "# test binary expansion is hot"
    print "--disable_warnings"
    print "DROP TABLE IF EXISTS t,ti;"
    print "--enable_warnings"
    print "SET SESSION DEFAULT_STORAGE_ENGINE=\"TokuDB\";"
    print "SET SESSION TOKUDB_DISABLE_SLOW_ALTER=1;"
    # all n takes too long to run, so here is a subset of tests
    for n in [ 1, 2, 3, 4, 5, 6, 7, 8, 16, 31, 32, 63, 64, 127, 128, 254, 255 ]:
        gen_test(n)
    return 0
sys.exit(main())

# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import imp
import os.path
import sys
import unittest

def _GetDirAbove(dirname):
  """Returns the directory "above" this file containing |dirname| (which must
  also be "above" this file)."""
  path = os.path.abspath(__file__)
  while True:
    path, tail = os.path.split(path)
    assert tail
    if tail == dirname:
      return path

try:
  imp.find_module("mojom")
except ImportError:
  sys.path.append(os.path.join(_GetDirAbove("pylib"), "pylib"))
from mojom.generate import module as mojom


class ModuleTest(unittest.TestCase):

  def testNonInterfaceAsInterfaceRequest(self):
    """Tests that a non-interface cannot be used for interface requests."""
    module = mojom.Module('test_module', 'test_namespace')
    struct = mojom.Struct('TestStruct', module=module)
    with self.assertRaises(Exception) as e:
      mojom.InterfaceRequest(struct)
    self.assertEquals(
        e.exception.__str__(),
        'Interface request requires \'x:TestStruct\' to be an interface.')

#!/usr/bin/python
#
# Copyright 2012 The Native Client Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# Copyright 2012, Google Inc.
#

"""
Produces a table from the in-memory representation.  Useful for storing the
optimized table for later use.
"""

from __future__ import print_function

import dgen_opt

def dump_tables(tables, out):
  """Dumps the given tables into a text file.

    Args:
        tables: list of Table objects to process.
        out: an output stream.
    """
  if len(tables) == 0:
    raise Exception('No tables provided.')

  _generate_header(out)
  for t in tables:
    _generate_table(t, out)


def _generate_header(out):
  # TODO do we need a big ridiculous license banner in generated code?
  out.write('# DO NOT EDIT: GENERATED CODE\n')


def _generate_table(t, out):
  rows = dgen_opt.optimize_rows(t.rows)
  print('Table %s: %d rows minimized to %d.' % (t.name, len(t.rows), len(rows)))

  out.write('\n')
  out.write('-- %s (%s)\n' % (t.name, t.citation))
  num_cols = len(rows[0].patterns)
  headers = ['pat%- 31s' % (str(n) + '(31:0)') for n in range(0, num_cols)]
  out.write(''.join(headers))
  out.write('\n')
  for row in rows:
    out.write(''.join(['%- 34s' % p for p in row.patterns]))
    out.write(row.action)
    if row.arch:
      out.write('(%s)' % row.arch)
    out.write('\n')

# -*- coding: utf-8 -*-
#-----------------------------------------------------------
#
# fTools
# Copyright (C) 2008-2011  Carson Farmer
# EMAIL: carson.farmer (at) gmail.com
# WEB  : http://www.ftools.ca/fTools.html
#
# A collection of data management and analysis tools for vector data
#
#-----------------------------------------------------------
#
# licensed under the terms of GNU GPL 2
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
#---------------------------------------------------------------------

from PyQt4.QtCore import *
from PyQt4.QtGui import *

from qgis.core import *
import ftools_utils
from ui_frmRandom import Ui_Dialog
import random
class Dialog(QDialog, Ui_Dialog):
    def __init__(self, iface):
        QDialog.__init__(self, iface.mainWindow())
        self.iface = iface
        # Set up the user interface from Designer.
        self.setupUi(self)
        QObject.connect(self.inShape, SIGNAL("currentIndexChanged(QString)"), self.changed)
        self.setWindowTitle(self.tr("Random selection"))
        # populate layer list
        self.progressBar.setValue(0)
        mapCanvas = self.iface.mapCanvas()
        self.buttonOk = self.buttonBox_2.button( QDialogButtonBox.Ok )
        layers = ftools_utils.getLayerNames([QGis.Point, QGis.Line, QGis.Polygon])
        self.inShape.addItems(layers)

    def changed(self, inputLayer):
        changedLayer = ftools_utils.getVectorLayerByName(inputLayer)
        changedProvider = changedLayer.dataProvider()
        upperVal = changedProvider.featureCount()
        self.spnNumber.setMaximum(upperVal)

    def accept(self):
        self.buttonOk.setEnabled( False )
        if self.inShape.currentText() == "":
            QMessageBox.information(self, self.tr("Random Selection Tool"), self.tr("No input shapefile specified"))
        else:
            self.progressBar.setValue(10)
            inName = self.inShape.currentText()
            self.progressBar.setValue(20)
            layer = ftools_utils.getVectorLayerByName(inName)
            self.progressBar.setValue(30)
            if self.rdoNumber.isChecked():
                value = self.spnNumber.value()
                self.progressBar.setValue(60)
            else:
                value = self.spnPercent.value()
                self.progressBar.setValue(50)
                value = int(round((value / 100.0000), 4) * layer.featureCount())
                self.progressBar.setValue(60)
        selran = random.sample(xrange(0, layer.featureCount()), value)
        self.progressBar.setValue(70)
        self.progressBar.setValue(80)
        self.progressBar.setValue(90)
        self.progressBar.setValue(100)
        layer.setSelectedFeatures(selran)
        self.progressBar.setValue(0)
        self.buttonOk.setEnabled( True )

'''
Created on May 28, 2012
@author: Felix

The following improvement methods are used:
1. Using one dimension array (list) instead of two dimension array (list of list)
2. Initialise list and then update instead of calling of list.append() as much as possible
3. Passing productList through constructor to reduce duplication of calculating productList
4. This ContingencyTable supports being built from LeafSparseADTree
'''
Record = None
ADTree = None
leafList = False

def importModules(recordModule, ADTreeModule):
    import ListContingencyTable
    ListContingencyTable.leafList = (('Leaf' in ADTreeModule) or ('leaf' in ADTreeModule))
    ListContingencyTable.Record = __import__(recordModule)
    ListContingencyTable.ADTree = __import__(ADTreeModule)

class ContingencyTable(object):
    
    def __init__(self, attributeList, ADN, productList=[]):
        self.__attributeList = attributeList
        self.__dimension = len(attributeList)
        self.__productList = productList
        if not self.__productList and attributeList:
            self.__productList = [1]*self.__dimension
            for index in range(self.__dimension-1, 0, -1):
                self.__productList[index-1] = self.__productList[index] * Record.arityList[self.__attributeList[index]-1]

        ctIndex = 0
        ctLength = 1 if not (self.__productList or self.__attributeList) else self.__productList[0]*Record.arityList[self.__attributeList[0]-1]
        self.__CT = [0]*ctLength
        
        if ADN:
            if attributeList:   # AD-node that has Vary node children
                if not leafList or ADN.getCount() >= ADTree.Rmin: # AD-node with children Vary-nodes
                    VN = ADN.getVNChild(attributeList[0])
                    MCV = VN.getMCV()
                    CTList = [None]*(Record.arityList[attributeList[0]-1])
        
                    for eachAttributeValue in range(1, Record.arityList[attributeList[0]-1]+1):
                        adNode = ADN if eachAttributeValue==MCV else VN.getADNChild(eachAttributeValue)
                        CTList[eachAttributeValue-1] = ContingencyTable(attributeList[1:], adNode, self.__productList[1:])
                                
                    # calculate the contingency table for MCV
                    for i, eachNotMCVCT in enumerate(CTList):
                        if i+1 != MCV:
                            CTList[MCV-1].subInRow(eachNotMCVCT)
                    self.concatenate(CTList, ctIndex)
                else:   # AD-node with leaf-list
                    # ctIndex is not necessary to build the current CT, since CT now is build by counting for each records
                    for eachRecordNum in ADN.getLeafList(): # plus one for each of the records in leaf-list
                        recordIndex = 0
                        # calculate the index in CT of a record
                        for eachAttributeIndex in range(self.__dimension):
                            recordIndex += ((Record.getRecord(eachRecordNum-1, self.__attributeList[eachAttributeIndex]-1)-1) * self.__productList[eachAttributeIndex])
                        self.__CT[recordIndex] += 1   # plus one on the counting in CT of the current record
            else:   # leaf AD-node
                self.__CT[ctIndex] = ADN.getCount()
                ctIndex += 1
        else:
            if attributeList:   # zero AD-node with subtree
                ctIndex += Record.arityList[attributeList[0]-1]
            else:   # zero leaf AD-node
                ctIndex += 1
        
    def concatenate(self, CTList, ctIndex):
        '''Make the concatenation of all conditional contingency tables for attributeNum'''
        for eachCT in CTList:
            for eachNum in eachCT.__CT:
                self.__CT[ctIndex] = eachNum
                ctIndex += 1

    def subInRow(self, other):
        for index, eachCount in enumerate(self.__CT):
            self.__CT[index] -= other.__CT[index]
        
    def getCount(self, query):
        rowNum = 0
        for j in range(self.__dimension):
            rowNum += ((query[j]-1) * self.__productList[j])
        return self.__CT[rowNum]
        
# coding=utf-8
"""
oauthlib.oauth2.rfc6749.errors
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Error used both by OAuth 2 clients and providers to represent the spec
defined error responses for all four core grant types.
"""
from __future__ import unicode_literals

import json

from oauthlib.common import add_params_to_uri, urlencode


class OAuth2Error(Exception):
    error = None
    status_code = 400
    description = ''

    def __init__(self, description=None, uri=None, state=None,
                 status_code=None, request=None):
        """
        :param description: A human-readable ASCII [USASCII] text providing
                            additional information, used to assist the client
                            developer in understanding the error that occurred.
                            Values for the "error_description" parameter
                            MUST NOT include characters outside the set
                            x20-21 / x23-5B / x5D-7E.

        :param uri: A URI identifying a human-readable web page with information
                    about the error, used to provide the client developer with
                    additional information about the error.  Values for the
                    "error_uri" parameter MUST conform to the URI- Reference
                    syntax, and thus MUST NOT include characters outside the set
                    x21 / x23-5B / x5D-7E.

        :param state: A CSRF protection value received from the client.

        :param status_code:

        :param request: OAuthlib request.
        :type request: oauthlib.common.Request
        """
        if description is not None:
            self.description = description

        message = '(%s) %s' % (self.error, self.description)
        if request:
            message += ' ' + repr(request)
        super(OAuth2Error, self).__init__(message)

        self.uri = uri
        self.state = state

        if status_code:
            self.status_code = status_code

        if request:
            self.redirect_uri = request.redirect_uri
            self.client_id = request.client_id
            self.scopes = request.scopes
            self.response_type = request.response_type
            self.response_mode = request.response_mode
            self.grant_type = request.grant_type
            if not state:
                self.state = request.state
        else:
            self.redirect_uri = None
            self.client_id = None
            self.scopes = None
            self.response_type = None
            self.response_mode = None
            self.grant_type = None

    def in_uri(self, uri):
        fragment = self.response_mode == "fragment"
        return add_params_to_uri(uri, self.twotuples, fragment)

    @property
    def twotuples(self):
        error = [('error', self.error)]
        if self.description:
            error.append(('error_description', self.description))
        if self.uri:
            error.append(('error_uri', self.uri))
        if self.state:
            error.append(('state', self.state))
        return error

    @property
    def urlencoded(self):
        return urlencode(self.twotuples)

    @property
    def json(self):
        return json.dumps(dict(self.twotuples))

    @property
    def headers(self):
        if self.status_code == 401:
            """
            https://tools.ietf.org/html/rfc6750#section-3

            All challenges defined by this specification MUST use the auth-scheme
            value "Bearer".  This scheme MUST be followed by one or more
            auth-param values.
            """
            authvalues = [
                "Bearer",
                'error="{}"'.format(self.error)
            ]
            if self.description:
                authvalues.append('error_description="{}"'.format(self.description))
            if self.uri:
                authvalues.append('error_uri="{}"'.format(self.uri))
            return {"WWW-Authenticate": ", ".join(authvalues)}
        return {}


class TokenExpiredError(OAuth2Error):
    error = 'token_expired'


class InsecureTransportError(OAuth2Error):
    error = 'insecure_transport'
    description = 'OAuth 2 MUST utilize https.'


class MismatchingStateError(OAuth2Error):
    error = 'mismatching_state'
    description = 'CSRF Warning! State not equal in request and response.'


class MissingCodeError(OAuth2Error):
    error = 'missing_code'


class MissingTokenError(OAuth2Error):
    error = 'missing_token'


class MissingTokenTypeError(OAuth2Error):
    error = 'missing_token_type'


class FatalClientError(OAuth2Error):
    """
    Errors during authorization where user should not be redirected back.

    If the request fails due to a missing, invalid, or mismatching
    redirection URI, or if the client identifier is missing or invalid,
    the authorization server SHOULD inform the resource owner of the
    error and MUST NOT automatically redirect the user-agent to the
    invalid redirection URI.

    Instead the user should be informed of the error by the provider itself.
    """
    pass


class InvalidRequestFatalError(FatalClientError):
    """
    For fatal errors, the request is missing a required parameter, includes
    an invalid parameter value, includes a parameter more than once, or is
    otherwise malformed.
    """
    error = 'invalid_request'


class InvalidRedirectURIError(InvalidRequestFatalError):
    description = 'Invalid redirect URI.'


class MissingRedirectURIError(InvalidRequestFatalError):
    description = 'Missing redirect URI.'


class MismatchingRedirectURIError(InvalidRequestFatalError):
    description = 'Mismatching redirect URI.'


class InvalidClientIdError(InvalidRequestFatalError):
    description = 'Invalid client_id parameter value.'


class MissingClientIdError(InvalidRequestFatalError):
    description = 'Missing client_id parameter.'


class InvalidRequestError(OAuth2Error):
    """
    The request is missing a required parameter, includes an invalid
    parameter value, includes a parameter more than once, or is
    otherwise malformed.
    """
    error = 'invalid_request'


class MissingResponseTypeError(InvalidRequestError):
    description = 'Missing response_type parameter.'


class MissingCodeChallengeError(InvalidRequestError):
    """
    If the server requires Proof Key for Code Exchange (PKCE) by OAuth
    public clients and the client does not send the "code_challenge" in
    the request, the authorization endpoint MUST return the authorization
    error response with the "error" value set to "invalid_request".  The
    "error_description" or the response of "error_uri" SHOULD explain the
    nature of error, e.g., code challenge required.
    """
    description = 'Code challenge required.'


class MissingCodeVerifierError(InvalidRequestError):
    """
    The request to the token endpoint, when PKCE is enabled, has
    the parameter `code_verifier` REQUIRED.
    """
    description = 'Code verifier required.'


class AccessDeniedError(OAuth2Error):
    """
    The resource owner or authorization server denied the request.
    """
    error = 'access_denied'


class UnsupportedResponseTypeError(OAuth2Error):
    """
    The authorization server does not support obtaining an authorization
    code using this method.
    """
    error = 'unsupported_response_type'


class UnsupportedCodeChallengeMethodError(InvalidRequestError):
    """
    If the server supporting PKCE does not support the requested
    transformation, the authorization endpoint MUST return the
    authorization error response with "error" value set to
    "invalid_request".  The "error_description" or the response of
    "error_uri" SHOULD explain the nature of error, e.g., transform
    algorithm not supported.
    """
    description = 'Transform algorithm not supported.'


class InvalidScopeError(OAuth2Error):
    """
    The requested scope is invalid, unknown, or malformed, or
    exceeds the scope granted by the resource owner.

    https://tools.ietf.org/html/rfc6749#section-5.2
    """
    error = 'invalid_scope'


class ServerError(OAuth2Error):
    """
    The authorization server encountered an unexpected condition that
    prevented it from fulfilling the request.  (This error code is needed
    because a 500 Internal Server Error HTTP status code cannot be returned
    to the client via a HTTP redirect.)
    """
    error = 'server_error'


class TemporarilyUnavailableError(OAuth2Error):
    """
    The authorization server is currently unable to handle the request
    due to a temporary overloading or maintenance of the server.
    (This error code is needed because a 503 Service Unavailable HTTP
    status code cannot be returned to the client via a HTTP redirect.)
    """
    error = 'temporarily_unavailable'


class InvalidClientError(FatalClientError):
    """
    Client authentication failed (e.g. unknown client, no client
    authentication included, or unsupported authentication method).
    The authorization server MAY return an HTTP 401 (Unauthorized) status
    code to indicate which HTTP authentication schemes are supported.
    If the client attempted to authenticate via the "Authorization" request
    header field, the authorization server MUST respond with an
    HTTP 401 (Unauthorized) status code, and include the "WWW-Authenticate"
    response header field matching the authentication scheme used by the
    client.
    """
    error = 'invalid_client'
    status_code = 401


class InvalidGrantError(OAuth2Error):
    """
    The provided authorization grant (e.g. authorization code, resource
    owner credentials) or refresh token is invalid, expired, revoked, does
    not match the redirection URI used in the authorization request, or was
    issued to another client.

    https://tools.ietf.org/html/rfc6749#section-5.2
    """
    error = 'invalid_grant'
    status_code = 400


class UnauthorizedClientError(OAuth2Error):
    """
    The authenticated client is not authorized to use this authorization
    grant type.
    """
    error = 'unauthorized_client'


class UnsupportedGrantTypeError(OAuth2Error):
    """
    The authorization grant type is not supported by the authorization
    server.
    """
    error = 'unsupported_grant_type'


class UnsupportedTokenTypeError(OAuth2Error):
    """
    The authorization server does not support the hint of the
    presented token type.  I.e. the client tried to revoke an access token
    on a server not supporting this feature.
    """
    error = 'unsupported_token_type'


class InvalidTokenError(OAuth2Error):
    """
    The access token provided is expired, revoked, malformed, or
    invalid for other reasons.  The resource SHOULD respond with
    the HTTP 401 (Unauthorized) status code.  The client MAY
    request a new access token and retry the protected resource
    request.
    """
    error = 'invalid_token'
    status_code = 401
    description = ("The access token provided is expired, revoked, malformed, "
                   "or invalid for other reasons.")


class InsufficientScopeError(OAuth2Error):
    """
    The request requires higher privileges than provided by the
    access token.  The resource server SHOULD respond with the HTTP
    403 (Forbidden) status code and MAY include the "scope"
    attribute with the scope necessary to access the protected
    resource.
    """
    error = 'insufficient_scope'
    status_code = 403
    description = ("The request requires higher privileges than provided by "
                   "the access token.")


class ConsentRequired(OAuth2Error):
    """
    The Authorization Server requires End-User consent.

    This error MAY be returned when the prompt parameter value in the
    Authentication Request is none, but the Authentication Request cannot be
    completed without displaying a user interface for End-User consent.
    """
    error = 'consent_required'


class LoginRequired(OAuth2Error):
    """
    The Authorization Server requires End-User authentication.

    This error MAY be returned when the prompt parameter value in the
    Authentication Request is none, but the Authentication Request cannot be
    completed without displaying a user interface for End-User authentication.
    """
    error = 'login_required'


class CustomOAuth2Error(OAuth2Error):
    """
    This error is a placeholder for all custom errors not described by the RFC.
    Some of the popular OAuth2 providers are using custom errors.
    """
    def __init__(self, error, *args, **kwargs):
        self.error = error
        super(CustomOAuth2Error, self).__init__(*args, **kwargs)


def raise_from_error(error, params=None):
    import inspect
    import sys
    kwargs = {
        'description': params.get('error_description'),
        'uri': params.get('error_uri'),
        'state': params.get('state')
    }
    for _, cls in inspect.getmembers(sys.modules[__name__], inspect.isclass):
        if cls.error == error:
            raise cls(**kwargs)
    raise CustomOAuth2Error(error=error, **kwargs)

#! /usr/bin/env python
# encoding: utf-8
# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file

from fnmatch import fnmatchcase
import os,os.path,re,stat
from waflib import Task,Utils,Node,Logs
from waflib.TaskGen import feature
DOXY_STR='${DOXYGEN} - '
DOXY_FMTS='html latex man rft xml'.split()
DOXY_FILE_PATTERNS='*.'+' *.'.join('''
c cc cxx cpp c++ java ii ixx ipp i++ inl h hh hxx hpp h++ idl odl cs php php3
inc m mm py f90c cc cxx cpp c++ java ii ixx ipp i++ inl h hh hxx
'''.split())
re_rl=re.compile('\\\\\r*\n',re.MULTILINE)
re_nl=re.compile('\r*\n',re.M)
def parse_doxy(txt):
	tbl={}
	txt=re_rl.sub('',txt)
	lines=re_nl.split(txt)
	for x in lines:
		x=x.strip()
		if not x or x.startswith('#')or x.find('=')<0:
			continue
		if x.find('+=')>=0:
			tmp=x.split('+=')
			key=tmp[0].strip()
			if key in tbl:
				tbl[key]+=' '+'+='.join(tmp[1:]).strip()
			else:
				tbl[key]='+='.join(tmp[1:]).strip()
		else:
			tmp=x.split('=')
			tbl[tmp[0].strip()]='='.join(tmp[1:]).strip()
	return tbl
class doxygen(Task.Task):
	vars=['DOXYGEN','DOXYFLAGS']
	color='BLUE'
	def runnable_status(self):
		'''
		self.pars are populated in runnable_status - because this function is being
		run *before* both self.pars "consumers" - scan() and run()

		set output_dir (node) for the output
		'''
		for x in self.run_after:
			if not x.hasrun:
				return Task.ASK_LATER
		if not getattr(self,'pars',None):
			txt=self.inputs[0].read()
			self.pars=parse_doxy(txt)
			if not self.pars.get('OUTPUT_DIRECTORY'):
				self.pars['OUTPUT_DIRECTORY']=self.inputs[0].parent.get_bld().abspath()
			self.doxy_inputs=getattr(self,'doxy_inputs',[])
			if not self.pars.get('INPUT'):
				self.doxy_inputs.append(self.inputs[0].parent)
			else:
				for i in self.pars.get('INPUT').split():
					if os.path.isabs(i):
						node=self.generator.bld.root.find_node(i)
					else:
						node=self.generator.path.find_node(i)
					if not node:
						self.generator.bld.fatal('Could not find the doxygen input %r'%i)
					self.doxy_inputs.append(node)
		if not getattr(self,'output_dir',None):
			bld=self.generator.bld
			self.output_dir=bld.root.find_dir(self.pars['OUTPUT_DIRECTORY'])
			if not self.output_dir:
				self.output_dir=bld.path.find_or_declare(self.pars['OUTPUT_DIRECTORY'])
		self.signature()
		return Task.Task.runnable_status(self)
	def scan(self):
		if self.pars.get('RECURSIVE')=='YES':
			Logs.warn("Doxygen RECURSIVE dependencies are not supported")
		exclude_patterns=self.pars.get('EXCLUDE_PATTERNS','').split()
		file_patterns=self.pars.get('FILE_PATTERNS','').split()
		if not file_patterns:
			file_patterns=DOXY_FILE_PATTERNS
		nodes=[]
		names=[]
		for node in self.doxy_inputs:
			if os.path.isdir(node.abspath()):
				for m in node.ant_glob(file_patterns):
					nodes.append(m)
			else:
				nodes.append(node)
		return(nodes,names)
	def run(self):
		dct=self.pars.copy()
		dct['INPUT']=' '.join([x.abspath()for x in self.doxy_inputs])
		code='\n'.join(['%s = %s'%(x,dct[x])for x in self.pars])
		code=code
		cmd=Utils.subst_vars(DOXY_STR,self.env)
		env=self.env.env or None
		proc=Utils.subprocess.Popen(cmd,shell=True,stdin=Utils.subprocess.PIPE,env=env,cwd=self.generator.bld.path.get_bld().abspath())
		proc.communicate(code)
		return proc.returncode
	def post_run(self):
		nodes=self.output_dir.ant_glob('**/*',quiet=True)
		for x in nodes:
			x.sig=Utils.h_file(x.abspath())
		self.outputs+=nodes
		return Task.Task.post_run(self)
class tar(Task.Task):
	run_str='${TAR} ${TAROPTS} ${TGT} ${SRC}'
	color='RED'
	after=['doxygen']
	def runnable_status(self):
		for x in getattr(self,'input_tasks',[]):
			if not x.hasrun:
				return Task.ASK_LATER
		if not getattr(self,'tar_done_adding',None):
			self.tar_done_adding=True
			for x in getattr(self,'input_tasks',[]):
				self.set_inputs(x.outputs)
			if not self.inputs:
				return Task.SKIP_ME
		return Task.Task.runnable_status(self)
	def __str__(self):
		tgt_str=' '.join([a.nice_path(self.env)for a in self.outputs])
		return'%s: %s\n'%(self.__class__.__name__,tgt_str)
@feature('doxygen')
def process_doxy(self):
	if not getattr(self,'doxyfile',None):
		self.generator.bld.fatal('no doxyfile??')
	node=self.doxyfile
	if not isinstance(node,Node.Node):
		node=self.path.find_resource(node)
	if not node:
		raise ValueError('doxygen file not found')
	dsk=self.create_task('doxygen',node)
	if getattr(self,'doxy_tar',None):
		tsk=self.create_task('tar')
		tsk.input_tasks=[dsk]
		tsk.set_outputs(self.path.find_or_declare(self.doxy_tar))
		if self.doxy_tar.endswith('bz2'):
			tsk.env['TAROPTS']=['cjf']
		elif self.doxy_tar.endswith('gz'):
			tsk.env['TAROPTS']=['czf']
		else:
			tsk.env['TAROPTS']=['cf']
def configure(conf):
	conf.find_program('doxygen',var='DOXYGEN')
	conf.find_program('tar',var='TAR')

#
# Copyright 2014 Modeliosoft
#
# 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.
#



    
juniper = selectedElements.get(0)
childs = [child for child in juniper.getCompositionChildren() if child.isStereotyped('JuniperIDE', 'SoftwareArchitectureModel')] 
for childSoft in childs :
	servers = [server for server in childSoft.getCompositionChildren() if server.isStereotyped('MongoDBModeler', 'MongoDBServer')]
	if len(servers) != 0 :
		interface = modelingSession.getModel().createInterface('IRelationalDatabase', childSoft)

for server in servers :
	
	getIp = modelingSession.getModel().createOperation('getIp', server)	
	attributeIp=modelingSession.getModel().createAttribute('ip', modelingSession.getModel().getUmlTypes().getSTRING(), server)
	hosts = server.getRepresenting()
	if len(hosts) >1 :
		for host in hosts :
			if host.isStereotyped('MongoDBModeler','Router') or host.isStereotyped('MongoDBModeler','Primary') :
				ip=host.getCluster().getTagValue('JuniperIDE','ip')
				attributeIp.setValue(ip)
	else :
		ip=hosts.get(0).getCluster().getTagValue('JuniperIDE','ip')
	 	attributeIp.setValue(ip)
	 	
	modelingSession.getModel().createReturnParameter('ip', modelingSession.getModel().getUmlTypes().getSTRING(), getIp)	
	modelingSession.getModel().createInterfaceRealization(server, interface)
	
	

	

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2011 OpenERP s.a. (<http://openerp.com>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

""" Library-wide configuration variables.

For now, configuration code is in openerp.tools.config. It is in mainly
unprocessed form, e.g. addons_path is a string with commas-separated
paths. The aim is to have code related to configuration (command line
parsing, configuration file loading and saving, ...) in this module
and provide real Python variables, e.g. addons_paths is really a list
of paths.

To initialize properly this module, openerp.tools.config.parse_config()
must be used.

"""

import deprecation

# Maximum number of threads processing concurrently cron jobs.
max_cron_threads = 4 # Actually the default value here is meaningless,
                     # look at tools.config for the default value.

# Paths to search for OpenERP addons.
addons_paths = []

# List of server-wide modules to load. Those modules are supposed to provide
# features not necessarily tied to a particular database. This is in contrast
# to modules that are always bound to a specific database when they are
# installed (i.e. the majority of OpenERP addons). This is set with the --load
# command-line option.
server_wide_modules = []

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

"""Basic checks for HomeKitSwitch."""

from aiohomekit.model.characteristics import (
    CharacteristicsTypes,
    InUseValues,
    IsConfiguredValues,
)
from aiohomekit.model.services import ServicesTypes

from tests.components.homekit_controller.common import setup_test_component


def create_switch_service(accessory):
    """Define outlet characteristics."""
    service = accessory.add_service(ServicesTypes.OUTLET)

    on_char = service.add_char(CharacteristicsTypes.ON)
    on_char.value = False

    outlet_in_use = service.add_char(CharacteristicsTypes.OUTLET_IN_USE)
    outlet_in_use.value = False


def create_valve_service(accessory):
    """Define valve characteristics."""
    service = accessory.add_service(ServicesTypes.VALVE)

    on_char = service.add_char(CharacteristicsTypes.ACTIVE)
    on_char.value = False

    in_use = service.add_char(CharacteristicsTypes.IN_USE)
    in_use.value = InUseValues.IN_USE

    configured = service.add_char(CharacteristicsTypes.IS_CONFIGURED)
    configured.value = IsConfiguredValues.CONFIGURED

    remaining = service.add_char(CharacteristicsTypes.REMAINING_DURATION)
    remaining.value = 99


async def test_switch_change_outlet_state(hass, utcnow):
    """Test that we can turn a HomeKit outlet on and off again."""
    helper = await setup_test_component(hass, create_switch_service)

    await hass.services.async_call(
        "switch", "turn_on", {"entity_id": "switch.testdevice"}, blocking=True
    )
    assert helper.characteristics[("outlet", "on")].value == 1

    await hass.services.async_call(
        "switch", "turn_off", {"entity_id": "switch.testdevice"}, blocking=True
    )
    assert helper.characteristics[("outlet", "on")].value == 0


async def test_switch_read_outlet_state(hass, utcnow):
    """Test that we can read the state of a HomeKit outlet accessory."""
    helper = await setup_test_component(hass, create_switch_service)

    # Initial state is that the switch is off and the outlet isn't in use
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.state == "off"
    assert switch_1.attributes["outlet_in_use"] is False

    # Simulate that someone switched on the device in the real world not via HA
    helper.characteristics[("outlet", "on")].set_value(True)
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.state == "on"
    assert switch_1.attributes["outlet_in_use"] is False

    # Simulate that device switched off in the real world not via HA
    helper.characteristics[("outlet", "on")].set_value(False)
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.state == "off"

    # Simulate that someone plugged something into the device
    helper.characteristics[("outlet", "outlet-in-use")].value = True
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.state == "off"
    assert switch_1.attributes["outlet_in_use"] is True


async def test_valve_change_active_state(hass, utcnow):
    """Test that we can turn a valve on and off again."""
    helper = await setup_test_component(hass, create_valve_service)

    await hass.services.async_call(
        "switch", "turn_on", {"entity_id": "switch.testdevice"}, blocking=True
    )
    assert helper.characteristics[("valve", "active")].value == 1

    await hass.services.async_call(
        "switch", "turn_off", {"entity_id": "switch.testdevice"}, blocking=True
    )
    assert helper.characteristics[("valve", "active")].value == 0


async def test_valve_read_state(hass, utcnow):
    """Test that we can read the state of a valve accessory."""
    helper = await setup_test_component(hass, create_valve_service)

    # Initial state is that the switch is off and the outlet isn't in use
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.state == "off"
    assert switch_1.attributes["in_use"] is True
    assert switch_1.attributes["is_configured"] is True
    assert switch_1.attributes["remaining_duration"] == 99

    # Simulate that someone switched on the device in the real world not via HA
    helper.characteristics[("valve", "active")].set_value(True)
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.state == "on"

    # Simulate that someone configured the device in the real world not via HA
    helper.characteristics[
        ("valve", "is-configured")
    ].value = IsConfiguredValues.NOT_CONFIGURED
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.attributes["is_configured"] is False

    # Simulate that someone using the device in the real world not via HA
    helper.characteristics[("valve", "in-use")].value = InUseValues.NOT_IN_USE
    switch_1 = await helper.poll_and_get_state()
    assert switch_1.attributes["in_use"] is False

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import logging
from django import forms
from django.conf import settings
from django.utils.safestring import mark_safe
from django.utils import timezone
from paypal.standard.widgets import ValueHiddenInput, ReservedValueHiddenInput
from paypal.standard.conf import (POSTBACK_ENDPOINT, SANDBOX_POSTBACK_ENDPOINT,
                                  IMAGE, SUBSCRIPTION_IMAGE, DONATION_IMAGE,
                                  SANDBOX_IMAGE, SUBSCRIPTION_SANDBOX_IMAGE, DONATION_SANDBOX_IMAGE)

log = logging.getLogger(__name__)


# 20:18:05 Jan 30, 2009 PST - PST timezone support is not included out of the box.
# PAYPAL_DATE_FORMAT = ("%H:%M:%S %b. %d, %Y PST", "%H:%M:%S %b %d, %Y PST",)
# PayPal dates have been spotted in the wild with these formats, beware!
PAYPAL_DATE_FORMATS = ["%H:%M:%S %b. %d, %Y PST",
                       "%H:%M:%S %b. %d, %Y PDT",
                       "%H:%M:%S %b %d, %Y PST",
                       "%H:%M:%S %b %d, %Y PDT",
                      ]


class PayPalDateTimeField(forms.DateTimeField):
    input_formats = PAYPAL_DATE_FORMATS

    def strptime(self, value, format):
        dt = super(PayPalDateTimeField, self).strptime(value, format)
        parts = format.split(" ")
        if timezone.pytz and settings.USE_TZ:
            if parts[-1] in ["PDT", "PST"]:
                # PST/PDT is 'US/Pacific'
                dt = timezone.make_aware(dt, timezone.pytz.timezone('US/Pacific'))
        return dt


class PayPalPaymentsForm(forms.Form):
    """
    Creates a PayPal Payments Standard "Buy It Now" button, configured for a
    selling a single item with no shipping.

    For a full overview of all the fields you can set (there is a lot!) see:
    http://tinyurl.com/pps-integration

    Usage:
    >>> f = PayPalPaymentsForm(initial={'item_name':'Widget 001', ...})
    >>> f.render()
    u'<form action="https://www.paypal.com/cgi-bin/webscr" method="post"> ...'

    """
    CMD_CHOICES = (
        ("_xclick", "Buy now or Donations"),
        ("_donations", "Donations"),
        ("_cart", "Shopping cart"),
        ("_xclick-subscriptions", "Subscribe")
    )
    SHIPPING_CHOICES = ((1, "No shipping"), (0, "Shipping"))
    NO_NOTE_CHOICES = ((1, "No Note"), (0, "Include Note"))
    RECURRING_PAYMENT_CHOICES = (
        (1, "Subscription Payments Recur"),
        (0, "Subscription payments do not recur")
    )
    REATTEMPT_ON_FAIL_CHOICES = (
        (1, "reattempt billing on Failure"),
        (0, "Do Not reattempt on failure")
    )

    BUY = 'buy'
    SUBSCRIBE = 'subscribe'
    DONATE = 'donate'

    # Where the money goes.
    business = forms.CharField(widget=ValueHiddenInput(), initial=settings.PAYPAL_RECEIVER_EMAIL)

    # Item information.
    amount = forms.IntegerField(widget=ValueHiddenInput())
    item_name = forms.CharField(widget=ValueHiddenInput())
    item_number = forms.CharField(widget=ValueHiddenInput())
    quantity = forms.CharField(widget=ValueHiddenInput())

    # Subscription Related.
    a1 = forms.CharField(widget=ValueHiddenInput())  # Trial 1 Price
    p1 = forms.CharField(widget=ValueHiddenInput())  # Trial 1 Duration
    t1 = forms.CharField(widget=ValueHiddenInput())  # Trial 1 unit of Duration, default to Month
    a2 = forms.CharField(widget=ValueHiddenInput())  # Trial 2 Price
    p2 = forms.CharField(widget=ValueHiddenInput())  # Trial 2 Duration
    t2 = forms.CharField(widget=ValueHiddenInput())  # Trial 2 unit of Duration, default to Month
    a3 = forms.CharField(widget=ValueHiddenInput())  # Subscription Price
    p3 = forms.CharField(widget=ValueHiddenInput())  # Subscription Duration
    t3 = forms.CharField(widget=ValueHiddenInput())  # Subscription unit of Duration, default to Month
    src = forms.CharField(widget=ValueHiddenInput()) # Is billing recurring? default to yes
    sra = forms.CharField(widget=ValueHiddenInput()) # Reattempt billing on failed cc transaction
    no_note = forms.CharField(widget=ValueHiddenInput())
    # Can be either 1 or 2. 1 = modify or allow new subscription creation, 2 = modify only
    modify = forms.IntegerField(widget=ValueHiddenInput()) # Are we modifying an existing subscription?

    # Localization / PayPal Setup
    lc = forms.CharField(widget=ValueHiddenInput())
    page_style = forms.CharField(widget=ValueHiddenInput())
    cbt = forms.CharField(widget=ValueHiddenInput())

    # IPN control.
    notify_url = forms.CharField(widget=ValueHiddenInput())
    cancel_return = forms.CharField(widget=ValueHiddenInput())
    return_url = forms.CharField(widget=ReservedValueHiddenInput(attrs={"name": "return"}))
    custom = forms.CharField(widget=ValueHiddenInput())
    invoice = forms.CharField(widget=ValueHiddenInput())

    # Default fields.
    cmd = forms.ChoiceField(widget=forms.HiddenInput(), initial=CMD_CHOICES[0][0])
    charset = forms.CharField(widget=forms.HiddenInput(), initial="utf-8")
    currency_code = forms.CharField(widget=forms.HiddenInput(), initial="USD")
    no_shipping = forms.ChoiceField(widget=forms.HiddenInput(), choices=SHIPPING_CHOICES,
                                    initial=SHIPPING_CHOICES[0][0])

    def __init__(self, button_type="buy", *args, **kwargs):
        super(PayPalPaymentsForm, self).__init__(*args, **kwargs)
        self.button_type = button_type
        if 'initial' in kwargs:
            # Dynamically create, so we can support everything PayPal does.
            for k, v in kwargs['initial'].items():
                if k not in self.base_fields:
                    self.fields[k] = forms.CharField(label=k, widget=ValueHiddenInput(), initial=v)

    def test_mode(self):
        return getattr(settings, 'PAYPAL_TEST', True)

    def get_endpoint(self):
        "Returns the endpoint url for the form."
        if self.test_mode():
            return SANDBOX_POSTBACK_ENDPOINT
        else:
            return POSTBACK_ENDPOINT


    def render(self):
        return mark_safe(u"""<form action="%s" method="post">
    %s
    <input type="image" src="%s" border="0" name="submit" alt="Buy it Now" />
</form>""" % (self.get_endpoint(), self.as_p(), self.get_image()))


    def sandbox(self):
        "Deprecated.  Use self.render() instead."
        import warnings
        warnings.warn("""PaypalPaymentsForm.sandbox() is deprecated.
                    Use the render() method instead.""", DeprecationWarning)
        return self.render()

    def get_image(self):
        return {
            (True, self.SUBSCRIBE): SUBSCRIPTION_SANDBOX_IMAGE,
            (True, self.BUY): SANDBOX_IMAGE,
            (True, self.DONATE): DONATION_SANDBOX_IMAGE,
            (False, self.SUBSCRIBE): SUBSCRIPTION_IMAGE,
            (False, self.BUY): IMAGE,
            (False, self.DONATE): DONATION_IMAGE,
        }[self.test_mode(), self.button_type]

    def is_transaction(self):
        return not self.is_subscription()

    def is_donation(self):
        return self.button_type == self.DONATE

    def is_subscription(self):
        return self.button_type == self.SUBSCRIBE


class PayPalEncryptedPaymentsForm(PayPalPaymentsForm):
    """
    Creates a PayPal Encrypted Payments "Buy It Now" button.
    Requires the M2Crypto package.

    Based on example at:
    http://blog.mauveweb.co.uk/2007/10/10/paypal-with-django/

    """

    def _encrypt(self):
        """Use your key thing to encrypt things."""
        from M2Crypto import BIO, SMIME, X509
        # @@@ Could we move this to conf.py?
        CERT = settings.PAYPAL_PRIVATE_CERT
        PUB_CERT = settings.PAYPAL_PUBLIC_CERT
        PAYPAL_CERT = settings.PAYPAL_CERT
        CERT_ID = settings.PAYPAL_CERT_ID

        # Iterate through the fields and pull out the ones that have a value.
        plaintext = 'cert_id=%s\n' % CERT_ID
        for name, field in self.fields.items():
            value = None
            if name in self.initial:
                value = self.initial[name]
            elif field.initial is not None:
                value = field.initial
            if value is not None:
                # @@@ Make this less hackish and put it in the widget.
                if name == "return_url":
                    name = "return"
                plaintext += u'%s=%s\n' % (name, value)
        plaintext = plaintext.encode('utf-8')

        # Begin crypto weirdness.
        s = SMIME.SMIME()
        s.load_key_bio(BIO.openfile(CERT), BIO.openfile(PUB_CERT))
        p7 = s.sign(BIO.MemoryBuffer(plaintext), flags=SMIME.PKCS7_BINARY)
        x509 = X509.load_cert_bio(BIO.openfile(PAYPAL_CERT))
        sk = X509.X509_Stack()
        sk.push(x509)
        s.set_x509_stack(sk)
        s.set_cipher(SMIME.Cipher('des_ede3_cbc'))
        tmp = BIO.MemoryBuffer()
        p7.write_der(tmp)
        p7 = s.encrypt(tmp, flags=SMIME.PKCS7_BINARY)
        out = BIO.MemoryBuffer()
        p7.write(out)
        return out.read()

    def as_p(self):
        return mark_safe(u"""
<input type="hidden" name="cmd" value="_s-xclick" />
<input type="hidden" name="encrypted" value="%s" />
        """ % self._encrypt())


class PayPalSharedSecretEncryptedPaymentsForm(PayPalEncryptedPaymentsForm):
    """
    Creates a PayPal Encrypted Payments "Buy It Now" button with a Shared Secret.
    Shared secrets should only be used when your IPN endpoint is on HTTPS.

    Adds a secret to the notify_url based on the contents of the form.

    """

    def __init__(self, *args, **kwargs):
        "Make the secret from the form initial data and slip it into the form."
        from paypal.standard.helpers import make_secret

        super(PayPalSharedSecretEncryptedPaymentsForm, self).__init__(*args, **kwargs)
        # @@@ Attach the secret parameter in a way that is safe for other query params.
        secret_param = "?secret=%s" % make_secret(self)
        # Initial data used in form construction overrides defaults
        if 'notify_url' in self.initial:
            self.initial['notify_url'] += secret_param
        else:
            self.fields['notify_url'].initial += secret_param


class PayPalStandardBaseForm(forms.ModelForm):
    """Form used to receive and record PayPal IPN/PDT."""
    # PayPal dates have non-standard formats.
    time_created = PayPalDateTimeField(required=False)
    payment_date = PayPalDateTimeField(required=False)
    next_payment_date = PayPalDateTimeField(required=False)
    subscr_date = PayPalDateTimeField(required=False)
    subscr_effective = PayPalDateTimeField(required=False)
    retry_at = PayPalDateTimeField(required=False)
    case_creation_date = PayPalDateTimeField(required=False)
    auction_closing_date = PayPalDateTimeField(required=False)

#!/usr/bin/python

# Copyright 2008-2012 WebDriver committers
# Copyright 2008-2012 Google Inc.
#
# 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.


import unittest
import pytest

from selenium.webdriver.common.by import By


class OpacityTests(unittest.TestCase):

    @pytest.mark.ignore_ie
    @pytest.mark.ignore_opera
    def testShouldBeAbleToClickOnElementsWithOpacityZero(self):
        self._loadPage("click_jacker")
        element = self.driver.find_element(By.ID, "clickJacker")
        self.assertEquals('0', element.value_of_css_property("opacity"),
                          "Precondition failed: clickJacker should be transparent.\
                          Value was %s" % element.value_of_css_property("opacity"))
        element.click()
        self.assertEquals('1', element.value_of_css_property("opacity"))

    @pytest.mark.ignore_ie
    def testShouldBeAbleToSelectOptionsFromAnInvisibleSelect(self):
        self._loadPage("formPage")
        select = self.driver.find_element(By.ID, "invisi_select")
        options = select.find_elements(By.TAG_NAME, "option")
        apples = options[0]
        oranges = options[1]

        self.assertTrue(apples.is_selected())
        self.assertFalse(oranges.is_selected())

        oranges.click()
        self.assertFalse(apples.is_selected())
        self.assertTrue(oranges.is_selected())


    def _pageURL(self, name):
        return self.webserver.where_is(name + '.html')

    def _loadSimplePage(self):
        self._loadPage("simpleTest")

    def _loadPage(self, name):
        self.driver.get(self._pageURL(name))

from __future__ import print_function, unicode_literals
from string import Template

__author__ = "danishabdullah"

__all__ = ("to_dict", "get_proxy_cls", "to_proxy", "from_proxy", "init", "add", "delete", "update", "comparator",
           "hash_function", "representor")

to_dict = Template("""
    def to_dict(self):
        return {x: y for x, y in self.__dict__.items() if not x.startswith("_sa")}""")

get_proxy_cls = Template("""
    def get_proxy_cls(self):
        # ${class_name}Proxy is useful when you want to persist data
        # independent of the sqlalchemy session. It's just a namedtuple
        # that has very low memory/cpu footprint compared the regular
        # orm class instances.
        keys = self.to_dict().keys()
        name = "${class_name}Proxy"
        return namedtuple(name, keys)""")

to_proxy = Template("""
    def to_proxy(self):
        # Proxy-ing is useful when you want to persist data
        # independent of the sqlalchemy session. It's just a namedtuple
        # that has very low memory/cpu footprint compared the regular
        # orm class instances.
        cls = self._get_proxy_cls()
        return cls(**self.to_dict())""")

from_proxy = Template("""
    @classmethod
    def from_proxy(cls, proxy):
        return cls(**proxy._asdict())""")

init = Template("""
    def __init__(self, $init_args):
        $col_assignments""")

add = Template("""
    def add(self, session):
        session.add(self)""")

delete = Template("""
    def delete(self, session):
        session.delete(self)""")

update = Template("""
    def update(self, $update_args):
        # This function only updates a value if it is not None.
        # Falsy values go through in the normal way.
        # To set things to None use the usual syntax:
        #    $class_name.column_name = None
        $not_none_col_assignments""")

comparator = Template("""
    def $func_name(self, other):
        return $negation_marker($key_col_comparisons)""")

representor = Template("""
    def __${func_name}__(self):
        return "<$class_name: $col_evaluators>".format($col_accessors)""")

hash_function = Template("""
    def __hash__(self):
        return hash($concated_primary_key_strs)""")

#!/usr/bin/env python
#
# Copyright 2012 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
#

from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals

import sys
from gnuradio import gr, blocks
import pmt

'''
sr    Sample rate (samples/second)
time  Time as uint64(secs), double(fractional secs)
type  Type of data (see gr_file_types enum)
cplx  is complex? (True or False)
strt  Start of data (or size of header) in bytes
size  Size of data in bytes
'''

HEADER_LENGTH = blocks.METADATA_HEADER_SIZE

ftype_to_string = {blocks.GR_FILE_BYTE: "bytes",
                   blocks.GR_FILE_SHORT: "short",
                   blocks.GR_FILE_INT: "int",
                   blocks.GR_FILE_LONG: "long",
                   blocks.GR_FILE_LONG_LONG: "long long",
                   blocks.GR_FILE_FLOAT: "float",
                   blocks.GR_FILE_DOUBLE: "double" }

ftype_to_size = {blocks.GR_FILE_BYTE: gr.sizeof_char,
                 blocks.GR_FILE_SHORT: gr.sizeof_short,
                 blocks.GR_FILE_INT: gr.sizeof_int,
                 blocks.GR_FILE_LONG: gr.sizeof_int,
                 blocks.GR_FILE_LONG_LONG: 2*gr.sizeof_int,
                 blocks.GR_FILE_FLOAT: gr.sizeof_float,
                 blocks.GR_FILE_DOUBLE: gr.sizeof_double}

def parse_header(p, VERBOSE=False):
    dump = pmt.PMT_NIL

    info = dict()

    if(pmt.is_dict(p) is False):
        sys.stderr.write("Header is not a PMT dictionary: invalid or corrupt data file.\n")
        sys.exit(1)

    # GET FILE FORMAT VERSION NUMBER
    if(pmt.dict_has_key(p, pmt.string_to_symbol("version"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("version"), dump)
        version = pmt.to_long(r)
        if(VERBOSE):
            print("Version Number: {0}".format(version))
    else:
        sys.stderr.write("Could not find key 'version': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SAMPLE RATE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_rate"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_rate"), dump)
        samp_rate = pmt.to_double(r)
        info["rx_rate"] = samp_rate
        if(VERBOSE):
            print("Sample Rate: {0:.2f} sps".format(samp_rate))
    else:
        sys.stderr.write("Could not find key 'sr': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT TIME STAMP
    if(pmt.dict_has_key(p, pmt.string_to_symbol("rx_time"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("rx_time"), dump)
        secs = pmt.tuple_ref(r, 0)
        fracs = pmt.tuple_ref(r, 1)
        secs = float(pmt.to_uint64(secs))
        fracs = pmt.to_double(fracs)
        t = secs + fracs
        info["rx_time"] = t
        if(VERBOSE):
            print("Seconds: {0:.6f}".format(t))
    else:
        sys.stderr.write("Could not find key 'time': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT ITEM SIZE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("size"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("size"), dump)
        dsize = pmt.to_long(r)
        info["size"] = dsize
        if(VERBOSE):
            print("Item size: {0}".format(dsize))
    else:
        sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT DATA TYPE
    if(pmt.dict_has_key(p, pmt.string_to_symbol("type"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("type"), dump)
        dtype = pmt.to_long(r)
        stype = ftype_to_string[dtype]
        info["type"] = stype
        if(VERBOSE):
            print("Data Type: {0} ({1})".format(stype, dtype))
    else:
        sys.stderr.write("Could not find key 'type': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT COMPLEX
    if(pmt.dict_has_key(p, pmt.string_to_symbol("cplx"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("cplx"), dump)
        cplx = pmt.to_bool(r)
        info["cplx"] = cplx
        if(VERBOSE):
            print("Complex? {0}".format(cplx))
    else:
        sys.stderr.write("Could not find key 'cplx': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT WHERE CURRENT SEGMENT STARTS
    if(pmt.dict_has_key(p, pmt.string_to_symbol("strt"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("strt"), dump)
        seg_start = pmt.to_uint64(r)
        info["hdr_len"] = seg_start
        info["extra_len"] = seg_start - HEADER_LENGTH
        info["has_extra"] = info["extra_len"] > 0
        if(VERBOSE):
            print("Header Length: {0} bytes".format(info["hdr_len"]))
            print("Extra Length:  {0}".format((info["extra_len"])))
            print("Extra Header?  {0}".format(info["has_extra"]))
    else:
        sys.stderr.write("Could not find key 'strt': invalid or corrupt data file.\n")
        sys.exit(1)

    # EXTRACT SIZE OF DATA
    if(pmt.dict_has_key(p, pmt.string_to_symbol("bytes"))):
        r = pmt.dict_ref(p, pmt.string_to_symbol("bytes"), dump)
        nbytes = pmt.to_uint64(r)

        nitems = nbytes / dsize
        info["nitems"] = nitems
        info["nbytes"] = nbytes

        if(VERBOSE):
            print("Size of Data: {0} bytes".format(nbytes))
            print("              {0} items".format(nitems))
    else:
        sys.stderr.write("Could not find key 'size': invalid or corrupt data file.\n")
        sys.exit(1)

    return info

# IF THERE IS EXTRA DATA, PULL OUT THE DICTIONARY AND PARSE IT
def parse_extra_dict(p, info, VERBOSE=False):
    if(pmt.is_dict(p) is False):
        sys.stderr.write("Extra header is not a PMT dictionary: invalid or corrupt data file.\n")
        sys.exit(1)

    items = pmt.dict_items(p)
    nitems = pmt.length(items)
    for i in range(nitems):
        item = pmt.nth(i, items)
        key = pmt.symbol_to_string(pmt.car(item))
        val = pmt.cdr(item)
        info[key] = val
        if(VERBOSE):
            print("{0}: {1}".format(key, val))

    return info

# -*- coding: utf-8 -*-
##############################################################################
#
#    Copyright (C) 2013 Agile Business Group sagl (<http://www.agilebg.com>)
#    Copyright (c) 2015 ACSONE SA/NV (<http://acsone.eu>)
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as published
#    by the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from . import po_line_invoice
from . import po_line_cancel_quantity

""" Handlers for OpenID Connect provider. """

from django.conf import settings
from django.core.cache import cache

from courseware.access import has_access
from openedx.core.djangoapps.content.course_overviews.models import CourseOverview
from openedx.core.djangoapps.user_api.models import UserPreference
from student.models import anonymous_id_for_user
from student.models import UserProfile
from lang_pref import LANGUAGE_KEY
from student.roles import GlobalStaff, CourseStaffRole, CourseInstructorRole


class OpenIDHandler(object):
    """ Basic OpenID Connect scope handler. """

    def scope_openid(self, _data):
        """ Only override the sub (subject) claim. """
        return ['sub']

    def claim_sub(self, data):
        """
        Return the value of the sub (subject) claim. The value should be
        unique for each user.

        """

        # Use the anonymous ID without any course as unique identifier.
        # Note that this ID is derived using the value of the `SECRET_KEY`
        # setting, this means that users will have different sub
        # values for different deployments.
        value = anonymous_id_for_user(data['user'], None)
        return value


class PermissionsHandler(object):
    """ Permissions scope handler """

    def scope_permissions(self, _data):
        return ['administrator']

    def claim_administrator(self, data):
        """
        Return boolean indicating user's administrator status.

        For our purposes an administrator is any user with is_staff set to True.
        """
        return data['user'].is_staff


class ProfileHandler(object):
    """ Basic OpenID Connect `profile` scope handler with `locale` claim. """

    def scope_profile(self, _data):
        """ Add specialized claims. """
        return ['name', 'locale']

    def claim_name(self, data):
        """ User displayable full name. """
        user = data['user']
        profile = UserProfile.objects.get(user=user)
        return profile.name

    def claim_locale(self, data):
        """
        Return the locale for the users based on their preferences.
        Does not return a value if the users have not set their locale preferences.
        """

        # Calling UserPreference directly because it is not clear which user made the request.
        language = UserPreference.get_value(data['user'], LANGUAGE_KEY)

        # If the user has no language specified, return the default one.
        if not language:
            language = settings.LANGUAGE_CODE

        return language


class CourseAccessHandler(object):
    """
    Defines two new scopes: `course_instructor` and `course_staff`. Each one is
    valid only if the user is instructor or staff of at least one course.

    Each new scope has a corresponding claim: `instructor_courses` and
    `staff_courses` that lists the course_ids for which the user has instructor
    or staff privileges.

    The claims support claim request values: if there is no claim request, the
    value of the claim is the list all the courses for which the user has the
    corresponding privileges. If a claim request is used, then the value of the
    claim the list of courses from the requested values that have the
    corresponding privileges.

    For example, if the user is staff of course_a and course_b but not
    course_c, the claim corresponding to the scope request:

        scope = openid course_staff

    has the value:

        {staff_courses: [course_a, course_b] }

    For the claim request:

        claims = {userinfo: {staff_courses: {values=[course_b, course_d]}}}

    the corresponding claim will have the value:

        {staff_courses: [course_b] }.

    This is useful to quickly determine if a user has the right privileges for a
    given course.

    For a description of the function naming and arguments, see:

        `edx_oauth2_provider/oidc/handlers.py`

    """

    COURSE_CACHE_TIMEOUT = getattr(settings, 'OIDC_COURSE_HANDLER_CACHE_TIMEOUT', 60)  # In seconds.

    def __init__(self, *_args, **_kwargs):
        self._course_cache = {}

    def scope_course_instructor(self, data):
        """
        Scope `course_instructor` valid only if the user is an instructor
        of at least one course.

        """

        # TODO: unfortunately there is not a faster and still correct way to
        # check if a user is instructor of at least one course other than
        # checking the access type against all known courses.
        course_ids = self.find_courses(data['user'], CourseInstructorRole.ROLE)
        return ['instructor_courses'] if course_ids else None

    def scope_course_staff(self, data):
        """
        Scope `course_staff` valid only if the user is an instructor of at
        least one course.

        """
        # TODO: see :method:CourseAccessHandler.scope_course_instructor
        course_ids = self.find_courses(data['user'], CourseStaffRole.ROLE)

        return ['staff_courses'] if course_ids else None

    def claim_instructor_courses(self, data):
        """
        Claim `instructor_courses` with list of course_ids for which the
        user has instructor privileges.

        """

        return self.find_courses(data['user'], CourseInstructorRole.ROLE, data.get('values'))

    def claim_staff_courses(self, data):
        """
        Claim `staff_courses` with list of course_ids for which the user
        has staff privileges.

        """

        return self.find_courses(data['user'], CourseStaffRole.ROLE, data.get('values'))

    def find_courses(self, user, access_type, values=None):
        """
        Find all courses for which the user has the specified access type. If
        `values` is specified, check only the courses from `values`.

        """

        # Check the instance cache and update if not present.  The instance
        # cache is useful since there are multiple scope and claims calls in the
        # same request.

        key = (user.id, access_type)
        if key in self._course_cache:
            course_ids = self._course_cache[key]
        else:
            course_ids = self._get_courses_with_access_type(user, access_type)
            self._course_cache[key] = course_ids

        # If values was specified, filter out other courses.
        if values is not None:
            course_ids = list(set(course_ids) & set(values))

        return course_ids

    # pylint: disable=missing-docstring
    def _get_courses_with_access_type(self, user, access_type):
        # Check the application cache and update if not present. The application
        # cache is useful since there are calls to different endpoints in close
        # succession, for example the id_token and user_info endpoints.

        key = '-'.join([str(self.__class__), str(user.id), access_type])
        course_ids = cache.get(key)

        if not course_ids:
            course_keys = CourseOverview.get_all_course_keys()

            # Global staff have access to all courses. Filter courses for non-global staff.
            if not GlobalStaff().has_user(user):
                course_keys = [course_key for course_key in course_keys if has_access(user, access_type, course_key)]

            course_ids = [unicode(course_key) for course_key in course_keys]

            cache.set(key, course_ids, self.COURSE_CACHE_TIMEOUT)

        return course_ids


class IDTokenHandler(OpenIDHandler, ProfileHandler, CourseAccessHandler, PermissionsHandler):
    """ Configure the ID Token handler for the LMS. """

    def claim_instructor_courses(self, data):
        # Don't return list of courses unless they are requested as essential.
        if data.get('essential'):
            return super(IDTokenHandler, self).claim_instructor_courses(data)
        else:
            return None

    def claim_staff_courses(self, data):
        # Don't return list of courses unless they are requested as essential.
        if data.get('essential'):
            return super(IDTokenHandler, self).claim_staff_courses(data)
        else:
            return None


class UserInfoHandler(OpenIDHandler, ProfileHandler, CourseAccessHandler, PermissionsHandler):
    """ Configure the UserInfo handler for the LMS. """
    pass

"""
Implements the background check on reported levels from the EN quality control
system, http://www.metoffice.gov.uk/hadobs/en3/OQCpaper.pdf
"""

from . import EN_spike_and_step_check
import gsw
import numpy as np
import util.obs_utils as outils
from netCDF4 import Dataset
import util.main as main
from util.dbutils import retrieve_existing_qc_result

def test(p, parameters):
    """
    Runs the quality control check on profile p and returns a numpy array
    of quality control decisions with False where the data value has
    passed the check and True where it failed.
    """

    # Check if the QC of this profile was already done and if not
    # run the QC.
    qc_log = retrieve_existing_qc_result('en_background_check', 
                                         p.uid(),
                                         parameters['table'], 
                                         parameters['db'])
    if qc_log is not None:
        return qc_log

    return run_qc(p, parameters)

def run_qc(p, parameters):
    """
    Performs the QC check.
    """

    # Define an array to hold results.
    qc = np.zeros(p.n_levels(), dtype=bool)

    # Create a record of the processing for use by the background
    # and buddy checks on standard levels.
    origLevels = []
    ptLevels   = []
    bgLevels   = []

    # Find grid cell nearest to the observation.
    ilon, ilat = findGridCell(p, parameters['enbackground']['lon'], parameters['enbackground']['lat'])

    # Extract the relevant auxiliary data.
    imonth = p.month() - 1
    clim = parameters['enbackground']['clim'][:, ilat, ilon, imonth]
    bgev = parameters['enbackground']['bgev'][:, ilat, ilon]
    bgStdLevels   = clim # Save for use in another check.
    bgevStdLevels = bgev # Save the full column for use by another check.
    obev = parameters['enbackground']['obev']
    depths = parameters['enbackground']['depth']

    # Remove missing data points.
    iOK = (clim.mask == False) & (bgev.mask == False)
    if np.count_nonzero(iOK) == 0: 
        record_parameters(p, bgStdLevels, bgevStdLevels, origLevels, ptLevels, bgLevels, parameters)
        return qc
    clim = clim[iOK]
    bgev = bgev[iOK]
    obev = obev[iOK]
    depths = depths[iOK]

    # Find which levels have data.
    t = p.t()
    s = p.s()
    z = p.z()
    isTemperature = (t.mask==False)
    isSalinity = (s.mask==False)
    isDepth = (z.mask==False)
    isData = isTemperature & isDepth

    # prep pressures ahead of time
    depth = np.ma.filled(z,30000)
    pressures = gsw.p_from_z(-depth, p.latitude())

    # Use the EN_spike_and_step_check to find suspect values.
    suspect = EN_spike_and_step_check.test(p, parameters, suspect=True)

    # Loop over levels.
    for iLevel in range(p.n_levels()):
        if isData[iLevel] == False: continue

        # Get the climatology and error variance values at this level.
        climLevel = np.interp(z[iLevel], depths, clim, right=99999)
        bgevLevel = np.interp(z[iLevel], depths, bgev, right=99999)
        obevLevel = np.interp(z[iLevel], depths, obev, right=99999)
        if climLevel == 99999:
            continue 
        assert bgevLevel > 0, 'Background error variance <= 0'
        assert obevLevel > 0, 'Observation error variance <= 0'
        
        # If at low latitudes the background error variance is increased. 
        # Also, because we are on reported levels instead of standard levels 
        # the variances are increased. NB multiplication factors are squared
        # because we are working with error variances instead of standard
        # deviations.
        if np.abs(p.latitude()) < 10.0: bgevLevel *= 1.5**2
        bgevLevel *= 2.0**2
        
        # Set up an initial estimate of probability of gross error. 
        pge = estimatePGE(p.probe_type(), suspect[iLevel])

        # Calculate potential temperature.
        if isSalinity[iLevel]:
            sLevel = s[iLevel]
        else:
            sLevel = 35.0
        potm = outils.pottem(t[iLevel], sLevel, pressures[iLevel], pressure=True)

        # Do Bayesian calculation.
        evLevel = obevLevel + bgevLevel
        sdiff   = (potm - climLevel)**2 / evLevel
        pdGood  = np.exp(-0.5 * np.min([sdiff, 160.0])) / np.sqrt(2.0 * np.pi * evLevel)
        pdTotal = 0.1 * pge + pdGood * (1.0 - pge)
        pgebk   = 0.1 * pge / pdTotal
              
        if pgebk >= 0.5: 
            qc[iLevel] = True
        else:
            # Store the results.
            origLevels.append(iLevel)
            ptLevels.append(potm)
            bgLevels.append(climLevel)
    record_parameters(p, bgStdLevels, bgevStdLevels, origLevels, ptLevels, bgLevels, parameters)

    return qc

def record_parameters(profile, bgStdLevels, bgevStdLevels, origLevels, ptLevels, bgLevels, parameters):
    # pack the parameter arrays into the enbackground table
    # for consumption by the buddy check

    bgstdlevels = main.pack_array(bgStdLevels)
    bgevstdlevels = main.pack_array(bgevStdLevels)
    origlevels = main.pack_array(origLevels)
    ptlevels = main.pack_array(ptLevels)
    bglevels = main.pack_array(bgLevels)
    query = "REPLACE INTO enbackground VALUES(?,?,?,?,?,?);"
    main.dbinteract(query, [profile.uid(), bgstdlevels, bgevstdlevels, origlevels, ptlevels, bglevels], targetdb=parameters["db"])


def findGridCell(p, gridLong, gridLat):
    '''
    Find grid cell nearest to the observation p, 
    where gridLong and gridLat are lists of grid coordinates.
    '''
    for i in range(1, len(gridLong)):
        assert gridLong[i] - gridLong[i-1] == gridLong[1] - gridLong[0], 'longitude grid points must be evenly spaced'
    lon = p.longitude()
    grid = gridLong
    nlon = len(grid)
    ilon = int(np.mod(np.round((lon - grid[0]) / (grid[1] - grid[0])), nlon))
    for i in range(1, len(gridLat)):
        assert gridLat[i] - gridLat[i-1] == gridLat[1] - gridLat[0], 'latitude grid points must be evenly spaced'
    lat = p.latitude()
    lat = main.normalize_latitude(lat)
    grid = gridLat
    nlat = len(grid)
    ilat = int( np.round((lat - grid[0]) / (grid[1] - grid[0])) )
    if ilat == nlat: ilat -= 1 # Checks for edge case where lat is ~90.

    assert ilon >=0 and ilon < nlon, 'Longitude is out of range: {} {}'.format(lon, ilon)
    assert ilat >=0 and ilat < nlat, 'Latitude is out of range: {} {}'.format(lat, ilat)

    return ilon, ilat


def estimatePGE(probe_type, isSuspect):
    '''
    Estimates the probability of gross error for a measurement taken by
    the given probe_type. Information from the EN_spike_and_step_check 
    is used here to increase the initial estimate if the observation is suspect.
    '''
    if probe_type in [1,2,3,13,16]:
        pge = 0.05    
    else: 
        pge = 0.01
    if isSuspect:
        pge = 0.5 + 0.5 * pge

    return pge

def readENBackgroundCheckAux():
    '''
    Reads auxiliary information needed by the EN background check.
    '''

    filename = 'data/EN_bgcheck_info.nc'
    nc = Dataset(filename)
    data = {}
    data['lon']   = nc.variables['longitude'][:]
    data['lat']   = nc.variables['latitude'][:]
    data['depth'] = nc.variables['depth'][:]
    data['month'] = nc.variables['month'][:]
    data['clim']  = nc.variables['potm_climatology'][:]
    data['bgev']  = nc.variables['bg_err_var'][:]
    data['obev']  = nc.variables['ob_err_var'][:]
    
    return data

def loadParameters(parameterStore):

    main.dbinteract("CREATE TABLE IF NOT EXISTS enbackground (uid INTEGER PRIMARY KEY, bgstdlevels BLOB, bgevstdlevels BLOB, origlevels BLOB, ptlevels BLOB, bglevels BLOB)", targetdb=parameterStore["db"])
    parameterStore['enbackground'] = readENBackgroundCheckAux()





# Copyright 2013-2015 Open Source Robotics Foundation, Inc.
#
# 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.

try:
    from urllib.parse import urlparse
except ImportError:
    from urlparse import urlparse


class Index(object):

    _type = 'buildfarm'

    def __init__(self, data, base_url):
        assert 'type' in data, "Expected file type is '%s'" % Index._type
        assert data['type'] == Index._type, \
            "Expected file type is '%s', not '%s' loaded from '%s'" % \
            (Index._type, data['type'], base_url)

        assert 'version' in data, \
            'Index file lacks required version information'
        # assert int(data['version']) > 1, \
        #     ("Unable to handle '%s' format version '%d' anymore, please " +
        #      "update your '%s' file to version '2'" %
        #      (Index._type, int(data['version']), Index._type)
        assert int(data['version']) in [1], \
            ("Unable to handle '%s' format version '%d', please update " +
             "ros_buildfarm") % (Index._type, int(data['version']))
        self.version = int(data['version'])

        self.distributions = {}
        if 'distributions' in data and data['distributions']:
            # if distributions is not a dict
            # raise an exception including the value
            # this can be used to notify users
            # (e.g. if an index.yaml file has been deleted / moved)
            if not isinstance(data['distributions'], dict):
                raise RuntimeError(
                    ("Distributions type is invalid: expected 'dict', but " +
                     "got '%s': %s") %
                    (type(data['distributions']).__name__,
                     data['distributions']))
            for distro_name in sorted(data['distributions']):
                self.distributions[distro_name] = {}
                distro_data = data['distributions'][distro_name]
                value_types = {
                    'doc_builds': dict,
                    'notification_emails': list,
                    'release_builds': dict,
                    'source_builds': dict,
                }
                for key in distro_data:
                    if key not in value_types.keys():
                        assert False, "unknown key '%s'" % key

                    value = distro_data[key]
                    if not isinstance(value, value_types[key]):
                        assert False, \
                            "wrong type of key '%s': %s" % (key, type(value))

                    if isinstance(value, dict):
                        self.distributions[distro_name][key] = {}
                        for k, v in value.items():
                            v = _resolve_url(base_url, v)
                            self.distributions[distro_name][key][k] = v
                    elif isinstance(value, list):
                        self.distributions[distro_name][key] = []
                        for v in value:
                            self.distributions[distro_name][key].append(v)
                    else:
                        assert False

                unset_keys = [
                    k for k in value_types.keys()
                    if k not in distro_data]
                for key in unset_keys:
                    self.distributions[distro_name][key] = value_types[key]()

        self.doc_builds = {}
        if 'doc_builds' in data and data['doc_builds']:
            assert isinstance(data['doc_builds'], dict)
            for k, v in data['doc_builds'].items():
                v = _resolve_url(base_url, v)
                self.doc_builds[k] = v

        self.git_ssh_credential_id = ''
        if 'git_ssh_credential_id' in data:
            self.git_ssh_credential_id = data['git_ssh_credential_id']
            assert isinstance(self.git_ssh_credential_id, str)

        self.jenkins_url = data['jenkins_url']

        self.notify_emails = []
        if 'notification_emails' in data:
            self.notify_emails = data['notification_emails']
            assert isinstance(self.notify_emails, list)

        self.prerequisites = data['prerequisites']

        self.rosdistro_index_url = data['rosdistro_index_url']

        self.status_page_repositories = {}
        if 'status_page_repositories' in data:
            assert isinstance(data['status_page_repositories'], dict)
            for status_page_name, repo_urls in \
                    data['status_page_repositories'].items():
                assert isinstance(repo_urls, list)
                self.status_page_repositories[status_page_name] = repo_urls


def _resolve_url(base_url, value):
    parts = urlparse(value)
    if not parts[0]:  # schema
        value = base_url + '/' + value
    return value

# -*- coding: utf-8 -*-
from __future__ import absolute_import
from django.conf import settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from unittest import skip

from zerver.forms import not_mit_mailing_list

from zerver.lib.rate_limiter import (
    add_ratelimit_rule,
    clear_user_history,
    remove_ratelimit_rule,
)

from zerver.lib.actions import compute_mit_user_fullname
from zerver.lib.test_helpers import AuthedTestCase
from zerver.models import get_user_profile_by_email
from zerver.lib.test_runner import slow

import time
import ujson
import urllib
import urllib2

from boto.s3.connection import S3Connection
from boto.s3.key import Key
from StringIO import StringIO

class MITNameTest(TestCase):
    def test_valid_hesiod(self):
        self.assertEquals(compute_mit_user_fullname("starnine@mit.edu"), "Athena Consulting Exchange User")
        self.assertEquals(compute_mit_user_fullname("sipbexch@mit.edu"), "Exch Sipb")
    def test_invalid_hesiod(self):
        self.assertEquals(compute_mit_user_fullname("1234567890@mit.edu"), "1234567890@mit.edu")
        self.assertEquals(compute_mit_user_fullname("ec-discuss@mit.edu"), "ec-discuss@mit.edu")

    def test_mailinglist(self):
        self.assertRaises(ValidationError, not_mit_mailing_list, "1234567890@mit.edu")
        self.assertRaises(ValidationError, not_mit_mailing_list, "ec-discuss@mit.edu")
    def test_notmailinglist(self):
        self.assertTrue(not_mit_mailing_list("sipbexch@mit.edu"))

class S3Test(AuthedTestCase):
    test_uris = [] # full URIs in public bucket
    test_keys = [] # keys in authed bucket

    @slow(2.6, "has to contact external S3 service")
    @skip("Need S3 mock")
    def test_file_upload_authed(self):
        """
        A call to /json/upload_file should return a uri and actually create an object.
        """
        self.login("hamlet@zulip.com")
        fp = StringIO("zulip!")
        fp.name = "zulip.txt"

        result = self.client.post("/json/upload_file", {'file': fp})
        self.assert_json_success(result)
        json = ujson.loads(result.content)
        self.assertIn("uri", json)
        uri = json["uri"]
        base = '/user_uploads/'
        self.assertEquals(base, uri[:len(base)])
        self.test_keys.append(uri[len(base):])

        response = self.client.get(uri)
        redirect_url = response['Location']

        self.assertEquals("zulip!", urllib2.urlopen(redirect_url).read().strip())

    def test_multiple_upload_failure(self):
        """
        Attempting to upload two files should fail.
        """
        self.login("hamlet@zulip.com")
        fp = StringIO("bah!")
        fp.name = "a.txt"
        fp2 = StringIO("pshaw!")
        fp2.name = "b.txt"

        result = self.client.post("/json/upload_file", {'f1': fp, 'f2': fp2})
        self.assert_json_error(result, "You may only upload one file at a time")

    def test_no_file_upload_failure(self):
        """
        Calling this endpoint with no files should fail.
        """
        self.login("hamlet@zulip.com")

        result = self.client.post("/json/upload_file")
        self.assert_json_error(result, "You must specify a file to upload")

    def tearDown(self):
        # clean up
        return
        # TODO: un-deadden this code when we have proper S3 mocking.
        conn = S3Connection(settings.S3_KEY, settings.S3_SECRET_KEY)
        for uri in self.test_uris:
            key = Key(conn.get_bucket(settings.S3_BUCKET))
            key.name = urllib2.urlparse.urlparse(uri).path[1:]
            key.delete()
            self.test_uris.remove(uri)

        for path in self.test_keys:
            key = Key(conn.get_bucket(settings.S3_AUTH_UPLOADS_BUCKET))
            key.name = path
            key.delete()
            self.test_keys.remove(path)

class RateLimitTests(AuthedTestCase):

    def setUp(self):
        settings.RATE_LIMITING = True
        add_ratelimit_rule(1, 5)


    def tearDown(self):
        settings.RATE_LIMITING = False
        remove_ratelimit_rule(1, 5)

    def send_api_message(self, email, api_key, content):
        return self.client.post("/api/v1/send_message", {"type": "stream",
                                                                   "to": "Verona",
                                                                   "client": "test suite",
                                                                   "content": content,
                                                                   "subject": "Test subject",
                                                                   "email": email,
                                                                   "api-key": api_key})
    def test_headers(self):
        email = "hamlet@zulip.com"
        user = get_user_profile_by_email(email)
        clear_user_history(user)
        api_key = self.get_api_key(email)

        result = self.send_api_message(email, api_key, "some stuff")
        self.assertTrue('X-RateLimit-Remaining' in result)
        self.assertTrue('X-RateLimit-Limit' in result)
        self.assertTrue('X-RateLimit-Reset' in result)

    def test_ratelimit_decrease(self):
        email = "hamlet@zulip.com"
        user = get_user_profile_by_email(email)
        clear_user_history(user)
        api_key = self.get_api_key(email)
        result = self.send_api_message(email, api_key, "some stuff")
        limit = int(result['X-RateLimit-Remaining'])

        result = self.send_api_message(email, api_key, "some stuff 2")
        newlimit = int(result['X-RateLimit-Remaining'])
        self.assertEqual(limit, newlimit + 1)

    @slow(1.1, 'has to sleep to work')
    def test_hit_ratelimits(self):
        email = "cordelia@zulip.com"
        user = get_user_profile_by_email(email)
        clear_user_history(user)

        api_key = self.get_api_key(email)
        for i in range(6):
            result = self.send_api_message(email, api_key, "some stuff %s" % (i,))

        self.assertEqual(result.status_code, 429)
        json = ujson.loads(result.content)
        self.assertEqual(json.get("result"), "error")
        self.assertIn("API usage exceeded rate limit, try again in", json.get("msg"))
        self.assertTrue('Retry-After' in result)
        self.assertIn(result['Retry-After'], json.get("msg"))

        # We actually wait a second here, rather than force-clearing our history,
        # to make sure the rate-limiting code automatically forgives a user
        # after some time has passed.
        time.sleep(1)

        result = self.send_api_message(email, api_key, "Good message")

        self.assert_json_success(result)

class APNSTokenTests(AuthedTestCase):
    def test_add_token(self):
        email = "cordelia@zulip.com"
        self.login(email)

        result = self.client.post('/json/users/me/apns_device_token', {'token': "test_token"})
        self.assert_json_success(result)

    def test_delete_token(self):
        email = "cordelia@zulip.com"
        self.login(email)

        token = "test_token"
        result = self.client.post('/json/users/me/apns_device_token', {'token':token})
        self.assert_json_success(result)

        result = self.client_delete('/json/users/me/apns_device_token', {'token': token})
        self.assert_json_success(result)

class GCMTokenTests(AuthedTestCase):
    def test_add_token(self):
        email = "cordelia@zulip.com"
        self.login(email)

        result = self.client.post('/json/users/me/apns_device_token', {'token': "test_token"})
        self.assert_json_success(result)

    def test_delete_token(self):
        email = "cordelia@zulip.com"
        self.login(email)

        token = "test_token"
        result = self.client.post('/json/users/me/android_gcm_reg_id', {'token':token})
        self.assert_json_success(result)

        result = self.client.delete('/json/users/me/android_gcm_reg_id', urllib.urlencode({'token': token}))
        self.assert_json_success(result)

    def test_change_user(self):
        token = "test_token"

        self.login("cordelia@zulip.com")
        result = self.client.post('/json/users/me/android_gcm_reg_id', {'token':token})
        self.assert_json_success(result)

        self.login("hamlet@zulip.com")
        result = self.client.post('/json/users/me/android_gcm_reg_id', {'token':token})
        self.assert_json_success(result)


# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    This module copyright (C) 2012 Therp BV (<http://therp.nl>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

{
    "name": "Groups assignment",
    "version": "1.2",
    "depends": ["auth_ldap"],
    "author": "Therp BV",
    "description": """
Adds user accounts to groups based on rules defined by the administrator.

Usage:

Define mappings in Settings->Companies->[your company]->tab configuration->[your
ldap server].

Decide whether you want only groups mapped from ldap (Only ldap groups=y) or a
mix of manually set groups and ldap groups (Only ldap groups=n). Setting this to
'no' will result in users never losing privileges when you remove them from a
ldap group, so that's a potential security issue. It is still the default to
prevent losing group information by accident.

For active directory, use LDAP attribute 'memberOf' and operator 'contains'.
Fill in the DN of the windows group as value and choose an OpenERP group users
with this windows group are to be assigned to.

For posix accounts, use operator 'query' and a value like
(&(cn=bzr)(objectClass=posixGroup)(memberUid=$uid))

The operator query matches if the filter in value returns something, and value
can contain $[attribute] which will be replaced by the first value of the
user's ldap record's attribute named [attribute].
""",
    "category": "Tools",
    "data": [
        'users_ldap_groups.xml',
        'security/ir.model.access.csv',
    ],
    "installable": True,
    "external_dependencies": {
        'python': ['ldap'],
    },
}

#retriever
from pkg_resources import parse_version

from retriever.lib.models import Table, Cleanup, correct_invalid_value
from retriever.lib.templates import Script

try:
    from retriever.lib.defaults import VERSION

    try:
        from retriever.lib.tools import open_fr, open_fw
    except ImportError:
        from retriever.lib.scripts import open_fr, open_fw
except ImportError:
    from retriever import open_fr, open_fw, VERSION


class main(Script):
    def __init__(self, **kwargs):
        Script.__init__(self, **kwargs)
        self.title = "Gulf of Maine intertidal density/cover (Petraitis et al. 2008)"
        self.citation = "Peter S. Petraitis, Harrison Liu, and " \
                        "Erika C. Rhile. 2008. Densities and cover " \
                        "data for intertidal organisms in the Gulf of " \
                        "Maine, USA, from 2003 to 2007. Ecology 89:588."
        self.name = "intertidal-abund-me"
        self.ref = "https://figshare.com/collections/DENSITIES_AND_COVER_DATA_FOR_INTERTIDAL_ORGANISMS_IN_THE_GULF_OF_MAINE_USA_FROM_2003_TO_2007/3300200"
        self.description = "The data on densities and percent cover in the " \
                           "60 experimental plots from 2003 to 2007 and to " \
                           "update data from 1996 to 2002 that are already " \
                           "published in Ecological Archives." \
                           "Includes densities of mussels, " \
                           "herbivorous limpet, herbivorous snails, " \
                           "predatory snail, barnacle , fucoid algae and " \
                           "percent cover by mussels, barnacles, fucoids, " \
                           "and other sessile organisms."
        self.retriever_minimum_version = '2.0.dev'
        self.version = '1.5.3'
        self.urls = {"main": "https://ndownloader.figshare.com/files/5600831"}
        self.cleanup_func_table = Cleanup(correct_invalid_value, missing_values=[-999.9])

        if parse_version(VERSION) <= parse_version("2.0.0"):
            self.shortname = self.name
            self.name = self.title
            self.cleanup_func_table = Cleanup(correct_invalid_value, nulls=[-999.9])
        self.tables = {"main": Table("main", cleanup=self.cleanup_func_table)}

    def download(self, engine=None, debug=False):
        Script.download(self, engine, debug)
        original_data = "Succession_sampling_03-07_data_original.txt"
        new_date = "Succession_sampling_03-07_data.txt"
        self.engine.download_file(self.urls["main"], original_data)
        data_path = self.engine.format_filename(new_date)
        old_data = open_fr(self.engine.find_file(original_data))
        new_data = open_fw(data_path)
        # original file's header contains an end of line charactor
        #  in the middle hence creating two lines
        # Read in the two lines and create the full header
        line1 = old_data.readline().strip()
        line2 = old_data.readline()
        newline = line1 + "\t" + line2
        new_data.write(newline)
        for line in old_data:
            new_data.write(line)
        new_data.close()
        old_data.close()

        self.engine.auto_create_table(self.tables["main"], filename=new_date)
        self.engine.insert_data_from_file(data_path)


SCRIPT = main()

# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from wechatpy.client.api.base import BaseWeChatAPI


class WeChatMisc(BaseWeChatAPI):

    def short_url(self, long_url):
        """
        将一条长链接转成短链接
        详情请参考
        http://mp.weixin.qq.com/wiki/10/165c9b15eddcfbd8699ac12b0bd89ae6.html

        :param long_url: 长链接地址
        :return: 返回的 JSON 数据包

        使用示例::

            from wechatpy import WeChatClient

            client = WeChatClient('appid', 'secret')
            res = client.misc.short_url('http://www.qq.com')

        """
        return self._post(
            'shorturl',
            data={
                'action': 'long2short',
                'long_url': long_url
            }
        )

    def get_wechat_ips(self):
        """
        获取微信服务器 IP 地址列表

        :return: IP 地址列表

        使用示例::

            from wechatpy import WeChatClient

            client = WeChatClient('appid', 'secret')
            ips = client.misc.get_wechat_ips()

        """
        res = self._get(
            'getcallbackip',
            result_processor=lambda x: x['ip_list']
        )
        return res

data = (
' a/c ',    # 0x00
' a/s ',    # 0x01
'C',    # 0x02
'',    # 0x03
'',    # 0x04
' c/o ',    # 0x05
' c/u ',    # 0x06
'',    # 0x07
'',    # 0x08
'',    # 0x09
'g',    # 0x0a
'H',    # 0x0b
'H',    # 0x0c
'H',    # 0x0d
'h',    # 0x0e
'',    # 0x0f
'I',    # 0x10
'I',    # 0x11
'L',    # 0x12
'l',    # 0x13
'',    # 0x14
'N',    # 0x15
'',    # 0x16
'',    # 0x17
'',    # 0x18
'P',    # 0x19
'Q',    # 0x1a
'R',    # 0x1b
'R',    # 0x1c
'R',    # 0x1d
'',    # 0x1e
'',    # 0x1f
'(sm)',    # 0x20
'TEL',    # 0x21
'(tm)',    # 0x22
'',    # 0x23
'Z',    # 0x24
'',    # 0x25
'',    # 0x26
'',    # 0x27
'Z',    # 0x28
'',    # 0x29
'K',    # 0x2a
'A',    # 0x2b
'B',    # 0x2c
'C',    # 0x2d
'e',    # 0x2e
'e',    # 0x2f
'E',    # 0x30
'F',    # 0x31
'F',    # 0x32
'M',    # 0x33
'o',    # 0x34
'',    # 0x35
'',    # 0x36
'',    # 0x37
'',    # 0x38
'i',    # 0x39
'',    # 0x3a
'FAX',    # 0x3b
'',    # 0x3c
'',    # 0x3d
'',    # 0x3e
'',    # 0x3f
'[?]',    # 0x40
'[?]',    # 0x41
'[?]',    # 0x42
'[?]',    # 0x43
'[?]',    # 0x44
'D',    # 0x45
'd',    # 0x46
'e',    # 0x47
'i',    # 0x48
'j',    # 0x49
'[?]',    # 0x4a
'[?]',    # 0x4b
'[?]',    # 0x4c
'[?]',    # 0x4d
'F',    # 0x4e
'[?]',    # 0x4f
' 1/7 ',    # 0x50
' 1/9 ',    # 0x51
' 1/10 ',    # 0x52
' 1/3 ',    # 0x53
' 2/3 ',    # 0x54
' 1/5 ',    # 0x55
' 2/5 ',    # 0x56
' 3/5 ',    # 0x57
' 4/5 ',    # 0x58
' 1/6 ',    # 0x59
' 5/6 ',    # 0x5a
' 1/8 ',    # 0x5b
' 3/8 ',    # 0x5c
' 5/8 ',    # 0x5d
' 7/8 ',    # 0x5e
' 1/',    # 0x5f
'I',    # 0x60
'II',    # 0x61
'III',    # 0x62
'IV',    # 0x63
'V',    # 0x64
'VI',    # 0x65
'VII',    # 0x66
'VIII',    # 0x67
'IX',    # 0x68
'X',    # 0x69
'XI',    # 0x6a
'XII',    # 0x6b
'L',    # 0x6c
'C',    # 0x6d
'D',    # 0x6e
'M',    # 0x6f
'i',    # 0x70
'ii',    # 0x71
'iii',    # 0x72
'iv',    # 0x73
'v',    # 0x74
'vi',    # 0x75
'vii',    # 0x76
'viii',    # 0x77
'ix',    # 0x78
'x',    # 0x79
'xi',    # 0x7a
'xii',    # 0x7b
'l',    # 0x7c
'c',    # 0x7d
'd',    # 0x7e
'm',    # 0x7f
'(D',    # 0x80
'D)',    # 0x81
'((|))',    # 0x82
')',    # 0x83
'[?]',    # 0x84
'[?]',    # 0x85
'[?]',    # 0x86
'[?]',    # 0x87
'[?]',    # 0x88
' 0/3 ',    # 0x89
'[?]',    # 0x8a
'[?]',    # 0x8b
'[?]',    # 0x8c
'[?]',    # 0x8d
'[?]',    # 0x8e
'[?]',    # 0x8f
'-',    # 0x90
'|',    # 0x91
'-',    # 0x92
'|',    # 0x93
'-',    # 0x94
'|',    # 0x95
'\\',    # 0x96
'/',    # 0x97
'\\',    # 0x98
'/',    # 0x99
'-',    # 0x9a
'-',    # 0x9b
'~',    # 0x9c
'~',    # 0x9d
'-',    # 0x9e
'|',    # 0x9f
'-',    # 0xa0
'|',    # 0xa1
'-',    # 0xa2
'-',    # 0xa3
'-',    # 0xa4
'|',    # 0xa5
'-',    # 0xa6
'|',    # 0xa7
'|',    # 0xa8
'-',    # 0xa9
'-',    # 0xaa
'-',    # 0xab
'-',    # 0xac
'-',    # 0xad
'-',    # 0xae
'|',    # 0xaf
'|',    # 0xb0
'|',    # 0xb1
'|',    # 0xb2
'|',    # 0xb3
'|',    # 0xb4
'|',    # 0xb5
'^',    # 0xb6
'V',    # 0xb7
'\\',    # 0xb8
'=',    # 0xb9
'V',    # 0xba
'^',    # 0xbb
'-',    # 0xbc
'-',    # 0xbd
'|',    # 0xbe
'|',    # 0xbf
'-',    # 0xc0
'-',    # 0xc1
'|',    # 0xc2
'|',    # 0xc3
'=',    # 0xc4
'|',    # 0xc5
'=',    # 0xc6
'=',    # 0xc7
'|',    # 0xc8
'=',    # 0xc9
'|',    # 0xca
'=',    # 0xcb
'=',    # 0xcc
'=',    # 0xcd
'=',    # 0xce
'=',    # 0xcf
'=',    # 0xd0
'|',    # 0xd1
'=',    # 0xd2
'|',    # 0xd3
'=',    # 0xd4
'|',    # 0xd5
'\\',    # 0xd6
'/',    # 0xd7
'\\',    # 0xd8
'/',    # 0xd9
'=',    # 0xda
'=',    # 0xdb
'~',    # 0xdc
'~',    # 0xdd
'|',    # 0xde
'|',    # 0xdf
'-',    # 0xe0
'|',    # 0xe1
'-',    # 0xe2
'|',    # 0xe3
'-',    # 0xe4
'-',    # 0xe5
'-',    # 0xe6
'|',    # 0xe7
'-',    # 0xe8
'|',    # 0xe9
'|',    # 0xea
'|',    # 0xeb
'|',    # 0xec
'|',    # 0xed
'|',    # 0xee
'|',    # 0xef
'-',    # 0xf0
'\\',    # 0xf1
'\\',    # 0xf2
'|',    # 0xf3
'[?]',    # 0xf4
'[?]',    # 0xf5
'[?]',    # 0xf6
'[?]',    # 0xf7
'[?]',    # 0xf8
'[?]',    # 0xf9
'[?]',    # 0xfa
'[?]',    # 0xfb
'[?]',    # 0xfc
'[?]',    # 0xfd
'[?]',    # 0xfe
)

# -*- coding: utf-8 -*-
# This file is part of Shoop.
#
# Copyright (c) 2012-2015, Shoop Ltd. All rights reserved.
#
# This source code is licensed under the AGPLv3 license found in the
# LICENSE file in the root directory of this source tree.
from __future__ import unicode_literals

from django.conf import settings
from django.core.urlresolvers import reverse
from django.db.models import Q
from django.utils.encoding import force_text
from django.utils.translation import ugettext_lazy as _
from django.views.generic import DetailView

from shoop.admin.toolbar import PostActionButton, Toolbar, URLActionButton
from shoop.core.models import Contact, Order, PersonContact


class ContactDetailToolbar(Toolbar):
    def __init__(self, contact):
        self.contact = contact
        self.user = getattr(self.contact, "user", None)
        super(ContactDetailToolbar, self).__init__()
        self.build()

    def build_renew_password_button(self):
        disable_reason = None

        if "shoop.front.apps.auth" not in settings.INSTALLED_APPS:
            disable_reason = _("The Shoop frontend is not enabled.")
        elif not self.user:
            disable_reason = _("Contact has no associated user.")
        elif not getattr(self.user, "email", None):
            disable_reason = _("User has no associated email.")

        self.append(PostActionButton(
            post_url=reverse("shoop_admin:contact.reset_password", kwargs={"pk": self.contact.pk}),
            name="pk",
            value=self.contact.pk,
            text=_(u"Reset password"),
            tooltip=_(u"Send a password renewal email."),
            confirm=_("Are you sure you wish to send a password recovery email to %s?") % self.contact.email,
            icon="fa fa-undo",
            disable_reason=disable_reason,
            extra_css_class="btn-gray btn-inverse",
        ))

    def build_new_user_button(self):
        if self.user:
            return
        self.append(URLActionButton(
            url=reverse("shoop_admin:user.new") + "?contact_id=%s" % self.contact.pk,
            text=_(u"New User"),
            tooltip=_(u"Create an user for the contact."),
            icon="fa fa-star",
            extra_css_class="btn-gray btn-inverse",
        ))

    def build(self):
        self.append(URLActionButton(
            url=reverse("shoop_admin:contact.edit", kwargs={"pk": self.contact.pk}),
            icon="fa fa-pencil",
            text=_(u"Edit..."),
            extra_css_class="btn-info",
        ))
        self.build_renew_password_button()
        self.build_new_user_button()


class ContactDetailView(DetailView):
    model = Contact
    template_name = "shoop/admin/contacts/detail.jinja"
    context_object_name = "contact"

    def get_context_data(self, **kwargs):
        context = super(ContactDetailView, self).get_context_data(**kwargs)
        if isinstance(self.object, PersonContact):
            order_q = Q(orderer=self.object) | Q(customer=self.object)
        else:
            order_q = Q(customer=self.object)
        user = getattr(self.object, "user", None)
        if user:
            order_q |= Q(creator=user)
        context["orders"] = Order.objects.filter(order_q).order_by("-id")
        context["toolbar"] = ContactDetailToolbar(contact=self.object)
        context["title"] = "%s: %s" % (
            self.object._meta.verbose_name.title(),
            force_text(self.object)
        )
        return context

#
# Copyright (c) 2011 OpenStack Foundation
# All Rights Reserved.
#
#    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.

# Based on glance/api/policy.py
"""Policy Engine For Heat"""

from oslo_config import cfg

from heat.common import exception
from heat.openstack.common import policy


CONF = cfg.CONF

DEFAULT_RULES = {
    'default': policy.FalseCheck(),
}


class Enforcer(object):
    """Responsible for loading and enforcing rules."""

    def __init__(self, scope='heat', exc=exception.Forbidden,
                 default_rule=DEFAULT_RULES['default'], policy_file=None):
        self.scope = scope
        self.exc = exc
        self.default_rule = default_rule
        self.enforcer = policy.Enforcer(
            default_rule=default_rule, policy_file=policy_file)

    def set_rules(self, rules, overwrite=True):
        """Create a new Rules object based on the provided dict of rules."""
        rules_obj = policy.Rules(rules, self.default_rule)
        self.enforcer.set_rules(rules_obj, overwrite)

    def load_rules(self, force_reload=False):
        """Set the rules found in the json file on disk."""
        self.enforcer.load_rules(force_reload)

    def _check(self, context, rule, target, exc, *args, **kwargs):
        """Verifies that the action is valid on the target in this context.

           :param context: Heat request context
           :param rule: String representing the action to be checked
           :param target: Dictionary representing the object of the action.
           :raises: self.exc (defaults to heat.common.exception.Forbidden)
           :returns: A non-False value if access is allowed.
        """
        do_raise = False if not exc else True
        credentials = context.to_dict()
        return self.enforcer.enforce(rule, target, credentials,
                                     do_raise, exc=exc, *args, **kwargs)

    def enforce(self, context, action, scope=None, target=None):
        """Verifies that the action is valid on the target in this context.

           :param context: Heat request context
           :param action: String representing the action to be checked
           :param target: Dictionary representing the object of the action.
           :raises: self.exc (defaults to heat.common.exception.Forbidden)
           :returns: A non-False value if access is allowed.
        """
        _action = '%s:%s' % (scope or self.scope, action)
        _target = target or {}
        return self._check(context, _action, _target, self.exc, action=action)

    def check_is_admin(self, context):
        """Whether or not roles contains 'admin' role according to policy.json

           :param context: Heat request context
           :returns: A non-False value if the user is admin according to policy
        """
        return self._check(context, 'context_is_admin', target={}, exc=None)

"""Functions that read and write gzipped files.

The user of the file doesn't have to worry about the compression,
but random access is not allowed."""

# based on Andrew Kuchling's minigzip.py distributed with the zlib module

import struct, sys, time
import zlib
import __builtin__

__all__ = ["GzipFile","open"]

FTEXT, FHCRC, FEXTRA, FNAME, FCOMMENT = 1, 2, 4, 8, 16

READ, WRITE = 1, 2

def U32(i):
    """Return i as an unsigned integer, assuming it fits in 32 bits.

    If it's >= 2GB when viewed as a 32-bit unsigned int, return a long.
    """
    if i < 0:
        i += 1L << 32
    return i

def LOWU32(i):
    """Return the low-order 32 bits of an int, as a non-negative int."""
    return i & 0xFFFFFFFFL

def write32(output, value):
    output.write(struct.pack("<l", value))

def write32u(output, value):
    # The L format writes the bit pattern correctly whether signed
    # or unsigned.
    output.write(struct.pack("<L", value))

def read32(input):
    return struct.unpack("<l", input.read(4))[0]

def open(filename, mode="rb", compresslevel=9):
    """Shorthand for GzipFile(filename, mode, compresslevel).

    The filename argument is required; mode defaults to 'rb'
    and compresslevel defaults to 9.

    """
    return GzipFile(filename, mode, compresslevel)

class GzipFile:
    """The GzipFile class simulates most of the methods of a file object with
    the exception of the readinto() and truncate() methods.

    """

    myfileobj = None
    # XXX: repeated 10mb chunk reads hurt test_gzip.test_many_append's
    # performance on Jython (maybe CPython's allocator recycles the same
    # 10mb buffer whereas Java's doesn't)
    #max_read_chunk = 10 * 1024 * 1024   # 10Mb
    max_read_chunk = 256 * 1024 # 256kb

    def __init__(self, filename=None, mode=None,
                 compresslevel=9, fileobj=None):
        """Constructor for the GzipFile class.

        At least one of fileobj and filename must be given a
        non-trivial value.

        The new class instance is based on fileobj, which can be a regular
        file, a StringIO object, or any other object which simulates a file.
        It defaults to None, in which case filename is opened to provide
        a file object.

        When fileobj is not None, the filename argument is only used to be
        included in the gzip file header, which may includes the original
        filename of the uncompressed file.  It defaults to the filename of
        fileobj, if discernible; otherwise, it defaults to the empty string,
        and in this case the original filename is not included in the header.

        The mode argument can be any of 'r', 'rb', 'a', 'ab', 'w', or 'wb',
        depending on whether the file will be read or written.  The default
        is the mode of fileobj if discernible; otherwise, the default is 'rb'.
        Be aware that only the 'rb', 'ab', and 'wb' values should be used
        for cross-platform portability.

        The compresslevel argument is an integer from 1 to 9 controlling the
        level of compression; 1 is fastest and produces the least compression,
        and 9 is slowest and produces the most compression.  The default is 9.

        """

        # guarantee the file is opened in binary mode on platforms
        # that care about that sort of thing
        if mode and 'b' not in mode:
            mode += 'b'
        if fileobj is None:
            fileobj = self.myfileobj = __builtin__.open(filename, mode or 'rb')
        if filename is None:
            if hasattr(fileobj, 'name'): filename = fileobj.name
            else: filename = ''
        if mode is None:
            if hasattr(fileobj, 'mode'): mode = fileobj.mode
            else: mode = 'rb'

        if mode[0:1] == 'r':
            self.mode = READ
            # Set flag indicating start of a new member
            self._new_member = True
            self.extrabuf = ""
            self.extrasize = 0
            self.filename = filename
            # Starts small, scales exponentially
            self.min_readsize = 100

        elif mode[0:1] == 'w' or mode[0:1] == 'a':
            self.mode = WRITE
            self._init_write(filename)
            self.compress = zlib.compressobj(compresslevel,
                                             zlib.DEFLATED,
                                             -zlib.MAX_WBITS,
                                             zlib.DEF_MEM_LEVEL,
                                             0)
        else:
            raise IOError, "Mode " + mode + " not supported"

        self.fileobj = fileobj
        self.offset = 0

        if self.mode == WRITE:
            self._write_gzip_header()

    def __repr__(self):
        s = repr(self.fileobj)
        return '<gzip ' + s[1:-1] + ' ' + hex(id(self)) + '>'

    def _init_write(self, filename):
        if filename[-3:] != '.gz':
            filename = filename + '.gz'
        self.filename = filename
        self.crc = zlib.crc32("")
        self.size = 0
        self.writebuf = []
        self.bufsize = 0

    def _write_gzip_header(self):
        self.fileobj.write('\037\213')             # magic header
        self.fileobj.write('\010')                 # compression method
        fname = self.filename[:-3]
        flags = 0
        if fname:
            flags = FNAME
        self.fileobj.write(chr(flags))
        write32u(self.fileobj, long(time.time()))
        self.fileobj.write('\002')
        self.fileobj.write('\377')
        if fname:
            self.fileobj.write(fname + '\000')

    def _init_read(self):
        self.crc = zlib.crc32("")
        self.size = 0

    def _read_gzip_header(self):
        magic = self.fileobj.read(2)
        if magic != '\037\213':
            raise IOError, 'Not a gzipped file'
        method = ord( self.fileobj.read(1) )
        if method != 8:
            raise IOError, 'Unknown compression method'
        flag = ord( self.fileobj.read(1) )
        # modtime = self.fileobj.read(4)
        # extraflag = self.fileobj.read(1)
        # os = self.fileobj.read(1)
        self.fileobj.read(6)

        if flag & FEXTRA:
            # Read & discard the extra field, if present
            xlen = ord(self.fileobj.read(1))
            xlen = xlen + 256*ord(self.fileobj.read(1))
            self.fileobj.read(xlen)
        if flag & FNAME:
            # Read and discard a null-terminated string containing the filename
            while True:
                s = self.fileobj.read(1)
                if not s or s=='\000':
                    break
        if flag & FCOMMENT:
            # Read and discard a null-terminated string containing a comment
            while True:
                s = self.fileobj.read(1)
                if not s or s=='\000':
                    break
        if flag & FHCRC:
            self.fileobj.read(2)     # Read & discard the 16-bit header CRC


    def write(self,data):
        if self.mode != WRITE:
            import errno
            raise IOError(errno.EBADF, "write() on read-only GzipFile object")

        if self.fileobj is None:
            raise ValueError, "write() on closed GzipFile object"
        if len(data) > 0:
            self.size = self.size + len(data)
            self.crc = zlib.crc32(data, self.crc)
            self.fileobj.write( self.compress.compress(data) )
            self.offset += len(data)

    def read(self, size=-1):
        if self.mode != READ:
            import errno
            raise IOError(errno.EBADF, "read() on write-only GzipFile object")

        if self.extrasize <= 0 and self.fileobj is None:
            return ''

        readsize = 1024
        if size < 0:        # get the whole thing
            try:
                while True:
                    self._read(readsize)
                    readsize = min(self.max_read_chunk, readsize * 2)
            except EOFError:
                size = self.extrasize
        else:               # just get some more of it
            try:
                while size > self.extrasize:
                    self._read(readsize)
                    readsize = min(self.max_read_chunk, readsize * 2)
            except EOFError:
                if size > self.extrasize:
                    size = self.extrasize

        chunk = self.extrabuf[:size]
        self.extrabuf = self.extrabuf[size:]
        self.extrasize = self.extrasize - size

        self.offset += size
        return chunk

    def _unread(self, buf):
        self.extrabuf = buf + self.extrabuf
        self.extrasize = len(buf) + self.extrasize
        self.offset -= len(buf)

    def _read(self, size=1024):
        if self.fileobj is None:
            raise EOFError, "Reached EOF"

        if self._new_member:
            # If the _new_member flag is set, we have to
            # jump to the next member, if there is one.
            #
            # First, check if we're at the end of the file;
            # if so, it's time to stop; no more members to read.
            pos = self.fileobj.tell()   # Save current position
            self.fileobj.seek(0, 2)     # Seek to end of file
            if pos == self.fileobj.tell():
                raise EOFError, "Reached EOF"
            else:
                self.fileobj.seek( pos ) # Return to original position

            self._init_read()
            self._read_gzip_header()
            self.decompress = zlib.decompressobj(-zlib.MAX_WBITS)
            self._new_member = False

        # Read a chunk of data from the file
        buf = self.fileobj.read(size)

        # If the EOF has been reached, flush the decompression object
        # and mark this object as finished.

        if buf == "":
            uncompress = self.decompress.flush()
            self._read_eof()
            self._add_read_data( uncompress )
            raise EOFError, 'Reached EOF'

        uncompress = self.decompress.decompress(buf)
        self._add_read_data( uncompress )

        if self.decompress.unused_data != "":
            # Ending case: we've come to the end of a member in the file,
            # so seek back to the start of the unused data, finish up
            # this member, and read a new gzip header.
            # (The number of bytes to seek back is the length of the unused
            # data, minus 8 because _read_eof() will rewind a further 8 bytes)
            self.fileobj.seek( -len(self.decompress.unused_data)+8, 1)

            # Check the CRC and file size, and set the flag so we read
            # a new member on the next call
            self._read_eof()
            self._new_member = True

    def _add_read_data(self, data):
        self.crc = zlib.crc32(data, self.crc)
        self.extrabuf = self.extrabuf + data
        self.extrasize = self.extrasize + len(data)
        self.size = self.size + len(data)

    def _read_eof(self):
        # We've read to the end of the file, so we have to rewind in order
        # to reread the 8 bytes containing the CRC and the file size.
        # We check the that the computed CRC and size of the
        # uncompressed data matches the stored values.  Note that the size
        # stored is the true file size mod 2**32.
        self.fileobj.seek(-8, 1)
        crc32 = read32(self.fileobj)
        isize = U32(read32(self.fileobj))   # may exceed 2GB
        if U32(crc32) != U32(self.crc):
            raise IOError, "CRC check failed"
        elif isize != LOWU32(self.size):
            raise IOError, "Incorrect length of data produced"

    def close(self):
        if self.mode == WRITE:
            self.fileobj.write(self.compress.flush())
            # The native zlib crc is an unsigned 32-bit integer, but
            # the Python wrapper implicitly casts that to a signed C
            # long.  So, on a 32-bit box self.crc may "look negative",
            # while the same crc on a 64-bit box may "look positive".
            # To avoid irksome warnings from the `struct` module, force
            # it to look positive on all boxes.
            write32u(self.fileobj, LOWU32(self.crc))
            # self.size may exceed 2GB, or even 4GB
            write32u(self.fileobj, LOWU32(self.size))
            self.fileobj = None
        elif self.mode == READ:
            self.fileobj = None
        if self.myfileobj:
            self.myfileobj.close()
            self.myfileobj = None

    def __del__(self):
        try:
            if (self.myfileobj is None and
                self.fileobj is None):
                return
        except AttributeError:
            return
        self.close()

    if not sys.platform.startswith('java'):
        def flush(self,zlib_mode=zlib.Z_SYNC_FLUSH):
            if self.mode == WRITE:
                # Ensure the compressor's buffer is flushed
                self.fileobj.write(self.compress.flush(zlib_mode))
            self.fileobj.flush()
    else:
        # Java lacks Z_SYNC_FLUSH; thus Jython can't flush the
        # compressobj until EOF
        def flush(self,zlib_mode=None):
            self.fileobj.flush()

    def fileno(self):
        """Invoke the underlying file object's fileno() method.

        This will raise AttributeError if the underlying file object
        doesn't support fileno().
        """
        return self.fileobj.fileno()

    def isatty(self):
        return False

    def tell(self):
        return self.offset

    def rewind(self):
        '''Return the uncompressed stream file position indicator to the
        beginning of the file'''
        if self.mode != READ:
            raise IOError("Can't rewind in write mode")
        self.fileobj.seek(0)
        self._new_member = True
        self.extrabuf = ""
        self.extrasize = 0
        self.offset = 0

    def seek(self, offset):
        if self.mode == WRITE:
            if offset < self.offset:
                raise IOError('Negative seek in write mode')
            count = offset - self.offset
            for i in range(count // 1024):
                self.write(1024 * '\0')
            self.write((count % 1024) * '\0')
        elif self.mode == READ:
            if offset < self.offset:
                # for negative seek, rewind and do positive seek
                self.rewind()
            count = offset - self.offset
            for i in range(count // 1024):
                self.read(1024)
            self.read(count % 1024)

    def readline(self, size=-1):
        if size < 0:
            size = sys.maxint
            readsize = self.min_readsize
        else:
            readsize = size
        bufs = []
        while size != 0:
            c = self.read(readsize)
            i = c.find('\n')

            # We set i=size to break out of the loop under two
            # conditions: 1) there's no newline, and the chunk is
            # larger than size, or 2) there is a newline, but the
            # resulting line would be longer than 'size'.
            if (size <= i) or (i == -1 and len(c) > size):
                i = size - 1

            if i >= 0 or c == '':
                bufs.append(c[:i + 1])    # Add portion of last chunk
                self._unread(c[i + 1:])   # Push back rest of chunk
                break

            # Append chunk to list, decrease 'size',
            bufs.append(c)
            size = size - len(c)
            readsize = min(size, readsize * 2)
        if readsize > self.min_readsize:
            self.min_readsize = min(readsize, self.min_readsize * 2, 512)
        return ''.join(bufs) # Return resulting line

    def readlines(self, sizehint=0):
        # Negative numbers result in reading all the lines
        if sizehint <= 0:
            sizehint = sys.maxint
        L = []
        while sizehint > 0:
            line = self.readline()
            if line == "":
                break
            L.append(line)
            sizehint = sizehint - len(line)

        return L

    def writelines(self, L):
        for line in L:
            self.write(line)

    def __iter__(self):
        return self

    def next(self):
        line = self.readline()
        if line:
            return line
        else:
            raise StopIteration


def _test():
    # Act like gzip; with -d, act like gunzip.
    # The input file is not deleted, however, nor are any other gzip
    # options or features supported.
    args = sys.argv[1:]
    decompress = args and args[0] == "-d"
    if decompress:
        args = args[1:]
    if not args:
        args = ["-"]
    for arg in args:
        if decompress:
            if arg == "-":
                f = GzipFile(filename="", mode="rb", fileobj=sys.stdin)
                g = sys.stdout
            else:
                if arg[-3:] != ".gz":
                    print "filename doesn't end in .gz:", repr(arg)
                    continue
                f = open(arg, "rb")
                g = __builtin__.open(arg[:-3], "wb")
        else:
            if arg == "-":
                f = sys.stdin
                g = GzipFile(filename="", mode="wb", fileobj=sys.stdout)
            else:
                f = __builtin__.open(arg, "rb")
                g = open(arg + ".gz", "wb")
        while True:
            chunk = f.read(1024)
            if not chunk:
                break
            g.write(chunk)
        if g is not sys.stdout:
            g.close()
        if f is not sys.stdin:
            f.close()

if __name__ == '__main__':
    _test()

import json

from django.core.exceptions import SuspiciousOperation
from django.core.signing import BadSignature

from django.contrib.formtools.wizard import storage


class CookieStorage(storage.BaseStorage):
    encoder = json.JSONEncoder(separators=(',', ':'))

    def __init__(self, *args, **kwargs):
        super(CookieStorage, self).__init__(*args, **kwargs)
        self.data = self.load_data()
        if self.data is None:
            self.init_data()

    def load_data(self):
        try:
            data = self.request.get_signed_cookie(self.prefix)
        except KeyError:
            data = None
        except BadSignature:
            raise SuspiciousOperation('WizardView cookie manipulated')
        if data is None:
            return None
        return json.loads(data, cls=json.JSONDecoder)

    def update_response(self, response):
        if self.data:
            response.set_signed_cookie(self.prefix, self.encoder.encode(self.data))
        else:
            response.delete_cookie(self.prefix)

import re

from streamlink.plugin import Plugin
from streamlink.plugin.api import validate
from streamlink.stream import HLSStream, HDSStream
from streamlink.compat import urljoin
from streamlink.stream import HTTPStream


class ard_live(Plugin):
    swf_url = "http://live.daserste.de/lib/br-player/swf/main.swf"
    _url_re = re.compile(r"https?://(www.)?daserste.de/", re.I)
    _player_re = re.compile(r'''dataURL\s*:\s*(?P<q>['"])(?P<url>.*?)(?P=q)''')
    _player_url_schema = validate.Schema(
        validate.transform(_player_re.search),
        validate.any(
            None,
            validate.all(validate.get("url"), validate.text)
        )
    )
    _livestream_schema = validate.Schema(
        validate.xml_findall(".//assets"),
        validate.filter(lambda x: x.attrib.get("type") != "subtitles"),
        validate.get(0),
        validate.xml_findall(".//asset"),
        [validate.union({
            "url": validate.xml_findtext("./fileName"),
            "bitrate": validate.xml_findtext("./bitrateVideo")
        })])

    @classmethod
    def can_handle_url(cls, url):
        return cls._url_re.match(url) is not None

    def _get_streams(self):
        data_url = self.session.http.get(self.url, schema=self._player_url_schema)
        if data_url:
            res = self.session.http.get(urljoin(self.url, data_url))
            stream_info = self.session.http.xml(res, schema=self._livestream_schema)

            for stream in stream_info:
                url = stream["url"]
                try:
                    if ".m3u8" in url:
                        for s in HLSStream.parse_variant_playlist(self.session, url, name_key="bitrate").items():
                            yield s
                    elif ".f4m" in url:
                        for s in HDSStream.parse_manifest(self.session, url, pvswf=self.swf_url, is_akamai=True).items():
                            yield s
                    elif ".mp4" in url:
                        yield "{0}k".format(stream["bitrate"]), HTTPStream(self.session, url)
                except IOError as err:
                    self.logger.warning("Error parsing stream: {0}", err)


__plugin__ = ard_live

# Copyright 2010 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# Copyright 2010 OpenStack Foundation
# All Rights Reserved.
#
#    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.

"""Utility methods for working with WSGI servers."""

from __future__ import print_function

import os.path
import socket
import ssl
import sys

import eventlet
import eventlet.wsgi
import greenlet
from oslo_config import cfg
from oslo_log import log as logging
from oslo_service import service
from oslo_utils import excutils
from paste import deploy
import routes.middleware
import six
import webob.dec
import webob.exc

from nova import exception
from nova.i18n import _, _LE, _LI

wsgi_opts = [
    cfg.StrOpt('api_paste_config',
               default="api-paste.ini",
               help='File name for the paste.deploy config for nova-api'),
    cfg.StrOpt('wsgi_log_format',
            default='%(client_ip)s "%(request_line)s" status: %(status_code)s'
                    ' len: %(body_length)s time: %(wall_seconds).7f',
            help='A python format string that is used as the template to '
                 'generate log lines. The following values can be formatted '
                 'into it: client_ip, date_time, request_line, status_code, '
                 'body_length, wall_seconds.'),
    cfg.StrOpt('ssl_ca_file',
               help="CA certificate file to use to verify "
                    "connecting clients"),
    cfg.StrOpt('ssl_cert_file',
                    help="SSL certificate of API server"),
    cfg.StrOpt('ssl_key_file',
                    help="SSL private key of API server"),
    cfg.IntOpt('tcp_keepidle',
               default=600,
               help="Sets the value of TCP_KEEPIDLE in seconds for each "
                    "server socket. Not supported on OS X."),
    cfg.IntOpt('wsgi_default_pool_size',
               default=1000,
               help="Size of the pool of greenthreads used by wsgi"),
    cfg.IntOpt('max_header_line',
               default=16384,
               help="Maximum line size of message headers to be accepted. "
                    "max_header_line may need to be increased when using "
                    "large tokens (typically those generated by the "
                    "Keystone v3 API with big service catalogs)."),
    cfg.BoolOpt('wsgi_keep_alive',
                default=True,
                help="If False, closes the client socket connection "
                     "explicitly."),
    cfg.IntOpt('client_socket_timeout', default=900,
               help="Timeout for client connections' socket operations. "
                    "If an incoming connection is idle for this number of "
                    "seconds it will be closed. A value of '0' means "
                    "wait forever."),
    ]
CONF = cfg.CONF
CONF.register_opts(wsgi_opts)

LOG = logging.getLogger(__name__)


class Server(service.ServiceBase):
    """Server class to manage a WSGI server, serving a WSGI application."""

    default_pool_size = CONF.wsgi_default_pool_size

    def __init__(self, name, app, host='0.0.0.0', port=0, pool_size=None,
                       protocol=eventlet.wsgi.HttpProtocol, backlog=128,
                       use_ssl=False, max_url_len=None):
        """Initialize, but do not start, a WSGI server.

        :param name: Pretty name for logging.
        :param app: The WSGI application to serve.
        :param host: IP address to serve the application.
        :param port: Port number to server the application.
        :param pool_size: Maximum number of eventlets to spawn concurrently.
        :param backlog: Maximum number of queued connections.
        :param max_url_len: Maximum length of permitted URLs.
        :returns: None
        :raises: nova.exception.InvalidInput
        """
        # Allow operators to customize http requests max header line size.
        eventlet.wsgi.MAX_HEADER_LINE = CONF.max_header_line
        self.name = name
        self.app = app
        self._server = None
        self._protocol = protocol
        self.pool_size = pool_size or self.default_pool_size
        self._pool = eventlet.GreenPool(self.pool_size)
        self._logger = logging.getLogger("nova.%s.wsgi.server" % self.name)
        self._use_ssl = use_ssl
        self._max_url_len = max_url_len
        self.client_socket_timeout = CONF.client_socket_timeout or None

        if backlog < 1:
            raise exception.InvalidInput(
                    reason='The backlog must be more than 1')

        bind_addr = (host, port)
        # TODO(dims): eventlet's green dns/socket module does not actually
        # support IPv6 in getaddrinfo(). We need to get around this in the
        # future or monitor upstream for a fix
        try:
            info = socket.getaddrinfo(bind_addr[0],
                                      bind_addr[1],
                                      socket.AF_UNSPEC,
                                      socket.SOCK_STREAM)[0]
            family = info[0]
            bind_addr = info[-1]
        except Exception:
            family = socket.AF_INET

        try:
            self._socket = eventlet.listen(bind_addr, family, backlog=backlog)
        except EnvironmentError:
            LOG.error(_LE("Could not bind to %(host)s:%(port)s"),
                      {'host': host, 'port': port})
            raise

        (self.host, self.port) = self._socket.getsockname()[0:2]
        LOG.info(_LI("%(name)s listening on %(host)s:%(port)s"),
                 {'name': self.name, 'host': self.host, 'port': self.port})

    def start(self):
        """Start serving a WSGI application.

        :returns: None
        """
        # The server socket object will be closed after server exits,
        # but the underlying file descriptor will remain open, and will
        # give bad file descriptor error. So duplicating the socket object,
        # to keep file descriptor usable.

        dup_socket = self._socket.dup()
        dup_socket.setsockopt(socket.SOL_SOCKET,
                              socket.SO_REUSEADDR, 1)
        # sockets can hang around forever without keepalive
        dup_socket.setsockopt(socket.SOL_SOCKET,
                              socket.SO_KEEPALIVE, 1)

        # This option isn't available in the OS X version of eventlet
        if hasattr(socket, 'TCP_KEEPIDLE'):
            dup_socket.setsockopt(socket.IPPROTO_TCP,
                                  socket.TCP_KEEPIDLE,
                                  CONF.tcp_keepidle)

        if self._use_ssl:
            try:
                ca_file = CONF.ssl_ca_file
                cert_file = CONF.ssl_cert_file
                key_file = CONF.ssl_key_file

                if cert_file and not os.path.exists(cert_file):
                    raise RuntimeError(
                          _("Unable to find cert_file : %s") % cert_file)

                if ca_file and not os.path.exists(ca_file):
                    raise RuntimeError(
                          _("Unable to find ca_file : %s") % ca_file)

                if key_file and not os.path.exists(key_file):
                    raise RuntimeError(
                          _("Unable to find key_file : %s") % key_file)

                if self._use_ssl and (not cert_file or not key_file):
                    raise RuntimeError(
                          _("When running server in SSL mode, you must "
                            "specify both a cert_file and key_file "
                            "option value in your configuration file"))
                ssl_kwargs = {
                    'server_side': True,
                    'certfile': cert_file,
                    'keyfile': key_file,
                    'cert_reqs': ssl.CERT_NONE,
                }

                if CONF.ssl_ca_file:
                    ssl_kwargs['ca_certs'] = ca_file
                    ssl_kwargs['cert_reqs'] = ssl.CERT_REQUIRED

                dup_socket = eventlet.wrap_ssl(dup_socket,
                                               **ssl_kwargs)
            except Exception:
                with excutils.save_and_reraise_exception():
                    LOG.error(_LE("Failed to start %(name)s on %(host)s"
                                  ":%(port)s with SSL support"),
                              {'name': self.name, 'host': self.host,
                               'port': self.port})

        wsgi_kwargs = {
            'func': eventlet.wsgi.server,
            'sock': dup_socket,
            'site': self.app,
            'protocol': self._protocol,
            'custom_pool': self._pool,
            'log': self._logger,
            'log_format': CONF.wsgi_log_format,
            'debug': False,
            'keepalive': CONF.wsgi_keep_alive,
            'socket_timeout': self.client_socket_timeout
            }

        if self._max_url_len:
            wsgi_kwargs['url_length_limit'] = self._max_url_len

        self._server = eventlet.spawn(**wsgi_kwargs)

    def reset(self):
        """Reset server greenpool size to default.

        :returns: None

        """
        self._pool.resize(self.pool_size)

    def stop(self):
        """Stop this server.

        This is not a very nice action, as currently the method by which a
        server is stopped is by killing its eventlet.

        :returns: None

        """
        LOG.info(_LI("Stopping WSGI server."))

        if self._server is not None:
            # Resize pool to stop new requests from being processed
            self._pool.resize(0)
            self._server.kill()

    def wait(self):
        """Block, until the server has stopped.

        Waits on the server's eventlet to finish, then returns.

        :returns: None

        """
        try:
            if self._server is not None:
                self._pool.waitall()
                self._server.wait()
        except greenlet.GreenletExit:
            LOG.info(_LI("WSGI server has stopped."))


class Request(webob.Request):
    pass


class Application(object):
    """Base WSGI application wrapper. Subclasses need to implement __call__."""

    @classmethod
    def factory(cls, global_config, **local_config):
        """Used for paste app factories in paste.deploy config files.

        Any local configuration (that is, values under the [app:APPNAME]
        section of the paste config) will be passed into the `__init__` method
        as kwargs.

        A hypothetical configuration would look like:

            [app:wadl]
            latest_version = 1.3
            paste.app_factory = nova.api.fancy_api:Wadl.factory

        which would result in a call to the `Wadl` class as

            import nova.api.fancy_api
            fancy_api.Wadl(latest_version='1.3')

        You could of course re-implement the `factory` method in subclasses,
        but using the kwarg passing it shouldn't be necessary.

        """
        return cls(**local_config)

    def __call__(self, environ, start_response):
        r"""Subclasses will probably want to implement __call__ like this:

        @webob.dec.wsgify(RequestClass=Request)
        def __call__(self, req):
          # Any of the following objects work as responses:

          # Option 1: simple string
          res = 'message\n'

          # Option 2: a nicely formatted HTTP exception page
          res = exc.HTTPForbidden(explanation='Nice try')

          # Option 3: a webob Response object (in case you need to play with
          # headers, or you want to be treated like an iterable, or or or)
          res = Response();
          res.app_iter = open('somefile')

          # Option 4: any wsgi app to be run next
          res = self.application

          # Option 5: you can get a Response object for a wsgi app, too, to
          # play with headers etc
          res = req.get_response(self.application)

          # You can then just return your response...
          return res
          # ... or set req.response and return None.
          req.response = res

        See the end of http://pythonpaste.org/webob/modules/dec.html
        for more info.

        """
        raise NotImplementedError(_('You must implement __call__'))


class Middleware(Application):
    """Base WSGI middleware.

    These classes require an application to be
    initialized that will be called next.  By default the middleware will
    simply call its wrapped app, or you can override __call__ to customize its
    behavior.

    """

    @classmethod
    def factory(cls, global_config, **local_config):
        """Used for paste app factories in paste.deploy config files.

        Any local configuration (that is, values under the [filter:APPNAME]
        section of the paste config) will be passed into the `__init__` method
        as kwargs.

        A hypothetical configuration would look like:

            [filter:analytics]
            redis_host = 127.0.0.1
            paste.filter_factory = nova.api.analytics:Analytics.factory

        which would result in a call to the `Analytics` class as

            import nova.api.analytics
            analytics.Analytics(app_from_paste, redis_host='127.0.0.1')

        You could of course re-implement the `factory` method in subclasses,
        but using the kwarg passing it shouldn't be necessary.

        """
        def _factory(app):
            return cls(app, **local_config)
        return _factory

    def __init__(self, application):
        self.application = application

    def process_request(self, req):
        """Called on each request.

        If this returns None, the next application down the stack will be
        executed. If it returns a response then that response will be returned
        and execution will stop here.

        """
        return None

    def process_response(self, response):
        """Do whatever you'd like to the response."""
        return response

    @webob.dec.wsgify(RequestClass=Request)
    def __call__(self, req):
        response = self.process_request(req)
        if response:
            return response
        response = req.get_response(self.application)
        return self.process_response(response)


class Debug(Middleware):
    """Helper class for debugging a WSGI application.

    Can be inserted into any WSGI application chain to get information
    about the request and response.

    """

    @webob.dec.wsgify(RequestClass=Request)
    def __call__(self, req):
        print(('*' * 40) + ' REQUEST ENVIRON')
        for key, value in req.environ.items():
            print(key, '=', value)
        print()
        resp = req.get_response(self.application)

        print(('*' * 40) + ' RESPONSE HEADERS')
        for (key, value) in six.iteritems(resp.headers):
            print(key, '=', value)
        print()

        resp.app_iter = self.print_generator(resp.app_iter)

        return resp

    @staticmethod
    def print_generator(app_iter):
        """Iterator that prints the contents of a wrapper string."""
        print(('*' * 40) + ' BODY')
        for part in app_iter:
            sys.stdout.write(part)
            sys.stdout.flush()
            yield part
        print()


class Router(object):
    """WSGI middleware that maps incoming requests to WSGI apps."""

    def __init__(self, mapper):
        """Create a router for the given routes.Mapper.

        Each route in `mapper` must specify a 'controller', which is a
        WSGI app to call.  You'll probably want to specify an 'action' as
        well and have your controller be an object that can route
        the request to the action-specific method.

        Examples:
          mapper = routes.Mapper()
          sc = ServerController()

          # Explicit mapping of one route to a controller+action
          mapper.connect(None, '/svrlist', controller=sc, action='list')

          # Actions are all implicitly defined
          mapper.resource('server', 'servers', controller=sc)

          # Pointing to an arbitrary WSGI app.  You can specify the
          # {path_info:.*} parameter so the target app can be handed just that
          # section of the URL.
          mapper.connect(None, '/v1.0/{path_info:.*}', controller=BlogApp())

        """
        self.map = mapper
        self._router = routes.middleware.RoutesMiddleware(self._dispatch,
                                                          self.map)

    @webob.dec.wsgify(RequestClass=Request)
    def __call__(self, req):
        """Route the incoming request to a controller based on self.map.

        If no match, return a 404.

        """
        return self._router

    @staticmethod
    @webob.dec.wsgify(RequestClass=Request)
    def _dispatch(req):
        """Dispatch the request to the appropriate controller.

        Called by self._router after matching the incoming request to a route
        and putting the information into req.environ.  Either returns 404
        or the routed WSGI app's response.

        """
        match = req.environ['wsgiorg.routing_args'][1]
        if not match:
            return webob.exc.HTTPNotFound()
        app = match['controller']
        return app


class Loader(object):
    """Used to load WSGI applications from paste configurations."""

    def __init__(self, config_path=None):
        """Initialize the loader, and attempt to find the config.

        :param config_path: Full or relative path to the paste config.
        :returns: None

        """
        self.config_path = None

        config_path = config_path or CONF.api_paste_config
        if not os.path.isabs(config_path):
            self.config_path = CONF.find_file(config_path)
        elif os.path.exists(config_path):
            self.config_path = config_path

        if not self.config_path:
            raise exception.ConfigNotFound(path=config_path)

    def load_app(self, name):
        """Return the paste URLMap wrapped WSGI application.

        :param name: Name of the application to load.
        :returns: Paste URLMap object wrapping the requested application.
        :raises: `nova.exception.PasteAppNotFound`

        """
        try:
            LOG.debug("Loading app %(name)s from %(path)s",
                      {'name': name, 'path': self.config_path})
            return deploy.loadapp("config:%s" % self.config_path, name=name)
        except LookupError:
            LOG.exception(_LE("Couldn't lookup app: %s"), name)
            raise exception.PasteAppNotFound(name=name, path=self.config_path)

from pycp2k.inputsection import InputSection


class _each330(InputSection):
    def __init__(self):
        InputSection.__init__(self)
        self.Just_energy = None
        self.Powell_opt = None
        self.Qs_scf = None
        self.Xas_scf = None
        self.Md = None
        self.Pint = None
        self.Metadynamics = None
        self.Geo_opt = None
        self.Rot_opt = None
        self.Cell_opt = None
        self.Band = None
        self.Ep_lin_solver = None
        self.Spline_find_coeffs = None
        self.Replica_eval = None
        self.Bsse = None
        self.Shell_opt = None
        self.Tddft_scf = None
        self._name = "EACH"
        self._keywords = {'Bsse': 'BSSE', 'Cell_opt': 'CELL_OPT', 'Just_energy': 'JUST_ENERGY', 'Band': 'BAND', 'Xas_scf': 'XAS_SCF', 'Rot_opt': 'ROT_OPT', 'Replica_eval': 'REPLICA_EVAL', 'Tddft_scf': 'TDDFT_SCF', 'Shell_opt': 'SHELL_OPT', 'Md': 'MD', 'Pint': 'PINT', 'Metadynamics': 'METADYNAMICS', 'Geo_opt': 'GEO_OPT', 'Spline_find_coeffs': 'SPLINE_FIND_COEFFS', 'Powell_opt': 'POWELL_OPT', 'Qs_scf': 'QS_SCF', 'Ep_lin_solver': 'EP_LIN_SOLVER'}


"""Module containing the Train class and support functionality."""
__authors__ = "Ian Goodfellow"
__copyright__ = "Copyright 2010-2012, Universite de Montreal"
__credits__ = ["Ian Goodfellow"]
__license__ = "3-clause BSD"
__maintainer__ = "LISA Lab"
__email__ = "pylearn-dev@googlegroups"
from datetime import datetime
import os
import sys
import logging
import warnings
from pylearn2.utils import serial
from pylearn2.utils.string_utils import preprocess
from pylearn2.monitor import Monitor
from pylearn2.space import NullSpace
from pylearn2.utils.timing import log_timing, total_seconds
from pylearn2.utils import sharedX


log = logging.getLogger(__name__)


class Train(object):
    """
    A class representing the main loop of the training script.  Trains the
    specified model using the specified algorithm on the specified dataset.
    After each call to the training algorithm, the model is saved to
    `save_path`. May be enhanced with `TrainExtension` plugins.

    Parameters
    ----------
    dataset : `pylearn2.datasets.dataset.Dataset`
    model : `pylearn2.models.model.Model`
    algorithm : \
        `pylearn2.training_algorithms.training_algorithm.TrainingAlgorithm`, \
        optional
    save_path : str, optional
        Path to save (with pickle / joblib) the model.
    save_freq : int, optional
        Frequency of saves, in epochs. A frequency of zero disables
        automatic saving altogether. A frequency of 1 saves every
        epoch. A frequency of 2 saves every other epoch, etc.
        (default=0, i.e. never save). Note: when automatic saving is
        enabled (eg save_freq > 0), the model is always saved after
        learning, even when the final epoch is not a multiple of
        `save_freq`.
    extensions : iterable, optional
        A collection of `TrainExtension` objects whose callbacks are
        triggered at various points in learning.
    allow_overwrite : bool, optional
        If `True`, will save the model to save_path even if there is
        already something there. Otherwise, will raise an error if the
        `save_path` is already occupied.
    """

    def __init__(self, dataset, model, algorithm=None, save_path=None,
                 save_freq=0, extensions=None, allow_overwrite=True):
        self.allow_overwrite = allow_overwrite
        self.first_save = True
        self.dataset = dataset
        self.model = model
        self.algorithm = algorithm
        if save_path is not None:
            if save_freq == 0:
                warnings.warn('save_path specified but save_freq is 0 '
                              '(never save). Is this intentional?')
            self.save_path = preprocess(save_path)
        else:
            if save_freq > 0:
                phase_variable = 'PYLEARN2_TRAIN_PHASE'
                if phase_variable in os.environ:
                    phase = 'phase%d' % os.environ[phase_variable]
                    tokens = [os.environ['PYLEARN2_TRAIN_FILE_FULL_STEM'],
                              phase, 'pkl']
                else:
                    tokens = os.environ['PYLEARN2_TRAIN_FILE_FULL_STEM'], 'pkl'
                self.save_path = '.'.join(tokens)
        self.save_freq = save_freq

        if hasattr(self.dataset, 'yaml_src'):
            self.model.dataset_yaml_src = self.dataset.yaml_src
        else:
            warnings.warn("dataset has no yaml src, model won't know what " +
                          "data it was trained on")

        self.extensions = extensions if extensions is not None else []
        self.training_seconds = sharedX(value=0,
                                        name='training_seconds_this_epoch')
        self.total_seconds = sharedX(value=0, name='total_seconds_last_epoch')

    def setup_extensions(self):
        """ Calls setup on all extensions."""
        for ext in self.extensions:
            ext.setup(self.model, self.dataset, self.algorithm)

    def exceeded_time_budget(self, t0, time_budget):
        """
        .. todo::

            WRITEME
        """
        dt = total_seconds(datetime.now() - t0)
        if time_budget is not None and dt >= time_budget:
            log.warning("Time budget exceeded (%.3f/%d seconds).",
                        dt, time_budget)
            self.model.monitor.time_budget_exceeded = True
            return True
        else:
            return False

    def setup(self):
        """
        Sets up the main loop. This is also called at the start of the
        main loop, so you need only call it if you're using a driver
        script that replaces the main loop with something else.
        """
        self.model.monitor = Monitor.get_monitor(self.model)
        self.model.monitor.time_budget_exceeded = False
        if self.algorithm is not None:
            self.algorithm.setup(model=self.model, dataset=self.dataset)
        self.setup_extensions()

        # Model.modify_updates is used by the training algorithm to
        # enforce constraints after each step of learning. Here we
        # make sure the constraints are enforced from the start.
        self.model.enforce_constraints()

    def main_loop(self, time_budget=None):
        """
        Repeatedly runs an epoch of the training algorithm, runs any
        epoch-level callbacks, and saves the model.

        Parameters
        ----------
        time_budget : int, optional
            The maximum number of seconds before interrupting
            training. Default is `None`, no time limit.
        """
        t0 = datetime.now()
        self.setup()
        if self.algorithm is None:
            extension_continue = self.run_callbacks_and_monitoring()
            # First check if the model is already beyond the stop criteria of
            # training, if so, just return directly.
            continue_learning = (self.model.continue_learning() and
                                 extension_continue)
            assert continue_learning in [True, False, 0, 1]
            while continue_learning:
                if self.exceeded_time_budget(t0, time_budget):
                    break

                rval = self.model.train_all(dataset=self.dataset)
                if rval is not None:
                    raise ValueError(
                        "Model.train_all should not return anything. Use "
                        "Model.continue_learning to control whether "
                        "learning continues.")
                self.model.monitor.report_epoch()
                extension_continue = self.run_callbacks_and_monitoring()
                freq = self.save_freq
                if freq > 0 and \
                    self.model.monitor.get_epochs_seen() % freq == 0:
                    self.save()
                continue_learning = (self.model.continue_learning() and
                                     extension_continue)
                assert continue_learning in [True, False, 0, 1]
        else:
            if not hasattr(self.model, 'monitor'):
                # TODO: is this really necessary? I just put this error here
                # to prevent an AttributeError later, but I think we could
                # rewrite to avoid the AttributeError
                raise RuntimeError("The algorithm is responsible for setting"
                                   " up the Monitor, but failed to.")
            if len(self.model.monitor._datasets) > 0:
                # This monitoring channel keeps track of a shared variable,
                # which does not need inputs nor data.
                self.training_seconds.__doc__ = """\
The number of seconds that were spent in actual training during the most
recent epoch. This excludes seconds that were spent running callbacks for
the extensions, computing monitoring channels, etc."""
                self.model.monitor.add_channel(
                    name="training_seconds_this_epoch",
                    ipt=None,
                    val=self.training_seconds,
                    data_specs=(NullSpace(), ''),
                    dataset=self.model.monitor._datasets[0])
                self.total_seconds.__doc__ = """\
The number of seconds that were spent on the entirety of processing for the
previous epoch. This includes not only training but also the computation of
the monitoring channels, running TrainExtension callbacks, etc. This value
is reported for the *previous* epoch because the amount of time spent on
monitoring for this epoch is not known until the monitoring channels have
already been reported."""
                self.model.monitor.add_channel(
                    name="total_seconds_last_epoch",
                    ipt=None,
                    val=self.total_seconds,
                    data_specs=(NullSpace(), ''),
                    dataset=self.model.monitor._datasets[0])
            extension_continue = self.run_callbacks_and_monitoring()

            # First check if the model is already beyond the stop criteria of
            # training, if so, just return directly.
            continue_learning = (
                self.algorithm.continue_learning(self.model) and
                extension_continue
            )
            assert continue_learning in [True, False, 0, 1]
            while continue_learning:
                if self.exceeded_time_budget(t0, time_budget):
                    break

                with log_timing(log, None, level=logging.DEBUG,
                                callbacks=[self.total_seconds.set_value]):
                    with log_timing(
                        log, None, final_msg='Time this epoch:',
                        callbacks=[self.training_seconds.set_value]
                    ):
                        rval = self.algorithm.train(dataset=self.dataset)
                    if rval is not None:
                        raise ValueError(
                            "TrainingAlgorithm.train should not return "
                            "anything. Use "
                            "TrainingAlgorithm.continue_learning to "
                            "control whether learning continues."
                        )
                    self.model.monitor.report_epoch()
                    extension_continue = self.run_callbacks_and_monitoring()
                    if self.save_freq > 0 and \
                        self.model.monitor.get_epochs_seen() % \
                        self.save_freq == 0:
                        self.save()
                continue_learning = (
                    self.algorithm.continue_learning(self.model) and
                    extension_continue
                )
                assert continue_learning in [True, False, 0, 1]

        self.model.monitor.training_succeeded = True

        if self.save_freq > 0:
            self.save()

    def run_callbacks_and_monitoring(self):
        """
        Runs the monitor, then calls Extension.on_monitor for all extensions.

        Returns
        -------
        continue_learning : bool
            If `False`, signals that at least one train
            extension wants to stop learning.
        """
        self.model.monitor()
        continue_learning = True
        for extension in self.extensions:
            try:
                extension.on_monitor(self.model, self.dataset, self.algorithm)
            except TypeError:
                logging.warning('Failure during callback ' + str(extension))
                raise
            # We catch an exception here instead of relying on return
            # values for backward compatibility. Lots of extensions
            # exist that don't return anything, currently.
            except StopIteration:
                log.info("Extension requested training halt.")
                continue_learning = False
        return continue_learning

    def save(self):
        """Saves the model."""
        #TODO-- save state of training algorithm so training can be
        # resumed after a crash
        for extension in self.extensions:
            extension.on_save(self.model, self.dataset, self.algorithm)
        if self.save_path is not None:
            with log_timing(log, 'Saving to ' + self.save_path):
                if self.first_save and (not self.allow_overwrite) \
                   and os.path.exists(self.save_path):
                    # Every job overwrites its own output on the second save
                    # and every save thereafter. The "allow_overwrite" flag
                    # only pertains to overwriting the output of previous jobs.
                    raise IOError("Trying to overwrite file when not allowed.")
                try:
                    # Make sure that saving does not serialize the dataset
                    self.dataset._serialization_guard = SerializationGuard()
                    serial.save(self.save_path, self.model,
                                on_overwrite='backup')
                finally:
                    self.dataset._serialization_guard = None
            self.first_save = False


class SerializationGuard(object):
    """
    This class exists to make objects that cannot be serialized. It is used to
    make sure you don't accidentally put pointers to objects that should not
    be serialized, such as the dataset, into objects that Train automatically
    serializes, such as the Model.
    """

    def __getstate__(self):
        """
        This method is called when someone attempts to serialize the object.
        This method raises an exception to prevent the serialization from
        occurring.
        """
        raise IOError("You tried to serialize something that should not"
                      " be serialized.")


if __name__ == "__main__":
    logging.basicConfig(level=logging.ERROR)
    log.error("You probably meant to run scripts/train.py")
    sys.exit(1)

#  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
#  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.
"""Example of DNNClassifier for Iris plant dataset."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from sklearn import model_selection
from sklearn import metrics
import tensorflow as tf


def main(unused_argv):
  # Load dataset.
  iris = tf.contrib.learn.datasets.load_dataset('iris')
  x_train, x_test, y_train, y_test = model_selection.train_test_split(
      iris.data, iris.target, test_size=0.2, random_state=42)

  # Build 3 layer DNN with 10, 20, 10 units respectively.
  feature_columns = tf.contrib.learn.infer_real_valued_columns_from_input(
      x_train)
  classifier = tf.contrib.learn.DNNClassifier(
      feature_columns=feature_columns, hidden_units=[10, 20, 10], n_classes=3)

  # Fit and predict.
  classifier.fit(x_train, y_train, steps=200)
  predictions = list(classifier.predict(x_test, as_iterable=True))
  score = metrics.accuracy_score(y_test, predictions)
  print('Accuracy: {0:f}'.format(score))


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

# Copyright 2016 Google Inc. All Rights Reserved.
#
# 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.
# ==============================================================================

r"""LSUN dataset formatting.

Download and format the LSUN dataset as follow:
git clone https://github.com/fyu/lsun.git
cd lsun
python2.7 download.py -c [CATEGORY]

Then unzip the downloaded .zip files before executing:
python2.7 data.py export [IMAGE_DB_PATH] --out_dir [LSUN_FOLDER] --flat

Then use the script as follow:
python lsun_formatting.py \
    --file_out [OUTPUT_FILE_PATH_PREFIX] \
    --fn_root [LSUN_FOLDER]

"""
from __future__ import print_function

import os
import os.path

import numpy
import skimage.transform
from PIL import Image
import tensorflow as tf


tf.flags.DEFINE_string("file_out", "",
                       "Filename of the output .tfrecords file.")
tf.flags.DEFINE_string("fn_root", "", "Name of root file path.")

FLAGS = tf.flags.FLAGS


def _int64_feature(value):
    return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))


def _bytes_feature(value):
    return tf.train.Feature(bytes_list=tf.train.BytesList(value=[value]))


def main():
    """Main converter function."""
    fn_root = FLAGS.fn_root
    img_fn_list = os.listdir(fn_root)
    img_fn_list = [img_fn for img_fn in img_fn_list
                   if img_fn.endswith('.webp')]
    num_examples = len(img_fn_list)

    n_examples_per_file = 10000
    for example_idx, img_fn in enumerate(img_fn_list):
        if example_idx % n_examples_per_file == 0:
            file_out = "%s_%05d.tfrecords"
            file_out = file_out % (FLAGS.file_out,
                                   example_idx // n_examples_per_file)
            print("Writing on:", file_out)
            writer = tf.python_io.TFRecordWriter(file_out)
        if example_idx % 1000 == 0:
            print(example_idx, "/", num_examples)
        image_raw = numpy.array(Image.open(os.path.join(fn_root, img_fn)))
        rows = image_raw.shape[0]
        cols = image_raw.shape[1]
        depth = image_raw.shape[2]
        downscale = min(rows / 96., cols / 96.)
        image_raw = skimage.transform.pyramid_reduce(image_raw, downscale)
        image_raw *= 255.
        image_raw = image_raw.astype("uint8")
        rows = image_raw.shape[0]
        cols = image_raw.shape[1]
        depth = image_raw.shape[2]
        image_raw = image_raw.tostring()
        example = tf.train.Example(
            features=tf.train.Features(
                feature={
                    "height": _int64_feature(rows),
                    "width": _int64_feature(cols),
                    "depth": _int64_feature(depth),
                    "image_raw": _bytes_feature(image_raw)
                }
            )
        )
        writer.write(example.SerializeToString())
        if example_idx % n_examples_per_file == (n_examples_per_file - 1):
            writer.close()
    writer.close()


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import asyncio
from aiohttp import web
from aiohttp_jinja2 import APP_KEY, render_template
from utils.constant import CONST


def geass(context, request, tmpl=None, *, app_key=APP_KEY, encoding='utf-8', status=200):
    # print('path->', request.url)
    if tmpl is None:
        return web.json_response(context)
    try:
        if 'identifier' in context:
            context['PAGE_IDENTIFIER'] = request.app.router[context['identifier']].url()
            # Auth
        context['drawer_category'] = CONST.CATEGORY
    except:
        raise RuntimeError

    response = render_template(tmpl, request, context,
                               app_key=app_key, encoding=encoding)
    response.set_status(status)
    return response


async def http_400_response(error_reason):
    return web.json_response({
        'status': 'error',
        'content': error_reason
    }, status=400)


async def http_401_response(error_reason):
    return web.json_response({
        'status': 'error',
        'content': error_reason
    }, status=401)


async def http_404_response(request, msg='Page Not Found!'):
    res = render_template('error/404.html', request, {'msg': msg})
    res.set_status(404)
    return res


async def http_503_response():
    return web.json_response({
        'status': 'error',
        'content': 'Service Temporarily Unavailable'
    }, status=503)
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import logging
import os
import unittest

from telemetry import benchmark
from telemetry.core import util
from telemetry.core.platform import mac_platform_backend
from telemetry.core.platform import platform_backend
from telemetry.core.platform.power_monitor import powermetrics_power_monitor


class PowerMetricsPowerMonitorTest(unittest.TestCase):
  @benchmark.Enabled('mac')
  def testCanMonitorPowerUsage(self):
    backend = mac_platform_backend.MacPlatformBackend()
    power_monitor = powermetrics_power_monitor.PowerMetricsPowerMonitor(backend)
    mavericks_or_later = (
        backend.GetOSVersionName() >= platform_backend.MAVERICKS)
    # Should always be able to monitor power usage on OS Version >= 10.9 .
    self.assertEqual(power_monitor.CanMonitorPower(), mavericks_or_later,
        "Error checking powermetrics availability: '%s'" % '|'.join(os.uname()))

  @benchmark.Enabled('mac')
  def testParseEmptyPowerMetricsOutput(self):
    # Important to handle zero length powermetrics outout - crbug.com/353250 .
    self.assertIsNone(powermetrics_power_monitor.PowerMetricsPowerMonitor.
        ParsePowerMetricsOutput(''))

  @benchmark.Enabled('mac')
  def testParsePowerMetricsOutput(self):
    def getOutput(output_file):
      test_data_path = os.path.join(util.GetUnittestDataDir(), output_file)
      with open(test_data_path, 'r') as f:
        process_output = f.read()
      return (powermetrics_power_monitor.PowerMetricsPowerMonitor.
          ParsePowerMetricsOutput(process_output))

    power_monitor = powermetrics_power_monitor.PowerMetricsPowerMonitor(
        mac_platform_backend.MacPlatformBackend())
    if not power_monitor.CanMonitorPower():
      logging.warning('Test not supported on this platform.')
      return

    # Not supported on Mac at this time.
    self.assertFalse(power_monitor.CanMeasurePerApplicationPower())

    # Supported hardware reports power samples and energy consumption.
    result = getOutput('powermetrics_output.output')

    self.assertTrue(result['energy_consumption_mwh'] > 0)

    # Verify that all component entries exist in output.
    component_utilization = result['component_utilization']
    for k in ['whole_package', 'gpu'] + ['cpu%d' % x for x in range(8)]:
      self.assertTrue(component_utilization[k]['average_frequency_hz'] > 0)
      self.assertTrue(component_utilization[k]['idle_percent'] > 0)

    # Unsupported hardware doesn't.
    result = getOutput('powermetrics_output_unsupported_hardware.output')
    self.assertNotIn('energy_consumption_mwh', result)

#!/usr/bin/python
# coding: utf-8 -*-

# Copyright: (c) 2017, Wayne Witzel III <wayne@riotousliving.com>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}


DOCUMENTATION = '''
---
module: tower_credential
author: "Wayne Witzel III (@wwitzel3)"
version_added: "2.3"
short_description: create, update, or destroy Ansible Tower credential.
description:
    - Create, update, or destroy Ansible Tower credentials. See
      U(https://www.ansible.com/tower) for an overview.
options:
    name:
      description:
        - The name to use for the credential.
      required: True
    description:
      description:
        - The description to use for the credential.
    user:
      description:
        - User that should own this credential.
    team:
      description:
        - Team that should own this credential.
    project:
      description:
        - Project that should for this credential.
    organization:
      description:
        - Organization that should own the credential.
      required: True
    kind:
      description:
        - Type of credential being added.  The ssh choice refers to a Tower Machine credential.
      required: True
      choices: ["ssh", "vault", "net", "scm", "aws", "vmware", "satellite6", "cloudforms", "gce", "azure_rm", "openstack", "rhv", "insights", "tower"]
    host:
      description:
        - Host for this credential.
    username:
      description:
        - Username for this credential. access_key for AWS.
    password:
      description:
        - Password for this credential. Use ASK for prompting. secret_key for AWS. api_key for RAX.
    ssh_key_data:
      description:
        - SSH private key content. To extract the content from a file path, use the lookup function (see examples).
      required: False
    ssh_key_unlock:
      description:
        - Unlock password for ssh_key. Use ASK for prompting.
    authorize:
      description:
        - Should use authorize for net type.
      type: bool
      default: 'no'
    authorize_password:
      description:
        - Password for net credentials that require authorize.
    client:
      description:
        - Client or application ID for azure_rm type.
    security_token:
      description:
        - STS token for aws type.
      version_added: "2.6"
    secret:
      description:
        - Secret token for azure_rm type.
    subscription:
      description:
        - Subscription ID for azure_rm type.
    tenant:
      description:
        - Tenant ID for azure_rm type.
    domain:
      description:
        - Domain for openstack type.
    become_method:
      description:
        - Become method to use for privilege escalation.
      choices: ["None", "sudo", "su", "pbrun", "pfexec", "pmrun"]
    become_username:
      description:
        - Become username. Use ASK for prompting.
    become_password:
      description:
        - Become password. Use ASK for prompting.
    vault_password:
      description:
        - Vault password. Use ASK for prompting.
    state:
      description:
        - Desired state of the resource.
      choices: ["present", "absent"]
      default: "present"
extends_documentation_fragment: tower
'''


EXAMPLES = '''
- name: Add tower credential
  tower_credential:
    name: Team Name
    description: Team Description
    organization: test-org
    kind: ssh
    state: present
    tower_config_file: "~/tower_cli.cfg"

- name: Create a valid SCM credential from a private_key file
  tower_credential:
    name: SCM Credential
    organization: Default
    state: present
    kind: scm
    username: joe
    password: secret
    ssh_key_data: "{{ lookup('file', '/tmp/id_rsa') }}"
    ssh_key_unlock: "passphrase"

- name: Add Credential Into Tower
  tower_credential:
    name: Workshop Credential
    ssh_key_data: "/home/{{ansible_user}}/.ssh/aws-private.pem"
    kind: ssh
    organization: Default
    tower_username: admin
    tower_password: ansible
    tower_host: https://localhost
  run_once: true
  delegate_to: localhost
'''

import os

from ansible.module_utils._text import to_text
from ansible.module_utils.ansible_tower import TowerModule, tower_auth_config, tower_check_mode

try:
    import tower_cli
    import tower_cli.exceptions as exc

    from tower_cli.conf import settings
except ImportError:
    pass


KIND_CHOICES = {
    'ssh': 'Machine',
    'vault': 'Ansible Vault',
    'net': 'Network',
    'scm': 'Source Control',
    'aws': 'Amazon Web Services',
    'vmware': 'VMware vCenter',
    'satellite6': 'Red Hat Satellite 6',
    'cloudforms': 'Red Hat CloudForms',
    'gce': 'Google Compute Engine',
    'azure_rm': 'Microsoft Azure Resource Manager',
    'openstack': 'OpenStack',
    'rhv': 'Red Hat Virtualization',
    'insights': 'Insights',
    'tower': 'Ansible Tower',
}


def credential_type_for_v1_kind(params, module):
    credential_type_res = tower_cli.get_resource('credential_type')
    kind = params.pop('kind')
    arguments = {'managed_by_tower': True}
    if kind == 'ssh':
        if params.get('vault_password'):
            arguments['kind'] = 'vault'
        else:
            arguments['kind'] = 'ssh'
    elif kind in ('net', 'scm', 'insights', 'vault'):
        arguments['kind'] = kind
    elif kind in KIND_CHOICES:
        arguments.update(dict(
            kind='cloud',
            name=KIND_CHOICES[kind]
        ))
    return credential_type_res.get(**arguments)


def main():

    argument_spec = dict(
        name=dict(required=True),
        user=dict(),
        team=dict(),
        kind=dict(required=True,
                  choices=KIND_CHOICES.keys()),
        host=dict(),
        username=dict(),
        password=dict(no_log=True),
        ssh_key_data=dict(no_log=True, type='str'),
        ssh_key_unlock=dict(no_log=True),
        authorize=dict(type='bool', default=False),
        authorize_password=dict(no_log=True),
        client=dict(),
        security_token=dict(),
        secret=dict(),
        tenant=dict(),
        subscription=dict(),
        domain=dict(),
        become_method=dict(),
        become_username=dict(),
        become_password=dict(no_log=True),
        vault_password=dict(no_log=True),
        description=dict(),
        organization=dict(required=True),
        project=dict(),
        state=dict(choices=['present', 'absent'], default='present'),
    )

    module = TowerModule(argument_spec=argument_spec, supports_check_mode=True)

    name = module.params.get('name')
    organization = module.params.get('organization')
    state = module.params.get('state')

    json_output = {'credential': name, 'state': state}

    tower_auth = tower_auth_config(module)
    with settings.runtime_values(**tower_auth):
        tower_check_mode(module)
        credential = tower_cli.get_resource('credential')
        try:
            params = {}
            params['create_on_missing'] = True
            params['name'] = name

            if organization:
                org_res = tower_cli.get_resource('organization')
                org = org_res.get(name=organization)
                params['organization'] = org['id']

            try:
                tower_cli.get_resource('credential_type')
            except (ImportError, AttributeError):
                # /api/v1/ backwards compat
                # older versions of tower-cli don't *have* a credential_type
                # resource
                params['kind'] = module.params['kind']
            else:
                credential_type = credential_type_for_v1_kind(module.params, module)
                params['credential_type'] = credential_type['id']

            if module.params.get('description'):
                params['description'] = module.params.get('description')

            if module.params.get('user'):
                user_res = tower_cli.get_resource('user')
                user = user_res.get(username=module.params.get('user'))
                params['user'] = user['id']

            if module.params.get('team'):
                team_res = tower_cli.get_resource('team')
                team = team_res.get(name=module.params.get('team'))
                params['team'] = team['id']

            if module.params.get('ssh_key_data'):
                data = module.params.get('ssh_key_data')
                if os.path.exists(data):
                    module.deprecate(
                        msg='ssh_key_data should be a string, not a path to a file. Use lookup(\'file\', \'/path/to/file\') instead',
                        version="2.12"
                    )
                    if os.path.isdir(data):
                        module.fail_json(msg='attempted to read contents of directory: %s' % data)
                    with open(data, 'rb') as f:
                        module.params['ssh_key_data'] = to_text(f.read())
                else:
                    module.params['ssh_key_data'] = data

            for key in ('authorize', 'authorize_password', 'client',
                        'security_token', 'secret', 'tenant', 'subscription',
                        'domain', 'become_method', 'become_username',
                        'become_password', 'vault_password', 'project', 'host',
                        'username', 'password', 'ssh_key_data',
                        'ssh_key_unlock'):
                if 'kind' in params:
                    params[key] = module.params.get(key)
                elif module.params.get(key):
                    params.setdefault('inputs', {})[key] = module.params.get(key)

            if state == 'present':
                result = credential.modify(**params)
                json_output['id'] = result['id']
            elif state == 'absent':
                result = credential.delete(**params)
        except (exc.NotFound) as excinfo:
            module.fail_json(msg='Failed to update credential, organization not found: {0}'.format(excinfo), changed=False)
        except (exc.ConnectionError, exc.BadRequest, exc.NotFound) as excinfo:
            module.fail_json(msg='Failed to update credential: {0}'.format(excinfo), changed=False)

    json_output['changed'] = result['changed']
    module.exit_json(**json_output)


if __name__ == '__main__':
    main()

# coding: utf-8
from __future__ import unicode_literals

import re

from .common import InfoExtractor
from ..utils import (
    extract_attributes,
)


class NZZIE(InfoExtractor):
    _VALID_URL = r'https?://(?:www\.)?nzz\.ch/(?:[^/]+/)*[^/?#]+-ld\.(?P<id>\d+)'
    _TEST = {
        'url': 'http://www.nzz.ch/zuerich/gymizyte/gymizyte-schreiben-schueler-heute-noch-diktate-ld.9153',
        'info_dict': {
            'id': '9153',
        },
        'playlist_mincount': 6,
    }

    def _real_extract(self, url):
        page_id = self._match_id(url)
        webpage = self._download_webpage(url, page_id)

        entries = []
        for player_element in re.findall(r'(<[^>]+class="kalturaPlayer"[^>]*>)', webpage):
            player_params = extract_attributes(player_element)
            if player_params.get('data-type') not in ('kaltura_singleArticle',):
                self.report_warning('Unsupported player type')
                continue
            entry_id = player_params['data-id']
            entries.append(self.url_result(
                'kaltura:1750922:' + entry_id, 'Kaltura', entry_id))

        return self.playlist_result(entries, page_id)

from django.core.exceptions import ValidationError

from mappings.validation_messages import OPENMRS_SINGLE_MAPPING_BETWEEN_TWO_CONCEPTS, OPENMRS_INVALID_MAPTYPE

class OpenMRSMappingValidator:
    def __init__(self, mapping):
        self.mapping = mapping

    def validate(self):
        self.pair_must_be_unique()
        self.lookup_attributes_should_be_valid()

    def pair_must_be_unique(self):
        from mappings.models import Mapping

        if self.mapping.to_concept:
            intersection = Mapping.objects\
                .filter(parent=self.mapping.parent_source, from_concept=self.mapping.from_concept, to_concept=self.mapping.to_concept, is_active=True, retired=False)\
                .exclude(id=self.mapping.id)
        elif self.mapping.to_concept_code:
            intersection = Mapping.objects \
                .filter(parent=self.mapping.parent_source, from_concept=self.mapping.from_concept, to_source=self.mapping.to_source, to_concept_code=self.mapping.to_concept_code, is_active=True, retired=False) \
                .exclude(id=self.mapping.id)
        elif self.mapping.to_concept_name:
            intersection = Mapping.objects \
                .filter(parent=self.mapping.parent_source, from_concept=self.mapping.from_concept, to_source=self.mapping.to_source, to_concept_name=self.mapping.to_concept_name, is_active=True, retired=False) \
                .exclude(id=self.mapping.id)

        if intersection:
            raise ValidationError(OPENMRS_SINGLE_MAPPING_BETWEEN_TWO_CONCEPTS)

    def map_type_should_be_valid_attribute(self, org):
        is_data_type_valid = self.is_attribute_valid(self.mapping.map_type, org, 'MapTypes', 'MapType')

        if not is_data_type_valid:
            raise ValidationError({'map_type': [OPENMRS_INVALID_MAPTYPE]})

    def is_attribute_valid(self, attribute_property, org, source_mnemonic, concept_class):
        from sources.models import Source
        from concepts.models import Concept

        attributetypes_source_filter = Source.objects.filter(parent_id=org.id, mnemonic=source_mnemonic)

        if attributetypes_source_filter.count() < 1:
            raise ValidationError({'non_field_errors': ['Lookup attributes must be imported']})

        source_attributetypes = attributetypes_source_filter.values_list('id').get()

        matching_attribute_types = {'retired': False, 'is_active': True, 'concept_class': concept_class,
                                    'parent_id': source_attributetypes[0], 'names.name': attribute_property or 'None'}

        return Concept.objects.raw_query(matching_attribute_types).count() > 0

    def lookup_attributes_should_be_valid(self):
        from orgs.models import Organization
        ocl_org_filter = Organization.objects.filter(mnemonic='OCL')

        if ocl_org_filter.count() < 1:
            raise ValidationError({'non_field_errors': ['Lookup attributes must be imported']})

        org = ocl_org_filter.get()

        self.map_type_should_be_valid_attribute(org)

#!/usr/bin/python2
'''
Test script for security-check.py
'''
from __future__ import division,print_function
import subprocess
import sys
import unittest

def write_testcode(filename):
    with open(filename, 'w') as f:
        f.write('''
    #include <stdio.h>
    int main()
    {
        printf("the quick brown fox jumps over the lazy god\\n");
        return 0;
    }
    ''')

def call_security_check(cc, source, executable, options):
    subprocess.check_call([cc,source,'-o',executable] + options)
    p = subprocess.Popen(['./security-check.py',executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
    (stdout, stderr) = p.communicate()
    return (p.returncode, stdout.rstrip())

class TestSecurityChecks(unittest.TestCase):
    def test_ELF(self):
        source = 'test1.c'
        executable = 'test1'
        cc = 'gcc'
        write_testcode(source)

        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-zexecstack','-fno-stack-protector','-Wl,-znorelro']), 
                (1, executable+': failed PIE NX RELRO Canary'))
        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fno-stack-protector','-Wl,-znorelro']), 
                (1, executable+': failed PIE RELRO Canary'))
        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-znorelro']), 
                (1, executable+': failed PIE RELRO'))
        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-znorelro','-pie','-fPIE']), 
                (1, executable+': failed RELRO'))
        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-zrelro','-Wl,-z,now','-pie','-fPIE']), 
                (0, ''))

    def test_PE(self):
        source = 'test1.c'
        executable = 'test1.exe'
        cc = 'i686-w64-mingw32-gcc'
        write_testcode(source)

        self.assertEqual(call_security_check(cc, source, executable, []), 
                (1, executable+': failed PIE NX'))
        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat']), 
                (1, executable+': failed PIE'))
        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat','-Wl,--dynamicbase']), 
                (0, ''))

if __name__ == '__main__':
    unittest.main()


# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import DataMigration
from django.db import models

class Migration(DataMigration):
    ALLOW = 1
    DENY = 0

    def forwards(self, orm):
        for permission in orm.FolderPermission.objects.all():
            permission.can_edit_new = self.ALLOW if permission.can_edit else self.DENY
            permission.can_read_new = self.ALLOW if permission.can_read else self.DENY
            permission.can_add_children_new = self.ALLOW if permission.can_add_children else self.DENY
            permission.save()

    def backwards(self, orm):
        # Backwards migration is lossy, but we play on a safe side and deny more
        for permission in orm.FolderPermission.objects.all():
            permission.can_edit = permission.can_edit_new == self.ALLOW
            permission.can_read = permission.can_read_new == self.ALLOW
            permission.can_add_children = permission.can_add_children_new == self.ALLOW
            permission.save()

    models = {
        'auth.group': {
            'Meta': {'object_name': 'Group'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
        },
        'auth.permission': {
            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        'auth.user': {
            'Meta': {'object_name': 'User'},
            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
        },
        'contenttypes.contenttype': {
            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'filer.clipboard': {
            'Meta': {'object_name': 'Clipboard'},
            'files': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'in_clipboards'", 'symmetrical': 'False', 'through': "orm['filer.ClipboardItem']", 'to': "orm['filer.File']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'filer_clipboards'", 'to': "orm['auth.User']"})
        },
        'filer.clipboarditem': {
            'Meta': {'object_name': 'ClipboardItem'},
            'clipboard': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['filer.Clipboard']"}),
            'file': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['filer.File']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
        },
        'filer.file': {
            'Meta': {'object_name': 'File'},
            '_file_size': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
            'description': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'file': ('django.db.models.fields.files.FileField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'folder': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'all_files'", 'null': 'True', 'to': "orm['filer.Folder']"}),
            'has_all_mandatory_data': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_public': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'modified_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'original_filename': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'owner': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'owned_files'", 'null': 'True', 'to': "orm['auth.User']"}),
            'polymorphic_ctype': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'polymorphic_filer.file_set'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
            'sha1': ('django.db.models.fields.CharField', [], {'default': "''", 'max_length': '40', 'blank': 'True'}),
            'uploaded_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'})
        },
        'filer.folder': {
            'Meta': {'ordering': "('name',)", 'unique_together': "(('parent', 'name'),)", 'object_name': 'Folder'},
            'created_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'level': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
            'lft': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
            'modified_at': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'owner': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'filer_owned_folders'", 'null': 'True', 'to': "orm['auth.User']"}),
            'parent': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'children'", 'null': 'True', 'to': "orm['filer.Folder']"}),
            'rght': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
            'tree_id': ('django.db.models.fields.PositiveIntegerField', [], {'db_index': 'True'}),
            'uploaded_at': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'})
        },
        'filer.folderpermission': {
            'Meta': {'object_name': 'FolderPermission'},
            'can_add_children': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'can_add_children_new': ('django.db.models.fields.SmallIntegerField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}),
            'can_edit': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'can_edit_new': ('django.db.models.fields.SmallIntegerField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}),
            'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'can_read_new': ('django.db.models.fields.SmallIntegerField', [], {'default': 'None', 'null': 'True', 'blank': 'True'}),
            'everybody': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'folder': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['filer.Folder']", 'null': 'True', 'blank': 'True'}),
            'group': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'filer_folder_permissions'", 'null': 'True', 'to': "orm['auth.Group']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'type': ('django.db.models.fields.SmallIntegerField', [], {'default': '0'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'filer_folder_permissions'", 'null': 'True', 'to': "orm['auth.User']"})
        },
        'filer.image': {
            'Meta': {'object_name': 'Image', '_ormbases': ['filer.File']},
            '_height': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
            '_width': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
            'author': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'date_taken': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
            'default_alt_text': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'default_caption': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'file_ptr': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['filer.File']", 'unique': 'True', 'primary_key': 'True'}),
            'must_always_publish_author_credit': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'must_always_publish_copyright': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'subject_location': ('django.db.models.fields.CharField', [], {'default': 'None', 'max_length': '64', 'null': 'True', 'blank': 'True'})
        }
    }

    complete_apps = ['filer']
    symmetrical = True

# -*- coding: utf-8 -*-

from whoosh.fields import SchemaClass, ID, DATETIME, TEXT, NUMERIC, STORED


class DateRevisionHybrid(SchemaClass):

    kind = ID(stored=True)

    page_date = DATETIME(stored=True)
    page_slug = ID(stored=True)
    page_title = TEXT(stored=True)
    page_status = ID(stored=True)
    page_path = ID(stored=True)
    page_blob_id = ID(stored=True)
    page_rendered = STORED()

    revision_date = DATETIME(stored=True)
    revision_slug = ID(stored=True)
    revision_title = TEXT(stored=True)
    revision_status = ID(stored=True)
    revision_path = ID(stored=True)
    revision_blob_id = ID(stored=True)
    revision_commit_id = ID(stored=True)
    revision_tree_id = ID(stored=True)
    revision_author = ID(stored=True)
    revision_committer = ID(stored=True)
    revision_author_time = DATETIME(stored=True)
    revision_commit_time = DATETIME(stored=True)
    revision_message = TEXT(stored=True)
    revision_rendered = STORED()

    attachment_id = ID(stored=True)
    attachment_data_blob_id = ID(stored=True)
    attachment_metadata_blob_id = ID(stored=True)
    attachment_content_type = ID(stored=True)
    attachment_content_disposition = ID(stored=True)
    attachment_content_length = NUMERIC(stored=True)

# -*- coding: utf-8 -*-
from __future__ import print_function

import filecmp
import os
import unittest
from shutil import rmtree
from tempfile import mkdtemp

import pytest
from pelican import Pelican
from pelican.settings import read_settings

from .notebook import IPYTHON_VERSION

PLUGIN_DIR = os.path.dirname(__file__)
TEST_DATA_DIR = os.path.join(PLUGIN_DIR, 'test_data')


class TestFullRun(unittest.TestCase):
    '''Test running Pelican with the Plugin'''

    def setUp(self):
        '''Create temporary output and cache folders'''
        self.temp_path = mkdtemp(prefix='pelicantests.')
        self.temp_cache = mkdtemp(prefix='pelican_cache.')
        os.chdir(TEST_DATA_DIR)

    def tearDown(self):
        '''Remove output and cache folders'''
        rmtree(self.temp_path)
        rmtree(self.temp_cache)
        os.chdir(PLUGIN_DIR)

    @pytest.mark.skipif(IPYTHON_VERSION >= 3,
                        reason="output must be created with ipython version 2")
    def test_generate_with_ipython3(self):
        '''Test generation of site with the plugin.'''

        base_path = os.path.dirname(os.path.abspath(__file__))
        base_path = os.path.join(base_path, 'test_data')
        content_path = os.path.join(base_path, 'content')
        output_path = os.path.join(base_path, 'output')
        settings_path = os.path.join(base_path, 'pelicanconf.py')
        settings = read_settings(path=settings_path,
                                 override={'PATH': content_path,
                                           'OUTPUT_PATH': self.temp_path,
                                           'CACHE_PATH': self.temp_cache,
                                           }
                                 )

        pelican = Pelican(settings)
        pelican.run()

        # test existence
        assert os.path.exists(os.path.join(self.temp_path,
                                           'test-ipython-notebook-nb-format-3.html'))
        assert os.path.exists(os.path.join(self.temp_path,
                                           'test-ipython-notebook-nb-format-4.html'))

        # test differences
        #assert filecmp.cmp(os.path.join(output_path,
        #                                'test-ipython-notebook-v2.html'),
        #                   os.path.join(self.temp_path,
        #                                'test-ipython-notebook.html'))

    @pytest.mark.skipif(IPYTHON_VERSION < 3,
                        reason="output must be created with ipython version 3")
    def test_generate_with_ipython2(self):
        '''Test generation of site with the plugin.'''

        base_path = os.path.dirname(os.path.abspath(__file__))
        base_path = os.path.join(base_path, 'test_data')
        content_path = os.path.join(base_path, 'content')
        output_path = os.path.join(base_path, 'output')
        settings_path = os.path.join(base_path, 'pelicanconf.py')
        settings = read_settings(path=settings_path,
                                 override={'PATH': content_path,
                                           'OUTPUT_PATH': self.temp_path,
                                           'CACHE_PATH': self.temp_cache,
                                           }
                                 )

        pelican = Pelican(settings)
        pelican.run()

        # test existence
        assert os.path.exists(os.path.join(self.temp_path,
                                           'test-ipython-notebook-nb-format-3.html'))
        assert os.path.exists(os.path.join(self.temp_path,
                                           'test-ipython-notebook-nb-format-4.html'))

        # test differences
        #assert filecmp.cmp(os.path.join(output_path,
        #                                'test-ipython-notebook-v3.html'),
        #                   os.path.join(self.temp_path,
        #                                'test-ipython-notebook.html'))

from time import sleep
import requests
import json
import argparse
import configparser

# GitHub
headers = {'Authorization': ''}
baseUrl = ''
owner = ''

# Arduino
url = 'http://172.19.106.227'

# Team Devs
teamDevs = {}

latestPR = {}


def post_to_printer(pr, repo):
    title = pr['title']
    user = teamXdevs[pr['head']['user']['login']]
    message = "**{0} opened PR in {2}:** {1}".format(user, title, repo)
    #print json.dumps(pr, indent=4, sort_keys=True)
    r = requests.get(url + '?p=' + message)
    print(r.status_code)
    sleep(1)

def post_new_line():
    r = requests.get(url + '?p= ')
    print(r.status_code)


def parse_and_print(PRs, latest):
    temp_num = 0
    for PR in PRs:
        user = PR['head']['user']['login']
        number = PR['number']
        repo = PR['head']['repo']['name']
        if user in teamDevs and number > latest:
            post_to_printer(PR, repo)
            temp_num = max(number, temp_num)
    if temp_num:
        latest = temp_num
    return latest


def poll(repos):
    changed = False
    global latestPR

    for repo in repos:
        if repo not in latestPR:
            latestPR[repo] = 0

        PRs = requests.get(baseUrl + 'repos/' + owner + '/' + repo +'/pulls', headers=headers, verify=False)

        if PRs.ok:
            PRsText = json.loads(PRs.text or PRs.content)
            tempNum = parse_and_print(PRsText, latestPR[repo])
            if tempNum > latestPR[repo]:
                changed = True
                latestPR[repo] = tempNum

    if changed:
        post_new_line()


if __name__ == "__main__":
    # Read values from config file
    Config = configparser.ConfigParser();
    Config.read("config.ini")
    section = 'GitHub'
    try:
        baseUrl = Config.get(section, 'baseUrl')
        owner = Config.get(section, 'owner')
        token = Config.get(section, 'token')
        headers['Authorization'] = 'token ' + token
    except KeyError:
        print("Unable to find config option")

    parser = argparse.ArgumentParser()
    parser.add_argument("-period", type=int,
                    help="period at which to poll")
    parser.add_argument('repositories', metavar='R', nargs='+',
                       help='a list of repositories to poll')

    args = parser.parse_args()
    reposToPoll = args.repositories

    while True:
        poll(reposToPoll)
        sleep(args.period)

import rospy
from geometry_msgs.msg import Wrench
from nav_msgs.msg import Odometry

import numpy

import math
from tf.transformations import quaternion_matrix
from tf.transformations import euler_from_quaternion


# to grab keystrokes
import pygame
UPKEY = 273
DWNKEY = 274
LFTKEY = 276
RGTKEY = 275
SPCKEY = 32

# simulation parameters
v = numpy.array([0,0,0,0])
rot = numpy.identity(3)

# gimbal position
yaw = 0  #positive yaw is left
pitch = 0 #positive pitch is up
g_chrate = 10


fu = numpy.array([0.25,0,0,0])
omega = 50
k = 0.5
freq = 100
t = 0
shoot = 0
jellyfactor = 4
t_limit = int(4*(math.pi**2) * freq / omega)

#is called from odometer each time its values are refreshed
def callback(data):
    # speed
    global v 
    # euler angles
    global rot 

    linear = data.twist.twist.linear
    v  = numpy.array([linear.x,linear.y,linear.z, 0])
    
    orientation = data.pose.pose.orientation
    rot = quaternion_matrix((orientation.w, orientation.x, orientation.y, orientation.z))
    v = numpy.dot(rot,v)


# this publisher will move the jellybot
pub = rospy.Publisher('/force', Wrench, queue_size=10)
rospy.init_node('controller')
r = rospy.Rate(freq)

# let's listen to the odometer
rospy.Subscriber('/odom', Odometry, callback)
wrench = Wrench() # will be used to move the jellybot

# pygame setup
pygame.init()
myfont = pygame.font.SysFont('monospace', 56)
screen = pygame.display.set_mode((300,150))
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((0,0,0))

# main loop
while not rospy.is_shutdown():
    
    if shoot == 1:
        # move the jellybot!
        resultant = fu + jellyfactor*fu*math.sin(omega*t/(freq*2*math.pi)) - k * v
        t = t + 1
        if (t % t_limit) == 0:
            # we enter here when the sin has made a full period
            shoot = 0
    else:
        # just brake a bit to make sure our bot does not hit Samanta in the head
        resultant = - k * v
    resultant = numpy.dot(numpy.linalg.inv(rot), resultant)

    wrench.force.x = resultant[0]
    wrench.force.y = resultant[1]
    wrench.force.z = resultant[2]

    # actually push the jellybot
    pub.publish(wrench)
    
    # pygame section
    for event in pygame.event.get():
        # check for keystrokes
        if event.type == pygame.KEYDOWN:
            if event.key == UPKEY:
                pitch = pitch - g_chrate
            elif event.key == DWNKEY:
                pitch = pitch + g_chrate
            elif event.key == LFTKEY:
                yaw = yaw + g_chrate
            elif event.key == RGTKEY:
                yaw = yaw - g_chrate
            elif event.key == SPCKEY:
                shoot = 1
    # blank the screen
    screen.blit(background, (0,0))
    
    # prepare the astronaut's interface
    gyaw =   'Yaw:    ' + str(yaw)
    gpitch = 'Pitch:  ' + str(pitch)

    gimb_pitch_label = myfont.render(gpitch, 1, (255,255,255))
    screen.blit(gimb_pitch_label, ((10,10)))
    
    gimb_yaw_label = myfont.render(gyaw, 1, (255,255,255))
    screen.blit(gimb_yaw_label, ((10,75)))
    
    # finally flip the astronaut interface display
    pygame.display.flip()
    # we need to sleep until the next time step
    r.sleep()


# All Rights Reserved.
#
#    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.

from sqlalchemy import Index, MetaData, Table
from sqlalchemy.exc import IntegrityError


def upgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine

    reservations = Table('reservations', meta, autoload=True)

    # Based on _quota_reservations_query
    # from: nova/db/sqlalchemy/api.py
    index = Index('reservations_uuid_idx', reservations.c.uuid)
    try:
        index.create(migrate_engine)
    except IntegrityError:
        pass


def downgrade(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine

    reservations = Table('reservations', meta, autoload=True)

    index = Index('reservations_uuid_idx', reservations.c.uuid)
    index.drop(migrate_engine)

#!/usr/bin/python
# Copyright (c) 2012 The Native Client Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# IMPORTANT NOTE: If you make local mods to this file, you must run:
#   %  pnacl/build.sh driver
# in order for them to take effect in the scons build.  This command
# updates the copy in the toolchain/ tree.
#

import driver_tools
from driver_env import env
from driver_log import Log

EXTRA_ENV = {
  'ARGS':    '',
  'COMMAND': ''
}
# just pass all args through to 'ARGS' and eventually to the underlying tool
PATTERNS = [ ( '(.*)',  "env.append('ARGS', $0)") ]

def main(argv):
  if len(argv) ==  0:
    print get_help(argv)
    return 1

  env.update(EXTRA_ENV)
  driver_tools.ParseArgs(argv, PATTERNS)

  # Note: --plugin must come after the command flags, but before the filename.
  #       (definitely confirmed that it cannot go before the command)
  #       for now assume command is just the very first args
  args = env.get('ARGS')
  command = args.pop(0)
  env.set('COMMAND', command)
  env.set('ARGS', *args)
  driver_tools.Run('"${AR}" ${COMMAND} --plugin=${GOLD_PLUGIN_SO} ${ARGS}')
  # only reached in case of no errors
  return 0


def get_help(unused_argv):
  return """
Usage: %s [-]{dmpqrstx}[abcDfilMNoPsSTuvV] [member-name] [count] archive-file file...
 commands:
  d            - delete file(s) from the archive
  m[ab]        - move file(s) in the archive
  p            - print file(s) found in the archive
  q[f]         - quick append file(s) to the archive
  r[ab][f][u]  - replace existing or insert new file(s) into the archive
  s            - act as ranlib
  t            - display contents of archive
  x[o]         - extract file(s) from the archive
 command specific modifiers:
  [a]          - put file(s) after [member-name]
  [b]          - put file(s) before [member-name] (same as [i])
  [D]          - use zero for timestamps and uids/gids
  [N]          - use instance [count] of name
  [f]          - truncate inserted file names
  [P]          - use full path names when matching
  [o]          - preserve original dates
  [u]          - only replace files that are newer than current archive contents
 generic modifiers:
  [c]          - do not warn if the library had to be created
  [s]          - create an archive index (cf. ranlib)
  [S]          - do not build a symbol table
  [T]          - make a thin archive
  [v]          - be verbose
  [V]          - display the version number
  @<file>      - read options from <file>
""" % env.getone('SCRIPT_NAME')

import asyncio
import functools


def unlock(lock):
    print('callback releasing lock')
    lock.release()


async def coro1(lock):
    print('coro1 waiting for the lock')
    with await lock:
        print('coro1 acquired lock')
    print('coro1 released lock')


async def coro2(lock):
    print('coro2 waiting for the lock')
    await lock
    try:
        print('coro2 acquired lock')
    finally:
        print('coro2 released lock')
        lock.release()


async def main(loop):
    # Create and acquire a shared lock.
    lock = asyncio.Lock()
    print('acquiring the lock before starting coroutines')
    await lock.acquire()
    print('lock acquired: {}'.format(lock.locked()))

    # Schedule a callback to unlock the lock.
    loop.call_later(0.1, functools.partial(unlock, lock))

    # Run the coroutines that want to use the lock.
    print('waiting for coroutines')
    await asyncio.wait([coro1(lock), coro2(lock)]),


event_loop = asyncio.get_event_loop()
try:
    event_loop.run_until_complete(main(event_loop))
finally:
    event_loop.close()

import numpy as np

from skimage.feature.util import (FeatureDetector, DescriptorExtractor,
                                  _mask_border_keypoints,
                                  _prepare_grayscale_input_2D)

from skimage.feature import (corner_fast, corner_orientations, corner_peaks,
                             corner_harris)
from skimage.transform import pyramid_gaussian

from .orb_cy import _orb_loop


OFAST_MASK = np.zeros((31, 31))
OFAST_UMAX = [15, 15, 15, 15, 14, 14, 14, 13, 13, 12, 11, 10, 9, 8, 6, 3]
for i in range(-15, 16):
    for j in range(-OFAST_UMAX[abs(i)], OFAST_UMAX[abs(i)] + 1):
        OFAST_MASK[15 + j, 15 + i]  = 1


class ORB(FeatureDetector, DescriptorExtractor):

    """Oriented FAST and rotated BRIEF feature detector and binary descriptor
    extractor.

    Parameters
    ----------
    n_keypoints : int, optional
        Number of keypoints to be returned. The function will return the best
        `n_keypoints` according to the Harris corner response if more than
        `n_keypoints` are detected. If not, then all the detected keypoints
        are returned.
    fast_n : int, optional
        The `n` parameter in `skimage.feature.corner_fast`. Minimum number of
        consecutive pixels out of 16 pixels on the circle that should all be
        either brighter or darker w.r.t test-pixel. A point c on the circle is
        darker w.r.t test pixel p if ``Ic < Ip - threshold`` and brighter if
        ``Ic > Ip + threshold``. Also stands for the n in ``FAST-n`` corner
        detector.
    fast_threshold : float, optional
        The ``threshold`` parameter in ``feature.corner_fast``. Threshold used
        to decide whether the pixels on the circle are brighter, darker or
        similar w.r.t. the test pixel. Decrease the threshold when more
        corners are desired and vice-versa.
    harris_k : float, optional
        The `k` parameter in `skimage.feature.corner_harris`. Sensitivity
        factor to separate corners from edges, typically in range ``[0, 0.2]``.
        Small values of `k` result in detection of sharp corners.
    downscale : float, optional
        Downscale factor for the image pyramid. Default value 1.2 is chosen so
        that there are more dense scales which enable robust scale invariance
        for a subsequent feature description.
    n_scales : int, optional
        Maximum number of scales from the bottom of the image pyramid to
        extract the features from.

    Attributes
    ----------
    keypoints : (N, 2) array
        Keypoint coordinates as ``(row, col)``.
    scales : (N, ) array
        Corresponding scales.
    orientations : (N, ) array
        Corresponding orientations in radians.
    responses : (N, ) array
        Corresponding Harris corner responses.
    descriptors : (Q, `descriptor_size`) array of dtype bool
        2D array of binary descriptors of size `descriptor_size` for Q
        keypoints after filtering out border keypoints with value at an
        index ``(i, j)`` either being ``True`` or ``False`` representing
        the outcome of the intensity comparison for i-th keypoint on j-th
        decision pixel-pair. It is ``Q == np.sum(mask)``.

    References
    ----------
    .. [1] Ethan Rublee, Vincent Rabaud, Kurt Konolige and Gary Bradski
          "ORB: An efficient alternative to SIFT and SURF"
          http://www.vision.cs.chubu.ac.jp/CV-R/pdf/Rublee_iccv2011.pdf

    Examples
    --------
    >>> from skimage.feature import ORB, match_descriptors
    >>> img1 = np.zeros((100, 100))
    >>> img2 = np.zeros_like(img1)
    >>> np.random.seed(1)
    >>> square = np.random.rand(20, 20)
    >>> img1[40:60, 40:60] = square
    >>> img2[53:73, 53:73] = square
    >>> detector_extractor1 = ORB(n_keypoints=5)
    >>> detector_extractor2 = ORB(n_keypoints=5)
    >>> detector_extractor1.detect_and_extract(img1)
    >>> detector_extractor2.detect_and_extract(img2)
    >>> matches = match_descriptors(detector_extractor1.descriptors,
    ...                             detector_extractor2.descriptors)
    >>> matches
    array([[0, 0],
           [1, 1],
           [2, 2],
           [3, 3],
           [4, 4]])
    >>> detector_extractor1.keypoints[matches[:, 0]]
    array([[ 42.,  40.],
           [ 47.,  58.],
           [ 44.,  40.],
           [ 59.,  42.],
           [ 45.,  44.]])
    >>> detector_extractor2.keypoints[matches[:, 1]]
    array([[ 55.,  53.],
           [ 60.,  71.],
           [ 57.,  53.],
           [ 72.,  55.],
           [ 58.,  57.]])

    """

    def __init__(self, downscale=1.2, n_scales=8,
                 n_keypoints=500, fast_n=9, fast_threshold=0.08,
                 harris_k=0.04):
        self.downscale = downscale
        self.n_scales = n_scales
        self.n_keypoints = n_keypoints
        self.fast_n = fast_n
        self.fast_threshold = fast_threshold
        self.harris_k = harris_k

        self.keypoints = None
        self.scales = None
        self.responses = None
        self.orientations = None
        self.descriptors = None

    def _build_pyramid(self, image):
        image = _prepare_grayscale_input_2D(image)
        return list(pyramid_gaussian(image, self.n_scales - 1, self.downscale))

    def _detect_octave(self, octave_image):
        # Extract keypoints for current octave
        fast_response = corner_fast(octave_image, self.fast_n,
                                    self.fast_threshold)
        keypoints = corner_peaks(fast_response, min_distance=1)

        if len(keypoints) == 0:
            return (np.zeros((0, 2), dtype=np.double),
                    np.zeros((0, ), dtype=np.double),
                    np.zeros((0, ), dtype=np.double))

        mask = _mask_border_keypoints(octave_image.shape, keypoints,
                                      distance=16)
        keypoints = keypoints[mask]

        orientations = corner_orientations(octave_image, keypoints,
                                           OFAST_MASK)

        harris_response = corner_harris(octave_image, method='k',
                                        k=self.harris_k)
        responses = harris_response[keypoints[:, 0], keypoints[:, 1]]

        return keypoints, orientations, responses

    def detect(self, image):
        """Detect oriented FAST keypoints along with the corresponding scale.

        Parameters
        ----------
        image : 2D array
            Input image.

        """

        pyramid = self._build_pyramid(image)

        keypoints_list = []
        orientations_list = []
        scales_list = []
        responses_list = []

        for octave in range(len(pyramid)):

            octave_image = np.ascontiguousarray(pyramid[octave])

            keypoints, orientations, responses = \
                self._detect_octave(octave_image)

            keypoints_list.append(keypoints * self.downscale ** octave)
            orientations_list.append(orientations)
            scales_list.append(self.downscale **  octave
                               * np.ones(keypoints.shape[0], dtype=np.intp))
            responses_list.append(responses)

        keypoints = np.vstack(keypoints_list)
        orientations = np.hstack(orientations_list)
        scales = np.hstack(scales_list)
        responses = np.hstack(responses_list)

        if keypoints.shape[0] < self.n_keypoints:
            self.keypoints = keypoints
            self.scales = scales
            self.orientations = orientations
            self.responses = responses
        else:
            # Choose best n_keypoints according to Harris corner response
            best_indices = responses.argsort()[::-1][:self.n_keypoints]
            self.keypoints = keypoints[best_indices]
            self.scales = scales[best_indices]
            self.orientations = orientations[best_indices]
            self.responses = responses[best_indices]

    def _extract_octave(self, octave_image, keypoints, orientations):
        mask = _mask_border_keypoints(octave_image.shape, keypoints,
                                      distance=20)
        keypoints = np.array(keypoints[mask], dtype=np.intp, order='C',
                             copy=False)
        orientations = np.array(orientations[mask], dtype=np.double, order='C',
                                copy=False)

        descriptors = _orb_loop(octave_image, keypoints, orientations)

        return descriptors, mask

    def extract(self, image, keypoints, scales, orientations):
        """Extract rBRIEF binary descriptors for given keypoints in image.

        Note that the keypoints must be extracted using the same `downscale`
        and `n_scales` parameters. Additionally, if you want to extract both
        keypoints and descriptors you should use the faster
        `detect_and_extract`.

        Parameters
        ----------
        image : 2D array
            Input image.
        keypoints : (N, 2) array
            Keypoint coordinates as ``(row, col)``.
        scales : (N, ) array
            Corresponding scales.
        orientations : (N, ) array
            Corresponding orientations in radians.

        """

        pyramid = self._build_pyramid(image)

        descriptors_list = []
        mask_list = []

        # Determine octaves from scales
        octaves = (np.log(scales) / np.log(self.downscale)).astype(np.intp)

        for octave in range(len(pyramid)):

            # Mask for all keypoints in current octave
            octave_mask = octaves == octave

            if np.sum(octave_mask) > 0:

                octave_image = np.ascontiguousarray(pyramid[octave])

                octave_keypoints = keypoints[octave_mask]
                octave_keypoints /= self.downscale ** octave

                octave_orientations = orientations[octave_mask]

                descriptors, mask = self._extract_octave(octave_image,
                                                         octave_keypoints,
                                                         octave_orientations)

                descriptors_list.append(descriptors)
                mask_list.append(mask)

        self.descriptors = np.vstack(descriptors_list).view(np.bool)
        self.mask_ = np.hstack(mask_list)

    def detect_and_extract(self, image):
        """Detect oriented FAST keypoints and extract rBRIEF descriptors.

        Note that this is faster than first calling `detect` and then
        `extract`.

        Parameters
        ----------
        image : 2D array
            Input image.

        """

        pyramid = self._build_pyramid(image)

        keypoints_list = []
        responses_list = []
        scales_list = []
        orientations_list = []
        descriptors_list = []

        for octave in range(len(pyramid)):

            octave_image = np.ascontiguousarray(pyramid[octave])

            keypoints, orientations, responses = \
                self._detect_octave(octave_image)

            if len(keypoints) == 0:
                keypoints_list.append(keypoints)
                responses_list.append(responses)
                descriptors_list.append(np.zeros((0, 256), dtype=np.bool))
                continue

            descriptors, mask = self._extract_octave(octave_image, keypoints,
                                                     orientations)

            keypoints_list.append(keypoints[mask] * self.downscale ** octave)
            responses_list.append(responses[mask])
            orientations_list.append(orientations[mask])
            scales_list.append(self.downscale **  octave
                               * np.ones(keypoints.shape[0], dtype=np.intp))
            descriptors_list.append(descriptors)

        keypoints = np.vstack(keypoints_list)
        responses = np.hstack(responses_list)
        scales = np.hstack(scales_list)
        orientations = np.hstack(orientations_list)
        descriptors = np.vstack(descriptors_list).view(np.bool)

        if keypoints.shape[0] < self.n_keypoints:
            self.keypoints = keypoints
            self.scales = scales
            self.orientations = orientations
            self.responses = responses
            self.descriptors = descriptors
        else:
            # Choose best n_keypoints according to Harris corner response
            best_indices = responses.argsort()[::-1][:self.n_keypoints]
            self.keypoints = keypoints[best_indices]
            self.scales = scales[best_indices]
            self.orientations = orientations[best_indices]
            self.responses = responses[best_indices]
            self.descriptors = descriptors[best_indices]

# -*- coding: utf-8 -*-
# Copyright (C) 2010  Wil Mahan <wmahan+fatics@gmail.com>
#
# This file is part of FatICS.
#
# FatICS is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# FatICS is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with FatICS.  If not, see <http://www.gnu.org/licenses/>.
#

def hms_words(secs):
    (days, secs) = divmod(secs, 86400)
    (hours, secs) = divmod(secs, 3600)
    (mins, secs) = divmod(secs, 60)
    ret = ''
    if days != 0:
        ret = ret + ngettext("%d day", "%d days", days) % days + " "
    if days != 0 or hours != 0:
        ret = ret + ngettext("%d hour", "%d hours", hours) % hours + " "
    if days != 0 or hours != 0 or mins != 0:
        ret = ret + ngettext("%d minute", "%d minutes", mins) % mins + " "
    ret = ret + ngettext("%d second", "%d seconds", secs) % secs
    return ret

def hms(secs, user=None):
    (hours, secs) = divmod(secs, 3600)
    (mins, secs) = divmod(secs, 60)

    if not user or user.session.ivars['ms']:
        if hours != 0:
            ret = '%d:%02d:%06.3f' % (hours, mins, secs)
        else:
            ret = '%d:%06.3f' % (mins, secs)
    else:
        if hours != 0:
            ret = '%d:%02d:%02d' % (hours, mins, secs)
        else:
            ret = '%d:%02d' % (mins, secs)
    return ret

# vim: expandtab tabstop=4 softtabstop=4 shiftwidth=4 smarttab autoindent

VariableGenerator_1 = VariableGenerator(
    Variable=(
        Struct(
            a=String('test'),
            b=Int(3)
        )
    )
)
VariableGenerator_2 = VariableGenerator(
    Variable=(
        Struct(
            a=String('test new'),
            b=Int(8)
        )
    )
)
VariableGenerator_3 = VariableGenerator(
    Variable=(
        Ensemble(
            (
                Struct(
                    a=String(),
                    bc_type=Int(),
                    time=Int(),
                    value=Float()
                )
            ),
            (
                Struct(
                    a=String('a1'),
                    bc_type=Int(4),
                    time=Int(500),
                    value=Float(5.0)
                )
            ),
            (
                Struct(
                    a=String('a2'),
                    bc_type=Int(4),
                    time=Int(650),
                    value=Float(2.0)
                )
            ),
            (
                Struct(
                    a=String('a3'),
                    bc_type=Int(3),
                    time=Int(700),
                    value=Float(8.0)
                )
            ),
            (
                Struct(
                    a=String('a4'),
                    bc_type=Int(4),
                    time=Int(750),
                    value=Float(12.0)
                )
            ),
            (
                Struct(
                    a=String('a5'),
                    bc_type=Int(3),
                    time=Int(850),
                    value=Float(2.0)
                )
            ),
            (
                Struct(
                    a=String('a6'),
                    bc_type=Int(4),
                    time=Int(900),
                    value=Float(13.0)
                )
            ),
            (
                Struct(
                    a=String('a7'),
                    bc_type=Int(6),
                    time=Int(1100),
                    value=Float(18.0)
                )
            )
        )
    )
)
Key_2 = KeyConvertor(
    Input(0).value
)
Conv_3 = Convertor(
    Struct(
        a=Input(0).a,
        b=Input(1).b,
        c=Input(2).sort(Key_2)
    )
)
Conn_6 = Connector(
    Inputs=[
        VariableGenerator_1,
        VariableGenerator_2,
        VariableGenerator_3
    ],
    Convertor=Conv_3
)

import logging
import six
from copy import deepcopy
from .connectors import get_connector
from user_sync.error import AssertionException


class PostSyncManager:
    def __init__(self, post_sync_config, test_mode):
        self.config = post_sync_config
        self.logger = logging.getLogger("post-sync")
        self.umapi_users = {}

        # Assemble to connector list
        self.connectors = [
            get_connector(m, c, test_mode) for m, c in six.iteritems(self.config['modules'])
        ]

    def get_directory_attributes(self):
        attributes = set()
        for conn in self.connectors:
            attributes |= set(conn.get_directory_attributes())
        return attributes

    def run(self, post_sync_data):
        """
        run each entry from the module dict from __init__
        :return:
        """
        for connector in self.connectors:
            self.logger.info("Running module " + connector.name)
            try:
                connector.run(post_sync_data)
            except AssertionException as e:
                self.logger.error("%s", e)
            self.logger.info("Finished running " + connector.name)


class PostSyncData:
    def __init__(self):
        self.umapi_data = {}
        self.source_attributes = {}

    def update_umapi_data(self, org_id, user_key, add_groups=[], remove_groups=[], **kwargs):
        """
        Update (or insert) sync data for a given user
        :param org_id:
        :param str user_key:
        :param list add_groups:
        :param list remove_groups:
        :return:
        """
        if org_id not in self.umapi_data:
            self.umapi_data[org_id] = {}

        umapi_data = self.umapi_data[org_id]
        user_store_data = umapi_data.get(user_key)

        if user_store_data is None:
            user_store_data = self._umapi_data_template()

        updated_store_data = deepcopy(user_store_data)
        groups_to_add = set(self._normalize_groups(add_groups))
        for k in updated_store_data:
            if k not in kwargs:
                continue
            if k == 'groups':
                groups_to_add |= set(self._normalize_groups(kwargs[k]))
            else:
                updated_store_data[k] = kwargs[k]

        updated_store_data['groups'] |= groups_to_add
        updated_store_data['groups'] -= set(self._normalize_groups(remove_groups))

        self.umapi_data[org_id][user_key] = updated_store_data

    def remove_umapi_user_groups(self, org_id, user_key):
        umapi_data = self.umapi_data.get(org_id)
        user_store_data = umapi_data.get(user_key)
        if user_store_data is None:
            return
        user_store_data['groups'] = []

    def remove_umapi_user(self, org_id, user_key):
        umapi_data = self.umapi_data.get(org_id)
        if user_key not in umapi_data:
            return
        del umapi_data[user_key]

    def update_source_attributes(self, user_key, source_attributes):
        self.source_attributes[user_key] = source_attributes

    @staticmethod
    def _umapi_data_template():
        return {
            'type': None,
            'username': None,
            'domain': None,
            'email': None,
            'firstname': None,
            'lastname': None,
            'groups': set(),
            'country': None,
        }

    @staticmethod
    def _normalize_groups(groups):
        return [g.lower() for g in groups]

"""Constants (like hbar) related to quantum mechanics."""

from __future__ import print_function, division

from sympy.core.numbers import NumberSymbol
from sympy.core.singleton import Singleton
from sympy.core.compatibility import u, with_metaclass
from sympy.printing.pretty.stringpict import prettyForm
import sympy.mpmath.libmp as mlib

#-----------------------------------------------------------------------------
# Constants
#-----------------------------------------------------------------------------

__all__ = [
    'hbar'
]


class HBar(with_metaclass(Singleton, NumberSymbol)):
    """Reduced Plank's constant in numerical and symbolic form [1]_.

    Examples
    ========

        >>> from sympy.physics.quantum.constants import hbar
        >>> hbar.evalf()
        1.05457162000000e-34

    References
    ==========

    .. [1] http://en.wikipedia.org/wiki/Planck_constant
    """

    is_real = True
    is_positive = True
    is_negative = False
    is_irrational = True

    __slots__ = []

    def _as_mpf_val(self, prec):
        return mlib.from_float(1.05457162e-34, prec)

    def _sympyrepr(self, printer, *args):
        return 'HBar()'

    def _sympystr(self, printer, *args):
        return 'hbar'

    def _pretty(self, printer, *args):
        if printer._use_unicode:
            return prettyForm(u('\u210f'))
        return prettyForm('hbar')

    def _latex(self, printer, *args):
        return r'\hbar'

# Create an instance for everyone to use.
hbar = HBar()

from twisted.cred.portal import IRealm
from twisted.internet.defer import maybeDeferred
from twisted.web.resource import IResource
from zope.interface import implements

from jumpmaplist.cred.guard import ExpireTokenResource
from jumpmaplist.routers import PublicRouter, PrivateRouter
from jumpmaplist.resource import ApplicationElement, LoginElement
from jumpmaplist.util import ContentTypeRouter, LeafRenderableResource



class MapListRealm(object):
    implements(IRealm)

    def __init__(self, database, jsPath, steamAPI, redirectTo):
        self.db = database
        self.jsPath = jsPath or 'https://static.tempus.xyz/maplist/js'
        self.steamAPI = steamAPI
        self.redirectTo = redirectTo


    def anonymous(self):
        html = LeafRenderableResource(LoginElement())
        json = PublicRouter(self.db)

        return ContentTypeRouter([
            ('text/html', html),
            ('application/json', json)
        ])


    def registered(self, avatarId):
        # steam:XXXXXXXXXXXXXXXXX
        steamID = int(avatarId[6:])
        user = self.db.users.get(steamID)
        if not user:
            return ExpireTokenResource(self.redirectTo)

        html = LeafRenderableResource(ApplicationElement(steamID, self.jsPath,
                                                         user.superuser))
        json = PrivateRouter(self.db, steamID, self.steamAPI)

        return ContentTypeRouter([
            ('text/html', html),
            ('application/json', json)
        ])


    def requestAvatar(self, avatarId, mind, *interfaces):
        if IResource in interfaces:
            if avatarId:
                d = maybeDeferred(self.registered, avatarId)
            else:
                d = maybeDeferred(self.anonymous)
            return d.addCallback(
                lambda avatar: (IResource, avatar, lambda: None))
        raise NotImplementedError()

#!/usr/bin/env python

# BCET Workflow

__author__ = 'Sam Brooke'
__date__ = 'September 2017'
__copyright__ = '(C) 2017, Sam Brooke'
__email__ = "sbrooke@tuta.io"

import os
import gdal
from geopandas import GeoDataFrame
from shapely.geometry import Polygon
import georasters as gr
import matplotlib.pyplot as plt
import numpy as np
from optparse import OptionParser
import json
import re

parser = OptionParser()
parser.add_option("-c", "--cloud", dest="cloud", help="Location of cloud raster", metavar="CLOUD")

(options, args) = parser.parse_args()

cloud_tif = False

if options.cloud:
	if os.path.isfile(options.cloud):
		cloud_tif = options.cloud

# args[0] for config file
# args[1] for LANDSAT TIF
# args[2] for file prefix

config_file = False
landsat_raster = False
file_prefix = ''

if len(args) > 1:
	if os.path.isfile(args[0]):
		config_file = args[0]

	if os.path.isfile(args[1]):
		landsat_raster = args[1]

	output_dir = args[2]


m = re.search(r"B[0-9]+",landsat_raster)
band_name = m.group()

config_data = False
if config_file:
	with open(config_file) as data_file:
    		config_data = json.load(data_file)


keys = config_data.keys()

# ROI (Region Of Interest) coordinates

roi = False
run_title = 'untitled'

if 'roi' in keys:
	top_left = config_data['roi']['top_left']
	bottom_right = config_data['roi']['bottom_right']
	roi = True

if 'name' in keys:
	run_title = config_data['name']

if roi:
# Create Polygon of ROI
	roi_poly = Polygon([(top_left[0], top_left[1]), (bottom_right[0], top_left[1]), (bottom_right[0], bottom_right[1]), (top_left[0], bottom_right[1])])

#
# Load and Process Rasters
#

# Load Raster
raster = os.path.join(landsat_raster)
ndv, xsize, ysize, geot, projection, datatype = gr.get_geo_info(raster) # Raster information
# ndv = no data value
data = gr.from_file(raster) # Create GeoRaster object
crs = projection.ExportToProj4() # Create a projection string in proj4 format

if roi:
	print('Clipping ROI')
	# Create GeoDataFrame of ROI polygon with correction projection
	clip_df = GeoDataFrame(crs=crs, geometry=[roi_poly])
	raster_clip = data.clip(clip_df)
	raster_data = raster_clip[0].raster
else:
	raster_data = data.raster

if cloud_tif:
	print('Preparing cloud mask')
	# Cloud mask layer
	# See
	cloud_mask = os.path.join(cloud_tif)
	cloud_mask_gr = gr.from_file(cloud_mask)
	cloud_clip = cloud_mask_gr.clip(clip_df)
	cloud_data = cloud_clip[0].raster

# Mask invalid data
raster_masked = np.ma.masked_invalid(raster_data, copy=True)

if cloud_tif:
	print('Running cloud mask')
	# Mask clouds, snow and shadows
	raster_processed = np.where(cloud_data == 1, raster_masked, ndv)
else:
	raster_processed = raster_masked

#
# BCET algebra
#

print('BCETing')

s = np.mean(np.power(raster_processed,2)) # mean squared
e = np.mean(raster_processed)
l = np.min(raster_processed)
h = np.max(raster_processed)

L = 0 # output minimum
H = 255 # output maximum
E = 110 # output mean


# Find b
b_nom = ((h**2)*(E-L))-(s*(H-L))+((l**2)*(H-E))
b_den = 2*((h*(E-L))-(e*(H-L))+(l*(H-E)))

b = b_nom/b_den

# Find a
a1 = H-L
a2 = h-l
a3 = h+l-(2*b)

a = a1/(a2*a3)

# Find c
c = L-(a*(l-b)**2)

# Process raster
bcet_raster = a*((raster_processed - b)**2) + c

print('New average value:')
print(bcet_raster.mean()) # should be 110!

#
# Output
#

output_gr = gr.GeoRaster(bcet_raster,
     raster_clip[0].geot,
     nodata_value=ndv,
     projection=raster_clip[0].projection,
     datatype=raster_clip[0].datatype)

output_dir_full = os.path.join(output_dir,run_title)

if not os.path.exists(output_dir_full):
  os.makedirs(output_dir_full)

new_path = os.path.join(output_dir_full,run_title+'_'+band_name)
print('Outputing '+new_path+' ...')
# Make Geotiff
output_gr.to_tiff(new_path)

# Add some metadata

ds = gdal.Open(new_path+'.tif', gdal.GA_Update)
ds.SetMetadataItem('ORIGINAL_LANDSAT', os.path.basename(landsat_raster))
ds.FlushCache()


s3gis_tests = load_module("tests.unit_tests.modules.s3.s3gis")
s3gis = s3gis_tests.s3gis

def test_KMLLayer():
    current.session.s3.debug = True
    current.request.utcnow = datetime.datetime.now()
    s3gis_tests.layer_test(
        db,
        db.gis_layer_kml,
        dict(
            name = "Test KML",
            description = "Test KML layer",
            enabled = True,
            created_on = datetime.datetime.now(),
            modified_on = datetime.datetime.now(),
            url = "test://test_KML",
        ),
        "S3.gis.layers_kml",
        [
            {
                "marker_height": 34, 
                "marker_image": u"gis_marker.image.marker_red.png", 
                "marker_width": 20, 
                "name": u"Test KML", 
                # this shows that caching is OK:
                "url": u"/eden/default/download/gis_cache2.file.Test_20KML.kml"
            }
        ],
        session = session,
        request = request,
    )

def test_KMLCaching_not_possible():
    import os.path
    import sys
    
    class Mock(object):
        pass
    mock_stderr = Mock()
    buffer = []
    def mock_write(error_message):
        buffer.append(error_message)
    mock_stderr.write = mock_write
    
    with s3gis_tests.Change(
        os.path,
        {
            "exists": lambda *a, **kw: False
        }
    ):
        with s3gis_tests.Change(
            sys,
            {
                "stderr": mock_stderr
            }
        ):
            with s3gis_tests.Change(
                current.session.s3,
                {
                    "debug": False
                }
            ):
                kml_layer = s3gis.KMLLayer(s3gis.GIS())
                js = kml_layer.as_javascript()
                
                assert session.error.startswith(
                    "GIS: KML layers cannot be cached: "
                )
                assert "GIS: KML layers cannot be cached:" in buffer[0]

width  = 75
height = 75
data   = [
  0x00,0x00,0x00,0x00,0x00,0xe0,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x01,0xf0,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x03,0xf0,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x03,0xf8,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x07,0xf8,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x0f,0xf8,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x1f,0xfc,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x1f,0xfc,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x3f,0xfc,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x7f,0xfe,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x7f,0xfe,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0xff,0xfe,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x01,0xff,0xff,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x03,0xff,0xff,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x03,0xff,0xff,0x00,0x00,0x00,0x00,
  0x00,0x00,0x00,0x07,0xff,0xff,0x80,0x00,0x00,0x00,
  0x00,0x00,0x00,0x07,0xff,0xff,0x80,0x00,0x00,0x00,
  0x00,0x00,0x00,0x07,0xff,0xff,0x80,0x00,0x00,0x00,
  0x00,0x00,0x00,0x0f,0xff,0xff,0x80,0x00,0x00,0x00,
  0x00,0x00,0x00,0x0f,0xff,0xff,0x80,0x00,0x00,0x00,
  0x7f,0xff,0xfc,0x0f,0xff,0xff,0x80,0x00,0x00,0x00,
  0xff,0xff,0xff,0x0f,0xff,0xff,0x80,0x00,0x00,0x00,
  0xff,0xff,0xff,0xcf,0xff,0xff,0x80,0x00,0x00,0x00,
  0xff,0xff,0xff,0xef,0xff,0xff,0x80,0x00,0x00,0x00,
  0x7f,0xff,0xff,0xf7,0xff,0xff,0x80,0x00,0x00,0x00,
  0x3f,0xff,0xff,0xff,0xfb,0xff,0x00,0x00,0x00,0x00,
  0x3f,0xff,0xff,0xff,0xf1,0xff,0x3f,0xf0,0x00,0x00,
  0x1f,0xff,0xff,0xff,0xf1,0xfe,0xff,0xfe,0x00,0x00,
  0x0f,0xff,0xff,0xff,0xf1,0xff,0xff,0xff,0xc0,0x00,
  0x0f,0xff,0xff,0xff,0xe1,0xff,0xff,0xff,0xf8,0x00,
  0x07,0xff,0xff,0xff,0xe1,0xff,0xff,0xff,0xff,0x00,
  0x03,0xff,0xff,0xff,0xe1,0xff,0xff,0xff,0xff,0xc0,
  0x01,0xff,0xff,0x3f,0xe1,0xff,0xff,0xff,0xff,0xe0,
  0x01,0xff,0xfe,0x07,0xe3,0xff,0xff,0xff,0xff,0xe0,
  0x00,0xff,0xff,0x03,0xe3,0xff,0xff,0xff,0xff,0xe0,
  0x00,0x7f,0xff,0x00,0xf7,0xff,0xff,0xff,0xff,0xc0,
  0x00,0x3f,0xff,0xc0,0xff,0xc0,0x7f,0xff,0xff,0x80,
  0x00,0x1f,0xff,0xf0,0xff,0x00,0x3f,0xff,0xff,0x00,
  0x00,0x0f,0xff,0xff,0xff,0x00,0x7f,0xff,0xfc,0x00,
  0x00,0x07,0xff,0xff,0xff,0x01,0xff,0xff,0xf8,0x00,
  0x00,0x01,0xff,0xff,0xff,0xff,0xff,0xff,0xf0,0x00,
  0x00,0x00,0x7f,0xff,0xff,0xff,0xff,0xff,0xc0,0x00,
  0x00,0x00,0x1f,0xfc,0x7f,0xff,0xff,0xff,0x80,0x00,
  0x00,0x00,0x7f,0xf8,0x78,0xff,0xff,0xfe,0x00,0x00,
  0x00,0x00,0xff,0xf0,0x78,0x7f,0xff,0xfc,0x00,0x00,
  0x00,0x01,0xff,0xe0,0xf8,0x7f,0xff,0xf0,0x00,0x00,
  0x00,0x03,0xff,0xc0,0xf8,0x3f,0xdf,0xc0,0x00,0x00,
  0x00,0x07,0xff,0xc1,0xfc,0x3f,0xe0,0x00,0x00,0x00,
  0x00,0x07,0xff,0x87,0xfc,0x1f,0xf0,0x00,0x00,0x00,
  0x00,0x0f,0xff,0xcf,0xfe,0x1f,0xf8,0x00,0x00,0x00,
  0x00,0x0f,0xff,0xff,0xff,0x1f,0xf8,0x00,0x00,0x00,
  0x00,0x1f,0xff,0xff,0xff,0x1f,0xfc,0x00,0x00,0x00,
  0x00,0x1f,0xff,0xff,0xff,0xff,0xfc,0x00,0x00,0x00,
  0x00,0x1f,0xff,0xff,0xff,0xff,0xfe,0x00,0x00,0x00,
  0x00,0x3f,0xff,0xff,0xff,0xff,0xfe,0x00,0x00,0x00,
  0x00,0x3f,0xff,0xff,0xff,0xff,0xfe,0x00,0x00,0x00,
  0x00,0x3f,0xff,0xff,0x3f,0xff,0xfe,0x00,0x00,0x00,
  0x00,0x7f,0xff,0xff,0x3f,0xff,0xfe,0x00,0x00,0x00,
  0x00,0x7f,0xff,0xff,0x3f,0xff,0xfe,0x00,0x00,0x00,
  0x00,0x7f,0xff,0xfe,0x3f,0xff,0xfe,0x00,0x00,0x00,
  0x00,0xff,0xff,0xfc,0x1f,0xff,0xfe,0x00,0x00,0x00,
  0x00,0xff,0xff,0xf8,0x1f,0xff,0xfe,0x00,0x00,0x00,
  0x00,0xff,0xff,0xe0,0x0f,0xff,0xfe,0x00,0x00,0x00,
  0x01,0xff,0xff,0x80,0x07,0xff,0xfe,0x00,0x00,0x00,
  0x01,0xff,0xfc,0x00,0x03,0xff,0xfe,0x00,0x00,0x00,
  0x01,0xff,0xe0,0x00,0x01,0xff,0xfe,0x00,0x00,0x00,
  0x01,0xff,0x00,0x00,0x00,0xff,0xfe,0x00,0x00,0x00,
  0x00,0xf8,0x00,0x00,0x00,0x7f,0xfe,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x1f,0xfe,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x0f,0xfe,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x07,0xfe,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x01,0xfe,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
  0x00,0x00,0x00,0x00,0x00,0x00,0x1c,0x00,0x00,0x00
]
#
# -*- coding: utf-8 -*-
# Copyright 2019 Red Hat
# GNU General Public License v3.0+
# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
"""
The ios_lacp_interfaces fact class
It is in this file the configuration is collected from the device
for a given resource, parsed, and the facts tree is populated
based on the configuration.
"""

from __future__ import absolute_import, division, print_function
__metaclass__ = type


import re
from copy import deepcopy
from ansible.module_utils.network.common import utils
from ansible.module_utils.network.ios.utils.utils import get_interface_type, normalize_interface
from ansible.module_utils.network.ios.argspec.lacp_interfaces.lacp_interfaces import Lacp_InterfacesArgs


class Lacp_InterfacesFacts(object):
    """ The ios_lacp_interfaces fact class
    """

    def __init__(self, module, subspec='config', options='options'):

        self._module = module
        self.argument_spec = Lacp_InterfacesArgs.argument_spec
        spec = deepcopy(self.argument_spec)
        if subspec:
            if options:
                facts_argument_spec = spec[subspec][options]
            else:
                facts_argument_spec = spec[subspec]
        else:
            facts_argument_spec = spec

        self.generated_spec = utils.generate_dict(facts_argument_spec)

    def populate_facts(self, connection, ansible_facts, data=None):
        """ Populate the facts for lacp_interfaces
        :param connection: the device connection
        :param ansible_facts: Facts dictionary
        :param data: previously collected conf
        :rtype: dictionary
        :returns: facts
        """
        if connection:
            pass

        objs = []
        if not data:
            data = connection.get('show running-config | section ^interface')
        # operate on a collection of resource x
        config = data.split('interface ')

        for conf in config:
            if conf:
                obj = self.render_config(self.generated_spec, conf)
                if obj:
                    objs.append(obj)
        facts = {}

        if objs:
            facts['lacp_interfaces'] = []
            params = utils.validate_config(self.argument_spec, {'config': objs})
            for cfg in params['config']:
                facts['lacp_interfaces'].append(utils.remove_empties(cfg))
        ansible_facts['ansible_network_resources'].update(facts)

        return ansible_facts

    def render_config(self, spec, conf):
        """
        Render config as dictionary structure and delete keys
          from spec for null values

        :param spec: The facts tree, generated from the argspec
        :param conf: The configuration
        :rtype: dictionary
        :returns: The generated config
        """
        config = deepcopy(spec)
        match = re.search(r'^(\S+)', conf)
        intf = match.group(1)
        if get_interface_type(intf) == 'unknown':
            return {}

        config['name'] = normalize_interface(intf)
        port_priority = utils.parse_conf_arg(conf, 'lacp port-priority')
        max_bundle = utils.parse_conf_arg(conf, 'lacp max-bundle')
        if port_priority:
            config['port_priority'] = int(port_priority)
        if 'lacp fast-switchover' in conf:
            config['fast_switchover'] = True
        if max_bundle:
            config['max_bundle'] = int(max_bundle)

        return utils.remove_empties(config)

"""Add TranslationSyncLogs

Revision ID: 21e927fdf78c
Revises: 44d704928d8c
Create Date: 2015-04-20 23:34:51.724151

"""

# revision identifiers, used by Alembic.
revision = '21e927fdf78c'
down_revision = '44d704928d8c'

from alembic import op
import sqlalchemy as sa


def upgrade():
    ### commands auto generated by Alembic - please adjust! ###
    op.create_table('TranslationSyncLogs',
    sa.Column('id', sa.Integer(), nullable=False),
    sa.Column('start_datetime', sa.DateTime(), nullable=True),
    sa.Column('end_datetime', sa.DateTime(), nullable=True),
    sa.PrimaryKeyConstraint('id')
    )
    op.create_index(u'ix_TranslationSyncLogs_end_datetime', 'TranslationSyncLogs', ['end_datetime'], unique=False)
    op.create_index(u'ix_TranslationSyncLogs_start_datetime', 'TranslationSyncLogs', ['start_datetime'], unique=False)
    ### end Alembic commands ###


def downgrade():
    ### commands auto generated by Alembic - please adjust! ###
    op.drop_index(u'ix_TranslationSyncLogs_start_datetime', table_name='TranslationSyncLogs')
    op.drop_index(u'ix_TranslationSyncLogs_end_datetime', table_name='TranslationSyncLogs')
    op.drop_table('TranslationSyncLogs')
    ### end Alembic commands ###

# coding: utf-8
from __future__ import unicode_literals

import re

from .common import InfoExtractor


class LocalNews8IE(InfoExtractor):
    _VALID_URL = r'https?://(?:www\.)?localnews8\.com/(?:[^/]+/)*(?P<display_id>[^/]+)/(?P<id>[0-9]+)'
    _TEST = {
        'url': 'http://www.localnews8.com/news/rexburg-business-turns-carbon-fiber-scraps-into-wedding-rings/35183304',
        'md5': 'be4d48aea61aa2bde7be2ee47691ad20',
        'info_dict': {
            'id': '35183304',
            'display_id': 'rexburg-business-turns-carbon-fiber-scraps-into-wedding-rings',
            'ext': 'mp4',
            'title': 'Rexburg business turns carbon fiber scraps into wedding ring',
            'description': 'The process was first invented by Lamborghini and less than a dozen companies around the world use it.',
            'duration': 153,
            'timestamp': 1441844822,
            'upload_date': '20150910',
            'uploader_id': 'api',
        }
    }

    def _real_extract(self, url):
        mobj = re.match(self._VALID_URL, url)
        video_id = mobj.group('id')
        display_id = mobj.group('display_id')

        webpage = self._download_webpage(url, display_id)

        partner_id = self._search_regex(
            r'partnerId\s*[:=]\s*(["\'])(?P<id>\d+)\1',
            webpage, 'partner id', group='id')
        kaltura_id = self._search_regex(
            r'videoIdString\s*[:=]\s*(["\'])kaltura:(?P<id>[0-9a-z_]+)\1',
            webpage, 'videl id', group='id')

        return {
            '_type': 'url_transparent',
            'url': 'kaltura:%s:%s' % (partner_id, kaltura_id),
            'ie_key': 'Kaltura',
            'id': video_id,
            'display_id': display_id,
        }

import logging
import json
import os
import requests
from tqdm import tqdm
import hashlib
from contextlib import closing

import csv
import codecs
from itertools import islice


class ApkDownloader(object):

    def __init__(self):
        # Configure Logging
        logging.basicConfig(level=logging.INFO)
        # logging.basicConfig(level=logging.WARNING)
        self.logger = logging.getLogger(__name__)
        # self.logger.setLevel(logging.INFO)
        self.logger.setLevel(logging.DEBUG)
        # self.logger.setLevel(logging.WARNING)

        self.config_file_path = os.path.join('config', 'APK_PATH.json')
        self.config_file = self.read_config_file(self.config_file_path)

        self.apk_list_path = self.config_file['config']['apk_dataset']['apk_url']
        self.apk_store_path = self.config_file['config']['remote']['apk_path']
        self.API_key =  self.config_file['config']['remote']['api_key']

        self.APK_filename_list = self.get_all_apk_filenames_from_source('All')

    def read_config_file(self, configPath):
        self.logger.debug("Config Path: %s" % str(configPath))
        with open(configPath) as data_file:
            data = json.load(data_file)
            # self.logger.debug("APK Config Path (in func): %s" % str(data['config'][apk_path_type]['apk_path']))

            # return str(data['config'][apk_path_type]['apk_path'])
            return data

    def download_apk(self, file_name, mal_type=''):
        success = False
        #self.logger.debug('Getting APK from REMOTE path: {}'.format(self.apk_store_path_type))
        self.logger.debug('Getting APK from REMOTE path: {}'.format(self.apk_store_path))
        # https://androzoo.uni.lu/api/download?apikey=${APIKEY}&sha256=${SHA256}
        params = {'apikey': self.API_key, 'sha256': file_name}
        # resp = requests.post(self.apk_files_path, data=params)
        resp = requests.get(self.apk_store_path, data=params, stream=True)
        self.logger.debug('Response Code: \n {}:{}'.format(resp.status_code, resp.reason))
        # self.logger.debug('Response: \n {}'.format(resp.text))
        extension = '.apk'
        sub_dir = mal_type
        if sub_dir != '':
            if os.path.exists(os.path.join('downloads', sub_dir)):
                self.logger.debug('Sub-dir [{}] exists.'.format(sub_dir))
            else:
                os.mkdir(os.path.join('downloads', sub_dir))
                self.logger.debug('Created Sub-dir: [{}]'.format(sub_dir))

        downloads_filepath = os.path.join('downloads', sub_dir, file_name + extension)
        if resp.ok:
            total_size = int(resp.headers.get('content-length'))
            self.logger.info('File Length: {}'.format(total_size))
            with open(downloads_filepath, 'wb') as file_handle:
                # if the file is large we do the writing in chunks
                # tqdm is a library for a portable progressbar (Default unit is "it" --> number of iterations)
                for block in tqdm(resp.iter_content(1024), unit='B', total=total_size / 1024, unit_scale=True):
                    file_handle.write(block)
                    # currsize = (file_handle/1000000)
                    # apk_file = file_handle
                    # apk_file_path = temp_filepath

            # Check the hash if the transfer has completed successfully
            #apk = apk_file.ApkFile(temp_filepath)
            self.logger.debug('Local SHA 256: {}'.format(self.get_sha256_hash(downloads_filepath)))
            success = True
        else:
            success = False
            self.logger.error(
                "Something went wrong with the file download: {} - {}".format(resp.status_code, resp.reason))

            # return apk_file
            # return apk_file_path

        #return apk
            return success

    def get_all_apk_filenames_from_source(self, mal_state='All'):
        url = self.apk_list_path
        self.logger.debug("Current APK Source: {}".format(url))
        apk_filenames = []
        with closing(requests.get(url, stream=True)) as r:
            reader = csv.reader(codecs.iterdecode(r.iter_lines(), 'utf-8'))
            # Picking all the filenames from the data source
            # for row in reader:
            #     apk_filenames.append(row[0])
            #     self.logger.debug('APK SHA256 (name): {}'.format(row[0]))

            # ***************************************
            # Picking only the first 10 file names
            # ***************************************
            self.row_zero_header = next(reader)
            self.logger.debug("Header Row: {}".format(self.row_zero_header))
            vt_detection_idx = self.row_zero_header.index('vt_detection')
            self.logger.debug("vt_detection INDEX: {}".format(vt_detection_idx))
            for idx, row in enumerate(islice(reader, 10)):
            #for idx, row in enumerate(islice(reader, 100)):
                if mal_state == 'malicious':
                    if int(row[vt_detection_idx]) > 0:
                        apk_filenames.append(row[0])
                        self.logger.debug('APK SHA256 (name): {}'.format(row[0]))
                        # print("SHA256: {}".format(row[0]))
                        # print(row)
                elif mal_state == 'benign':
                    if int(row[vt_detection_idx]) == 0:
                        apk_filenames.append(row[0])
                        self.logger.debug('APK SHA256 (name): {}'.format(row[0]))
                        # print("SHA256: {}".format(row[0]))
                        # print(row)
                elif mal_state == 'All':
                    apk_filenames.append(row[0])
                    self.logger.debug('APK SHA256 [{}] (name): {}'.format(len(apk_filenames),row[0]))

        return  apk_filenames

    def get_sha256_hash(self, filepath, block_size=65536):
        sha256 = hashlib.sha256()
        with open(filepath, 'rb') as f:
            for block in iter(lambda: f.read(block_size), b''):
                sha256.update(block)
        return str(sha256.hexdigest()).upper()

    def do_download(self):
        for apk_file_name in self.APK_filename_list:
            self.download_apk(apk_file_name)

def main():
    apk_downloader = ApkDownloader()
    apk_downloader.do_download()


if __name__ == "__main__":
    main()
# -*- coding: utf-8 -*-
#
# protocol.py - decode binary messages received from WeeChat/relay
#
# Copyright (C) 2011-2015 Sébastien Helleu <flashcode@flashtux.org>
#
# This file is part of QWeeChat, a Qt remote GUI for WeeChat.
#
# QWeeChat is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# QWeeChat is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with QWeeChat.  If not, see <http://www.gnu.org/licenses/>.
#

#
# For info about protocol and format of messages, please read document
# "WeeChat Relay Protocol", available at:  https://weechat.org/doc/
#
# History:
#
# 2011-11-23, Sébastien Helleu <flashcode@flashtux.org>:
#     start dev
#

import collections
import struct
import zlib

if hasattr(collections, 'OrderedDict'):
    # python >= 2.7
    class WeechatDict(collections.OrderedDict):
        def __str__(self):
            return '{%s}' % ', '.join(
                ['%s: %s' % (repr(key), repr(self[key])) for key in self])
else:
    # python <= 2.6
    WeechatDict = dict


class WeechatObject:
    def __init__(self, objtype, value, separator='\n'):
        self.objtype = objtype
        self.value = value
        self.separator = separator
        self.indent = '  ' if separator == '\n' else ''
        self.separator1 = '\n%s' % self.indent if separator == '\n' else ''

    def _str_value(self, v):
        if type(v) is str and v is not None:
            return '\'%s\'' % v
        return str(v)

    def _str_value_hdata(self):
        lines = ['%skeys: %s%s%spath: %s' % (self.separator1,
                                             str(self.value['keys']),
                                             self.separator,
                                             self.indent,
                                             str(self.value['path']))]
        for i, item in enumerate(self.value['items']):
            lines.append('  item %d:%s%s' % (
                (i + 1), self.separator,
                self.separator.join(
                    ['%s%s: %s' % (self.indent * 2, key,
                                   self._str_value(value))
                     for key, value in item.items()])))
        return '\n'.join(lines)

    def _str_value_infolist(self):
        lines = ['%sname: %s' % (self.separator1, self.value['name'])]
        for i, item in enumerate(self.value['items']):
            lines.append('  item %d:%s%s' % (
                (i + 1), self.separator,
                self.separator.join(
                    ['%s%s: %s' % (self.indent * 2, key,
                                   self._str_value(value))
                     for key, value in item.items()])))
        return '\n'.join(lines)

    def _str_value_other(self):
        return self._str_value(self.value)

    def __str__(self):
        self._obj_cb = {
            'hda': self._str_value_hdata,
            'inl': self._str_value_infolist,
        }
        return '%s: %s' % (self.objtype,
                           self._obj_cb.get(self.objtype,
                                            self._str_value_other)())


class WeechatObjects(list):
    def __init__(self, separator='\n'):
        self.separator = separator

    def __str__(self):
        return self.separator.join([str(obj) for obj in self])


class WeechatMessage:
    def __init__(self, size, size_uncompressed, compression, uncompressed,
                 msgid, objects):
        self.size = size
        self.size_uncompressed = size_uncompressed
        self.compression = compression
        self.uncompressed = uncompressed
        self.msgid = msgid
        self.objects = objects

    def __str__(self):
        if self.compression != 0:
            return 'size: %d/%d (%d%%), id=\'%s\', objects:\n%s' % (
                self.size, self.size_uncompressed,
                100 - ((self.size * 100) // self.size_uncompressed),
                self.msgid, self.objects)
        else:
            return 'size: %d, id=\'%s\', objects:\n%s' % (self.size,
                                                          self.msgid,
                                                          self.objects)


class Protocol:
    """Decode binary message received from WeeChat/relay."""

    def __init__(self):
        self._obj_cb = {
            'chr': self._obj_char,
            'int': self._obj_int,
            'lon': self._obj_long,
            'str': self._obj_str,
            'buf': self._obj_buffer,
            'ptr': self._obj_ptr,
            'tim': self._obj_time,
            'htb': self._obj_hashtable,
            'hda': self._obj_hdata,
            'inf': self._obj_info,
            'inl': self._obj_infolist,
            'arr': self._obj_array,
        }

    def _obj_type(self):
        """Read type in data (3 chars)."""
        if len(self.data) < 3:
            self.data = ''
            return ''
        objtype = str(self.data[0:3])
        self.data = self.data[3:]
        return objtype

    def _obj_len_data(self, length_size):
        """Read length (1 or 4 bytes), then value with this length."""
        if len(self.data) < length_size:
            self.data = ''
            return None
        if length_size == 1:
            length = struct.unpack('B', self.data[0:1])[0]
            self.data = self.data[1:]
        else:
            length = self._obj_int()
        if length < 0:
            return None
        if length > 0:
            value = self.data[0:length]
            self.data = self.data[length:]
        else:
            value = ''
        return value

    def _obj_char(self):
        """Read a char in data."""
        if len(self.data) < 1:
            return 0
        value = struct.unpack('b', self.data[0:1])[0]
        self.data = self.data[1:]
        return value

    def _obj_int(self):
        """Read an integer in data (4 bytes)."""
        if len(self.data) < 4:
            self.data = ''
            return 0
        value = struct.unpack('>i', self.data[0:4])[0]
        self.data = self.data[4:]
        return value

    def _obj_long(self):
        """Read a long integer in data (length on 1 byte + value as string)."""
        value = self._obj_len_data(1)
        if value is None:
            return None
        return int(str(value))

    def _obj_str(self):
        """Read a string in data (length on 4 bytes + content)."""
        value = self._obj_len_data(4)
        if value is None:
            return None
        return str(value)

    def _obj_buffer(self):
        """Read a buffer in data (length on 4 bytes + data)."""
        return self._obj_len_data(4)

    def _obj_ptr(self):
        """Read a pointer in data (length on 1 byte + value as string)."""
        value = self._obj_len_data(1)
        if value is None:
            return None
        return '0x%s' % str(value)

    def _obj_time(self):
        """Read a time in data (length on 1 byte + value as string)."""
        value = self._obj_len_data(1)
        if value is None:
            return None
        return int(str(value))

    def _obj_hashtable(self):
        """
        Read a hashtable in data
        (type for keys + type for values + count + items).
        """
        type_keys = self._obj_type()
        type_values = self._obj_type()
        count = self._obj_int()
        hashtable = WeechatDict()
        for i in range(0, count):
            key = self._obj_cb[type_keys]()
            value = self._obj_cb[type_values]()
            hashtable[key] = value
        return hashtable

    def _obj_hdata(self):
        """Read a hdata in data."""
        path = self._obj_str()
        keys = self._obj_str()
        count = self._obj_int()
        list_path = path.split('/')
        list_keys = keys.split(',')
        keys_types = []
        dict_keys = WeechatDict()
        for key in list_keys:
            items = key.split(':')
            keys_types.append(items)
            dict_keys[items[0]] = items[1]
        items = []
        for i in range(0, count):
            item = WeechatDict()
            item['__path'] = []
            pointers = []
            for p in range(0, len(list_path)):
                pointers.append(self._obj_ptr())
            for key, objtype in keys_types:
                item[key] = self._obj_cb[objtype]()
            item['__path'] = pointers
            items.append(item)
        return {
            'path': list_path,
            'keys': dict_keys,
            'count': count,
            'items': items,
        }

    def _obj_info(self):
        """Read an info in data."""
        name = self._obj_str()
        value = self._obj_str()
        return (name, value)

    def _obj_infolist(self):
        """Read an infolist in data."""
        name = self._obj_str()
        count_items = self._obj_int()
        items = []
        for i in range(0, count_items):
            count_vars = self._obj_int()
            variables = WeechatDict()
            for v in range(0, count_vars):
                var_name = self._obj_str()
                var_type = self._obj_type()
                var_value = self._obj_cb[var_type]()
                variables[var_name] = var_value
            items.append(variables)
        return {
            'name': name,
            'items': items
        }

    def _obj_array(self):
        """Read an array of values in data."""
        type_values = self._obj_type()
        count_values = self._obj_int()
        values = []
        for i in range(0, count_values):
            values.append(self._obj_cb[type_values]())
        return values

    def decode(self, data, separator='\n'):
        """Decode binary data and return list of objects."""
        self.data = data
        size = len(self.data)
        size_uncompressed = size
        uncompressed = None
        # uncompress data (if it is compressed)
        compression = struct.unpack('b', self.data[4:5])[0]
        if compression:
            uncompressed = zlib.decompress(self.data[5:])
            size_uncompressed = len(uncompressed) + 5
            uncompressed = '%s%s%s' % (struct.pack('>i', size_uncompressed),
                                       struct.pack('b', 0), uncompressed)
            self.data = uncompressed
        else:
            uncompressed = self.data[:]
        # skip length and compression flag
        self.data = self.data[5:]
        # read id
        msgid = self._obj_str()
        if msgid is None:
            msgid = ''
        # read objects
        objects = WeechatObjects(separator=separator)
        while len(self.data) > 0:
            objtype = self._obj_type()
            value = self._obj_cb[objtype]()
            objects.append(WeechatObject(objtype, value, separator=separator))
        return WeechatMessage(size, size_uncompressed, compression,
                              uncompressed, msgid, objects)


def hex_and_ascii(data, bytes_per_line=10):
    """Convert a QByteArray to hex + ascii output."""
    num_lines = ((len(data) - 1) // bytes_per_line) + 1
    if num_lines == 0:
        return ''
    lines = []
    for i in range(0, num_lines):
        str_hex = []
        str_ascii = []
        for char in data[i*bytes_per_line:(i*bytes_per_line)+bytes_per_line]:
            byte = struct.unpack('B', char)[0]
            str_hex.append('%02X' % int(byte))
            if byte >= 32 and byte <= 127:
                str_ascii.append(char)
            else:
                str_ascii.append('.')
        fmt = '%%-%ds %%s' % ((bytes_per_line * 3) - 1)
        lines.append(fmt % (' '.join(str_hex), ''.join(str_ascii)))
    return '\n'.join(lines)

#!/usr/bin/python

"""
Cobbler external inventory script
=================================

Ansible has a feature where instead of reading from /etc/ansible/hosts
as a text file, it can query external programs to obtain the list
of hosts, groups the hosts are in, and even variables to assign to each host.  

To use this, copy this file over /etc/ansible/hosts and chmod +x the file.
This, more or less, allows you to keep one central database containing
info about all of your managed instances.

This script is an example of sourcing that data from Cobbler
(http://cobbler.github.com).  With cobbler each --mgmt-class in cobbler 
will correspond to a group in Ansible, and --ks-meta variables will be 
passed down for use in templates or even in argument lines.

NOTE: The cobbler system names will not be used.  Make sure a
cobbler --dns-name is set for each cobbler system.   If a system
appears with two DNS names we do not add it twice because we don't want
ansible talking to it twice.  The first one found will be used. If no
--dns-name is set the system will NOT be visible to ansible.  We do
not add cobbler system names because there is no requirement in cobbler
that those correspond to addresses.  

See http://ansible.github.com/api.html for more info

Tested with Cobbler 2.0.11. 
"""

# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible,
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

######################################################################


import sys
import xmlrpclib
import shlex

try:
    import json
except:
    import simplejson as json

# NOTE -- this file assumes Ansible is being accessed FROM the cobbler
# server, so it does not attempt to login with a username and password.
# this will be addressed in a future version of this script.

conn = xmlrpclib.Server("http://127.0.0.1/cobbler_api", allow_none=True)

###################################################
# executed with no parameters, return the list of
# all groups and hosts

if len(sys.argv) == 1:

    systems = conn.get_item_names('system')
    groups = { 'ungrouped' : [] }

    for system in systems:

        data = conn.get_blended_data(None, system)

        dns_name = None
        interfaces = data['interfaces']
        for (iname, ivalue) in interfaces.iteritems():
            this_dns_name = ivalue.get('dns_name', None)
            if this_dns_name is not None:
                dns_name = this_dns_name       
 
        if dns_name is None:
            continue

        classes  = data['mgmt_classes']
        for cls in classes:
            if cls not in groups:
                groups[cls] = []
            # hostname is not really what we want to insert, really insert the
            # first DNS name but no further DNS names
            groups[cls].append(dns_name)
 
    print json.dumps(groups)
    sys.exit(0)

#####################################################
# executed with a hostname as a parameter, return the
# variables for that host

if len(sys.argv) == 2:

    # look up the system record for the given DNS name
    result = conn.find_system_by_dns_name(sys.argv[1])
    system = result.get('name', None)
    data = {}
    if system is None:
        print json.dumps({})
        sys.exit(1)
    data = conn.get_system_for_koan(system)

    # return the ksmeta data for that system
    metadata = data['ks_meta']
    tokens = shlex.split(metadata)
    results = {}
    for t in tokens:
        if t.find("=") != -1:
           (k,v) = t.split("=",1)
           results[k]=v
    print json.dumps(results)
    sys.exit(0)


from django.contrib.admin import ModelAdmin
from django.contrib.gis.admin.widgets import OpenLayersWidget
from django.contrib.gis.gdal import OGRGeomType
from django.contrib.gis.db import models

class GeoModelAdmin(ModelAdmin):
    """
    The administration options class for Geographic models. Map settings
    may be overloaded from their defaults to create custom maps.
    """
    # The default map settings that may be overloaded -- still subject
    # to API changes.
    default_lon = 0
    default_lat = 0
    default_zoom = 4
    display_wkt = False
    display_srid = False
    extra_js = []
    num_zoom = 18
    max_zoom = False
    min_zoom = False
    units = False
    max_resolution = False
    max_extent = False
    modifiable = True
    mouse_position = True
    scale_text = True
    layerswitcher = True
    scrollable = True
    map_width = 600
    map_height = 400
    map_srid = 4326
    map_template = 'gis/admin/openlayers.html'
    openlayers_url = 'http://openlayers.org/api/2.11/OpenLayers.js'
    point_zoom = num_zoom - 6
    wms_url = 'http://vmap0.tiles.osgeo.org/wms/vmap0'
    wms_layer = 'basic'
    wms_name = 'OpenLayers WMS'
    wms_options = {'format': 'image/jpeg'}
    debug = False
    widget = OpenLayersWidget

    @property
    def media(self):
        "Injects OpenLayers JavaScript into the admin."
        media = super(GeoModelAdmin, self).media
        media.add_js([self.openlayers_url])
        media.add_js(self.extra_js)
        return media

    def formfield_for_dbfield(self, db_field, **kwargs):
        """
        Overloaded from ModelAdmin so that an OpenLayersWidget is used
        for viewing/editing GeometryFields.
        """
        if isinstance(db_field, models.GeometryField):
            request = kwargs.pop('request', None)
            # Setting the widget with the newly defined widget.
            kwargs['widget'] = self.get_map_widget(db_field)
            return db_field.formfield(**kwargs)
        else:
            return super(GeoModelAdmin, self).formfield_for_dbfield(db_field, **kwargs)

    def get_map_widget(self, db_field):
        """
        Returns a subclass of the OpenLayersWidget (or whatever was specified
        in the `widget` attribute) using the settings from the attributes set
        in this class.
        """
        is_collection = db_field.geom_type in ('MULTIPOINT', 'MULTILINESTRING', 'MULTIPOLYGON', 'GEOMETRYCOLLECTION')
        if is_collection:
            if db_field.geom_type == 'GEOMETRYCOLLECTION': collection_type = 'Any'
            else: collection_type = OGRGeomType(db_field.geom_type.replace('MULTI', ''))
        else:
            collection_type = 'None'

        class OLMap(self.widget):
            template = self.map_template
            geom_type = db_field.geom_type

            wms_options = ''
            if self.wms_options:
                wms_options = ["%s: '%s'" % pair for pair in self.wms_options.items()]
                wms_options = ', %s' % ', '.join(wms_options)

            params = {'default_lon' : self.default_lon,
                      'default_lat' : self.default_lat,
                      'default_zoom' : self.default_zoom,
                      'display_wkt' : self.debug or self.display_wkt,
                      'geom_type' : OGRGeomType(db_field.geom_type),
                      'field_name' : db_field.name,
                      'is_collection' : is_collection,
                      'scrollable' : self.scrollable,
                      'layerswitcher' : self.layerswitcher,
                      'collection_type' : collection_type,
                      'is_linestring' : db_field.geom_type in ('LINESTRING', 'MULTILINESTRING'),
                      'is_polygon' : db_field.geom_type in ('POLYGON', 'MULTIPOLYGON'),
                      'is_point' : db_field.geom_type in ('POINT', 'MULTIPOINT'),
                      'num_zoom' : self.num_zoom,
                      'max_zoom' : self.max_zoom,
                      'min_zoom' : self.min_zoom,
                      'units' : self.units, #likely shoud get from object
                      'max_resolution' : self.max_resolution,
                      'max_extent' : self.max_extent,
                      'modifiable' : self.modifiable,
                      'mouse_position' : self.mouse_position,
                      'scale_text' : self.scale_text,
                      'map_width' : self.map_width,
                      'map_height' : self.map_height,
                      'point_zoom' : self.point_zoom,
                      'srid' : self.map_srid,
                      'display_srid' : self.display_srid,
                      'wms_url' : self.wms_url,
                      'wms_layer' : self.wms_layer,
                      'wms_name' : self.wms_name,
                      'wms_options' : wms_options,
                      'debug' : self.debug,
                      }
        return OLMap

from django.contrib.gis import gdal
if gdal.HAS_GDAL:
    # Use the official spherical mercator projection SRID on versions
    # of GDAL that support it; otherwise, fallback to 900913.
    if gdal.GDAL_VERSION >= (1, 7):
        spherical_mercator_srid = 3857
    else:
        spherical_mercator_srid = 900913

    class OSMGeoAdmin(GeoModelAdmin):
        map_template = 'gis/admin/osm.html'
        num_zoom = 20
        map_srid = spherical_mercator_srid
        max_extent = '-20037508,-20037508,20037508,20037508'
        max_resolution = '156543.0339'
        point_zoom = num_zoom - 6
        units = 'm'

# (c) 2015, Ansible, Inc
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

from os.path import isdir, isfile, isabs, exists, lexists, islink, samefile, ismount
from ansible import errors

class TestModule(object):
    ''' Ansible file jinja2 tests '''

    def tests(self):
        return {
            # file testing
            'is_dir'  : isdir,
            'is_file' : isfile,
            'is_link' : islink,
            'exists' : exists,
            'link_exists' : lexists,

            # path testing
            'is_abs' : isabs,
            'is_same_file' : samefile,
            'is_mount' : ismount,
        }

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)
from ..extern import six
from ..extern.six.moves import zip as izip

import platform
import warnings

import numpy as np

from ..utils.exceptions import AstropyUserWarning


__all__ = ['TableGroups', 'ColumnGroups']


def table_group_by(table, keys):
    """
    Get groups for ``table`` on specified ``keys``.

    Parameters
    ----------
    table : `Table`
        Table to group
    keys : str, list of str, `Table`, or Numpy array
        Grouping key specifier

    Returns
    -------
    grouped_table : Table object with groups attr set accordingly
    """
    from .table import Table

    # Pre-convert string to tuple of strings, or Table to the underlying structured array
    if isinstance(keys, six.string_types):
        keys = (keys,)

    if isinstance(keys, (list, tuple)):
        for name in keys:
            if name not in table.colnames:
                raise ValueError('Table does not have key column {0!r}'.format(name))
            if table.masked and np.any(table[name].mask):
                raise ValueError('Missing values in key column {0!r} are not allowed'.format(name))

        keys = tuple(keys)
        table_keys = table[keys]
        grouped_by_table_cols = True  # Grouping keys are columns from the table being grouped

    elif isinstance(keys, (np.ndarray, Table)):
        table_keys = keys
        if len(table_keys) != len(table):
            raise ValueError('Input keys array length {0} does not match table length {1}'
                             .format(len(table_keys), len(table)))
        grouped_by_table_cols = False  # Grouping key(s) are external

    else:
        raise TypeError('Keys input must be string, list, tuple or numpy array, but got {0}'
                        .format(type(keys)))

    try:
        idx_sort = table_keys.argsort(kind='mergesort')
        stable_sort = True
    except TypeError:
        # Some versions (likely 1.6 and earlier) of numpy don't support
        # 'mergesort' for all data types.  MacOSX (Darwin) doesn't have a stable
        # sort by default, nor does Windows, while Linux does (or appears to).
        idx_sort = table_keys.argsort()
        stable_sort = platform.system() not in ('Darwin', 'Windows')
    table_keys = table_keys[idx_sort]

    # Get all keys
    diffs = np.concatenate(([True], table_keys[1:] != table_keys[:-1], [True]))
    indices = np.flatnonzero(diffs)

    # If the sort is not stable (preserves original table order) then sort idx_sort in
    # place within each group.
    if not stable_sort:
        for i0, i1 in izip(indices[:-1], indices[1:]):
            idx_sort[i0:i1].sort()

    # Make a new table and set the _groups to the appropriate TableGroups object.
    # Take the subset of the original keys at the indices values (group boundaries).
    out = table.__class__(table[idx_sort])
    out_keys = table_keys[indices[:-1]]
    if isinstance(out_keys, Table):
        out_keys.meta['grouped_by_table_cols'] = grouped_by_table_cols
    out._groups = TableGroups(out, indices=indices, keys=out_keys)

    return out


def column_group_by(column, keys):
    """
    Get groups for ``column`` on specified ``keys``

    Parameters
    ----------
    column : Column object
        Column to group
    keys : Table or Numpy array of same length as col
        Grouping key specifier

    Returns
    -------
    grouped_column : Column object with groups attr set accordingly
    """
    from .table import Table

    if isinstance(keys, Table):
        keys = keys.as_array()

    if not isinstance(keys, np.ndarray):
        raise TypeError('Keys input must be numpy array, but got {0}'
                        .format(type(keys)))

    if len(keys) != len(column):
        raise ValueError('Input keys array length {0} does not match column length {1}'
                         .format(len(keys), len(column)))

    idx_sort = keys.argsort()
    keys = keys[idx_sort]

    # Get all keys
    diffs = np.concatenate(([True], keys[1:] != keys[:-1], [True]))
    indices = np.flatnonzero(diffs)

    # Make a new column and set the _groups to the appropriate ColumnGroups object.
    # Take the subset of the original keys at the indices values (group boundaries).
    out = column.__class__(column[idx_sort])
    out._groups = ColumnGroups(out, indices=indices, keys=keys[indices[:-1]])

    return out


class BaseGroups(object):
    """
    A class to represent groups within a table of heterogeneous data.

      - ``keys``: key values corresponding to each group
      - ``indices``: index values in parent table or column corresponding to group boundaries
      - ``aggregate()``: method to create new table by aggregating within groups
    """
    @property
    def parent(self):
        return self.parent_column if isinstance(self, ColumnGroups) else self.parent_table

    def __iter__(self):
        self._iter_index = 0
        return self

    def next(self):
        ii = self._iter_index
        if ii < len(self.indices) - 1:
            i0, i1 = self.indices[ii], self.indices[ii + 1]
            self._iter_index += 1
            return self.parent[i0:i1]
        else:
            raise StopIteration
    __next__ = next

    def __getitem__(self, item):
        parent = self.parent

        if isinstance(item, int):
            i0, i1 = self.indices[item], self.indices[item + 1]
            out = parent[i0:i1]
            out.groups._keys = parent.groups.keys[item]
        else:
            indices0, indices1 = self.indices[:-1], self.indices[1:]
            try:
                i0s, i1s = indices0[item], indices1[item]
            except:
                raise TypeError('Index item for groups attribute must be a slice, '
                                'numpy mask or int array')
            mask = np.zeros(len(parent), dtype=np.bool)
            # Is there a way to vectorize this in numpy?
            for i0, i1 in izip(i0s, i1s):
                mask[i0:i1] = True
            out = parent[mask]
            out.groups._keys = parent.groups.keys[item]
            out.groups._indices = np.concatenate([[0], np.cumsum(i1s - i0s)])

        return out

    def __repr__(self):
        return '<{0} indices={1}>'.format(self.__class__.__name__, self.indices)

    def __len__(self):
        return len(self.indices) - 1


class ColumnGroups(BaseGroups):
    def __init__(self, parent_column, indices=None, keys=None):
        self.parent_column = parent_column  # parent Column
        self.parent_table = parent_column.parent_table
        self._indices = indices
        self._keys = keys

    @property
    def indices(self):
        # If the parent column is in a table then use group indices from table
        if self.parent_table:
            return self.parent_table.groups.indices
        else:
            if self._indices is None:
                return np.array([0, len(self.parent_column)])
            else:
                return self._indices

    @property
    def keys(self):
        # If the parent column is in a table then use group indices from table
        if self.parent_table:
            return self.parent_table.groups.keys
        else:
            return self._keys

    def aggregate(self, func):
        from .column import MaskedColumn, col_getattr

        i0s, i1s = self.indices[:-1], self.indices[1:]
        par_col = self.parent_column
        masked = isinstance(par_col, MaskedColumn)
        reduceat = hasattr(func, 'reduceat')
        sum_case = func is np.sum
        mean_case = func is np.mean
        try:
            if not masked and (reduceat or sum_case or mean_case):
                if mean_case:
                    vals = np.add.reduceat(par_col, i0s) / np.diff(self.indices)
                else:
                    if sum_case:
                        func = np.add
                    vals = func.reduceat(par_col, i0s)
            else:
                vals = np.array([func(par_col[i0: i1]) for i0, i1 in izip(i0s, i1s)])
        except Exception:
            raise TypeError("Cannot aggregate column '{0}' with type '{1}'"
                            .format(col_getattr(par_col, 'name'),
                                    col_getattr(par_col, 'dtype')))

        out = par_col.__class__(data=vals,
                                name=col_getattr(par_col, 'name'),
                                description=col_getattr(par_col, 'description'),
                                unit=col_getattr(par_col, 'unit'),
                                format=col_getattr(par_col, 'format'),
                                meta=col_getattr(par_col, 'meta'))
        return out

    def filter(self, func):
        """
        Filter groups in the Column based on evaluating function ``func`` on each
        group sub-table.

        The function which is passed to this method must accept one argument:

        - ``column`` : `Column` object

        It must then return either `True` or `False`.  As an example, the following
        will select all column groups with only positive values::

          def all_positive(column):
              if np.any(column < 0):
                  return False
              return True

        Parameters
        ----------
        func : function
            Filter function

        Returns
        -------
        out : Column
            New column with the aggregated rows.
        """
        mask = np.empty(len(self), dtype=np.bool)
        for i, group_column in enumerate(self):
            mask[i] = func(group_column)

        return self[mask]


class TableGroups(BaseGroups):
    def __init__(self, parent_table, indices=None, keys=None):
        self.parent_table = parent_table  # parent Table
        self._indices = indices
        self._keys = keys

    @property
    def key_colnames(self):
        """
        Return the names of columns in the parent table that were used for grouping.
        """
        # If the table was grouped by key columns *in* the table then treat those columns
        # differently in aggregation.  In this case keys will be a Table with
        # keys.meta['grouped_by_table_cols'] == True.  Keys might not be a Table so we
        # need to handle this.
        grouped_by_table_cols = getattr(self.keys, 'meta', {}).get('grouped_by_table_cols', False)
        return self.keys.colnames if grouped_by_table_cols else ()

    @property
    def indices(self):
        if self._indices is None:
            return np.array([0, len(self.parent_table)])
        else:
            return self._indices

    def aggregate(self, func):
        """
        Aggregate each group in the Table into a single row by applying the reduction
        function ``func`` to group values in each column.

        Parameters
        ----------
        func : function
            Function that reduces an array of values to a single value

        Returns
        -------
        out : Table
            New table with the aggregated rows.
        """
        from .column import col_getattr

        i0s, i1s = self.indices[:-1], self.indices[1:]
        out_cols = []
        parent_table = self.parent_table

        for col in six.itervalues(parent_table.columns):
            # For key columns just pick off first in each group since they are identical
            if col_getattr(col, 'name') in self.key_colnames:
                new_col = col.take(i0s)
            else:
                try:
                    new_col = col.groups.aggregate(func)
                except TypeError as err:
                    warnings.warn(six.text_type(err), AstropyUserWarning)
                    continue

            out_cols.append(new_col)

        return parent_table.__class__(out_cols, meta=parent_table.meta)

    def filter(self, func):
        """
        Filter groups in the Table based on evaluating function ``func`` on each
        group sub-table.

        The function which is passed to this method must accept two arguments:

        - ``table`` : `Table` object
        - ``key_colnames`` : tuple of column names in ``table`` used as keys for grouping

        It must then return either `True` or `False`.  As an example, the following
        will select all table groups with only positive values in the non-key columns::

          def all_positive(table, key_colnames):
              colnames = [name for name in table.colnames if name not in key_colnames]
              for colname in colnames:
                  if np.any(table[colname] < 0):
                      return False
              return True

        Parameters
        ----------
        func : function
            Filter function

        Returns
        -------
        out : Table
            New table with the aggregated rows.
        """
        mask = np.empty(len(self), dtype=np.bool)
        key_colnames = self.key_colnames
        for i, group_table in enumerate(self):
            mask[i] = func(group_table, key_colnames)

        return self[mask]

    @property
    def keys(self):
        return self._keys

#!/usr/bin/python
# -*- coding: utf-8 -*-
# vim: ts=4:sw=4:et:

__doc__ = """ A class for an identifier parsed by the preprocessor.
It contains it's name, arguments and macro value.
"""

import sys
import copy

from typing import Optional

from .macrocall import MacroCall
from src.api.debug import __DEBUG__
from .output import CURRENT_FILE
import src.zxbpp.prepro as prepro

DEBUG_LEVEL = 3  # Which -d level is required to show debug info


class ID:
    """ This class represents an identifier. It stores a string
    (the ID name and value by default).
    """
    __slots__ = 'name', 'value', 'lineno', 'fname', 'args', 'evaluating'

    def __init__(self, id_: str, args=None, value=None, lineno: int = None, fname: str = None):
        if fname is None:
            fname = CURRENT_FILE[-1]

        if value is None:
            value = [id_]

        if not isinstance(value, list):
            value = [value]

        self.name: str = id_
        self.value: list = value
        self.lineno: Optional[int] = lineno  # line number at which de ID was defined
        self.fname: str = fname  # file name in which the ID was defined
        self.args = args
        self.evaluating = False

    @property
    def hasArgs(self) -> bool:
        return self.args is not None

    def __str__(self):
        return self.name

    @staticmethod
    def __dumptable(table: 'prepro.DefinesTable') -> None:
        """ Dumps table on screen for debugging purposes
        """
        for k, v in table.table.items():
            sys.stdout.write("{0}\t<--- {1} {2}".format(k, v, type(v)))
            if isinstance(v, ID):
                sys.stdout.write(" {0}".format(v.value)),
            sys.stdout.write("\n")

    def __call__(self, table, macro: MacroCall) -> str:
        __DEBUG__("evaluating id '%s'" % self.name, DEBUG_LEVEL)
        if self.value is None:
            __DEBUG__("undefined (null) value. BUG?", DEBUG_LEVEL)
            return ''

        if self.evaluating:
            result = self.name
            if self.hasArgs:
                result += '('
                result += ', '.join(table[arg.name](table, self)
                                    if isinstance(arg, ID) else str(arg) for arg in self.args)
                result += ')'
            return result

        self.evaluating = True

        result = ''
        for token in self.value:
            __DEBUG__("evaluating token '%s'" % str(token), DEBUG_LEVEL)
            if isinstance(token, MacroCall):
                if isinstance(token.id_, MacroCall):
                    token.id_ = token.id_(table)
                __DEBUG__("token '%s'(%s) is a MacroCall" % (token.id_, str(token)), DEBUG_LEVEL)
                if table.defined(token.id_):
                    tmp = table[token.id_]
                    __DEBUG__("'%s' is defined in the symbol table as '%s'" % (token.id_, tmp.name), DEBUG_LEVEL)

                    if isinstance(tmp, ID) and not tmp.hasArgs:
                        __DEBUG__("'%s' is an ID" % tmp.name, DEBUG_LEVEL)
                        token = copy.deepcopy(token)
                        token.id_ = tmp(table, macro)
                        __DEBUG__("'%s' is the new id" % token.id_, DEBUG_LEVEL)

                __DEBUG__("executing MacroCall '%s'" % token.id_, DEBUG_LEVEL)
                tmp = token(table)
            else:
                if isinstance(token, ID):
                    __DEBUG__("token '%s' is an ID" % token.name, DEBUG_LEVEL)
                    token = token(table, macro)
                tmp = token

            __DEBUG__("token got value '%s'" % tmp, DEBUG_LEVEL)
            result += tmp

        self.evaluating = False
        return result

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.
"""This module contains sensors for AWS CloudFormation."""
from typing import Optional

try:
    from functools import cached_property
except ImportError:
    from cached_property import cached_property

from airflow.providers.amazon.aws.hooks.cloud_formation import AWSCloudFormationHook
from airflow.sensors.base import BaseSensorOperator


class CloudFormationCreateStackSensor(BaseSensorOperator):
    """
    Waits for a stack to be created successfully on AWS CloudFormation.

    :param stack_name: The name of the stack to wait for (templated)
    :type stack_name: str
    :param aws_conn_id: ID of the Airflow connection where credentials and extra configuration are
        stored
    :type aws_conn_id: str
    :param poke_interval: Time in seconds that the job should wait between each try
    :type poke_interval: int
    """

    template_fields = ['stack_name']
    ui_color = '#C5CAE9'

    def __init__(self, *, stack_name, aws_conn_id='aws_default', region_name=None, **kwargs):
        super().__init__(**kwargs)
        self.stack_name = stack_name
        self.aws_conn_id = aws_conn_id
        self.region_name = region_name

    def poke(self, context):
        stack_status = self.hook.get_stack_status(self.stack_name)
        if stack_status == 'CREATE_COMPLETE':
            return True
        if stack_status in ('CREATE_IN_PROGRESS', None):
            return False
        raise ValueError(f'Stack {self.stack_name} in bad state: {stack_status}')

    @cached_property
    def hook(self) -> AWSCloudFormationHook:
        """Create and return an AWSCloudFormationHook"""
        return AWSCloudFormationHook(aws_conn_id=self.aws_conn_id, region_name=self.region_name)


class CloudFormationDeleteStackSensor(BaseSensorOperator):
    """
    Waits for a stack to be deleted successfully on AWS CloudFormation.

    :param stack_name: The name of the stack to wait for (templated)
    :type stack_name: str
    :param aws_conn_id: ID of the Airflow connection where credentials and extra configuration are
        stored
    :type aws_conn_id: str
    :param poke_interval: Time in seconds that the job should wait between each try
    :type poke_interval: int
    """

    template_fields = ['stack_name']
    ui_color = '#C5CAE9'

    def __init__(
        self,
        *,
        stack_name: str,
        aws_conn_id: str = 'aws_default',
        region_name: Optional[str] = None,
        **kwargs,
    ):
        super().__init__(**kwargs)
        self.aws_conn_id = aws_conn_id
        self.region_name = region_name
        self.stack_name = stack_name

    def poke(self, context):
        stack_status = self.hook.get_stack_status(self.stack_name)
        if stack_status in ('DELETE_COMPLETE', None):
            return True
        if stack_status == 'DELETE_IN_PROGRESS':
            return False
        raise ValueError(f'Stack {self.stack_name} in bad state: {stack_status}')

    @cached_property
    def hook(self) -> AWSCloudFormationHook:
        """Create and return an AWSCloudFormationHook"""
        return AWSCloudFormationHook(aws_conn_id=self.aws_conn_id, region_name=self.region_name)

# test equality

print(None == None)

print(False == None)
print(False == False)
print(False == True)

print(() == ())
print(() == [])
print([] == [])
print(() == {})
print({} == ())

print(() == None)
print(() == False)
print(() == print)

print([] == None)
print([] == False)
print([] == print)

print({} == None)
print({} == False)
print({} == print)

print(1 == 1)
print(1 == 2)
print(1 == ())
print(1 == [])
print(1 == {})
print(1 == 'a')

print('a' == 'a')
print('a' == 'ab')
print('a' == 1)
print('a' == ())

# same as above but with !=

print(None != None)

print(False != None)
print(False != False)
print(False != True)

print(() != ())
print(() != [])
print([] != [])
print(() != {})
print({} != ())

print(() != None)
print(() != False)
print(() != print)

print([] != None)
print([] != False)
print([] != print)

print({} != None)
print({} != False)
print({} != print)

print(1 != 1)
print(1 != 2)
print(1 != ())
print(1 != [])
print(1 != {})
print(1 != 'a')

print('a' != 'a')
print('a' != 'ab')
print('a' != 1)
print('a' != ())

# ===============================================================================
# Copyright 2016 ross
#
# 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.
# ===============================================================================

# ============= standard library imports ========================
# ============= local library imports  ==========================
from pyface.tasks.action.task_action import TaskAction

from pychron.processing.analyses.analysis_group import AnalysisGroup
from pychron.pychron_constants import DVC_PROTOCOL


class UploadAction(TaskAction):
    name = 'Upload to Geochron...'

    def perform(self, event):
        app = event.task.application
        geochron_service = app.get_service('pychron.geochron.geochron_service.GeochronService')

        dvc = app.get_service(DVC_PROTOCOL)
        with dvc.session_ctx():
            ai = dvc.get_analysis('c038c72a-cf21-49f9-a5b5-1e43bb4a6b93')
            ans = dvc.make_analyses(ai)

            ag = AnalysisGroup()
            ag.analyses = ans
            print geochron_service.assemble_xml(ag)

# ============= EOF =============================================

"""Zookeeper Serializers, Deserializers, and NamedTuple objects"""
from collections import namedtuple
import struct

from kazoo.exceptions import EXCEPTIONS
from kazoo.protocol.states import ZnodeStat
from kazoo.security import ACL
from kazoo.security import Id

# Struct objects with formats compiled
bool_struct = struct.Struct('B')
int_struct = struct.Struct('!i')
int_int_struct = struct.Struct('!ii')
int_int_long_struct = struct.Struct('!iiq')

int_long_int_long_struct = struct.Struct('!iqiq')
multiheader_struct = struct.Struct('!iBi')
reply_header_struct = struct.Struct('!iqi')
stat_struct = struct.Struct('!qqqqiiiqiiq')

try:  # pragma: nocover
    basestring
except NameError:
    basestring = str


def read_string(buffer, offset):
    """Reads an int specified buffer into a string and returns the
    string and the new offset in the buffer"""
    length = int_struct.unpack_from(buffer, offset)[0]
    offset += int_struct.size
    if length < 0:
        return None, offset
    else:
        index = offset
        offset += length
        return buffer[index:index + length].decode('utf-8'), offset


def read_acl(bytes, offset):
    perms = int_struct.unpack_from(bytes, offset)[0]
    offset += int_struct.size
    scheme, offset = read_string(bytes, offset)
    id, offset = read_string(bytes, offset)
    return ACL(perms, Id(scheme, id)), offset


def write_string(bytes):
    if not bytes:
        return int_struct.pack(-1)
    else:
        utf8_str = bytes.encode('utf-8')
        return int_struct.pack(len(utf8_str)) + utf8_str


def write_buffer(bytes):
    if bytes is None:
        return int_struct.pack(-1)
    else:
        return int_struct.pack(len(bytes)) + bytes


def read_buffer(bytes, offset):
    length = int_struct.unpack_from(bytes, offset)[0]
    offset += int_struct.size
    if length < 0:
        return None, offset
    else:
        index = offset
        offset += length
        return bytes[index:index + length], offset


class Close(namedtuple('Close', '')):
    type = -11

    @classmethod
    def serialize(cls):
        return b''

CloseInstance = Close()


class Ping(namedtuple('Ping', '')):
    type = 11

    @classmethod
    def serialize(cls):
        return b''

PingInstance = Ping()


class Connect(namedtuple('Connect', 'protocol_version last_zxid_seen'
                         ' time_out session_id passwd read_only')):
    type = None

    def serialize(self):
        b = bytearray()
        b.extend(int_long_int_long_struct.pack(
            self.protocol_version, self.last_zxid_seen, self.time_out,
            self.session_id))
        b.extend(write_buffer(self.passwd))
        b.extend([1 if self.read_only else 0])
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        proto_version, timeout, session_id = int_int_long_struct.unpack_from(
            bytes, offset)
        offset += int_int_long_struct.size
        password, offset = read_buffer(bytes, offset)

        try:
            read_only = bool_struct.unpack_from(bytes, offset)[0] is 1
            offset += bool_struct.size
        except struct.error:
            read_only = False
        return cls(proto_version, 0, timeout, session_id, password,
                   read_only), offset


class Create(namedtuple('Create', 'path data acl flags')):
    type = 1

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend(write_buffer(self.data))
        b.extend(int_struct.pack(len(self.acl)))
        for acl in self.acl:
            b.extend(int_struct.pack(acl.perms) +
                     write_string(acl.id.scheme) + write_string(acl.id.id))
        b.extend(int_struct.pack(self.flags))
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        return read_string(bytes, offset)[0]


class Delete(namedtuple('Delete', 'path version')):
    type = 2

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend(int_struct.pack(self.version))
        return b

    @classmethod
    def deserialize(self, bytes, offset):
        return True


class Exists(namedtuple('Exists', 'path watcher')):
    type = 3

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend([1 if self.watcher else 0])
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        stat = ZnodeStat._make(stat_struct.unpack_from(bytes, offset))
        return stat if stat.czxid != -1 else None


class GetData(namedtuple('GetData', 'path watcher')):
    type = 4

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend([1 if self.watcher else 0])
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        data, offset = read_buffer(bytes, offset)
        stat = ZnodeStat._make(stat_struct.unpack_from(bytes, offset))
        return data, stat


class SetData(namedtuple('SetData', 'path data version')):
    type = 5

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend(write_buffer(self.data))
        b.extend(int_struct.pack(self.version))
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        return ZnodeStat._make(stat_struct.unpack_from(bytes, offset))


class GetACL(namedtuple('GetACL', 'path')):
    type = 6

    def serialize(self):
        return bytearray(write_string(self.path))

    @classmethod
    def deserialize(cls, bytes, offset):
        count = int_struct.unpack_from(bytes, offset)[0]
        offset += int_struct.size
        if count == -1:  # pragma: nocover
            return []

        acls = []
        for c in range(count):
            acl, offset = read_acl(bytes, offset)
            acls.append(acl)
        stat = ZnodeStat._make(stat_struct.unpack_from(bytes, offset))
        return acls, stat


class SetACL(namedtuple('SetACL', 'path acls version')):
    type = 7

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend(int_struct.pack(len(self.acls)))
        for acl in self.acls:
            b.extend(int_struct.pack(acl.perms) +
                     write_string(acl.id.scheme) + write_string(acl.id.id))
        b.extend(int_struct.pack(self.version))
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        return ZnodeStat._make(stat_struct.unpack_from(bytes, offset))


class GetChildren(namedtuple('GetChildren', 'path watcher')):
    type = 8

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend([1 if self.watcher else 0])
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        count = int_struct.unpack_from(bytes, offset)[0]
        offset += int_struct.size
        if count == -1:  # pragma: nocover
            return []

        children = []
        for c in range(count):
            child, offset = read_string(bytes, offset)
            children.append(child)
        return children


class Sync(namedtuple('Sync', 'path')):
    type = 9

    def serialize(self):
        return write_string(self.path)

    @classmethod
    def deserialize(cls, buffer, offset):
        return read_string(buffer, offset)[0]


class GetChildren2(namedtuple('GetChildren2', 'path watcher')):
    type = 12

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend([1 if self.watcher else 0])
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        count = int_struct.unpack_from(bytes, offset)[0]
        offset += int_struct.size
        if count == -1:  # pragma: nocover
            return []

        children = []
        for c in range(count):
            child, offset = read_string(bytes, offset)
            children.append(child)
        stat = ZnodeStat._make(stat_struct.unpack_from(bytes, offset))
        return children, stat


class CheckVersion(namedtuple('CheckVersion', 'path version')):
    type = 13

    def serialize(self):
        b = bytearray()
        b.extend(write_string(self.path))
        b.extend(int_struct.pack(self.version))
        return b


class Transaction(namedtuple('Transaction', 'operations')):
    type = 14

    def serialize(self):
        b = bytearray()
        for op in self.operations:
            b.extend(MultiHeader(op.type, False, -1).serialize() +
                     op.serialize())
        return b + multiheader_struct.pack(-1, True, -1)

    @classmethod
    def deserialize(cls, bytes, offset):
        header = MultiHeader(None, False, None)
        results = []
        response = None
        while not header.done:
            if header.type == Create.type:
                response, offset = read_string(bytes, offset)
            elif header.type == Delete.type:
                response = True
            elif header.type == SetData.type:
                response = ZnodeStat._make(
                    stat_struct.unpack_from(bytes, offset))
                offset += stat_struct.size
            elif header.type == CheckVersion.type:
                response = True
            elif header.type == -1:
                err = int_struct.unpack_from(bytes, offset)[0]
                offset += int_struct.size
                response = EXCEPTIONS[err]()
            if response:
                results.append(response)
            header, offset = MultiHeader.deserialize(bytes, offset)
        return results

    @staticmethod
    def unchroot(client, response):
        resp = []
        for result in response:
            if isinstance(result, basestring):
                resp.append(client.unchroot(result))
            else:
                resp.append(result)
        return resp


class Auth(namedtuple('Auth', 'auth_type scheme auth')):
    type = 100

    def serialize(self):
        return (int_struct.pack(self.auth_type) + write_string(self.scheme) +
                write_string(self.auth))


class SASL(namedtuple('SASL', 'token')):
    type = 102

    def serialize(self):
        b = bytearray()
        b.extend(write_buffer(self.token))
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        token, offset = read_buffer(bytes, offset)
        return token, offset


class Watch(namedtuple('Watch', 'type state path')):
    @classmethod
    def deserialize(cls, bytes, offset):
        """Given bytes and the current bytes offset, return the
        type, state, path, and new offset"""
        type, state = int_int_struct.unpack_from(bytes, offset)
        offset += int_int_struct.size
        path, offset = read_string(bytes, offset)
        return cls(type, state, path), offset


class ReplyHeader(namedtuple('ReplyHeader', 'xid, zxid, err')):
    @classmethod
    def deserialize(cls, bytes, offset):
        """Given bytes and the current bytes offset, return a
        :class:`ReplyHeader` instance and the new offset"""
        new_offset = offset + reply_header_struct.size
        return cls._make(
            reply_header_struct.unpack_from(bytes, offset)), new_offset


class MultiHeader(namedtuple('MultiHeader', 'type done err')):
    def serialize(self):
        b = bytearray()
        b.extend(int_struct.pack(self.type))
        b.extend([1 if self.done else 0])
        b.extend(int_struct.pack(self.err))
        return b

    @classmethod
    def deserialize(cls, bytes, offset):
        t, done, err = multiheader_struct.unpack_from(bytes, offset)
        offset += multiheader_struct.size
        return cls(t, done is 1, err), offset

# -*- coding: utf-8 -*-
###############################################################################
#
#    Copyright (C) 2001-2014 Micronaet SRL (<http://www.micronaet.it>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as published
#    by the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
###############################################################################
import os
import sys
import logging
import openerp
import openerp.netsvc as netsvc
import openerp.addons.decimal_precision as dp
from openerp.osv import fields, osv, expression, orm
from datetime import datetime, timedelta
from dateutil.relativedelta import relativedelta
from openerp import SUPERUSER_ID, api
from openerp import tools
from openerp.tools.translate import _
from openerp.tools.float_utils import float_round as round
from openerp.tools import (DEFAULT_SERVER_DATE_FORMAT, 
    DEFAULT_SERVER_DATETIME_FORMAT, 
    DATETIME_FORMATS_MAP, 
    float_compare)


_logger = logging.getLogger(__name__)

class StockPicking(orm.Model):
    """ Stock Picking note
    """    
    _inherit = 'stock.picking'

    def onchange_note(self, cr, uid, ids, item_id, field, context=None):
        ''' On change pre 
        '''
        res = {'value': {}}
        if item_id:
           res['value'][field] = self.pool.get('res.note.template').browse(
               cr, uid, item_id, context=context)['text']
        return res
    
    _columns = {
        'text_note_pre_id': fields.many2one('res.note.template', 
            'Set pre'), 
        'text_note_post_id': fields.many2one('res.note.template', 
            'Set post'), 
        'text_note_pre': fields.text('Pre text'),    
        'text_note_post': fields.text('Post text'),    
        }
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

#!/usr/bin/python

# (c) 2016, NetApp, Inc
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#
ANSIBLE_METADATA = {'status': ['preview'],
                    'supported_by': 'community',
                    'version': '1.0'}

DOCUMENTATION = """
---
module: netapp_e_amg_role
short_description: Update the role of a storage array within an Asynchronous Mirror Group (AMG).
description:
    - Update a storage array to become the primary or secondary instance in an asynchronous mirror group
version_added: '2.2'
author: Kevin Hulquest (@hulquest)
options:
    api_username:
        required: true
        description:
        - The username to authenticate with the SANtricity WebServices Proxy or embedded REST API.
    api_password:
        required: true
        description:
        - The password to authenticate with the SANtricity WebServices Proxy or embedded REST API.
    api_url:
        required: true
        description:
        - The url to the SANtricity WebServices Proxy or embedded REST API.
        example:
        - https://prod-1.wahoo.acme.com/devmgr/v2
    validate_certs:
        required: false
        default: true
        description:
        - Should https certificates be validated?
    ssid:
        description:
            - The ID of the primary storage array for the async mirror action
        required: yes
    role:
        description:
            - Whether the array should be the primary or secondary array for the AMG
        required: yes
        choices: ['primary', 'secondary']
    noSync:
        description:
            - Whether to avoid synchronization prior to role reversal
        required: no
        default: no
        choices: [yes, no]
    force:
        description:
            - Whether to force the role reversal regardless of the online-state of the primary
        required: no
        default: no
"""

EXAMPLES = """
    - name: Update the role of a storage array
      netapp_e_amg_role:
        name: updating amg role
        role: primary
        ssid: "{{ ssid }}"
        api_url: "{{ netapp_api_url }}"
        api_username: "{{ netapp_api_username }}"
        api_password: "{{ netapp_api_password }}"
        validate_certs: "{{ netapp_api_validate_certs }}"
"""

RETURN = """
msg:
    description: Failure message
    returned: failure
    type: string
    sample: "No Async Mirror Group with the name."
"""
import json

from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule

from ansible.module_utils.pycompat24 import get_exception
from ansible.module_utils.urls import open_url
from ansible.module_utils.six.moves.urllib.error import HTTPError

HEADERS = {
    "Content-Type": "application/json",
    "Accept": "application/json",
}


def request(url, data=None, headers=None, method='GET', use_proxy=True,
            force=False, last_mod_time=None, timeout=10, validate_certs=True,
            url_username=None, url_password=None, http_agent=None, force_basic_auth=True, ignore_errors=False):
    try:
        r = open_url(url=url, data=data, headers=headers, method=method, use_proxy=use_proxy,
                     force=force, last_mod_time=last_mod_time, timeout=timeout, validate_certs=validate_certs,
                     url_username=url_username, url_password=url_password, http_agent=http_agent,
                     force_basic_auth=force_basic_auth)
    except HTTPError:
        err = get_exception()
        r = err.fp

    try:
        raw_data = r.read()
        if raw_data:
            data = json.loads(raw_data)
        else:
            raw_data = None
    except:
        if ignore_errors:
            pass
        else:
            raise Exception(raw_data)

    resp_code = r.getcode()

    if resp_code >= 400 and not ignore_errors:
        raise Exception(resp_code, data)
    else:
        return resp_code, data


def has_match(module, ssid, api_url, api_pwd, api_usr, body, name):
    amg_exists = False
    has_desired_role = False
    amg_id = None
    amg_data = None
    get_amgs = 'storage-systems/%s/async-mirrors' % ssid
    url = api_url + get_amgs
    try:
        amg_rc, amgs = request(url, url_username=api_usr, url_password=api_pwd,
                               headers=HEADERS)
    except:
        module.fail_json(msg="Failed to find AMGs on storage array. Id [%s]" % (ssid))

    for amg in amgs:
        if amg['label'] == name:
            amg_exists = True
            amg_id = amg['id']
            amg_data = amg
            if amg['localRole'] == body.get('role'):
                has_desired_role = True

    return amg_exists, has_desired_role, amg_id, amg_data


def update_amg(module, ssid, api_url, api_usr, api_pwd, body, amg_id):
    endpoint = 'storage-systems/%s/async-mirrors/%s/role' % (ssid, amg_id)
    url = api_url + endpoint
    post_data = json.dumps(body)
    try:
        request(url, data=post_data, method='POST', url_username=api_usr,
                url_password=api_pwd, headers=HEADERS)
    except:
        err = get_exception()
        module.fail_json(
            msg="Failed to change role of AMG. Id [%s].  AMG Id [%s].  Error [%s]" % (ssid, amg_id, str(err)))

    status_endpoint = 'storage-systems/%s/async-mirrors/%s' % (ssid, amg_id)
    status_url = api_url + status_endpoint
    try:
        rc, status = request(status_url, method='GET', url_username=api_usr,
                             url_password=api_pwd, headers=HEADERS)
    except:
        err = get_exception()
        module.fail_json(
            msg="Failed to check status of AMG after role reversal. " +
                "Id [%s].  AMG Id [%s].  Error [%s]" % (ssid, amg_id, str(err)))

    # Here we wait for the role reversal to complete
    if 'roleChangeProgress' in status:
        while status['roleChangeProgress'] != "none":
            try:
                rc, status = request(status_url, method='GET',
                                     url_username=api_usr, url_password=api_pwd, headers=HEADERS)
            except:
                err = get_exception()
                module.fail_json(
                    msg="Failed to check status of AMG after role reversal. " +
                        "Id [%s].  AMG Id [%s].  Error [%s]" % (ssid, amg_id, str(err)))
    return status


def main():
    argument_spec = basic_auth_argument_spec()
    argument_spec.update(dict(
        name=dict(required=True, type='str'),
        role=dict(required=True, choices=['primary', 'secondary']),
        noSync=dict(required=False, type='bool', default=False),
        force=dict(required=False, type='bool', default=False),
        ssid=dict(required=True, type='str'),
        api_url=dict(required=True),
        api_username=dict(required=False),
        api_password=dict(required=False, no_log=True),
    ))

    module = AnsibleModule(argument_spec=argument_spec)

    p = module.params

    ssid = p.pop('ssid')
    api_url = p.pop('api_url')
    user = p.pop('api_username')
    pwd = p.pop('api_password')
    name = p.pop('name')

    if not api_url.endswith('/'):
        api_url += '/'

    agm_exists, has_desired_role, async_id, amg_data = has_match(module, ssid, api_url, pwd, user, p, name)

    if not agm_exists:
        module.fail_json(msg="No Async Mirror Group with the name: '%s' was found" % name)
    elif has_desired_role:
        module.exit_json(changed=False, **amg_data)

    else:
        amg_data = update_amg(module, ssid, api_url, user, pwd, p, async_id)
        if amg_data:
            module.exit_json(changed=True, **amg_data)
        else:
            module.exit_json(changed=True, msg="AMG role changed.")


if __name__ == '__main__':
    main()

from ajenti.ui import *
from ajenti.com import implements
from ajenti.api import *
from ajenti.utils import *

from backend import *


class FirewallPlugin(CategoryPlugin):
    text = 'Firewall'
    icon = '/dl/iptables/icon.png'
    folder = 'system'

    defactions = ['ACCEPT', 'DROP', 'REJECT', 'LOG', 'EXIT', 'MASQUERADE']

    def on_init(self):
        self.cfg = Config(self.app)
        self.cfg.load()

    def on_session_start(self):
        self._tab = 0
        self._shuffling = None
        self._shuffling_table = None
        self._adding_chain = None
        self._editing_table = None
        self._editing_chain = None
        self._editing_rule = None
        self._error = None

    def get_ui(self):
        ui = self.app.inflate('iptables:main')
        if self.cfg.has_autostart():
            btn = ui.find('autostart')
            btn.set('text', 'Disable autostart')
            btn.set('id', 'noautostart')


        tc = UI.TabControl(active=self._tab)
        ui.append('root', tc)

        if len(self.cfg.tables) == 0:
            self.cfg.load_runtime()

        for t in self.cfg.tables:
            t = self.cfg.tables[t]
            vc = UI.VContainer(spacing=15)
            for ch in t.chains:
                ch = t.chains[ch]
                uic = UI.FWChain(tname=t.name, name=ch.name, default=ch.default)
                idx = 0
                for r in ch.rules:
                    uic.append(
                        UI.FWRule(
                            action=r.action,
                            desc=('' if r.action in self.defactions else r.action + ' ') + r.desc,
                            id='%s/%s/%i'%(t.name,ch.name,idx)
                        ))
                    idx += 1
                vc.append(uic)
            vc.append(UI.Button(icon='/dl/core/ui/stock/add.png', text='Add new chain to '+t.name, id='addchain/'+t.name))
            tc.add(t.name, vc)

        if self._error is not None and len(self._error) > 0:
            self.put_message('warn', self._error)
            self._error = None

        if self._shuffling != None:
            ui.append('root', self.get_ui_shuffler())

        if self._adding_chain != None:
            ui.append('root', UI.InputBox(id='dlgAddChain', text='Chain name:'))

        if self._editing_rule != None:
            ui.append('root', self.get_ui_edit_rule(
                        rule=self.cfg.tables[self._editing_table].\
                                      chains[self._editing_chain].\
                                      rules[self._editing_rule]
                    ))

        return ui

    def get_ui_edit_rule(self, rule=Rule()):
        protocols = (('TCP','tcp'), ('UDP','udp'), ('ICMP','icmp'))

        tc = UI.TabControl(active='r0')
        tc.add('Main',
            UI.Container(
                UI.Formline(
                    UI.Radio(text='Accept', name='caction', value='ACCEPT',     checked=rule.action=="ACCEPT"),
                    UI.Radio(text='Drop',   name='caction', value='DROP',       checked=rule.action=="DROP"),
                    UI.Radio(text='Reject', name='caction', value='REJECT',     checked=rule.action=="REJECT"),
                    UI.Radio(text='Log',    name='caction', value='LOG',        checked=rule.action=="LOG"),
                    UI.Radio(text='Masq',   name='caction', value='MASQUERADE', checked=rule.action=="MASQUERADE"),
                    UI.Radio(text='Exit',   name='caction', value='EXIT',       checked=rule.action=="EXIT"),
                    UI.Radio(text='Run chain:', name='caction', value='RUN',    checked=rule.action not in self.defactions),
                    UI.TextInput(name='runchain', value=rule.action),
                    text='Action'
                ),
                UI.Formline(
                    rule.get_ui_select('protocol', protocols),
                    text='Protocol'
                ),
                UI.Formline(
                    rule.get_ui_text('source'),
                    text='Source IP',
                    help='You can specify IP mask like 192.168.0.0/24'
                ),
                UI.Formline(
                    rule.get_ui_text('destination'),
                    text='Destination IP',
                ),
                UI.Formline(
                    rule.get_ui_text('mac_source'),
                    text='Source MAC'
                ),
                UI.Formline(
                    rule.get_ui_select('in_interface', self.cfg.get_devices()),
                    text='Incoming interface'
                ),
                UI.Formline(
                    rule.get_ui_select('out_interface', self.cfg.get_devices()),
                    text='Outgoing interface'
                ),
                UI.Formline(
                    rule.get_ui_bool('fragmented'),
                    text='Fragmentation'
                ),
                UI.Formline(
                    UI.TextInput(name='modules', value=' '.join(rule.modules)),
                    text='Modules',
                    help='Additional IPTables modules to load',
                ),
                UI.Formline(
                    UI.TextInput(name='options', value=' '.join(rule.miscopts)),
                    text='Additional options',
                ),
            ), id='r0')

        tc.add('TCP/UDP',
            UI.Container(
                UI.Formline(
                    rule.get_ui_text('sport'),
                    text='Source port',
                    help='Can accept lists and ranges like 80:85,8000 up to 15 ports',
                ),
                UI.Formline(
                    rule.get_ui_text('dport'),
                    text='Destination port'
                ),
                UI.Formline(
                    rule.get_ui_flags(),
                    text='TCP flags',
                ),
                UI.Formline(
                    rule.get_ui_states(),
                    text='TCP states',
                ),
            ), id='r1')

        return UI.DialogBox(tc, id='dlgEditRule', miscbtn='Delete', miscbtnid='deleterule')

    def get_ui_shuffler(self):
        li = UI.SortList(id='list')
        for r in self.cfg.tables[self._shuffling_table].chains[self._shuffling].rules:
            li.append(
                UI.SortListItem(
                    UI.FWRule(action=r.action, desc=r.desc, id=''),
                    id=r.raw
                ))

        return UI.DialogBox(li, id='dlgShuffler')

    @event('button/click')
    def on_click(self, event, params, vars=None):
        if params[0] == 'apply':
            self._error = self.cfg.apply_now()
        if params[0] == 'autostart':
            self.cfg.set_autostart(True)
        if params[0] == 'noautostart':
            self.cfg.set_autostart(False)
        if params[0] == 'loadruntime':
            self.cfg.load_runtime()
        if params[0] == 'setdefault':
            self._tab = self.cfg.table_index(params[1])
            self.cfg.tables[params[1]].chains[params[2]].default = params[3]
            self.cfg.save()
        if params[0] == 'shuffle':
            self._tab = self.cfg.table_index(params[1])
            self._shuffling_table = params[1]
            self._shuffling = params[2]
        if params[0] == 'addchain':
            self._tab = self.cfg.table_index(params[1])
            self._adding_chain = params[1]
        if params[0] == 'deletechain':
            self._tab = self.cfg.table_index(params[1])
            self.cfg.tables[params[1]].chains.pop(params[2])
            self.cfg.save()
        if params[0] == 'addrule':
            self._tab = self.cfg.table_index(params[1])
            self._editing_table = params[1]
            self._editing_chain = params[2]
            ch = self.cfg.tables[self._editing_table].\
                         chains[self._editing_chain]
            self._editing_rule = len(ch.rules)
            ch.rules.append(Rule('-A %s -j ACCEPT'%params[2]))
            self.cfg.save()

        if params[0] == 'deleterule':
            self.cfg.tables[self._editing_table].\
                     chains[self._editing_chain].\
                     rules.pop(self._editing_rule)
            self._editing_chain = None
            self._editing_table = None
            self._editing_rule = None
            self.cfg.save()

    @event('fwrule/click')
    def on_fwrclick(self, event, params, vars=None):
        self._tab = self.cfg.table_index(params[0])
        self._editing_table = params[0]
        self._editing_chain = params[1]
        self._editing_rule = int(params[2])

    @event('dialog/submit')
    def on_submit(self, event, params, vars):
        if params[0] == 'dlgAddChain':
            if vars.getvalue('action', '') == 'OK':
                n = vars.getvalue('value', '')
                if n == '': return
                self.cfg.tables[self._adding_chain].chains[n] = Chain(n, '-')
                self.cfg.save()
            self._adding_chain = None
        if params[0] == 'dlgShuffler':
            if vars.getvalue('action', '') == 'OK':
                d = vars.getvalue('list', '').split('|')
                ch = self.cfg.tables[self._shuffling_table].chains[self._shuffling]
                ch.rules = []
                for s in d:
                    ch.rules.append(Rule(s))
                self.cfg.save()
            self._shuffling = None
            self._shuffling_table = None
        if params[0] == 'dlgEditRule':
            if vars.getvalue('action', '') == 'OK':
                self.cfg.tables[self._editing_table].\
                         chains[self._editing_chain].\
                          rules[self._editing_rule].apply_vars(vars)
                self.cfg.save()
            self._editing_chain = None
            self._editing_table = None
            self._editing_rule = None

import sys, time, utils, math

if utils.PQT5 == True:
	from PyQt5.QtCore import Qt, QTimer
	from PyQt5.QtWidgets import QApplication,QWidget, QLabel, QHBoxLayout, QVBoxLayout, QPushButton,QCheckBox
	from PyQt5.QtGui import QPalette, QColor
else:
	from PyQt4.QtCore import Qt, QTimer
	from PyQt4.QtGui import QPalette, QColor, QApplication, QWidget,\
	QLabel, QHBoxLayout, QVBoxLayout, QPushButton, QCheckBox

import sys, time, utils, math
import pyqtgraph as pg
import numpy as np
import eyes17.eyemath17 as em


class Expt(QWidget):
	TIMER = 50
	loopCounter = 0
	AWGmin = 1
	AWGmax = 5000
	AWGval = 150
	waveindex = 0
	wgainindex = 2
	
	RPVspacing = 2											# Right panel Widget spacing
	RPWIDTH = 300
	LABW = 60
		
	# Scope parameters
	MAXCHAN = 5
	timeData    = [None]*MAXCHAN
	voltData    = [None]*MAXCHAN
	voltDataFit = [None]*MAXCHAN
	traceWidget = [None]*MAXCHAN
	traceWidgetF= [None]*MAXCHAN
	fitResWidget= [None]*MAXCHAN
	fitFine     = [0]*MAXCHAN
	Amplitude   = [0]*MAXCHAN
	Frequency   = [0]*MAXCHAN
	Phase       = [0]*MAXCHAN
	rangeVals   = [4]*MAXCHAN			# selected value of range
	rangeTexts  = ['4 V']*MAXCHAN		# selected value of range
	scaleLabs   = [None]*MAXCHAN		# display fullscale value inside pg
	phasorPlot = None
	phasorTraces = [None]*5

	MAXRES = 7	# Number of results to show
	resLabs     = [None]*MAXRES
	Results     = [None]*MAXRES
	MINV = -4.0
	MAXV = 4.0
	sources = ['A1','A2','A3', 'MIC']
	#chancols = ['black', 'red', 'blue','magenta']
	chanpens = ['y','g','r','m','c']     #pqtgraph pen colors

	tbvals = [0.100, 0.200, 0.500, 1.0, 2.0, 5.0, 10.0, 20.0, 50.0]	# allowed mS/div values
	NP = 500			# Number of samples
	TG = 1				# Number of channels
	MINDEL = 1			# minimum time between samples, in usecs
	MAXDEL = 1000
	delay = MINDEL		# Time interval between samples
	TBval = 4			# timebase list index
	Trigindex = 0
	Triglevel = 0
	resCols = ['w','y','g','r','w','m','c']

	def __init__(self, device=None):
		QWidget.__init__(self)
		self.p = device										# connection to the device hardware 
		try:
			self.p.select_range('A1',8.0)
			self.p.select_range('A2',8.0)
			self.p.configure_trigger(1, 'A2', 0)
			self.p.set_sine(self.AWGval)
		except:
			pass	
		
		self.pwin = pg.PlotWidget()							# pyqtgraph window
		self.pwin.showGrid(x=True, y=True)					# with grid
		for k in range(self.MAXCHAN):						# pg textItem to show the voltage scales
			self.scaleLabs.append(pg.TextItem(text=''))
		ax = self.pwin.getAxis('bottom')
		ax.setLabel('Time (mS)')	
		ax = self.pwin.getAxis('left')
		ax.setLabel('Voltage')

		self.set_timebase(self.TBval)
		self.pwin.disableAutoRange()
		self.pwin.setXRange(0, self.tbvals[self.TBval]*10)
		self.pwin.setYRange(self.MINV, self.MAXV)
		self.pwin.hideButtons()									# Do not show the 'A' button of pg

		for ch in range(self.MAXCHAN):							# initialize the pg trace widgets
			self.traceWidget[ch] = self.pwin.plot([0,0],[0,0], pen = self.chanpens[ch])
			x=pg.mkPen(self.chanpens[ch], width=.5, style=Qt.DashLine) 
			self.traceWidgetF[ch] = self.pwin.plot([0,0],[0,0], pen = x)

		right = QVBoxLayout()									# right side vertical layout
		right.setAlignment(Qt.AlignTop)
		right.setSpacing(self.RPVspacing)

		# Phasor plot window
		self.ppwin = pg.PlotWidget()						# pyqtgraph window
		self.ppwin.setMaximumWidth(300)
		self.ppwin.setMaximumHeight(300)
		self.ppwin.setMinimumHeight(300)
		self.ppwin.disableAutoRange()
		self.ppwin.setXRange(-0.03,3)
		self.ppwin.setYRange(-3,3)
		self.ppwin.hideButtons()									# Do not show the 'A' button of pg
		right.addWidget(self.ppwin)

		for ch in range(5):
			x=pg.mkPen(self.chanpens[ch], width=2) 
			self.phasorTraces[ch] = self.ppwin.plot([0,0],[0,0], width=3, pen = x)

		#Results
		for k in range(self.MAXRES):						# pg textItem to show the Results
			self.resLabs[k] = pg.TextItem()
			self.pwin.addItem(self.resLabs[k])
		
		H = QHBoxLayout()
		l = QLabel(text=self.tr('Timebase'))
		l.setMaximumWidth(60)
		H.addWidget(l)
		self.TBslider = utils.slider(0, 8, self.TBval, 150, self.set_timebase)
		H.addWidget(self.TBslider)
		right.addLayout(H)

		H = QHBoxLayout()
		l = QLabel(text=self.tr('WG'))
		l.setMaximumWidth(25)
		H.addWidget(l)
		self.AWGslider = utils.slider(self.AWGmin, self.AWGmax, self.AWGval,100,self.awg_slider)
		H.addWidget(self.AWGslider)
		self.AWGtext = utils.lineEdit(70, self.AWGval, 6, self.awg_text)
		H.addWidget(self.AWGtext)
		l = QLabel(text=self.tr('Hz'))
		l.setMaximumWidth(20)
		H.addWidget(l)
		right.addLayout(H)	
		
	
		H = QHBoxLayout()
		self.SaveButton = QPushButton(self.tr("Save Data to"))
		self.SaveButton.setMaximumWidth(90)
		self.SaveButton.clicked.connect(self.save_data)		
		H.addWidget(self.SaveButton)
		self.Filename = utils.lineEdit(150, 'RCs-data.txt', 20, None)
		H.addWidget(self.Filename)
		right.addLayout(H)

		self.VLC = QCheckBox('Monitor LC junction (with A3)')
		right.addWidget(self.VLC)
		self.VLC.stateChanged.connect(self.action_vlc)
		
		l = QLabel(text='')
		right.addWidget(l)
		l = QLabel(text=self.tr('<font color="blue">Impedance Calculator'))
		right.addWidget(l)

		
		H = QHBoxLayout()
		l = QLabel(text=self.tr('F (in Hz)'))
		l.setMaximumWidth(50)
		H.addWidget(l)
		self.uFreq = utils.lineEdit(50, 150, 6, None)
		H.addWidget(self.uFreq)		

		l = QLabel(text=self.tr('R (in Ohms)'))
		l.setMaximumWidth(75)
		H.addWidget(l)
		self.uRes = utils.lineEdit(50, 1000, 6, None)
		H.addWidget(self.uRes)
		right.addLayout(H)

		
		H = QHBoxLayout()
		l = QLabel(text=self.tr('C (in uF)'))
		l.setMaximumWidth(50)
		H.addWidget(l)
		self.uCap = utils.lineEdit(50, 1, 6, None)
		H.addWidget(self.uCap)
		l = QLabel(text=self.tr('L (in mH)'))
		l.setMaximumWidth(75)
		H.addWidget(l)
		self.uInd = utils.lineEdit(50, 0, 6, None)
		H.addWidget(self.uInd)
		right.addLayout(H)	
		
				
		b=QPushButton('Calculate XL, XC and Fo')
		b.clicked.connect(self.calc)		
		right.addWidget(b)
		self.uResult =QLabel(text='')
		right.addWidget(self.uResult)
		
		#------------------------end of right panel ----------------
		
		top = QHBoxLayout()
		top.addWidget(self.pwin)
		top.addLayout(right)
		
		full = QVBoxLayout()
		full.addLayout(top)
		self.msgwin = QLabel(text=self.tr('messages'))
		full.addWidget(self.msgwin)
				
		self.setLayout(full)
		
		self.timer = QTimer()
		self.timer.timeout.connect(self.update)
		self.timer.start(self.TIMER)
		#----------------------------- end of init ---------------


	def verify_fit(self,y,y1):
		sum = 0.0
		for k in range(len(y)):
			sum += abs((y[k] - y1[k])/y[k])
		err = sum/len(y)
		if err/sum > 0.01:
			self.msg('Curve fitting result rejected')
			return False
		else:
			return True

	def update(self):
		try:
			if self.VLC.isChecked() == True:
				self.timeData[0], self.voltData[0],\
				self.timeData[1], self.voltData[1],\
				self.timeData[2], self.voltData[2],\
				self.timeData[3], self.voltData[3] = self.p.capture4(self.NP, self.TG)

				self.timeData[4] = self.timeData[0]			
				self.voltData[3] = self.voltData[2] - self.voltData[0]   # voltage across C				
				self.voltData[4] = self.voltData[1] - self.voltData[2]   # voltage across L
				self.voltData[2] = self.voltData[1] - self.voltData[0]   # voltage across LC	
			else:
				self.timeData[0], self.voltData[0],\
				self.timeData[1], self.voltData[1] = self.p.capture2(self.NP, self.TG)
				self.timeData[2] = self.timeData[0]			
				self.voltData[2] = self.voltData[0] - self.voltData[1]   # voltage across LC
		except:
			self.msg('<font color="red">Communication Error. Try Reconnect from the Device menu')		
			return

		for ch in range(3):
			self.traceWidget[ch].setData(self.timeData[ch], self.voltData[ch])
			fa = em.fit_sine(self.timeData[ch],self.voltData[ch])
			if fa != None:
				self.traceWidgetF[ch].setData(self.timeData[ch], fa[0])
				if self.verify_fit(self.voltData[ch], fa[0]) == False:
					return
				self.voltDataFit[ch] = fa[0]
				self.Amplitude[ch] = (fa[1][0])
				self.Frequency[ch] = fa[1][1]*1000
				self.Phase[ch] = fa[1][2] * 180/em.pi
				self.fitFine[ch] = 1
			else:
				self.err('Data Analysis Error')
				return
		phaseDiff = (self.Phase[0] - self.Phase[1])
	
		if self.VLC.isChecked() == True:
			for ch in range(3,5):
				self.traceWidget[ch].setData(self.timeData[ch], self.voltData[ch])
				fa = em.fit_sine(self.timeData[ch],self.voltData[ch])
				if fa != None:
					self.traceWidgetF[ch].setData(self.timeData[ch], fa[0])
					if self.verify_fit(self.voltData[ch], fa[0]) == False:
						return
					self.voltDataFit[ch] = fa[0]
					self.Amplitude[ch] = (fa[1][0])
					self.Frequency[ch] = fa[1][1]*1000
					self.Phase[ch] = fa[1][2] * 180/em.pi
					self.fitFine[ch] = 1
				else:
					self.err('Data Analysis Error')
					return			
		
		for k in range(self.MAXRES): self.Results[k] = ''
		
		self.Results[0] = 'F = %5.1f Hz'%(self.Frequency[0])
		self.Results[1] = 'Vtotal (A1) = %5.2f V'%(self.Amplitude[0])
		self.Results[2] = 'Vr (A2) = %5.2f V'%(self.Amplitude[1])
		self.Results[3] = 'Vlc (A2-A1) = %5.2f V'%(self.Amplitude[2])
		self.Results[4] = 'Phase Diff = %5.1f deg'%phaseDiff

		if self.VLC.isChecked() == True:
			self.Results[5] = 'Vc (A3-A1) = %5.2f V'%(self.Amplitude[3])
			self.Results[6] = 'Vl (A2-A3) = %5.2f V'%(self.Amplitude[4])
		else:
			self.Results[5] = ''
			self.Results[6] = ''

		for k in range(5):
			self.pwin.removeItem(self.resLabs[k])
			self.resLabs[k] = pg.TextItem(text=self.Results[k],	color= self.resCols[k])
			self.resLabs[k].setPos(0, -4 +0.3*k)
			self.pwin.addItem(self.resLabs[k])

		for k in range(5,7):
			self.pwin.removeItem(self.resLabs[k])
			self.resLabs[k] = pg.TextItem(text=self.Results[k],	color= self.resCols[k])
			self.resLabs[k].setPos(0, 4 -0.3*(k-5))
			self.pwin.addItem(self.resLabs[k])


		if self.fitFine[0] == 1 and self.fitFine[1] == 1 and self.fitFine[2] == 1:
			self.draw_phasor()
		# End of update


	def draw_phasor(self):
		Va = self.Amplitude[0]
		Vr = self.Amplitude[1]
		Vlc = self.Amplitude[2]
		pd01 = math.atan(Vr/Va)
		Vl = self.Amplitude[3]
		Vc = self.Amplitude[4]
		
		
		phaseDiff = (self.Phase[1]-self.Phase[0])*np.pi/180
		sign = -np.sign(phaseDiff)
		rx = Va * math.sin(phaseDiff)
		ry = Va * math.cos(phaseDiff) 

		x0 = -0.03
		if self.VLC.isChecked() == True:
			self.phasorTraces[3].setData([x0, x0], [x0, Vl])
			self.phasorTraces[4].setData([x0, x0], [x0, -Vc])
		else:
			self.phasorTraces[3].setData([0,0], [0,0])
			self.phasorTraces[4].setData([0,0], [0,0])
			
		self.phasorTraces[0].setData([0,Vr], [0,sign*Vlc])
		self.phasorTraces[1].setData([0,Vr], [0,0])
		self.phasorTraces[2].setData([0,0], [0,sign*Vlc])
		

	def action_vlc(self):
		if self.VLC.isChecked() == False:
			self.Results[5] = ''
			self.Results[6] = ''
			for ch in range(3,5):
				self.traceWidget[ch].setData([0,0],[0,0])
				self.traceWidgetF[ch].setData([0,0],[0,0])
		
	def calc(self):
		try:
			f = float(self.uFreq.text())
			C = float(self.uCap.text())*1e-6
			L = float(self.uInd.text())*1e-3
			R = float(self.uRes.text())
			Xl = 2*np.pi*f*L

			if C != 0:
				Xc = 1./(2*np.pi*f*C)
			else:
				Xc = 0.0

			dphi = math.atan((Xc-Xl)/R)*180./np.pi

			if L != 0 and C != 0:
				f0 = 1./(2*np.pi*np.sqrt(L*C))
				s = 'Xc = %5.1f     Xl = %5.1f    phi = %5.1f deg\nFo = %5.1f Hz'%(Xc, Xl, dphi,f0)
				self.uResult.setText(s)
			else:
				s = 'Xc = %5.1f  Xl = %5.1f  phi = %5.1f deg'%(Xc, Xl, dphi)
				self.uResult.setText(s)				
		except:
			self.uResult.setText('Invalid Input in some field')
	
	def save_data(self):
		fn = self.Filename.text()
		dat = []
		for ch in range(self.MAXCHAN):
				dat.append( [self.timeData[ch], self.voltData[ch] ])
		self.p.save(dat,fn)
		self.msg('Traces saved to %s'%fn)
			
	def set_timebase(self, tb):
		self.TBval = tb
		self.pwin.setXRange(0, self.tbvals[self.TBval]*10)
		msperdiv = self.tbvals[int(tb)]				#millisecs / division
		totalusec = msperdiv * 1000 * 10.0  	# total 10 divisions
		self.TG = int(totalusec/self.NP)
		if self.TG < self.MINDEL:
			self.TG = self.MINDEL
		elif self.TG > self.MAXDEL:
			self.TG = self.MAXDEL

	def set_wave(self):
		if 1:
			res = self.p.set_sine(self.AWGval)
			self.msg('AWG set to %6.2f Hz'%res)
			T5 = 2000./res
			for k in range(len(self.tbvals)): 
				tmax = 10* self.tbvals[k]
				if tmax > T5:
					self.TBval = k
					self.TBslider.setValue(self.TBval)
					self.set_timebase(k)
					break
		else:
			self.msg('<font color="red">Communication Error. Try Reconnect from the Device menu')		
			return

	def awg_text(self, text):
		val = float(text)
		if self.AWGmin <= val <= self.AWGmax:
			self.AWGval = val
			self.AWGslider.setValue(self.AWGval)
			self.set_wave()

	def awg_slider(self, val):
		if self.AWGmin <= val <= self.AWGmax:
			self.AWGval = val
			self.AWGtext.setText(str(val))
			self.set_wave()
		
	def msg(self, m):
		self.msgwin.setText(self.tr(m))
		

if __name__ == '__main__':
	import eyes17.eyes
	dev = eyes17.eyes.open()
	app = QApplication(sys.argv)
	mw = Expt(dev)
	mw.show()
	sys.exit(app.exec_())
	

# -*- coding: utf-8 -*-
"""
    pygments.scanner
    ~~~~~~~~~~~~~~~~

    This library implements a regex based scanner. Some languages
    like Pascal are easy to parse but have some keywords that
    depend on the context. Because of this it's impossible to lex
    that just by using a regular expression lexer like the
    `RegexLexer`.

    Have a look at the `DelphiLexer` to get an idea of how to use
    this scanner.

    :copyright: 2006-2007 by Armin Ronacher.
    :license: BSD, see LICENSE for more details.
"""
import re


class EndOfText(RuntimeError):
    """
    Raise if end of text is reached and the user
    tried to call a match function.
    """


class Scanner(object):
    """
    Simple scanner

    All method patterns are regular expression strings (not
    compiled expressions!)
    """

    def __init__(self, text, flags=0):
        """
        :param text:    The text which should be scanned
        :param flags:   default regular expression flags
        """
        self.data = text
        self.data_length = len(text)
        self.start_pos = 0
        self.pos = 0
        self.flags = flags
        self.last = None
        self.match = None
        self._re_cache = {}

    def eos(self):
        """`True` if the scanner reached the end of text."""
        return self.pos >= self.data_length
    eos = property(eos, eos.__doc__)

    def check(self, pattern):
        """
        Apply `pattern` on the current position and return
        the match object. (Doesn't touch pos). Use this for
        lookahead.
        """
        if self.eos:
            raise EndOfText()
        if pattern not in self._re_cache:
            self._re_cache[pattern] = re.compile(pattern, self.flags)
        return self._re_cache[pattern].match(self.data, self.pos)

    def test(self, pattern):
        """Apply a pattern on the current position and check
        if it patches. Doesn't touch pos."""
        return self.check(pattern) is not None

    def scan(self, pattern):
        """
        Scan the text for the given pattern and update pos/match
        and related fields. The return value is a boolen that
        indicates if the pattern matched. The matched value is
        stored on the instance as ``match``, the last value is
        stored as ``last``. ``start_pos`` is the position of the
        pointer before the pattern was matched, ``pos`` is the
        end position.
        """
        if self.eos:
            raise EndOfText()
        if pattern not in self._re_cache:
            self._re_cache[pattern] = re.compile(pattern, self.flags)
        self.last = self.match
        m = self._re_cache[pattern].match(self.data, self.pos)
        if m is None:
            return False
        self.start_pos = m.start()
        self.pos = m.end()
        self.match = m.group()
        return True

    def get_char(self):
        """Scan exactly one char."""
        self.scan('.')

    def __repr__(self):
        return '<%s %d/%d>' % (
            self.__class__.__name__,
            self.pos,
            self.data_length
        )

# -*- encoding: utf-8 -*-
#
# Copyright © 2012 New Dream Network, LLC (DreamHost)
#
# Author: Steven Berler <steven.berler@dreamhost.com>
#
# 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.
"""Test getting the max resource volume.
"""

import datetime
import testscenarios

from ceilometer.publisher import utils
from ceilometer import sample

from ceilometer.tests import api as tests_api
from ceilometer.tests import db as tests_db

load_tests = testscenarios.load_tests_apply_scenarios


class TestMaxResourceVolume(tests_api.TestBase,
                            tests_db.MixinTestsWithBackendScenarios):

    def setUp(self):
        super(TestMaxResourceVolume, self).setUp()
        for i in range(3):
            s = sample.Sample(
                'volume.size',
                'gauge',
                'GiB',
                5 + i,
                'user-id',
                'project1',
                'resource-id',
                timestamp=datetime.datetime(2012, 9, 25, 10 + i, 30 + i),
                resource_metadata={'display_name': 'test-volume',
                                   'tag': 'self.sample',
                                   },
                source='source1',
            )
            msg = utils.meter_message_from_counter(
                s,
                self.CONF.publisher.metering_secret,
            )
            self.conn.record_metering_data(msg)

    def test_no_time_bounds(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max')
        expected = {'volume': 7}
        self.assertEqual(data, expected)

    def test_no_time_bounds_non_admin(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max',
                        headers={"X-Roles": "Member",
                                 "X-Project-Id": "project1"})
        self.assertEqual(data, {'volume': 7})

    def test_no_time_bounds_wrong_tenant(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max',
                        headers={"X-Roles": "Member",
                                 "X-Project-Id": "??"})
        self.assertEqual(data, {'volume': None})

    def test_start_timestamp(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max',
                        start_timestamp='2012-09-25T11:30:00')
        expected = {'volume': 7}
        self.assertEqual(data, expected)

    def test_start_timestamp_after(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max',
                        start_timestamp='2012-09-25T12:34:00')
        expected = {'volume': None}
        self.assertEqual(data, expected)

    def test_end_timestamp(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max',
                        end_timestamp='2012-09-25T11:30:00')
        expected = {'volume': 5}
        self.assertEqual(data, expected)

    def test_end_timestamp_before(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max',
                        end_timestamp='2012-09-25T09:54:00')
        expected = {'volume': None}
        self.assertEqual(data, expected)

    def test_start_end_timestamp(self):
        data = self.get('/resources/resource-id/meters/volume.size/volume/max',
                        start_timestamp='2012-09-25T11:30:00',
                        end_timestamp='2012-09-25T11:32:00')
        expected = {'volume': 6}
        self.assertEqual(data, expected)

#!/usr/bin/env python
#-*- coding: utf-8 -*-

# Written by Jacopo Prendin (nidnerpREPLACEWITHANICEATCHARACTERgmail.com)
# This file is part of Aqueduct.
# Aqueduct is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# Aqueduct is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with Aqueduct.  If not, see <http://www.gnu.org/licenses/>.

#
# Always require date, title, author, author's address
#

xml="""
<?xml version="1.0" encoding="UTF-8"?>
<screenplay>
<head>
    <date>%s<date>
    <title>%s<title>
    <author>%s<author>
    <source>%s<source>
    <contact>%s<contact>
    </head>

"""

html="""<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <style>
    body
    {
    width:210mm;
    font-size:12pt;
    font-family:Courier New, Monospace;
    padding:20mm;
    }
    
    div.description
    {
    font-style:italic;
    margin-bottom:5mm;
    }

    div.dialogue
    {
    padding-left:20mm;
    padding-right:20mm;
    padding-bottom:5mm;
    }

    div.character
    {
    text-align:center;
    }

    h3{
    page-break-before: always;
    }
  </style>

</head>
<body>

<div class="date">%s</div>
<h1>%s</h1>
<p>%s</p>
<p>by %s<br>
%s
</p>
"""

# ****************************** LATEX
latex="""
\\documentclass{screenplay}[%s]
\\title{%s}
\\credit{%s}
\\author{%s}
\\address{%s}

%% ... preamble finished, let's go ...
\\begin{document}
\\newcommand{\\chapter}[1]{\\large{#1}
%% Make a title page ...
\\coverpage

"""

import pytest

from nordb.database import station2sql
from nordb.database import sitechan2sql
from nordb.database import sensor2sql
from nordb.database import instrument2sql
from nordb.database import response2sql
from nordb.database import sql2station
from nordb.database.norDBManagement import countStations
from nordb.core import usernameUtilities
from nordb.nordic import station
from nordb.nordic import sitechan
from nordb.nordic import sensor
from nordb.nordic import instrument
from nordb.nordic import response

@pytest.mark.userfixtures("setupdb", "stationFiles")
class TestSQL2Station(object):
    def testGetAllWorks(self, setupdb, stationFiles):
        stations = []
        for stat in stationFiles:
            stations.append(station.readStationStringToStation(stat, "HE"))

        for stat in stations:
            station2sql.insertStation2Database(stat, stat.network)

        stations = sql2station.getAllStations(station_date = None)

        assert len(stations) == len(stationFiles)

    def testGetStationsWorks(self, setupdb, stationFiles, responseFiles,
                             siteChanFiles, instrumentFiles, sensorFiles):
        for resp in responseFiles:
            response2sql.insertResponse2Database(response.readResponseArrayToResponse(resp[0], resp[1]))

        stations = []
        for stat in stationFiles:
            stations.append(station.readStationStringToStation(stat, "HE"))

        sitechans = []
        for chan in siteChanFiles:
            sitechans.append(sitechan.readSiteChanStringToSiteChan(chan))

        instruments = []
        for ins in instrumentFiles:
            instruments.append(instrument.readInstrumentStringToInstrument(ins))

        sensors = []
        for sen in sensorFiles:
            sensors.append(sensor.readSensorStringToSensor(sen))

        for stat in stations:
            station2sql.insertStation2Database(stat, stat.network)

        for chan in sitechans:
            sitechan2sql.insertSiteChan2Database(chan)

        for ins in instruments:
            instrument2sql.insertInstrument2Database(ins)

        for sen in sensors:
            sensor2sql.insertSensor2Database(sen)

        stations = sql2station.getStations([1,2,3])

        assert len(stations) == 3

    def testGetOneWorks(self, setupdb, stationFiles):
        stations = []

        for stat in stationFiles:
            stations.append(station.readStationStringToStation(stat, "HE"))
        for stat in stations:
            station2sql.insertStation2Database(stat, stat.network)
        stat = sql2station.getStation(1)

        assert str(stat).strip() == stationFiles[0].strip()


from __future__ import absolute_import

from django import http
from django.conf import settings
from django.contrib import comments
from django.contrib.comments import signals
from django.contrib.comments.views.utils import next_redirect, confirmation_view
from django.core.exceptions import ObjectDoesNotExist, ValidationError
from django.db import models
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.template.loader import render_to_string
from django.utils.html import escape
from django.views.decorators.csrf import csrf_protect
from django.views.decorators.http import require_POST



class CommentPostBadRequest(http.HttpResponseBadRequest):
    """
    Response returned when a comment post is invalid. If ``DEBUG`` is on a
    nice-ish error message will be displayed (for debugging purposes), but in
    production mode a simple opaque 400 page will be displayed.
    """
    def __init__(self, why):
        super(CommentPostBadRequest, self).__init__()
        if settings.DEBUG:
            self.content = render_to_string("comments/400-debug.html", {"why": why})

@csrf_protect
@require_POST
def post_comment(request, next=None, using=None):
    """
    Post a comment.

    HTTP POST is required. If ``POST['submit'] == "preview"`` or if there are
    errors a preview template, ``comments/preview.html``, will be rendered.
    """
    # Fill out some initial data fields from an authenticated user, if present
    data = request.POST.copy()
    if request.user.is_authenticated():
        if not data.get('name', ''):
            data["name"] = request.user.get_full_name() or request.user.username
        if not data.get('email', ''):
            data["email"] = request.user.email

    # Look up the object we're trying to comment about
    ctype = data.get("content_type")
    object_pk = data.get("object_pk")
    if ctype is None or object_pk is None:
        return CommentPostBadRequest("Missing content_type or object_pk field.")
    try:
        model = models.get_model(*ctype.split(".", 1))
        target = model._default_manager.using(using).get(pk=object_pk)
    except TypeError:
        return CommentPostBadRequest(
            "Invalid content_type value: %r" % escape(ctype))
    except AttributeError:
        return CommentPostBadRequest(
            "The given content-type %r does not resolve to a valid model." % \
                escape(ctype))
    except ObjectDoesNotExist:
        return CommentPostBadRequest(
            "No object matching content-type %r and object PK %r exists." % \
                (escape(ctype), escape(object_pk)))
    except (ValueError, ValidationError), e:
        return CommentPostBadRequest(
            "Attempting go get content-type %r and object PK %r exists raised %s" % \
                (escape(ctype), escape(object_pk), e.__class__.__name__))

    # Do we want to preview the comment?
    preview = "preview" in data

    # Construct the comment form
    form = comments.get_form()(target, data=data)

    # Check security information
    if form.security_errors():
        return CommentPostBadRequest(
            "The comment form failed security verification: %s" % \
                escape(str(form.security_errors())))

    # If there are errors or if we requested a preview show the comment
    if form.errors or preview:
        template_list = [
            # These first two exist for purely historical reasons.
            # Django v1.0 and v1.1 allowed the underscore format for
            # preview templates, so we have to preserve that format.
            "comments/%s_%s_preview.html" % (model._meta.app_label, model._meta.module_name),
            "comments/%s_preview.html" % model._meta.app_label,
            # Now the usual directory based template hierarchy.
            "comments/%s/%s/preview.html" % (model._meta.app_label, model._meta.module_name),
            "comments/%s/preview.html" % model._meta.app_label,
            "comments/preview.html",
        ]
        return render_to_response(
            template_list, {
                "comment": form.data.get("comment", ""),
                "form": form,
                "next": data.get("next", next),
            },
            RequestContext(request, {})
        )

    # Otherwise create the comment
    comment = form.get_comment_object()
    comment.ip_address = request.META.get("REMOTE_ADDR", None)
    if request.user.is_authenticated():
        comment.user = request.user

    # Signal that the comment is about to be saved
    responses = signals.comment_will_be_posted.send(
        sender  = comment.__class__,
        comment = comment,
        request = request
    )

    for (receiver, response) in responses:
        if response == False:
            return CommentPostBadRequest(
                "comment_will_be_posted receiver %r killed the comment" % receiver.__name__)

    # Save the comment and signal that it was saved
    comment.save()
    signals.comment_was_posted.send(
        sender  = comment.__class__,
        comment = comment,
        request = request
    )

    return next_redirect(request, next, comment_done, c=comment._get_pk_val())

comment_done = confirmation_view(
    template = "comments/posted.html",
    doc = """Display a "comment was posted" success page."""
)


"""
Provides mathematical functions
"""

 #############################################################################
 #                                                                           #
 #    PyMS software for processing of metabolomic mass-spectrometry data     #
 #    Copyright (C) 2005-2012 Vladimir Likic                                 #
 #                                                                           #
 #    This program is free software; you can redistribute it and/or modify   #
 #    it under the terms of the GNU General Public License version 2 as      #
 #    published by the Free Software Foundation.                             #
 #                                                                           #
 #    This program is distributed in the hope that it will be useful,        #
 #    but WITHOUT ANY WARRANTY; without even the implied warranty of         #
 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          #
 #    GNU General Public License for more details.                           #
 #                                                                           #
 #    You should have received a copy of the GNU General Public License      #
 #    along with this program; if not, write to the Free Software            #
 #    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              #
 #                                                                           #
 #############################################################################

import copy, math

from pyms.Utils.Error import error
from pyms.Utils.Utils import is_list, is_number

def median(v):

    """
    @summary: Returns a median of a list or numpy array

    @param v: Input list or array
    @type v: ListType or numpy.core.ndarray
    @return: The median of the input list
    @rtype: FloatType

    @author: Vladimir Likic
    """

    if not is_list(v):
        error("argument neither list nor array")

    local_data = copy.deepcopy(v)
    local_data.sort()
    N = len(local_data)

    if (N % 2) == 0:
        # even number of points
        K = N/2 - 1 
        median = (local_data[K] + local_data[K+1])/2.0
    else:
	    # odd number of points
        K = (N - 1)/2 - 1
        median = local_data[K+1]

    return median

def vector_by_step(vstart,vstop,vstep):

    """
    @summary: generates a list by using start, stop, and step values

    @param vstart: Initial value 
    @type vstart: A number
    @param vstop: Max value
    @type vstop: A number
    @param vstep: Step
    @type vstep: A number
   
    @return: A list generated
    @rtype: ListType

    @author: Vladimir Likic
    """

    if not is_number(vstart) or not is_number(vstop) or not is_number(vstep):
        error("parameters start, stop, step must be numbers")

    v = []

    p = vstart 
    while p < vstop:
        v.append(p)
        p = p + vstep

    return v

def MAD(v):

    """
    @summary: median absolute deviation

    @param v: A list or array
    @type v: ListType, TupleType, or numpy.core.ndarray

    @return: median absolute deviation
    @rtype: FloatType

    @author: Vladimir Likic
    """

    if not is_list(v):
        error("argument neither list nor array")

    m = median(v)
    m_list = []

    for xi in v:
        d = math.fabs(xi - m)
        m_list.append(d)

    mad = median(m_list)/0.6745

    return mad

def amin(v):

    """
    @summary: Finds the minimum element in a list or array

    @param v: A list or array
    @type v: ListType, TupleType, or numpy.core.ndarray

    @return: Tuple (maxi, maxv), where maxv is the minimum 
        element in the list and maxi is its index
    @rtype: TupleType

    @author: Vladimir Likic
    """

    if not is_list(v):
        error("argument neither list nor array")

    minv = max(v) # built-in max() function
    mini = None

    for ii in range(len(v)):
        if v[ii] < minv:
            minv = v[ii]
            mini = ii

    if mini == None:
        error("finding maximum failed")

    return mini, minv

def mean(v):

    """
    @summary: Calculates the mean

    @param v: A list or array
    @type v: ListType, TupleType, or numpy.core.ndarray

    @return: Mean
    @rtype: FloatType

    @author: Vladimir Likic
    """

    if not is_list(v):
        error("argument neither list nor array")

    s = 0.0
    for e in v:
        s = s + e 
    s_mean = s/float(len(v))

    return s_mean

def std(v):

    """
    @summary: Calculates standard deviation

    @param v: A list or array
    @type v: ListType, TupleType, or numpy.core.ndarray

    @return: Mean
    @rtype: FloatType

    @author: Vladimir Likic
    """

    if not is_list(v):
        error("argument neither list nor array")

    v_mean = mean(v)

    s = 0.0 
    for e in v:
        d = e - v_mean
        s = s + d*d
    s_mean = s/float(len(v)-1)
    v_std = math.sqrt(s_mean)

    return v_std


def rmsd(list1, list2):

    """
    @summary: Calculates RMSD for the 2 lists

    @param list1: First data set
    @type list1: ListType, TupleType, or numpy.core.ndarray 
    @param list2: Second data set
    @type list2: ListType, TupleType, or numpy.core.ndarray 
    @return: RMSD value
    @rtype: FloatType

    @author: Qiao Wang
    @author: Andrew Isaac
    @author: Vladimir Likic
    """

    if not is_list(list1):
        error("argument neither list nor array")

    if not is_list(list2):
        error("argument neither list nor array")

    sum = 0.0
    for i in range(len(list1)):
        sum = sum + (list1[i] - list2[i]) ** 2
    rmsd = math.sqrt(sum / len(list1))
    return rmsd


"""

Load npy xy, plot and save


"""

import os, sys

import matplotlib

#matplotlib.use('Agg') # Must be before importing matplotlib.pyplot or pylab!

import matplotlib.pyplot as plt
import matplotlib.cm as mpl_cm

from matplotlib import rc
from matplotlib.font_manager import FontProperties
from matplotlib import rcParams
from matplotlib import cm

rc('text', usetex=True)

rcParams['text.usetex']=True
rcParams['text.latex.unicode']=True

rc('font', family = 'serif', serif = 'cmr10')

import numpy as np

from datetime import timedelta
import datetime

import imp

import re
from textwrap import wrap

model_name_convert_legend = imp.load_source('util', '/nfs/see-fs-01_users/eepdw/python_scripts/modules/model_name_convert_legend.py')
#unrotate = imp.load_source('util', '/home/pwille/python_scripts/modules/unrotate_pole.py')

###############
# Things to change

top_dir='/nfs/a90/eepdw/Data/Rain_Land_Sea_Diurnal'

pp_file = 'avg.5216'

lon_max = 101.866
lon_min = 80
lat_max= 5
lat_min=-10

trmm_dir = '/nfs/a90/eepdw/Data/Observations/Satellite/TRMM/Diurnal/'
trmm_file = "trmm_diurnal_average_lat_%s_%s_lon_%s_%s_southern_eastern_indian_ocean.npz" % (lat_min,lat_max, lon_min, lon_max)

# Make own time x-axis
utc_to_local=datetime.timedelta(hours=5, minutes=30)
d = matplotlib.dates.drange(datetime.datetime(2011, 8, 21, 6,30)+utc_to_local, datetime.datetime(2011, 8, 22, 6, 30)+utc_to_local, timedelta(hours=1))
#d = matplotlib.dates.drange(datetime.datetime(2011, 8, 21, 6,30), datetime.datetime(2011, 8, 22, 6, 30), timedelta(hours=1))
#############

# Make own time x-axis

#d = matplotlib.dates.drange(datetime.datetime(2011, 8, 21, 6,30), datetime.datetime(2011, 8, 22, 6, 30), timedelta(hours=1))

formatter = matplotlib.dates.DateFormatter('%H:%M')

def main():
 #experiment_ids = ['djznw', 'djzny', 'djznq', 'djzns', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq', 'dkbhu', 'djznu', 'dkhgu' ] # All 12
 experiment_ids_p = [ 'dkmbq', 'dklzq' ] # Most of Params
 experiment_ids_e = ['dklyu', 'dklwu'] # Most of Explicit
#experiment_ids = ['djzny', 'djznq', 'djzns', 'djznw', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq' ] 
#plt.ion()

 NUM_COLOURS = 15
 cmap=cm.get_cmap(cm.Set1, NUM_COLOURS)
 #cgen = (cmap(1.*i/NUM_COLORS) for i in range(NUM_COLORS))

 for ls in ['sea']:
  fig = plt.figure(figsize=(12,6))
  ax = fig.add_subplot(111)
  legendEntries=[]
  legendtext=[]

  plot_trmm = np.load('%s%s_%s' % (trmm_dir, ls, trmm_file))
 
  dates_trmm=[]
 
  p=[]
  for dp in plot_trmm['hour']:
      print dp
      if ((int(dp)<23) & (int(dp)>=6)):
          dates_trmm.append(datetime.datetime(2011, 8, 21, int(dp), 0))
          p.append(plot_trmm['mean'][plot_trmm['hour']==dp])
      if ((int(dp)>=0) & (int(dp)<=6)):
          dates_trmm.append(datetime.datetime(2011, 8, 22, int(dp), 0))
          p.append(plot_trmm['mean'][plot_trmm['hour']==dp])
              
  #print dates_trmm
  a = np.argsort(dates_trmm,axis=0)

  d_trmm = np.array(dates_trmm)[a]
  pl = (np.array(p)[a])
  #pl=np.sort(pl,axis=1)
  
  l, = plt.plot_date(d_trmm+utc_to_local, pl, label='TRMM', linewidth=2, linestyle='-', marker='', markersize=2, fmt='', color='#262626')

  legendEntries.append(l)
  legendtext.append('TRMM')

  cmorph_dir = '/nfs/a90/eepdw/Data/Observations/Satellite/CMORPH/Diurnal/'
  cmorph_file = "cmorph_diurnal_average_southern_eastern_indian_ocean_polygon.npz"
  
  plot_cmorph = np.load('%s%s_%s' % (cmorph_dir, ls, cmorph_file))
  dates_cmorph=[]

  p=[]
  for dp in plot_cmorph['hour']:
      print dp
      if ((int(dp)<23) & (int(dp)>=6)):
          dates_cmorph.append(datetime.datetime(2011, 8, 21, int(dp), 0))
          p.append(plot_cmorph['mean'][plot_cmorph['hour']==dp])
      if ((int(dp)>=0) & (int(dp)<=6)):
          dates_cmorph.append(datetime.datetime(2011, 8, 22, int(dp), 0))
          p.append(plot_cmorph['mean'][plot_cmorph['hour']==dp])


 #print dates_trmm
  a = np.argsort(dates_cmorph,axis=0)

  d_cmorph = np.array(dates_cmorph)[a]
  pl = (np.array(p)[a])
  #pl=np.sort(pl,axis=1)
  
  l, = plt.plot_date(d_cmorph+utc_to_local, pl, label='CMORPH', linewidth=2, linestyle=':', marker='', markersize=2, fmt='', color='black')

  legendEntries.append(l)
  legendtext.append('CMORPH')

  
  #l0=plt.legend(legendEntries, legendtext,title='', frameon=False, loc=9, bbox_to_anchor=(0, 0,1, 1))
  l0=plt.legend(legendEntries, legendtext,title='', frameon=False, loc=9, bbox_to_anchor=(0.31, 0,1, 1))

  gsmap_dir = '/nfs/a90/eepdw/Data/Observations/Satellite/GSMAP_Aug_Sep_2011/Diurnal/'
  gsmap_file = "gsmap_diurnal_average_southern_eastern_indian_ocean_polygon.npz"
  
  plot_gsmap = np.load('%s%s_%s' % (gsmap_dir, ls, gsmap_file))
  dates_gsmap=[]

  p=[]
  for dp in plot_gsmap['hour']:
      print dp
      if ((int(dp)<23) & (int(dp)>=6)):
          dates_gsmap.append(datetime.datetime(2011, 8, 21, int(dp), 0))
          p.append(plot_gsmap['mean'][plot_gsmap['hour']==dp])
      if ((int(dp)>=0) & (int(dp)<=6)):
          dates_gsmap.append(datetime.datetime(2011, 8, 22, int(dp), 0))
          p.append(plot_gsmap['mean'][plot_gsmap['hour']==dp])


 #print dates_trmm
  a = np.argsort(dates_gsmap,axis=0)

  d_gsmap = np.array(dates_gsmap)[a]
  pl = (np.array(p)[a])
  #pl=np.sort(pl,axis=1)
  
  l, = plt.plot_date(d_gsmap+utc_to_local, pl, label='GSMAP', linewidth=2, linestyle='--', marker='', markersize=2, fmt='', color='black')

  legendEntries.append(l)
  legendtext.append('GSMAP')
  l0=plt.legend(legendEntries, legendtext,title='', frameon=False, prop={'size':8}, loc=9, bbox_to_anchor=(0.21, 0,1, 1))

  # Change the legend label colors to almost black
  texts = l0.texts
  for t in texts:
    t.set_color('#262626')

  legendEntries=[]
  legendtext=[]        

  for c, experiment_id in enumerate(experiment_ids_p):

   expmin1 = experiment_id[:-1]
  

   if (experiment_id=='djznw'):
          print experiment_id
          colour = cmap(1.*1/NUM_COLOURS)
          linewidth=0.2
          linestylez='--'
   if (experiment_id=='djzny'):
          print experiment_id
          colour = cmap(1.*3/NUM_COLOURS)
          linewidth=0.5
          linestylez='--'
   if ((experiment_id=='djznq') or (experiment_id=='dkjxq')):
          print experiment_id
          colour = cmap(1.*5/NUM_COLOURS)
          linewidth=0.8
          if (experiment_id=='djznq'):
              linestylez='--'
          if (experiment_id=='dkjxq'):
              linestylez=':'
              
   if ((experiment_id=='dklzq') or (experiment_id=='dklwu')):
          print experiment_id
          colour = cmap(1.*7/NUM_COLOURS)
          linewidth=1
          if (experiment_id=='dklzq'):
              linestylez='--'
          if (experiment_id=='dklwu'):
              linestylez='-'
   if ((experiment_id=='dklyu') or (experiment_id=='dkmbq')):
          print experiment_id
          colour = cmap(1.*9/NUM_COLOURS)
          linewidth=1.3
          if (experiment_id=='dkmbq'):
              linestylez='--'
          if (experiment_id=='dklyu'):
              linestylez='-'
   if (experiment_id=='djzns'):
          print experiment_id
          colour = cmap(1.*11/NUM_COLOURS)
          linewidth=1.6
          linestylez='-'
   if ((experiment_id=='dkbhu')or (experiment_id=='dkhgu')):
          print experiment_id
          colour = cmap(1.*13/NUM_COLOURS)
          linewidth=1.9
          if (experiment_id=='dkbhu'):
              linestylez='-'
          if (experiment_id=='dkhgu'):
              linestylez=':'
   if (experiment_id=='djznu'):
          print experiment_id
          colour = cmap(1.*15/NUM_COLOURS)
          linewidth=2.
          linestylez='-'
   try:
      plotnp = np.load('%s/%s/%s/%s_%s_rainfall_diurnal_np_domain_constrain_lat_%s-%s_lon-%s-%s.npy' % (top_dir, expmin1, experiment_id, pp_file, ls, lat_min, lat_max, lon_min, lon_max))
   
      l, = plt.plot_date(d, plotnp[0]*3600, label='%s' % (model_name_convert_legend.main(experiment_id)), linewidth=linewidth, linestyle=linestylez, marker='', markersize=2, fmt='', color=colour)

      legendEntries.append(l)
      legendtext.append('%s' % (model_name_convert_legend.main(experiment_id)))
  

   except Exception, e:
      print e
      pass

  l1=plt.legend(legendEntries, legendtext, title='Parametrised', loc=9, frameon=False, prop={'size':8}, bbox_to_anchor=(0, 0,1, 1))

  # Change the legend label colors to almost black
  texts = l1.texts
  for t in texts:
    t.set_color('#262626')

  legendEntries=[]
  legendtext=[]
 
  c1=0
  for c, experiment_id in enumerate(experiment_ids_e):


   if (experiment_id=='djznw'):
          print experiment_id
          colour = cmap(1.*1/NUM_COLOURS)
          linewidth=0.2
          linestylez='--'
   if (experiment_id=='djzny'):
          print experiment_id
          colour = cmap(1.*3/NUM_COLOURS)
          linewidth=0.5
          linestylez='--'
   if ((experiment_id=='djznq') or (experiment_id=='dkjxq')):
          print experiment_id
          colour = cmap(1.*5/NUM_COLOURS)
          linewidth=0.8
          if (experiment_id=='djznq'):
              linestylez='--'
          if (experiment_id=='dkjxq'):
              linestylez=':'
              
   if ((experiment_id=='dklzq') or (experiment_id=='dklwu')):
          print experiment_id
          colour = cmap(1.*7/NUM_COLOURS)
          linewidth=1
          if (experiment_id=='dklzq'):
              linestylez='--'
          if (experiment_id=='dklwu'):
              linestylez='-'
   if ((experiment_id=='dklyu') or (experiment_id=='dkmbq')):
          print experiment_id
          colour = cmap(1.*9/NUM_COLOURS)
          linewidth=1.3
          if (experiment_id=='dkmbq'):
              linestylez='--'
          if (experiment_id=='dklyu'):
              linestylez='-'
   if (experiment_id=='djzns'):
          print experiment_id
          colour = cmap(1.*11/NUM_COLOURS)
          linewidth=1.6
          linestylez='-'
   if ((experiment_id=='dkbhu')or (experiment_id=='dkhgu')):
          print experiment_id
          colour = cmap(1.*13/NUM_COLOURS)
          linewidth=1.9
          if (experiment_id=='dkbhu'):
              linestylez='-'
          if (experiment_id=='dkhgu'):
              linestylez=':'
   if (experiment_id=='djznu'):
          print experiment_id
          colour = cmap(1.*15/NUM_COLOURS)
          linewidth=2.
          linestylez='-'


   expmin1 = experiment_id[:-1]

   try:
      plotnp = np.load('%s/%s/%s/%s_%s_rainfall_diurnal_np_domain_constrain_lat_%s-%s_lon-%s-%s.npy' % (top_dir, expmin1, experiment_id, pp_file, ls, lat_min, lat_max, lon_min, lon_max))
   
      l, = plt.plot_date(d, plotnp[0]*3600, label='%s' % (model_name_convert_legend.main(experiment_id)), linewidth=linewidth, linestyle=linestylez, marker='', markersize=2, fmt='', color=colour)

      legendEntries.append(l)
      legendtext.append('%s' % (model_name_convert_legend.main(experiment_id)))

   except Exception, e:
      print e
      pass

  l2=plt.legend(legendEntries, legendtext, title='Explicit', loc=9, frameon=False, bbox_to_anchor=(0.11, 0,1, 1), prop={'size':8})
  plt.gca().add_artist(l1)
  plt.gca().add_artist(l0)
  plt.gca().xaxis.set_major_formatter(formatter)

  # Change the legend label colors to almost black
  texts = l2.texts
  for t in texts:
    t.set_color('#262626')

  plt.xlabel('Time (UTC)')
  plt.ylabel('mm/h')

  title="Domain Averaged Rainfall - %s" % ls

  t=re.sub('(.{68} )', '\\1\n', str(title), 0, re.DOTALL)
  t = re.sub(r'[(\']', ' ', t)
  t = re.sub(r'[\',)]', ' ', t)
  
  pp_filenodot= pp_file.replace(".", "")

# Bit of formatting 
  # Set colour of axis lines
  spines_to_keep = ['bottom', 'left']
  for spine in spines_to_keep:
    ax.spines[spine].set_linewidth(0.5)
    ax.spines[spine].set_color('#262626')
  # Remove top and right axes lines ("spines")
  spines_to_remove = ['top', 'right']
  for spine in spines_to_remove:
      ax.spines[spine].set_visible(False)
  # Get rid of ticks. The position of the numbers is informative enough of
  # the position of the value.
  ax.xaxis.set_ticks_position('none')
  ax.yaxis.set_ticks_position('none')

  # Change the labels to the off-black
  ax.xaxis.label.set_color('#262626')
  ax.yaxis.label.set_color('#262626')


  if not os.path.exists('/nfs/a90/eepdw/Figures/EMBRACE/Diurnal/'): os.makedirs('/nfs/a90/eepdw/Figures/EMBRACE/Diurnal/')
  #plt.savefig('/nfs/a90/eepdw/Figures/EMBRACE/Diurnal/%s_%s_latlon_southern_eastern_indian_ocean_notitle_8and12kmonly.png' % (pp_filenodot, ls), format='png', bbox_inches='tight')

  plt.title('\n'.join(wrap('%s' % (t.title()), 1000,replace_whitespace=False)), fontsize=16)
  plt.show()
  
  #plt.savefig('/nfs/a90/eepdw/Figures/EMBRACE/Diurnal/%s_%s_latlon_southern_eastern_indian_ocean_8and12kmonly.png' % (pp_filenodot, ls), format='png', bbox_inches='tight')
  plt.close()


if __name__ == '__main__':
   main()

   
       




#-------------------------------------------------------------------------------
# Name:        Brute Force Traveling Salesman Solver
# Purpose:     Traveling salesman brute force solver
#
# Author:      Martin Schneider
#
# Created:     07/09/2014
# Copyright:   (c) Martin 2014
# Licence:     Creative Commons (CC)
#-------------------------------------------------------------------------------
import os, sys
lib_path = os.path.abspath('..')
sys.path.append(lib_path)
lib_path = os.path.abspath('../../helpers')
sys.path.append(lib_path)
import Coordinate
import math
import TravelingSalesmanSolver
import LineOverlapEliminatorTravelingSalesmanSolver
import random
import copy

class AntTotalDistanceSolver (LineOverlapEliminatorTravelingSalesmanSolver.LineOverlapEliminatorTravelingSalesmanSolver):
  def __init__(self,params=None):
     self.initSolver(params)
     self.initOverlapSolver()
     self.phermones =[[]]
     self.CALCULATIONS=10000
     self.CALCULATION_UPDATES=100
     self.BEST_UPDATES=1000
     self.debugData=""
     self.traversed=[]
     self.numTraversed=0
     self.start=0
     self.totalDistance=0
     self.bestDistance=float("inf")
     self.avgEdgeWeight=0
     self.PHERNOME_SCALE=1000000
     self.PHERNOME_EXP  =3#must be odd
     self.order = []
  def solve(self):
    if self.REMOVE_LINE_CROSSES:
      self.calculateIntersects()
#    self.startTime = self.millis()
    self.initArrays()
    self.compute()
    self.printBestPath()
    return self.answer;

  def compute(self):
    for i in range(0,self.CALCULATIONS):
      if i%self.CALCULATION_UPDATES==0:
        pDone=float(i)/self.CALCULATIONS
        self.setStatusDone(str(math.floor(pDone*100))+"% | "+self.remainingTime(pDone))
        self.checkTimeout(self)
      if i%self.BEST_UPDATES==0:
        self.printBestPath()
        self.setSolution(self.answer)

      self.traverse()
      #self.printPhermones()
  def printPhermones(self):
    self.debugData+="PHERMONES:"
    for i in range(0,len(self.cords)):
      self.debugData+="<br>"
      for j in range(0,len(self.cords)):
        self.debugData+=str(round(self.phermones[i][j]*10000)/10000)+" "

  def initArrays(self):
    #self.probability = [[0.0000001]*len(self.cords)]*len(self.cords)
    self.phermones =[[1 for i in range(0,len(self.cords))] for i in range(0,len(self.cords))]
    #totalEdgeDist=0
    #for i in range(0,len(self.cords)):
      #for j in range(0,len(self.cords)):
        #if i==j:
          #continue
        #totalEdgeDist+=self.cords[i].dist(self.cords[j])
    #self.avgEdgeWeight=totalEdgeDist/pow(len(self.cords),2)
    edgeDistScale=self.PHERNOME_SCALE/10#totalEdgeDist/len(self.cords)
    for i in range(0,len(self.cords)):
      for j in range(0,len(self.cords)):
        if i==j:

          continue
        if self.cdists[i][j] == 0:
            self.cdists[i][j] = 0.000000000000001
            self.cdists[j][i] = 0.000000000000001
        self.phermones[i][j]+=edgeDistScale/pow(self.cdists[i][j],3)#self.PHERNOME_EXP)
        self.phermones[j][i]+=edgeDistScale/pow(self.cdists[i][j],3)#self.PHERNOME_EXP)
    self.resetArrays()
  def resetArrays(self):
    self.traversed = [False for i in range(0,len(self.cords))]
    self.totalDistance=0
    self.numTraversed=0
    self.order = []
    self.bestOrder = []
  def traverse(self):
    self.resetArrays()
    self.start=random.randint(0,len(self.cords)-1)
    self.oneStep(self.start)
  def oneStep(self,c):
    self.numTraversed+=1
    works = True
    self.traversed[c]=True
    self.order.append(c)

    if self.numTraversed>=len(self.cords):
      #x=self.order[0]
      #for i in range(1,len(self.order)):
        #x=self.order[i-1]m
        #if(not works):break
        #xi = (min(x,i),max(x,i))
        #for a in range(1,len(self.order)):
          #b=self.order[a-1]
          #if(not works):break
          #ab = (min(a,b),max(a,b))
          #print "<br> Test", x,i,a,b
          #for l in range(1,len(self.intersecting[min(x,i)][max(x,i)])):
            #if ab == xi:
              #works=False
              #break
      if works:
        self.updatePhermones(c,self.start)
      return works

    total=0
    for j in range(0,len(self.cords)):
      if self.traversed[j]:
        continue
      total+=self.phermones[c][j]

    r = random.uniform(0,total)
    #self.debugData+="<br>"+" "+str(r)+" "+str(total)
    cur=0
    for j in range(0,len(self.cords)):
      if self.traversed[j]:
        continue
      cur+=self.phermones[c][j]
      if cur>r:
        self.totalDistance+=self.cdists[c][j]
        works = self.oneStep(j)
        break

    if works:
      self.updatePhermones(c,j)
    return works
  def updatePhermones(self, c, j):
    avg = self.avgEdgeWeight*len(self.cords)
    self.phermones[c][j]+=self.PHERNOME_SCALE/pow(avg-self.totalDistance,self.PHERNOME_EXP)
    self.phermones[j][c]+=self.PHERNOME_SCALE/pow(avg-self.totalDistance,self.PHERNOME_EXP)

  def printBestPath(self):
    self.resetArrays()


    self.bestStep(0)
    if self.REMOVE_LINE_CROSSES:
        self.removeLineCrosses()
    self.answer=self.debugData
    for c in range(0,len(self.bestOrder)):
      self.answer+=str(self.bestOrder[c])+","

    if self.totalDistance!=0:
      self.bestDistance=min(self.totalDistance,self.bestDistance)

  def bestStep(self,c):
    self.bestOrder.append(c)
    self.numTraversed+=1
    if self.numTraversed>=len(self.cords):
      self.totalDistance+=self.cdists[c][0]
      return

    self.traversed[c]=True
    best=0
    bc=0
    for i in range(1,len(self.cords)):
      if self.traversed[i]:
        continue
      #print "<br>?",c,i,best,self.phermones[c][i]
      if self.phermones[c][i]>best:
        #print "!"
        best=self.phermones[c][i]
        bc=i

    #print "<br>B",best,bc

    if bc==0:
      self.totalDistance=float("inf")
    else:
      self.totalDistance+=self.cdists[c][bc]
      self.bestStep(bc)


#a = AntTotalDistanceSolver()
#a.loadCoordinatesFromXYArrays([0,10,0,10],[0,0,10,10])
#print a.solve()
#!/usr/bin/env python3

import pytest
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), "../../lib/"))

import re

from dartsense.webapp import app as tl_app
tl_app.config['DEBUG'] = True
tl_app.config['TESTING'] = True


@pytest.fixture
def app(setup_db):
    return tl_app


def login(client):
    tl_app.config['TEST_LOGIN'] = True
    res = client.get('/user', follow_redirects=True)

    cookie = res.headers['Set-Cookie']
    match = re.search(r'dartsense_session=([^;]+);', cookie)
    sessionid = match.group(1)

    client.set_cookie('localhost', 'dartsense_session', sessionid)


def test_list_index(client):
    res = client.get('/list')
    assert res.status_code == 401
    res = client.get('/list/')
    assert res.status_code == 401

    login(client)

    res = client.get('/list')
    assert res.status_code == 200
    res = client.get('/list/')
    assert res.status_code == 200


def test_list_competitions(client):
    res = client.get('/list/competitions')
    assert res.status_code == 401
    res = client.get('/list/competitions/')
    assert res.status_code == 401

    login(client)

    res = client.get('/list/competitions')
    assert res.status_code == 200
    res = client.get('/list/competitions/')
    assert res.status_code == 200


def test_list_competition(client):
    res = client.get('/list/competition/' +
                     str(pytest.setup_vars['testtournament1_id']))
    assert res.status_code == 401
    res = client.get('/list/competition/99999999')
    assert res.status_code == 401

    login(client)

    res = client.get('/list/competition/' +
                     str(pytest.setup_vars['testtournament1_id']))
    assert res.status_code == 200
    res = client.get('/list/competition/99999999')
    assert res.status_code == 404


def test_list_player(client):
    res = client.get('/list/player/' + str(pytest.setup_vars['player1_id']))
    assert res.status_code == 401
    res = client.get('/list/player/999999999')
    assert res.status_code == 401

    login(client)

    res = client.get('/list/player/' + str(pytest.setup_vars['player1_id']))
    assert res.status_code == 200
    res = client.get('/list/player/999999999')
    assert res.status_code == 404


def test_list_organisations(client):
    res = client.get('/list/organisations')
    assert res.status_code == 401

    login(client)

    res = client.get('/list/organisations')
    assert res.status_code == 200


def test_list_organisation(client):
    res = client.get('/list/organisation/' + str(pytest.setup_vars['organisation1_id']))
    assert res.status_code == 401

    login(client)

    res = client.get('/list/organisation/' + str(pytest.setup_vars['organisation1_id']))
    assert res.status_code == 200


def test_list_event(client):
    res = client.get('/list/event/' + str(pytest.setup_vars['testcompetition1_round1_id']))
    assert res.status_code == 401

    login(client)

    res = client.get('/list/event/' + str(pytest.setup_vars['testcompetition1_round1_id']))
    assert res.status_code == 200

#!/usr/bin/python
# -*- coding: utf-8 -*-

# (c) 2016, Gregory Shulov (gregory.shulov@gmail.com)
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.

ANSIBLE_METADATA = {'status': ['preview'],
                    'supported_by': 'community',
                    'version': '1.0'}

DOCUMENTATION = '''
---
module: infini_host
version_added: 2.3
short_description: Create, Delete and Modify Hosts on Infinibox
description:
    - This module creates, deletes or modifies hosts on Infinibox.
author: Gregory Shulov (@GR360RY)
options:
  name:
    description:
      - Host Name
    required: true
  state:
    description:
      - Creates/Modifies Host when present or removes when absent
    required: false
    default: present
    choices: [ "present", "absent" ]
  wwns:
    description:
      - List of wwns of the host
    required: false
  volume:
    description:
      - Volume name to map to the host
    required: false
extends_documentation_fragment:
    - infinibox
'''

EXAMPLES = '''
- name: Create new new host
  infini_host:
    name: foo.example.com
    user: admin
    password: secret
    system: ibox001

- name: Make sure host bar is available with wwn ports
  infini_host:
    name: bar.example.com
    wwns:
      - "00:00:00:00:00:00:00"
      - "11:11:11:11:11:11:11"
    system: ibox01
    user: admin
    password: secret

- name: Map host foo.example.com to volume bar
  infini_host:
    name: foo.example.com
    volume: bar
    system: ibox01
    user: admin
    password: secret
'''

RETURN = '''
'''

HAS_INFINISDK = True
try:
    from infinisdk import InfiniBox, core
except ImportError:
    HAS_INFINISDK = False

from ansible.module_utils.infinibox import *
from collections import Counter


@api_wrapper
def get_host(module, system):

    host  = None

    for h in system.hosts.to_list():
        if h.get_name() == module.params['name']:
            host = h
            break

    return host


@api_wrapper
def create_host(module, system):

    changed = True

    if not module.check_mode:
        host = system.hosts.create(name=module.params['name'])
        if module.params['wwns']:
            for p in module.params['wwns']:
                host.add_fc_port(p)
        if module.params['volume']:
            host.map_volume(system.volumes.get(name=module.params['volume']))
    module.exit_json(changed=changed)


@api_wrapper
def update_host(module, host):
    changed = False
    name = module.params['name']
    module.exit_json(changed=changed)


@api_wrapper
def delete_host(module, host):
    changed = True
    if not module.check_mode:
        host.delete()
    module.exit_json(changed=changed)


def main():
    argument_spec = infinibox_argument_spec()
    argument_spec.update(
        dict(
            name   = dict(required=True),
            state  = dict(default='present', choices=['present', 'absent']),
            wwns   = dict(type='list'),
            volume = dict()
        )
    )

    module = AnsibleModule(argument_spec, supports_check_mode=True)

    if not HAS_INFINISDK:
        module.fail_json(msg='infinisdk is required for this module')

    state  = module.params['state']
    system = get_system(module)
    host   = get_host(module, system)

    if module.params['volume']:
        try:
            system.volumes.get(name=module.params['volume'])
        except:
            module.fail_json(msg='Volume {} not found'.format(module.params['volume']))

    if host and state == 'present':
        update_host(module, host)
    elif host and state == 'absent':
        delete_host(module, host)
    elif host is None and state == 'absent':
        module.exit_json(changed=False)
    else:
        create_host(module, system)


# Import Ansible Utilities
from ansible.module_utils.basic import AnsibleModule
if __name__ == '__main__':
    main()

#!/usr/bin/python
# -*- coding: utf-8 -*-

# Ansible module to import third party repo keys to your rpm db
# Copyright: (c) 2013, Héctor Acosta <hector.acosta@gazzang.com>

# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'core'}

DOCUMENTATION = '''
---
module: rpm_key
author:
  - Hector Acosta (@hacosta) <hector.acosta@gazzang.com>
short_description: Adds or removes a gpg key from the rpm db
description:
  - Adds or removes (rpm --import) a gpg key to your rpm database.
version_added: "1.3"
options:
    key:
      description:
        - Key that will be modified. Can be a url, a file on the managed node, or a keyid if the key
          already exists in the database.
      required: true
    state:
      description:
        - If the key will be imported or removed from the rpm db.
      default: present
      choices: [ absent, present ]
    validate_certs:
      description:
        - If C(no) and the C(key) is a url starting with https, SSL certificates will not be validated.
        - This should only be used on personally controlled sites using self-signed certificates.
      type: bool
      default: 'yes'
    fingerprint:
      description:
        - The long-form fingerprint of the key being imported.
        - This will be used to verify the specified key.
      type: str
      version_added: 2.9
'''

EXAMPLES = '''
# Example action to import a key from a url
- rpm_key:
    state: present
    key: http://apt.sw.be/RPM-GPG-KEY.dag.txt

# Example action to import a key from a file
- rpm_key:
    state: present
    key: /path/to/key.gpg

# Example action to ensure a key is not present in the db
- rpm_key:
    state: absent
    key: DEADB33F

# Verify the key, using a fingerprint, before import
- rpm_key:
    key: /path/to/RPM-GPG-KEY.dag.txt
    fingerprint: EBC6 E12C 62B1 C734 026B  2122 A20E 5214 6B8D 79E6
'''
import re
import os.path
import tempfile

# import module snippets
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.urls import fetch_url
from ansible.module_utils._text import to_native


def is_pubkey(string):
    """Verifies if string is a pubkey"""
    pgp_regex = ".*?(-----BEGIN PGP PUBLIC KEY BLOCK-----.*?-----END PGP PUBLIC KEY BLOCK-----).*"
    return bool(re.match(pgp_regex, to_native(string, errors='surrogate_or_strict'), re.DOTALL))


class RpmKey(object):

    def __init__(self, module):
        # If the key is a url, we need to check if it's present to be idempotent,
        # to do that, we need to check the keyid, which we can get from the armor.
        keyfile = None
        should_cleanup_keyfile = False
        self.module = module
        self.rpm = self.module.get_bin_path('rpm', True)
        state = module.params['state']
        key = module.params['key']
        fingerprint = module.params['fingerprint']
        if fingerprint:
            fingerprint = fingerprint.replace(' ', '').upper()

        self.gpg = self.module.get_bin_path('gpg')
        if not self.gpg:
            self.gpg = self.module.get_bin_path('gpg2', required=True)

        if '://' in key:
            keyfile = self.fetch_key(key)
            keyid = self.getkeyid(keyfile)
            should_cleanup_keyfile = True
        elif self.is_keyid(key):
            keyid = key
        elif os.path.isfile(key):
            keyfile = key
            keyid = self.getkeyid(keyfile)
        else:
            self.module.fail_json(msg="Not a valid key %s" % key)
        keyid = self.normalize_keyid(keyid)

        if state == 'present':
            if self.is_key_imported(keyid):
                module.exit_json(changed=False)
            else:
                if not keyfile:
                    self.module.fail_json(msg="When importing a key, a valid file must be given")
                if fingerprint:
                    has_fingerprint = self.getfingerprint(keyfile)
                    if fingerprint != has_fingerprint:
                        self.module.fail_json(
                            msg="The specified fingerprint, '%s', does not match the key fingerprint '%s'" % (fingerprint, has_fingerprint)
                        )
                self.import_key(keyfile)
                if should_cleanup_keyfile:
                    self.module.cleanup(keyfile)
                module.exit_json(changed=True)
        else:
            if self.is_key_imported(keyid):
                self.drop_key(keyid)
                module.exit_json(changed=True)
            else:
                module.exit_json(changed=False)

    def fetch_key(self, url):
        """Downloads a key from url, returns a valid path to a gpg key"""
        rsp, info = fetch_url(self.module, url)
        if info['status'] != 200:
            self.module.fail_json(msg="failed to fetch key at %s , error was: %s" % (url, info['msg']))

        key = rsp.read()
        if not is_pubkey(key):
            self.module.fail_json(msg="Not a public key: %s" % url)
        tmpfd, tmpname = tempfile.mkstemp()
        self.module.add_cleanup_file(tmpname)
        tmpfile = os.fdopen(tmpfd, "w+b")
        tmpfile.write(key)
        tmpfile.close()
        return tmpname

    def normalize_keyid(self, keyid):
        """Ensure a keyid doesn't have a leading 0x, has leading or trailing whitespace, and make sure is uppercase"""
        ret = keyid.strip().upper()
        if ret.startswith('0x'):
            return ret[2:]
        elif ret.startswith('0X'):
            return ret[2:]
        else:
            return ret

    def getkeyid(self, keyfile):
        stdout, stderr = self.execute_command([self.gpg, '--no-tty', '--batch', '--with-colons', '--fixed-list-mode', keyfile])
        for line in stdout.splitlines():
            line = line.strip()
            if line.startswith('pub:'):
                return line.split(':')[4]

        self.module.fail_json(msg="Unexpected gpg output")

    def getfingerprint(self, keyfile):
        stdout, stderr = self.execute_command([
            self.gpg, '--no-tty', '--batch', '--with-colons',
            '--fixed-list-mode', '--with-fingerprint', keyfile
        ])
        for line in stdout.splitlines():
            line = line.strip()
            if line.startswith('fpr:'):
                # As mentioned here,
                #
                # https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gnupg.git;a=blob_plain;f=doc/DETAILS
                #
                # The description of the `fpr` field says
                #
                # "fpr :: Fingerprint (fingerprint is in field 10)"
                #
                return line.split(':')[9]

        self.module.fail_json(msg="Unexpected gpg output")

    def is_keyid(self, keystr):
        """Verifies if a key, as provided by the user is a keyid"""
        return re.match('(0x)?[0-9a-f]{8}', keystr, flags=re.IGNORECASE)

    def execute_command(self, cmd):
        rc, stdout, stderr = self.module.run_command(cmd, use_unsafe_shell=True)
        if rc != 0:
            self.module.fail_json(msg=stderr)
        return stdout, stderr

    def is_key_imported(self, keyid):
        cmd = self.rpm + ' -q  gpg-pubkey'
        rc, stdout, stderr = self.module.run_command(cmd)
        if rc != 0:  # No key is installed on system
            return False
        cmd += ' --qf "%{description}" | ' + self.gpg + ' --no-tty --batch --with-colons --fixed-list-mode -'
        stdout, stderr = self.execute_command(cmd)
        for line in stdout.splitlines():
            if keyid in line.split(':')[4]:
                return True
        return False

    def import_key(self, keyfile):
        if not self.module.check_mode:
            self.execute_command([self.rpm, '--import', keyfile])

    def drop_key(self, keyid):
        if not self.module.check_mode:
            self.execute_command([self.rpm, '--erase', '--allmatches', "gpg-pubkey-%s" % keyid[-8:].lower()])


def main():
    module = AnsibleModule(
        argument_spec=dict(
            state=dict(type='str', default='present', choices=['absent', 'present']),
            key=dict(type='str', required=True),
            fingerprint=dict(type='str'),
            validate_certs=dict(type='bool', default=True),
        ),
        supports_check_mode=True,
    )

    RpmKey(module)


if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-

# OpenGL example code - Geometry Shader and Blending
# Uses a geometry shader to expand points to billboard quads.
# The billboards are then blended while drawing to create a galaxy
# made of particles.

import math
from random import random as rand
import ctypes

import numpy as np
from OpenGL.GL import *
from OpenGL.GL import shaders

from glfw import *
import glm


class Window(object):

    def __init__(self, width=640, height=480, title='GLFW opengl window'):
        self.width = width
        self.height = height
        self.title = title
        self.window = None

        self.__vertexShader = './shaders/%s.vert' % self.title
        self.__geomShader = './shaders/%s.geom' % self.title
        self.__fragmentShader = './shaders/%s.frag' % self.title
        self.__shaderProgram = None
        self.__vao = None

        self.__viewLocation = None
        self.__projLocation = None

        self.__particles = 128 * 1024

    def shaderFromFile(self, shaderType, shaderFile):
        """read shader from file and compile it"""
        shaderSrc = ''
        with open(shaderFile) as sf:
            shaderSrc = sf.read()

        return shaders.compileShader(shaderSrc, shaderType)

    def initGL(self):
        """opengl initialization"""
        # load shaders
        vertexShader = self.shaderFromFile(GL_VERTEX_SHADER, self.__vertexShader)
        geomShader = self.shaderFromFile(GL_GEOMETRY_SHADER, self.__geomShader)
        fragmentShader = self.shaderFromFile(GL_FRAGMENT_SHADER, self.__fragmentShader)
        self.__shaderProgram = shaders.compileProgram(vertexShader, geomShader, fragmentShader)
        if not self.__shaderProgram:
            self.close()

        # obtain location of projection uniform
        self.__viewLocation = glGetUniformLocation(self.__shaderProgram, 'View')
        self.__projLocation = glGetUniformLocation(self.__shaderProgram, 'Projection')

        # generate and bind the vao
        self.__vao = glGenVertexArrays(1)
        glBindVertexArray(self.__vao)

        # generate and bind the buffer object
        vbo = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, vbo)

        # create a galaxy like distribution of points
        vertexData = []
        for i in xrange(self.__particles):
            arm = 3 * rand()
            alpha = 1 / (.1 + math.pow(rand(), .7)) - 1/1.1
            r = 4.0 * alpha
            alpha += arm * 2.0 * 3.1416 / 3.0

            x = r * math.sin(alpha)
            y = 0
            z = r * math.cos(alpha)

            x += (4.0 - .2 * alpha) * (2 - rand() + rand() + rand() + rand())
            y += (2.0 - .1 * alpha) * (2 - rand() + rand() + rand() + rand())
            z += (4.0 - .2 * alpha) * (2 - rand() + rand() + rand() + rand())
            vertexData.append((x, y, z))
        vertexData = np.array(vertexData, dtype=np.float32)

        # fill with data
        glBufferData(GL_ARRAY_BUFFER, vertexData.nbytes, vertexData, GL_STATIC_DRAW)

        # set up generic attrib pointers
        glEnableVertexAttribArray(0)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * 4, None)

        glBindVertexArray(0)

        # we are blending so no depth testing
        glDisable(GL_DEPTH_TEST)

        # enable blending
        glEnable(GL_BLEND)
        # and set the blend function to result = 1 * source + 1 * destination
        glBlendFunc(GL_ONE, GL_ONE)

    def renderGL(self):
        """opengl render method"""
        # get the time in seconds
        t = glfwGetTime()

        # clear first
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

        # use the shader program
        glUseProgram(self.__shaderProgram)

        # calculate ViewProjection matrix
        projection = glm.perspective(90.0, 4.0 / 3.0, .1, 100.0)
        projection = np.array(projection, dtype=np.float32)

        # translate the world/view position
        view = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -50.0))

        # make the camera rotate around the origin
        view = glm.rotate(view, 30.0 * math.sin(t * 0.1), glm.vec3(1.0, 0.0, 0.0))
        view = glm.rotate(view, -22.5 * t, glm.vec3(0.0, 1.0, 0.0))
        view = np.array(view, dtype=np.float32)

        # set the uniform
        glUniformMatrix4fv(self.__viewLocation, 1, GL_FALSE, view)
        glUniformMatrix4fv(self.__projLocation, 1, GL_FALSE, projection)

        # bind the vao
        glBindVertexArray(self.__vao)

        # draw
        glDrawArrays(GL_POINTS, 0, self.__particles)

        glBindVertexArray(0)
        glUseProgram(0)

    def initWindow(self):
        """setup window options. etc, opengl version"""
        # select opengl version
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE)
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3)
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3)

    def show(self):
        """create the window and show it"""
        self.initWindow()

        self.window = glfwCreateWindow(self.width, self.height, self.title, 0, 0)
        if self.window == 0:
            glfwTerminate()
            raise Exception('failed to open window')

        glfwMakeContextCurrent(self.window)

        # initialize opengl
        self.initGL()

        while not glfwWindowShouldClose(self.window):
            glfwPollEvents()

            self.renderGL()

            # check for errors
            error = glGetError()
            if error != GL_NO_ERROR:
                raise Exception(error)

            # finally swap buffers
            glfwSwapBuffers(self.window)

        self.close()

    def close(self):
        glfwDestroyWindow(self.window)
        glfwTerminate()



if __name__ == '__main__':
    import os.path

    if glfwInit() == GL_FALSE:
        raise Exception('failed to init GLFW')

    title = os.path.basename(__file__)
    win = Window(title=title[:-3])
    win.show()


# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import re

from ansible.module_utils.six.moves import reduce

from ansible.module_utils.basic import bytes_to_human

from ansible.module_utils.facts.utils import get_file_content, get_mount_size

from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
from ansible.module_utils.facts import timeout


class SunOSHardware(Hardware):
    """
    In addition to the generic memory and cpu facts, this also sets
    swap_reserved_mb and swap_allocated_mb that is available from *swap -s*.
    """
    platform = 'SunOS'

    def populate(self, collected_facts=None):
        hardware_facts = {}

        # FIXME: could pass to run_command(environ_update), but it also tweaks the env
        #        of the parent process instead of altering an env provided to Popen()
        # Use C locale for hardware collection helpers to avoid locale specific number formatting (#24542)
        self.module.run_command_environ_update = {'LANG': 'C', 'LC_ALL': 'C', 'LC_NUMERIC': 'C'}

        cpu_facts = self.get_cpu_facts()
        memory_facts = self.get_memory_facts()
        dmi_facts = self.get_dmi_facts()
        device_facts = self.get_device_facts()
        uptime_facts = self.get_uptime_facts()

        mount_facts = {}
        try:
            mount_facts = self.get_mount_facts()
        except timeout.TimeoutError:
            pass

        hardware_facts.update(cpu_facts)
        hardware_facts.update(memory_facts)
        hardware_facts.update(dmi_facts)
        hardware_facts.update(device_facts)
        hardware_facts.update(uptime_facts)
        hardware_facts.update(mount_facts)

        return hardware_facts

    def get_cpu_facts(self, collected_facts=None):
        physid = 0
        sockets = {}

        cpu_facts = {}
        collected_facts = collected_facts or {}

        rc, out, err = self.module.run_command("/usr/bin/kstat cpu_info")

        cpu_facts['processor'] = []

        for line in out.splitlines():
            if len(line) < 1:
                continue

            data = line.split(None, 1)
            key = data[0].strip()

            # "brand" works on Solaris 10 & 11. "implementation" for Solaris 9.
            if key == 'module:':
                brand = ''
            elif key == 'brand':
                brand = data[1].strip()
            elif key == 'clock_MHz':
                clock_mhz = data[1].strip()
            elif key == 'implementation':
                processor = brand or data[1].strip()
                # Add clock speed to description for SPARC CPU
                # FIXME
                if collected_facts.get('ansible_machine') != 'i86pc':
                    processor += " @ " + clock_mhz + "MHz"
                if 'ansible_processor' not in collected_facts:
                    cpu_facts['processor'] = []
                cpu_facts['processor'].append(processor)
            elif key == 'chip_id':
                physid = data[1].strip()
                if physid not in sockets:
                    sockets[physid] = 1
                else:
                    sockets[physid] += 1

        # Counting cores on Solaris can be complicated.
        # https://blogs.oracle.com/mandalika/entry/solaris_show_me_the_cpu
        # Treat 'processor_count' as physical sockets and 'processor_cores' as
        # virtual CPUs visisble to Solaris. Not a true count of cores for modern SPARC as
        # these processors have: sockets -> cores -> threads/virtual CPU.
        if len(sockets) > 0:
            cpu_facts['processor_count'] = len(sockets)
            cpu_facts['processor_cores'] = reduce(lambda x, y: x + y, sockets.values())
        else:
            cpu_facts['processor_cores'] = 'NA'
            cpu_facts['processor_count'] = len(cpu_facts['processor'])

        return cpu_facts

    def get_memory_facts(self):
        memory_facts = {}

        rc, out, err = self.module.run_command(["/usr/sbin/prtconf"])

        for line in out.splitlines():
            if 'Memory size' in line:
                memory_facts['memtotal_mb'] = int(line.split()[2])

        rc, out, err = self.module.run_command("/usr/sbin/swap -s")

        allocated = int(out.split()[1][:-1])
        reserved = int(out.split()[5][:-1])
        used = int(out.split()[8][:-1])
        free = int(out.split()[10][:-1])

        memory_facts['swapfree_mb'] = free // 1024
        memory_facts['swaptotal_mb'] = (free + used) // 1024
        memory_facts['swap_allocated_mb'] = allocated // 1024
        memory_facts['swap_reserved_mb'] = reserved // 1024

        return memory_facts

    @timeout.timeout()
    def get_mount_facts(self):
        mount_facts = {}
        mount_facts['mounts'] = []

        # For a detailed format description see mnttab(4)
        #   special mount_point fstype options time
        fstab = get_file_content('/etc/mnttab')

        if fstab:
            for line in fstab.splitlines():
                fields = line.split('\t')
                mount_statvfs_info = get_mount_size(fields[1])
                mount_info = {'mount': fields[1],
                              'device': fields[0],
                              'fstype': fields[2],
                              'options': fields[3],
                              'time': fields[4]}
                mount_info.update(mount_statvfs_info)
                mount_facts['mounts'].append(mount_info)

        return mount_facts

    def get_dmi_facts(self):
        dmi_facts = {}

        # On Solaris 8 the prtdiag wrapper is absent from /usr/sbin,
        # but that's okay, because we know where to find the real thing:
        rc, platform, err = self.module.run_command('/usr/bin/uname -i')
        platform_sbin = '/usr/platform/' + platform.rstrip() + '/sbin'

        prtdiag_path = self.module.get_bin_path("prtdiag", opt_dirs=[platform_sbin])
        rc, out, err = self.module.run_command(prtdiag_path)
        """
        rc returns 1
        """
        if out:
            system_conf = out.split('\n')[0]

            # If you know of any other manufacturers whose names appear in
            # the first line of prtdiag's output, please add them here:
            vendors = [
                "Fujitsu",
                "Oracle Corporation",
                "QEMU",
                "Sun Microsystems",
                "VMware, Inc.",
            ]
            vendor_regexp = "|".join(map(re.escape, vendors))
            system_conf_regexp = (r'System Configuration:\s+'
                                  + r'(' + vendor_regexp + r')\s+'
                                  + r'(?:sun\w+\s+)?'
                                  + r'(.+)')

            found = re.match(system_conf_regexp, system_conf)
            if found:
                dmi_facts['system_vendor'] = found.group(1)
                dmi_facts['product_name'] = found.group(2)

        return dmi_facts

    def get_device_facts(self):
        # Device facts are derived for sdderr kstats. This code does not use the
        # full output, but rather queries for specific stats.
        # Example output:
        # sderr:0:sd0,err:Hard Errors     0
        # sderr:0:sd0,err:Illegal Request 6
        # sderr:0:sd0,err:Media Error     0
        # sderr:0:sd0,err:Predictive Failure Analysis     0
        # sderr:0:sd0,err:Product VBOX HARDDISK   9
        # sderr:0:sd0,err:Revision        1.0
        # sderr:0:sd0,err:Serial No       VB0ad2ec4d-074a
        # sderr:0:sd0,err:Size    53687091200
        # sderr:0:sd0,err:Soft Errors     0
        # sderr:0:sd0,err:Transport Errors        0
        # sderr:0:sd0,err:Vendor  ATA

        device_facts = {}
        device_facts['devices'] = {}

        disk_stats = {
            'Product': 'product',
            'Revision': 'revision',
            'Serial No': 'serial',
            'Size': 'size',
            'Vendor': 'vendor',
            'Hard Errors': 'hard_errors',
            'Soft Errors': 'soft_errors',
            'Transport Errors': 'transport_errors',
            'Media Error': 'media_errors',
            'Predictive Failure Analysis': 'predictive_failure_analysis',
            'Illegal Request': 'illegal_request',
        }

        cmd = ['/usr/bin/kstat', '-p']

        for ds in disk_stats:
            cmd.append('sderr:::%s' % ds)

        d = {}
        rc, out, err = self.module.run_command(cmd)
        if rc != 0:
            return device_facts

        sd_instances = frozenset(line.split(':')[1] for line in out.split('\n') if line.startswith('sderr'))
        for instance in sd_instances:
            lines = (line for line in out.split('\n') if ':' in line and line.split(':')[1] == instance)
            for line in lines:
                text, value = line.split('\t')
                stat = text.split(':')[3]

                if stat == 'Size':
                    d[disk_stats.get(stat)] = bytes_to_human(float(value))
                else:
                    d[disk_stats.get(stat)] = value.rstrip()

            diskname = 'sd' + instance
            device_facts['devices'][diskname] = d
            d = {}

        return device_facts

    def get_uptime_facts(self):
        uptime_facts = {}
        # On Solaris, unix:0:system_misc:snaptime is created shortly after machine boots up
        # and displays tiem in seconds. This is much easier than using uptime as we would
        # need to have a parsing procedure for translating from human-readable to machine-readable
        # format.
        # Example output:
        # unix:0:system_misc:snaptime     1175.410463590
        rc, out, err = self.module.run_command('/usr/bin/kstat -p unix:0:system_misc:snaptime')

        if rc != 0:
            return

        uptime_facts['uptime_seconds'] = int(float(out.split('\t')[1]))

        return uptime_facts


class SunOSHardwareCollector(HardwareCollector):
    _fact_class = SunOSHardware
    _platform = 'SunOS'

    required_facts = set(['platform'])

#####################################################################
# u8.py
#
# (c) Copyright 2021, Benjamin Parzella. All rights reserved.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This software is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#####################################################################
"""SECS 8 byte unsigned integer variable type."""

from .base_number import BaseNumber


class U8(BaseNumber):
    """
    Secs type for 8 byte unsigned data.

    :param value: initial value
    :type value: list/integer
    :param count: number of items this value
    :type count: integer
    """

    format_code = 0o50
    text_code = "U8"
    _base_type = int
    _min = 0
    _max = 18446744073709551615
    _bytes = 8
    _struct_code = "Q"
    preferred_types = [int]

# encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
from oscar.core.compat import AUTH_USER_MODEL, AUTH_USER_MODEL_NAME


class Migration(SchemaMigration):

    def forwards(self, orm):
        
        # Adding model 'Notification'
        db.create_table('customer_notification', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('recipient', self.gf('django.db.models.fields.related.ForeignKey')(related_name='notifications', to=orm[AUTH_USER_MODEL])),
            ('sender', self.gf('django.db.models.fields.related.ForeignKey')(to=orm[AUTH_USER_MODEL], null=True)),
            ('subject', self.gf('django.db.models.fields.CharField')(max_length=255)),
            ('body', self.gf('django.db.models.fields.TextField')()),
            ('category', self.gf('django.db.models.fields.CharField')(max_length=255, null=True)),
            ('location', self.gf('django.db.models.fields.CharField')(default='Inbox', max_length=32)),
            ('date_sent', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
            ('date_read', self.gf('django.db.models.fields.DateTimeField')(null=True)),
        ))
        db.send_create_signal('customer', ['Notification'])


    def backwards(self, orm):
        
        # Deleting model 'Notification'
        db.delete_table('customer_notification')


    models = {
        'auth.group': {
            'Meta': {'object_name': 'Group'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
        },
        'auth.permission': {
            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        AUTH_USER_MODEL: {
            'Meta': {'object_name': AUTH_USER_MODEL_NAME},
            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 9, 14, 11, 35, 23, 997732)'}),
            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 9, 14, 11, 35, 23, 997629)'}),
            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
        },
        'contenttypes.contenttype': {
            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'customer.communicationeventtype': {
            'Meta': {'object_name': 'CommunicationEventType'},
            'category': ('django.db.models.fields.CharField', [], {'default': "u'Order related'", 'max_length': '255'}),
            'code': ('django.db.models.fields.SlugField', [], {'max_length': '128', 'db_index': 'True'}),
            'date_created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'date_updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'email_body_html_template': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'email_body_template': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'email_subject_template': ('django.db.models.fields.CharField', [], {'max_length': '255', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'sms_template': ('django.db.models.fields.CharField', [], {'max_length': '170', 'blank': 'True'})
        },
        'customer.email': {
            'Meta': {'object_name': 'Email'},
            'body_html': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'body_text': ('django.db.models.fields.TextField', [], {}),
            'date_sent': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'subject': ('django.db.models.fields.TextField', [], {'max_length': '255'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'emails'", 'to': "orm['{0}']".format(AUTH_USER_MODEL)})
        },
        'customer.notification': {
            'Meta': {'ordering': "('-date_sent',)", 'object_name': 'Notification'},
            'body': ('django.db.models.fields.TextField', [], {}),
            'category': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True'}),
            'date_read': ('django.db.models.fields.DateTimeField', [], {'null': 'True'}),
            'date_sent': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'location': ('django.db.models.fields.CharField', [], {'default': "'Inbox'", 'max_length': '32'}),
            'recipient': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'notifications'", 'to': "orm['{0}']".format(AUTH_USER_MODEL)}),
            'sender': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['{0}']".format(AUTH_USER_MODEL), 'null': 'True'}),
            'subject': ('django.db.models.fields.CharField', [], {'max_length': '255'})
        }
    }

    complete_apps = ['customer']

# 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.

from oslo_log import log as logging
from sqlalchemy import Index, MetaData, Table

from nova.i18n import _LI

LOG = logging.getLogger(__name__)


INDEX_COLUMNS = ['deleted', 'allocated', 'updated_at']
INDEX_NAME = 'fixed_ips_%s_idx' % ('_'.join(INDEX_COLUMNS),)


def _get_table_index(migrate_engine):
    meta = MetaData()
    meta.bind = migrate_engine
    table = Table('fixed_ips', meta, autoload=True)
    for idx in table.indexes:
        if idx.columns.keys() == INDEX_COLUMNS:
            break
    else:
        idx = None
    return meta, table, idx


def upgrade(migrate_engine):
    meta, table, index = _get_table_index(migrate_engine)
    if index:
        LOG.info(_LI('Skipped adding %s because an equivalent index'
                     ' already exists.'), INDEX_NAME)
        return
    columns = [getattr(table.c, col_name) for col_name in INDEX_COLUMNS]
    index = Index(INDEX_NAME, *columns)
    index.create(migrate_engine)

# Copyright (c) 2010 Google Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import unittest2 as unittest

from webkitpy.common.net.buildbot import Build
from webkitpy.common.net.failuremap import *
from webkitpy.common.net.regressionwindow import RegressionWindow
from webkitpy.common.net.buildbot.buildbot_mock import MockBuilder


class FailureMapTest(unittest.TestCase):
    builder1 = MockBuilder("Builder1")
    builder2 = MockBuilder("Builder2")

    build1a = Build(builder1, build_number=22, revision=1233, is_green=True)
    build1b = Build(builder1, build_number=23, revision=1234, is_green=False)
    build2a = Build(builder2, build_number=89, revision=1233, is_green=True)
    build2b = Build(builder2, build_number=90, revision=1235, is_green=False)

    regression_window1 = RegressionWindow(build1a, build1b, failing_tests=[u'test1', u'test1'])
    regression_window2 = RegressionWindow(build2a, build2b, failing_tests=[u'test1'])

    def _make_failure_map(self):
        failure_map = FailureMap()
        failure_map.add_regression_window(self.builder1, self.regression_window1)
        failure_map.add_regression_window(self.builder2, self.regression_window2)
        return failure_map

    def test_failing_revisions(self):
        failure_map = self._make_failure_map()
        self.assertEqual(failure_map.failing_revisions(), [1234, 1235])

    def test_new_failures(self):
        failure_map = self._make_failure_map()
        failure_map.filter_out_old_failures(lambda revision: False)
        self.assertEqual(failure_map.failing_revisions(), [1234, 1235])

    def test_new_failures_with_old_revisions(self):
        failure_map = self._make_failure_map()
        failure_map.filter_out_old_failures(lambda revision: revision == 1234)
        self.assertEqual(failure_map.failing_revisions(), [])

    def test_new_failures_with_more_old_revisions(self):
        failure_map = self._make_failure_map()
        failure_map.filter_out_old_failures(lambda revision: revision == 1235)
        self.assertEqual(failure_map.failing_revisions(), [1234])

    def test_tests_failing_for(self):
        failure_map = self._make_failure_map()
        self.assertEqual(failure_map.tests_failing_for(1234), [u'test1'])

    def test_failing_tests(self):
        failure_map = self._make_failure_map()
        self.assertEqual(failure_map.failing_tests(), set([u'test1']))

# -*- coding: iso-8859-1 -*-
# This file is part of pybliographer
# 
# Copyright (C) 1998-2004 Frederic GOBRY
# Email : gobry@pybliographer.org
# 	   
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2 
# of the License, or (at your option) any later version.
#   
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details. 
# 
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
# 
# 

# Extension module for Medline files

from Pyblio import Base, Fields, Types, Autoload, Open, Iterator, Utils, Config

import re, string,sys

header = re.compile ('^(\w\w[\w ][\w ])- (.*)$')
contin = re.compile ('^      (.*)$')

one_to_one = Config.get ('medline/mapping').data

medurl = 'http://eutils.ncbi.nlm.nih.gov/entrez/eutils/elink.fcgi?cmd=prlinks&dbfrom=pubmed&retmode=ref&id='


class MedlineIterator (Iterator.Iterator):

    def __init__ (self, file):
        self.file = file
        return
    
    
    def first (self):
        # rewind the file
        self.file.seek (0)

        return self.next ()

    def next (self):
        current = None
        data    = ''
        
        table = {}

        # Skip whitespace
        while 1:
            line = self.file.readline ()
            if line == '': return table
            
            line = string.rstrip (line)
            if line != '': break

        while 1:
            head = header.match (line)
            if head:
                if current:
                    if table.has_key (current):
                        table [current].append (data)
                    else:
                        table [current] = [data]
                        
                current = string.strip (head.group (1))
                data    = head.group (2)
            else:
                cont = contin.match (line)
                if cont:
                    data = data + ' ' + cont.group (1)
        
            line = self.file.readline ()
            if line == '': break

            line = string.rstrip (line)
            if line == '': break

        # don't forget the last item
        if current:
            if table.has_key (current):
                table [current].append (data)
            else:
                table [current] = [data]

        # create the entry with the actual fields
        norm = {}
        type = Types.get_entry ('article')

        if table.has_key ('PMID'):
            norm ['url'] = Fields.URL (medurl + table ['PMID'] [0])
            norm ['medline-pmid'] = Fields.Text (table ['PMID'] [0])
            del table ['PMID']
    
        if table.has_key ('UI'):
            norm [one_to_one ['UI']] = Fields.Text (table ['UI'] [0])
            del table ['UI']

        if table.has_key ('AU'):
            group = Fields.AuthorGroup ()
            
            for au in table ['AU']:
                # analyze the author by ourself.
                first, last, lineage = [], [], []
                
                for part in string.split (au, ' '):
		    if part.isupper ():
                        # in upper-case, this is a first name
                        if len (last) > 0:
                            first.append (part)
                        else:
                            # if there is no last name, there can't be a first name
                            last.append (part)
                    else:
                        if len (first) > 0:
                            # there was a first name, this must be a lineage
                            lineage.append (part)
                        else:
                            last.append (part)

                if len (first) > 1:
                    print "medline: long first name found. skipping."
                    first = first [0:1]

                if len (first) > 0:
                    first = string.join (first [0], '. ') + '.'
                else:
                    first = None

                if len (last) > 0:
                    last = string.join (last, ' ')
                else:
                    last = None

                if len (lineage) > 0:
                    lineage = string.join (lineage, ' ')
                else:
                    lineage = None
                    
                group.append (Fields.Author ((None, first, last, lineage)))
                
            norm [one_to_one ['AU']] = group
            del table ['AU']

        if table.has_key ('DP'):
            fields = string.split (table ['DP'][0], ' ')
            norm [one_to_one ['DP']] = Fields.Date (fields [0])
            del table ['DP']
            
        # The simple fields...
        for f in table.keys ():
            f_mapped = one_to_one.get(f, 'medline-%s' %(f.lower()))
            text_type = Types.get_field(f_mapped).type
            norm [f_mapped] = text_type (string.join (table [f], " ; "))
        
        return Base.Entry (None, type, norm)


# UI identifiant unique
# AU auteurs *
# TI titre 
# LA langue *
# MH mots clés *
# PT *  type : JOURNAL ARTICLE, REVIEW, REVIEW, TUTORIAL,CLINICAL TRIAL,
#              RANDOMIZED CONTROLLED TRIAL, LETTER, EDITORIAL, MULTICENTER STUDY,
#              NEWS, HISTORICAL ARTICLE
# DA date de ?? en yyyymmdd 
# DP date de ?? en yyyy mois +/-j
# IS 
# TA titre de la revue
# PG  
# SB 
# CY pays d'édition ?
# IP  
# VI 
# JC  
# AA semble être toujours Author ou AUTHOR
# EM date de?? en yyyymm
# AB  
# AD 
# PMID
# SO  référence complète
# RN semble indexer des substances chimiques
# TT titre dans la langue d'origine
# 4099 URL vers l'article
# 4100 URL vers abstract de l'article ??
    

class Medline (Base.DataBase):
    
    id = 'Medline'
    
    properties = {
        'change_id'   : 0,
        'change_type' : 0
        }

    def __init__ (self, url):
        Base.DataBase.__init__ (self, url)

        iter = iterator (url, 0)

        entry = iter.first ()
        while entry:
            self.add (entry)
            entry = iter.next ()

        return


def writer (iter, output, **argh):

    entry = iter.first ()
    while entry:

        ekeys = {}
        for k in entry.keys (): ekeys [k] = 1
        
        med = one_to_one ['UI']

        if entry.has_key (med):
            del ekeys [med]
            ui = str (entry [med])
        else:
            print "warning: entry has no medline reference"
            ui = 0
            
        output.write ('%-4.4s- %s\n' % ('UI', ui))

        med = one_to_one ['AU']
        
        if entry.has_key (med):
            del ekeys [med]
            for auth in entry [med]:
                first = auth.first or ''
                compact = []
                for seq in string.split (first, ' '):
                    if len (seq) > 0: compact.append (seq [0])

                first = string.join (compact, '')
                text = string.join ((auth.last or '', first, auth.lineage or ''), ' ')
                
                output.write ('%-4.4s- %s\n' % ('AU', text))

        med = one_to_one ['DP']
        if entry.has_key (med):
            del ekeys [med]
            output.write ('%-4.4s- %s\n' % ('DP', str (entry [med])))

        # write the remaining know fields
        for key in one_to_one.keys ():
            field = one_to_one [key]

            if not ekeys.has_key (field): continue
            del ekeys [field]
            
            output.write ('%-4.4s- %s\n' % (key, Utils.format (str (entry [field]),
                                                              75, 0, 6)))
        # write the unknown fields
        remaining = ekeys.keys ()
        remaining.sort ()
        for field in remaining:
            if field [0:8] == 'medline-':
                key = string.upper (field [8:])
                output.write ('%-4.4s- %s\n' % (key, Utils.format (str (entry [field]),
                                                                   75, 0, 6)))
            
        
        entry = iter.next ()
        if entry: output.write ('\n')

        
def opener (url, check):
	
	base = None

	if (not check) or (url.url [2] [-4:] == '.med'):
		base = Medline (url)
		
	return base


def iterator (url, check):
	''' This methods returns an iterator that will parse the
	database on the fly (useful for merging or to parse broken
	databases '''

        if check and url.url [2] [-4:] != '.med': return
        
        return MedlineIterator (open (Open.url_to_local (url), 'r'))


Autoload.register ('format', 'Medline', {'open'  : opener,
                                         'write' : writer,
                                         'iter'  : iterator})

### Local Variables:
### Mode: python
### py-master-file : "ut_medline.py"
### End:

# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================

"""SSDFeatureExtractor for InceptionV3 features."""
import tensorflow as tf

from object_detection.meta_architectures import ssd_meta_arch
from object_detection.models import feature_map_generators
from object_detection.utils import ops
from object_detection.utils import shape_utils
from nets import inception_v3

slim = tf.contrib.slim


class SSDInceptionV3FeatureExtractor(ssd_meta_arch.SSDFeatureExtractor):
  """SSD Feature Extractor using InceptionV3 features."""

  def __init__(self,
               is_training,
               depth_multiplier,
               min_depth,
               pad_to_multiple,
               conv_hyperparams_fn,
               reuse_weights=None,
               use_explicit_padding=False,
               use_depthwise=False,
               override_base_feature_extractor_hyperparams=False):
    """InceptionV3 Feature Extractor for SSD Models.

    Args:
      is_training: whether the network is in training mode.
      depth_multiplier: float depth multiplier for feature extractor.
      min_depth: minimum feature extractor depth.
      pad_to_multiple: the nearest multiple to zero pad the input height and
        width dimensions to.
      conv_hyperparams_fn: A function to construct tf slim arg_scope for conv2d
        and separable_conv2d ops in the layers that are added on top of the
        base feature extractor.
      reuse_weights: Whether to reuse variables. Default is None.
      use_explicit_padding: Whether to use explicit padding when extracting
        features. Default is False.
      use_depthwise: Whether to use depthwise convolutions. Default is False.
      override_base_feature_extractor_hyperparams: Whether to override
        hyperparameters of the base feature extractor with the one from
        `conv_hyperparams_fn`.

    Raises:
      ValueError: If `override_base_feature_extractor_hyperparams` is False.
    """
    super(SSDInceptionV3FeatureExtractor, self).__init__(
        is_training=is_training,
        depth_multiplier=depth_multiplier,
        min_depth=min_depth,
        pad_to_multiple=pad_to_multiple,
        conv_hyperparams_fn=conv_hyperparams_fn,
        reuse_weights=reuse_weights,
        use_explicit_padding=use_explicit_padding,
        use_depthwise=use_depthwise,
        override_base_feature_extractor_hyperparams=
        override_base_feature_extractor_hyperparams)

    if not self._override_base_feature_extractor_hyperparams:
      raise ValueError('SSD Inception V3 feature extractor always uses'
                       'scope returned by `conv_hyperparams_fn` for both the '
                       'base feature extractor and the additional layers '
                       'added since there is no arg_scope defined for the base '
                       'feature extractor.')

  def preprocess(self, resized_inputs):
    """SSD preprocessing.

    Maps pixel values to the range [-1, 1].

    Args:
      resized_inputs: a [batch, height, width, channels] float tensor
        representing a batch of images.

    Returns:
      preprocessed_inputs: a [batch, height, width, channels] float tensor
        representing a batch of images.
    """
    return (2.0 / 255.0) * resized_inputs - 1.0

  def extract_features(self, preprocessed_inputs):
    """Extract features from preprocessed inputs.

    Args:
      preprocessed_inputs: a [batch, height, width, channels] float tensor
        representing a batch of images.

    Returns:
      feature_maps: a list of tensors where the ith tensor has shape
        [batch, height_i, width_i, depth_i]
    """
    preprocessed_inputs = shape_utils.check_min_image_dim(
        33, preprocessed_inputs)

    feature_map_layout = {
        'from_layer': ['Mixed_5d', 'Mixed_6e', 'Mixed_7c', '', '', ''],
        'layer_depth': [-1, -1, -1, 512, 256, 128],
        'use_explicit_padding': self._use_explicit_padding,
        'use_depthwise': self._use_depthwise,
    }

    with slim.arg_scope(self._conv_hyperparams_fn()):
      with tf.variable_scope('InceptionV3', reuse=self._reuse_weights) as scope:
        _, image_features = inception_v3.inception_v3_base(
            ops.pad_to_multiple(preprocessed_inputs, self._pad_to_multiple),
            final_endpoint='Mixed_7c',
            min_depth=self._min_depth,
            depth_multiplier=self._depth_multiplier,
            scope=scope)
        feature_maps = feature_map_generators.multi_resolution_feature_maps(
            feature_map_layout=feature_map_layout,
            depth_multiplier=self._depth_multiplier,
            min_depth=self._min_depth,
            insert_1x1_conv=True,
            image_features=image_features)

    return feature_maps.values()

# -*- coding: utf-8 -*-

"""
***************************************************************************
    lasthin.py
    ---------------------
    Date                 : September 2013
    Copyright            : (C) 2013 by Martin Isenburg
    Email                : martin near rapidlasso point com
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""

__author__ = 'Martin Isenburg'
__date__ = 'September 2013'
__copyright__ = '(C) 2013, Martin Isenburg'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'

import os
from LAStoolsUtils import LAStoolsUtils
from LAStoolsAlgorithm import LAStoolsAlgorithm

from processing.core.parameters import ParameterBoolean
from processing.core.parameters import ParameterNumber
from processing.core.parameters import ParameterSelection

class lasthin(LAStoolsAlgorithm):

    THIN_STEP = "THIN_STEP"
    OPERATION = "OPERATION"
    OPERATIONS= ["lowest", "random", "highest"]
    WITHHELD = "WITHHELD"
    CLASSIFY_AS = "CLASSIFY_AS"
    CLASSIFY_AS_CLASS = "CLASSIFY_AS_CLASS"

    def defineCharacteristics(self):
        self.name = "lasthin"
        self.group = "LAStools"
        self.addParametersVerboseGUI()
        self.addParametersPointInputGUI()
        self.addParameter(ParameterNumber(lasthin.THIN_STEP,
            self.tr("size of grid used for thinning"), 0, None, 1.0))
        self.addParameter(ParameterSelection(lasthin.OPERATION,
            self.tr("keep particular point per cell"), lasthin.OPERATIONS, 0))
        self.addParameter(ParameterBoolean(lasthin.WITHHELD,
            self.tr("mark thinned-away points as withheld"), False))
        self.addParameter(ParameterBoolean(lasthin.CLASSIFY_AS,
            self.tr("classify surviving points as class"), False))
        self.addParameter(ParameterNumber(lasthin.CLASSIFY_AS_CLASS,
            self.tr("class"), 0, None, 8))
        self.addParametersPointOutputGUI()
        self.addParametersAdditionalGUI()

    def processAlgorithm(self, progress):
        commands = [os.path.join(LAStoolsUtils.LAStoolsPath(), "bin", "lasthin")]
        self.addParametersVerboseCommands(commands)
        self.addParametersPointInputCommands(commands)
        step = self.getParameterValue(lasthin.THIN_STEP)
        if step != 0.0:
            commands.append("-step")
            commands.append(str(step))
        operation = self.getParameterValue(lasthin.OPERATION)
        if operation != 0:
            commands.append("-" + self.OPERATIONS[operation])
        if self.getParameterValue(lasthin.WITHHELD):
            commands.append("-withheld")
        if self.getParameterValue(lasthin.CLASSIFY_AS):
            commands.append("-classify_as")
            commands.append(str(self.getParameterValue(lasthin.CLASSIFY_AS_CLASS)))
        self.addParametersPointOutputCommands(commands)
        self.addParametersAdditionalCommands(commands)

        LAStoolsUtils.runLAStools(commands, progress)

# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================

"""Delegating optimizer to clip norm for specified variables."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import contextlib

from tensorflow.python.framework import ops
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import clip_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.platform import tf_logging as logging
from tensorflow.python.training import optimizer

__all__ = ["VariableClippingOptimizer"]


class VariableClippingOptimizer(optimizer.Optimizer):
  """Wrapper optimizer that clips the norm of specified variables after update.

  This optimizer delegates all aspects of gradient calculation and application
  to an underlying optimizer.  After applying gradients, this optimizer then
  clips the variable to have a maximum L2 norm along specified dimensions.
  NB: this is quite different from clipping the norm of the gradients.

  Multiple instances of `VariableClippingOptimizer` may be chained to specify
  different max norms for different subsets of variables.

  @@__init__
  """

  def __init__(self,
               opt,
               vars_to_clip_dims,
               max_norm,
               use_locking=False,
               colocate_clip_ops_with_vars=False,
               name="VariableClipping"):
    """Construct a new clip-norm optimizer.

    Args:
      opt: The actual optimizer that will be used to compute and apply the
        gradients. Must be one of the Optimizer classes.
      vars_to_clip_dims: A dict with keys as Variables and values as lists
        of dimensions along which to compute the L2-norm.  See
        `tf.clip_by_norm` for more details.
      max_norm: The L2-norm to clip to, for all variables specified.
      use_locking: If `True` use locks for clip update operations.
      colocate_clip_ops_with_vars: If `True`, try colocating the clip norm
        ops with the corresponding variable.
      name: Optional name prefix for the operations created when applying
        gradients.  Defaults to "VariableClipping".
    """
    super(VariableClippingOptimizer, self).__init__(use_locking, name)
    self._opt = opt
    # Defensive copy of input dict
    self._vars_to_clip_dims = {
        var: clip_dims[:] for var, clip_dims in vars_to_clip_dims.items()}
    self._max_norm = max_norm
    self._colocate_clip_ops_with_vars = colocate_clip_ops_with_vars

  def compute_gradients(self, *args, **kwargs):
    return self._opt.compute_gradients(*args, **kwargs)

  def get_slot(self, *args, **kwargs):
    return self._opt.get_slot(*args, **kwargs)

  def get_slot_names(self, *args, **kwargs):
    return self._opt.get_slot_names(*args, **kwargs)

  def apply_gradients(self, grads_and_vars, global_step=None, name=None):
    with ops.name_scope(name, self._name) as name:
      update_op = self._opt.apply_gradients(
          grads_and_vars, global_step=global_step)
      clip_update_ops = []
      with ops.control_dependencies([update_op]):
        for grad, var in grads_and_vars:
          if grad is None or var not in self._vars_to_clip_dims:
            continue
          with ops.name_scope("clip_" + var.op.name):
            if isinstance(grad, ops.Tensor):
              clip_update_ops.append(self._clip_dense(var))
            else:
              clip_update_ops.append(self._clip_sparse(grad, var))

      # In case no var was clipped, still need to run the update_op.
      return control_flow_ops.group(*([update_op] + clip_update_ops), name=name)

  def _clip_dense(self, var):
    with self._maybe_colocate_with(var):
      updated_var_value = array_ops.identity(var.ref())
      normalized_var = clip_ops.clip_by_norm(
          updated_var_value, self._max_norm, self._vars_to_clip_dims[var])
      delta = updated_var_value - normalized_var
    with ops.colocate_with(var):
      return var.assign_sub(delta, use_locking=self._use_locking)

  def _clip_sparse(self, grad, var):
    assert isinstance(grad, ops.IndexedSlices)
    clip_dims = self._vars_to_clip_dims[var]
    if 0 in clip_dims:
      logging.warning("Clipping norm across dims %s for %s is inefficient "
                      "when including sparse dimension 0.", clip_dims,
                      var.op.name)
      return self._clip_dense(var)

    with ops.colocate_with(var):
      var_subset = array_ops.gather(var.ref(), grad.indices)
    with self._maybe_colocate_with(var):
      normalized_var_subset = clip_ops.clip_by_norm(
          var_subset, self._max_norm, clip_dims)
      delta = ops.IndexedSlices(
          var_subset - normalized_var_subset, grad.indices, grad.dense_shape)
    with ops.colocate_with(var):
      return var.scatter_sub(delta, use_locking=self._use_locking)

  @contextlib.contextmanager
  def _maybe_colocate_with(self, var):
    """Context to colocate with `var` if `colocate_clip_ops_with_vars`."""
    if self._colocate_clip_ops_with_vars:
      with ops.colocate_with(var):
        yield
    else:
      yield

"""ZWave Thermostat."""

# Because we do not compile openzwave on CI
# pylint: disable=import-error
import logging
from homeassistant.components.thermostat import DOMAIN
from homeassistant.components.thermostat import (
    ThermostatDevice,
    STATE_IDLE)
from homeassistant.components import zwave
from homeassistant.const import TEMP_FAHRENHEIT, TEMP_CELSIUS

_LOGGER = logging.getLogger(__name__)

CONF_NAME = 'name'
DEFAULT_NAME = 'ZWave Thermostat'

REMOTEC = 0x5254
REMOTEC_ZXT_120 = 0x8377
REMOTEC_ZXT_120_THERMOSTAT = (REMOTEC, REMOTEC_ZXT_120)

WORKAROUND_IGNORE = 'ignore'

DEVICE_MAPPINGS = {
    REMOTEC_ZXT_120_THERMOSTAT: WORKAROUND_IGNORE
}

COMMAND_CLASS_THERMOSTAT_FAN_STATE = 69  # 0x45
COMMAND_CLASS_THERMOSTAT_SETPOINT = 67  # 0x43
COMMAND_CLASS_SENSOR_MULTILEVEL = 49  # 0x31
COMMAND_CLASS_THERMOSTAT_OPERATING_STATE = 66  # 0x42
COMMAND_CLASS_THERMOSTAT_MODE = 64  # 0x40


def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the ZWave thermostats."""
    if discovery_info is None or zwave.NETWORK is None:
        _LOGGER.debug("No discovery_info=%s or no NETWORK=%s",
                      discovery_info, zwave.NETWORK)
        return

    node = zwave.NETWORK.nodes[discovery_info[zwave.ATTR_NODE_ID]]
    value = node.values[discovery_info[zwave.ATTR_VALUE_ID]]
    value.set_change_verified(False)
    # Make sure that we have values for the key before converting to int
    if (value.node.manufacturer_id.strip() and
            value.node.product_id.strip()):
        specific_sensor_key = (int(value.node.manufacturer_id, 16),
                               int(value.node.product_id, 16))
        if specific_sensor_key in DEVICE_MAPPINGS:
            if DEVICE_MAPPINGS[specific_sensor_key] == WORKAROUND_IGNORE:
                _LOGGER.debug("Remotec ZXT-120 Zwave Thermostat, ignoring")
                return

    add_devices([ZWaveThermostat(value)])
    _LOGGER.debug("discovery_info=%s and zwave.NETWORK=%s",
                  discovery_info, zwave.NETWORK)


# pylint: disable=too-many-arguments, too-many-instance-attributes
# pylint: disable=abstract-method
class ZWaveThermostat(zwave.ZWaveDeviceEntity, ThermostatDevice):
    """Represents a HeatControl thermostat."""

    def __init__(self, value):
        """Initialize the zwave thermostat."""
        from openzwave.network import ZWaveNetwork
        from pydispatch import dispatcher
        zwave.ZWaveDeviceEntity.__init__(self, value, DOMAIN)
        self._node = value.node
        self._index = value.index
        self._current_temperature = None
        self._unit = None
        self._current_operation_state = STATE_IDLE
        self._target_temperature = None
        self._current_fan_state = STATE_IDLE
        self.update_properties()
        # register listener
        dispatcher.connect(
            self.value_changed, ZWaveNetwork.SIGNAL_VALUE_CHANGED)

    def value_changed(self, value):
        """Called when a value has changed on the network."""
        if self._value.value_id == value.value_id:
            self.update_properties()
            self.update_ha_state()

    def update_properties(self):
        """Callback on data change for the registered node/value pair."""
        # current Temp
        for _, value in self._node.get_values_for_command_class(
                COMMAND_CLASS_SENSOR_MULTILEVEL).items():
            self._current_temperature = int(value.data)
            self._unit = value.units

        # operation state
        for _, value in self._node.get_values(
                class_id=COMMAND_CLASS_THERMOSTAT_OPERATING_STATE).items():
            self._current_operation_state = value.data_as_string

        # target temperature
        temps = []
        for _, value in self._node.get_values(
                class_id=COMMAND_CLASS_THERMOSTAT_SETPOINT).items():
            temps.append(int(value.data))
            if value.index == self._index:
                self._target_temperature = value.data
        self._target_temperature_high = max(temps)
        self._target_temperature_low = min(temps)

        # fan state
        for _, value in self._node.get_values(
                class_id=COMMAND_CLASS_THERMOSTAT_FAN_STATE).items():
            self._current_fan_state = value.data_as_string

    @property
    def should_poll(self):
        """No polling on ZWave."""
        return False

    @property
    def unit_of_measurement(self):
        """Return the unit of measurement."""
        unit = self._unit
        if unit == 'C':
            return TEMP_CELSIUS
        elif unit == 'F':
            return TEMP_FAHRENHEIT
        else:
            return unit

    @property
    def current_temperature(self):
        """Return the current temperature."""
        return self._current_temperature

    @property
    def operation(self):
        """Return current operation ie. heat, cool, idle."""
        return self._current_operation_state

    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
        return self._target_temperature

    @property
    def is_fan_on(self):
        """Return true if the fan is on."""
        return not (self._current_fan_state == 'Idle' or
                    self._current_fan_state == STATE_IDLE)

    def set_temperature(self, temperature):
        """Set new target temperature."""
        # set point
        for _, value in self._node.get_values_for_command_class(
                COMMAND_CLASS_THERMOSTAT_SETPOINT).items():
            if int(value.data) != 0 and value.index == self._index:
                value.data = temperature
                break

# -*- coding: utf-8 -*-
"""
    pygments.lexers.varnish
    ~~~~~~~~~~~~~~~~~~~~~~~

    Lexers for Varnish configuration

    :copyright: Copyright 2006-2017 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

from pygments.lexer import RegexLexer, include, bygroups, using, this, \
    inherit, words
from pygments.token import Text, Comment, Operator, Keyword, Name, String, \
    Number, Punctuation, Literal

__all__ = ['VCLLexer', 'VCLSnippetLexer']


class VCLLexer(RegexLexer):
    """
    For Varnish Configuration Language (VCL).

    .. versionadded:: 2.2
    """
    name = 'VCL'
    aliases = ['vcl']
    filenames = ['*.vcl']
    mimetypes = ['text/x-vclsrc']

    def analyse_text(text):
        # If the very first line is 'vcl 4.0;' it's pretty much guaranteed
        # that this is VCL
        if text.startswith('vcl 4.0;'):
            return 1.0
        # Skip over comments and blank lines
        # This is accurate enough that returning 0.9 is reasonable.
        # Almost no VCL files start without some comments.
        elif '\nvcl 4.0;' in text[:1000]:
            return 0.9

    tokens = {
        'probe': [
            include('whitespace'),
            include('comments'),
            (r'(\.\w+)(\s*=\s*)([^;]*)(;)',
             bygroups(Name.Attribute, Operator, using(this), Punctuation)),
            (r'\}', Punctuation, '#pop'),
        ],
        'acl': [
            include('whitespace'),
            include('comments'),
            (r'[!/]+', Operator),
            (r';', Punctuation),
            (r'\d+', Number),
            (r'\}', Punctuation, '#pop'),
        ],
        'backend': [
            include('whitespace'),
            (r'(\.probe)(\s*=\s*)(\w+)(;)',
             bygroups(Name.Attribute, Operator, Name.Variable.Global, Punctuation)),
            (r'(\.probe)(\s*=\s*)(\{)',
             bygroups(Name.Attribute, Operator, Punctuation), 'probe'),
            (r'(\.\w+\b)(\s*=\s*)([^;]*)(\s*;)',
             bygroups(Name.Attribute, Operator, using(this), Punctuation)),
            (r'\{', Punctuation, '#push'),
            (r'\}', Punctuation, '#pop'),
        ],
        'statements': [
            (r'(\d\.)?\d+[sdwhmy]', Literal.Date),
            (r'(\d\.)?\d+ms', Literal.Date),
            (r'(vcl_pass|vcl_hash|vcl_hit|vcl_init|vcl_backend_fetch|vcl_pipe|'
             r'vcl_backend_response|vcl_synth|vcl_deliver|vcl_backend_error|'
             r'vcl_fini|vcl_recv|vcl_purge|vcl_miss)\b', Name.Function),
            (r'(pipe|retry|hash|synth|deliver|purge|abandon|lookup|pass|fail|ok|'
             r'miss|fetch|restart)\b', Name.Constant),
            (r'(beresp|obj|resp|req|req_top|bereq)\.http\.[a-zA-Z_-]+\b', Name.Variable),
            (words((
                'obj.status', 'req.hash_always_miss', 'beresp.backend', 'req.esi_level',
                'req.can_gzip', 'beresp.ttl', 'obj.uncacheable', 'req.ttl', 'obj.hits',
                'client.identity', 'req.hash_ignore_busy', 'obj.reason', 'req.xid',
                'req_top.proto', 'beresp.age', 'obj.proto', 'obj.age', 'local.ip',
                'beresp.uncacheable', 'req.method', 'beresp.backend.ip', 'now',
                'obj.grace', 'req.restarts', 'beresp.keep', 'req.proto', 'resp.proto',
                'bereq.xid', 'bereq.between_bytes_timeout', 'req.esi',
                'bereq.first_byte_timeout', 'bereq.method', 'bereq.connect_timeout',
                'beresp.do_gzip',  'resp.status', 'beresp.do_gunzip',
                'beresp.storage_hint', 'resp.is_streaming', 'beresp.do_stream',
                'req_top.method', 'bereq.backend', 'beresp.backend.name', 'beresp.status',
                'req.url', 'obj.keep', 'obj.ttl', 'beresp.reason', 'bereq.retries',
                'resp.reason', 'bereq.url', 'beresp.do_esi', 'beresp.proto', 'client.ip',
                'bereq.proto', 'server.hostname', 'remote.ip', 'req.backend_hint',
                'server.identity', 'req_top.url', 'beresp.grace', 'beresp.was_304',
                'server.ip', 'bereq.uncacheable'), suffix=r'\b'),
             Name.Variable),
            (r'[!%&+*\-,/<.}{>=|~]+', Operator),
            (r'[();]', Punctuation),

            (r'[,]+', Punctuation),
            (words(('hash_data', 'regsub', 'regsuball', 'if', 'else',
                    'elsif', 'elif', 'synth', 'synthetic', 'ban',
                    'return', 'set', 'unset', 'import', 'include', 'new',
                    'rollback', 'call'), suffix=r'\b'),
             Keyword),
            (r'storage\.\w+\.\w+\b', Name.Variable),
            (words(('true', 'false')), Name.Builtin),
            (r'\d+\b', Number),
            (r'(backend)(\s+\w+)(\s*\{)',
             bygroups(Keyword, Name.Variable.Global, Punctuation), 'backend'),
            (r'(probe\s)(\s*\w+\s)(\{)',
             bygroups(Keyword, Name.Variable.Global, Punctuation), 'probe'),
            (r'(acl\s)(\s*\w+\s)(\{)',
             bygroups(Keyword, Name.Variable.Global, Punctuation), 'acl'),
            (r'(vcl )(4.0)(;)$',
             bygroups(Keyword.Reserved, Name.Constant, Punctuation)),
            (r'(sub\s+)([a-zA-Z]\w*)(\s*\{)',
                bygroups(Keyword, Name.Function, Punctuation)),
            (r'([a-zA-Z_]\w*)'
             r'(\.)'
             r'([a-zA-Z_]\w*)'
             r'(\s*\(.*\))',
             bygroups(Name.Function, Punctuation, Name.Function, using(this))),
            (r'[a-zA-Z_]\w*', Name),
        ],
        'comment': [
            (r'[^*/]+', Comment.Multiline),
            (r'/\*', Comment.Multiline, '#push'),
            (r'\*/', Comment.Multiline, '#pop'),
            (r'[*/]', Comment.Multiline),
        ],
        'comments': [
            (r'#.*$', Comment),
            (r'/\*', Comment.Multiline, 'comment'),
            (r'//.*$', Comment),
        ],
        'string': [
            (r'"', String, '#pop'),
            (r'[^"\n]+', String),  # all other characters
        ],
        'multistring': [
            (r'[^"}]', String),
            (r'"\}', String, '#pop'),
            (r'["}]', String),
        ],
        'whitespace': [
            (r'L?"', String, 'string'),
            (r'\{"', String, 'multistring'),
            (r'\n', Text),
            (r'\s+', Text),
            (r'\\\n', Text),  # line continuation
        ],
        'root': [
            include('whitespace'),
            include('comments'),
            include('statements'),
            (r'\s+', Text),
        ],
    }


class VCLSnippetLexer(VCLLexer):
    """
    For Varnish Configuration Language snippets.

    .. versionadded:: 2.2
    """
    name = 'VCLSnippets'
    aliases = ['vclsnippets', 'vclsnippet']
    mimetypes = ['text/x-vclsnippet']
    filenames = []

    def analyse_text(text):
        # override method inherited from VCLLexer
        return 0

    tokens = {
        'snippetspre': [
            (r'\.\.\.+', Comment),
            (r'(bereq|req|req_top|resp|beresp|obj|client|server|local|remote|'
             r'storage)($|\.\*)', Name.Variable),
        ],
        'snippetspost': [
            (r'(backend)\b', Keyword.Reserved),
        ],
        'root': [
            include('snippetspre'),
            inherit,
            include('snippetspost'),
        ],
    }

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

{
    'name': 'Automated Action Rules',
    'version': '1.0',
    'category': 'Sales Management',
    'description': """
This module allows to implement action rules for any object.
============================================================

Use automated actions to automatically trigger actions for various screens.

**Example:** A lead created by a specific user may be automatically set to a specific
sales team, or an opportunity which still has status pending after 14 days might
trigger an automatic reminder email.
    """,
    'author': 'OpenERP SA',
    'website': 'http://www.openerp.com',
    'depends': ['base', 'resource', 'mail'],
    'data': [
        'base_action_rule_view.xml',
        'security/ir.model.access.csv',
        'base_action_rule_data.xml'
    ],
    'demo': [],
    'installable': True,
    'auto_install': False,
    'images': ['images/base_action_rule1.jpeg','images/base_action_rule2.jpeg','images/base_action_rule3.jpeg'],
}
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

# -*- coding: utf-8 -*-
##############################################################################
#
#    Author: Alexandre Fayolle, Guewen Baconnier, Joel Grand-Guillaume
#    Copyright 2012 Camptocamp SA
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from __future__ import division

import logging
from itertools import chain
from openerp.osv import orm, fields
import openerp.addons.decimal_precision as dp

_logger = logging.getLogger(__name__)


def topological_sort(data):
    """ Topological sort on a dict expressing dependencies.

    Recipe from:
    http://code.activestate.com/recipes/578272-topological-sort/
    Slightly modified, adapted for Python 2.6

    Dependencies are expressed as a dictionary whose keys are items
    and whose values are a set of dependent items. Output is a list of
    sets in topological order. The first set consists of items with no
    dependences, each subsequent set consists of items that depend upon
    items in the preceeding sets.

    >>> print '\\n'.join(repr(sorted(x)) for x in topological_sort({
    ...     2: set([11]),
    ...     9: set([11,8]),
    ...     10: set([11,3]),
    ...     11: set([7,5]),
    ...     8: set([7,3]),
    ...     }) )
    [3, 5, 7]
    [8, 11]
    [2, 9, 10]

    """
    # Ignore self dependencies.
    for k, v in data.items():
        v.discard(k)
    # Find all items that don't depend on anything.
    extra_items_in_deps = set.union(*data.itervalues()) - set(data.iterkeys())
    # Add empty dependences where needed
    data.update(dict((item, set()) for item in extra_items_in_deps))
    while True:
        ordered = set(item for item, dep in data.iteritems() if not dep)
        if not ordered:
            break
        yield ordered
        data = dict((item, (dep - ordered))
                    for item, dep in data.iteritems()
                    if item not in ordered)
    assert not data, \
        "Cyclic dependencies exist among these items " \
        ":\n%s" % '\n'.join(repr(x) for x in data.iteritems())


class product_product(orm.Model):
    _inherit = 'product.product'

    def _compute_purchase_price(self, cr, uid, ids, context=None):
        """ Compute the purchase price of products

        Take into account the sub products (bills of materials) and the
        routing.

        As an example, we have such a hierarchy of products::

            - Table A
                - 2x Plank 20.-
                - 4x Wood leg 10.-
            - Table B
                - 3x Plank 20.-
                - 4x Red wood leg
            - Red wood leg
                - 1x Wood leg 10.-
                - 1x Red paint pot 10.-
            - Chair
                - 1x Plank
                - 4x Wood leg
            - Table and Chair
                - 1x Table Z
                - 4x Chair Z

        When we update the ``standard_price`` of a "Wood leg", all cost
        prices of the products upper in the tree must be computed again.
        Here, that is: "Table A", "Red wood leg", "Chair", "Table B".
        The price of all theses products are computed at the same
        time in this function, the effect is that we should take:

        1. to not read the cost price of a product in the browse_record,
           if it is computed here because it has likely changed, but use
           the new cost instead
        2. compute the prices in a topological order, so we start at the
           leaves of the tree thus we know the prices of all the sub
           products when we go up the tree

        The topological sort, in this example, when we modify the "Wood
        leg", will returns successively 3 generators::

            [set('Wood plank', 'Red Paint Pot', 'Wood Leg')],
            [set('Table A', 'Red wood leg')],
            [set('Table B')]]

        The first set having no dependencies and the subsequent sets
        having items that depend upon items in the preceding set.

        """
        if context is None:
            context = {}
        product_uom = context.get('product_uom')
        bom_properties = context.get('properties', [])

        bom_obj = self.pool.get('mrp.bom')
        uom_obj = self.pool.get('product.uom')

        computed = {}
        if not ids:
            return computed
        _logger.debug("_compute_purchase_price with ids %s" % ids)

        depends = dict((product_id, set()) for product_id in ids)
        product_bom = {}
        for product_id in ids:
            bom_id = bom_obj._bom_find(cr, uid, product_id,
                                       product_uom=product_uom,
                                       properties=bom_properties)
            if not bom_id:  # no BoM: use standard_price
                continue
            bom = bom_obj.browse(cr, uid, bom_id, context=context)
            if bom.type == 'phantom' and not bom.bom_lines:
                continue # work around lp:1281054 calling _bom_explode in that
                         # case will cause an infinite recursion
            subproducts, routes = bom_obj._bom_explode(cr, uid, bom,
                                                       factor=1,
                                                       properties=bom_properties,
                                                       addthis=True)
            # set the dependencies of "product_id"
            depends[product_id].update([sp['product_id'] for sp in
                                        subproducts])
            product_bom[product_id] = {
                'bom': bom,
                'subproducts': subproducts
            }

        # eagerly read all the dependencies products
        sub_read = self.read(cr, uid,
                             list(chain.from_iterable(depends.itervalues())),
                             ['cost_price', 'uom_po_id'], context=context)
        subproduct_costs = dict((p['id'], p) for p in sub_read)

        ordered = list(chain.from_iterable(topological_sort(depends)))

        # extract all the products not in a bom and get their costs
        # first, avoid to read them one by one
        no_bom_ids = [p_id for p_id in ordered if
                      p_id not in product_bom and
                      p_id in ids]
        costs = super(product_product, self)._compute_purchase_price(
            cr, uid, no_bom_ids, context=context)
        computed.update(costs)

        for product_id in ordered:
            if not product_id in ids:
                # the product is a dependency so it appears in the
                # topological sort, but the cost price should not be
                # recomputed
                continue
            if product_id not in product_bom:
                # already computed with ``super``
                continue

            cost = 0.
            subproduct_infos = product_bom[product_id]['subproducts']
            for subproduct_info in subproduct_infos:
                subproduct_id = subproduct_info['product_id']
                subproduct = subproduct_costs[subproduct_id]
                # The cost price could have been recomputed in an
                # earlier iteration.  Thanks to the topological sort,
                # the subproducts are always computed before their
                # parents
                subcost = computed.get(subproduct_id, subproduct['cost_price'])
                qty = uom_obj._compute_qty(
                    cr, uid,
                    from_uom_id=subproduct_info['product_uom'],
                    qty=subproduct_info['product_qty'],
                    to_uom_id=subproduct['uom_po_id'][0])
                cost += subcost * qty

            bom = product_bom[product_id]['bom']
            if bom.routing_id:
                for wline in bom.routing_id.workcenter_lines:
                    wc = wline.workcenter_id
                    cycle = wline.cycle_nbr
                    hour = ((wc.time_start + wc.time_stop +
                             cycle * wc.time_cycle) *
                            (wc.time_efficiency or 1.0))
                    cost += wc.costs_cycle * cycle + wc.costs_hour * hour
            cost /= bom.product_qty

            cost = uom_obj._compute_price(
                cr, uid, bom.product_uom.id,
                cost, bom.product_id.uom_id.id)
            computed[product_id] = cost

        return computed

    def _cost_price(self, cr, uid, ids, field_name, arg, context=None):
        return self._compute_purchase_price(cr, uid, ids, context=context)

    def _get_bom_product(self, cr, uid, ids, context=None):
        """ return ids of modified product and ids of all product that use
        as sub-product one of this ids.

        Example::

            BoM:
                Product A
                    - Product B
                    - Product C

        => If we change standard_price of product B, we want to update
        Product A as well...

        """
        def _get_parent_bom(bom_record):
            """ Recursively find the parent bom of all the impacted products
            and return a list of bom ids

            """
            bom_result = []
            if bom_record.bom_id:
                bom_result.append(bom_record.bom_id.id)
                bom_result.extend(_get_parent_bom(bom_record.bom_id))
            return bom_result

        bom_obj = self.pool.get('mrp.bom')
        bom_ids = bom_obj.search(cr, uid, [('product_id', 'in', ids)],
                                 context=context)
        if not bom_ids:
            return ids

        boms = bom_obj.browse(cr, uid, bom_ids, context=context)
        parent_bom_ids = set(chain.from_iterable(_get_parent_bom(bom) for
                                                 bom in boms))
        bom_ids = set(bom_ids)
        product_ids = set(ids)
        # product ids from the other BoMs
        bom_product_ids = self._get_product_id_from_bom(
            cr, uid, list(parent_bom_ids), context=context)
        product_ids.update(bom_product_ids)
        # recurse in the other BoMs to find all the product ids
        recurs_ids = self._get_bom_product(cr, uid,
                                           bom_product_ids,
                                           context=context)
        product_ids.update(recurs_ids)
        return list(product_ids)

    def _get_product(self, cr, uid, ids, context=None):
        """ Return all product impacted from a change in a bom, that means
        current product and all parent that is composed by it.

        """
        bom_obj = self.pool.get('mrp.bom')
        prod_obj = self.pool.get('product.product')
        res = set()
        for bom in bom_obj.read(cr, uid, ids, ['product_id'], context=context):
            res.add(bom['product_id'][0])
        final_res = prod_obj._get_bom_product(cr, uid,
                                              list(res),
                                              context=context)
        _logger.debug("trigger on mrp.bom model for product ids %s", final_res)
        return final_res

    def _get_product_id_from_bom(self, cr, uid, ids, context=None):
        """ Return a list of product ids from bom """
        bom_obj = self.pool.get('mrp.bom')
        res = set()
        for bom in bom_obj.read(cr, uid, ids, ['product_id'], context=context):
            res.add(bom['product_id'][0])
        return list(res)

    def _get_product_from_template2(self, cr, uid, ids, context=None):
        prod_obj = self.pool.get('product.product')
        res = prod_obj._get_product_from_template(cr, uid, ids, context=context)
        return res

    # Trigger on product.product is set to None, otherwise do not trigg
    # on product creation !
    _cost_price_triggers = {
        'product.product': (_get_bom_product, None, 5),
        'product.template': (_get_product_from_template2,
                             ['standard_price'], 5),
        'mrp.bom': (_get_product,
                    ['bom_id',
                     'bom_lines',
                     'product_id',
                     'product_uom',
                     'product_qty',
                     'product_uos',
                     'product_uos_qty',
                     ],
                    10)
    }

    _columns = {
        'cost_price': fields.function(
            _cost_price,
            store=_cost_price_triggers,
            string='Cost Price (incl. BoM)',
            digits_compute=dp.get_precision('Product Price'),
            help="The cost price is the standard price or, if the "
                 "product has a bom, the sum of all standard price "
                 "of its components. it take also care of the bom "
                 "costing like cost per cycle.")
    }

#!/usr/bin/env python3
# vim: set encoding=utf-8 tabstop=4 softtabstop=4 shiftwidth=4 expandtab
#########################################################################
# Copyright 2016-2017   Martin Sinn                         m.sinn@gmx.de
# -Parts (from the parser) Copyright 2013 Marcus Pop       marcus@popp.mx
#########################################################################
#  This file is part of SmartHomeNG
#  https://github.com/smarthomeNG/smarthome
#  http://knx-user-forum.de/
#
#  SmartHomeNG is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  SmartHomeNG is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with SmartHomeNG. If not, see <http://www.gnu.org/licenses/>.
#########################################################################

"""
This file is a special version of the configuration loader. It has been modified to
support the conversion from CONF to YAML format. This configuration loader is only called
by the converter tools/conf_to_yaml_converter.py.
"""

import os

RUAMEL_YAML_INSTALLED = False
try:
    import ruamel.yaml as yaml
    RUAMEL_YAML_INSTALLED = True
except:
    print('ERROR: module ruamel.yaml not found')
    print('')
    print('Please install ruamel.yaml using the command:')
    print('sudo pip3 install ruamel.yaml')
    print('')
    RUAMEL_YAML_INSTALLED = False
    import yaml


import collections
from collections import OrderedDict


yaml_version = '1.1'
indent_spaces = 4
store_raw_output = False			# Only for testing, otherwise False


def is_ruamelyaml_installed():

    return RUAMEL_YAML_INSTALLED


# ==================================================================================
#   config loader from config.py modified for parsing to yaml
#


def _strip_quotes(string):
    string = string.strip()
    # check if string starts with ' or ", and end with it, if they are the only one
    if len(string) >= 2 and string[0] in ['"', "'"] and string[0] == string[-1] and string.count(string[0]) == 2:
        string = string[1:-1]  # remove them
    return string


def _handle_multiline_string(string):
    if len(string) > 0 and string.find('\n') > -1 and string[0] != '|':
        string = '|\n' + string
    return string


def parse_for_convert(filename=None, conf_code=None, config=None):
    valid_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_@*'
    valid_set = set(valid_chars)
    if config is None:
        config = collections.OrderedDict()
    item = config
    offset = 0
    lastline_was_comment = False
    last_comment_nr = 0

    if filename != None:
        print("- parsing '{}'".format(os.path.basename(filename)), end="")
        with open(filename, 'r', encoding='UTF-8') as f:
            lines = iter(f.readlines())
    elif isinstance(conf_code, str):
        lines = conf_code.splitlines()
    else:
        return config

    linenu = 0
    parents = collections.OrderedDict()
    parent = collections.OrderedDict()
    if 1 == 1:
        for raw in lines:
            linenu += 1
            line = raw.lstrip('\ufeff')  # remove BOM

            multiline = []
            if line.rstrip().endswith('\\'):
                i = 0
                while line.rstrip().endswith('\\'):
                    multiline.append( line.rstrip().rstrip('\\').strip() )
                    i += 1
                    linenu += 1
                    line = next(lines, '').lstrip()
                line = '\n'.join(multiline) + '\n'+line.strip()
                lastline_was_comment = False

            if (len(multiline) == 0) or (line[0] == '#'):
                if len(multiline) == 0:
                    comment_in_line = line.find('#')
                    comment = line.partition('#')[2].strip()
                    if comment_in_line > -1 and comment == '':
                        comment = '>**<'
                    line = line.partition('#')[0].strip()
                    # inline comment
                    if (line != '') and (comment != '') and line.find('[') == -1:
                        attr, __, value = line.partition('=')
                        if ("'" in line) or ("|" in line):
                            comment = attr.strip() + ': ' + comment
                        else:
                            line = line + '    ## ' + comment
                            comment = ''
                else:
                    comment = line
                    line = ''
                if comment != '':
                    while (comment != '') and (comment[0] == '#'):
                        comment = comment[1:].strip()
                if comment != '':
                    comment = comment.replace('\t', ' ')
                    if 'comment' in item.keys():
                        if lastline_was_comment:
                            if last_comment_nr > 0:
                                item['comment'+str(last_comment_nr)] = _handle_multiline_string(item['comment'+str(last_comment_nr)] + '\n' + _strip_quotes(comment))
                            else:
                                item['comment'] = _handle_multiline_string(item['comment'] + '\n' + _strip_quotes(comment))
                        else:
                            i = 1
                            while 'comment'+str(i) in item.keys():
                                i += 1
                            item['comment'+str(i)] = _handle_multiline_string(_strip_quotes(comment))
                            last_comment_nr = i
                    else:
#                        logger.info("comment: '{}'".format(comment))
                        item['comment'] = _handle_multiline_string(_strip_quotes(comment))
                        last_comment_nr = 0
                    lastline_was_comment = True

            if line == '':
                continue
            if line[0] == '[':  # item
                lastline_was_comment = False
                #
                comment_in_line = line.find('#')
                comment = line.partition('#')[2].strip()
                if comment_in_line > -1 and comment == '':
                    comment = '>**<'
                line = line.partition('#')[0].strip()
                #
                brackets = 0
                level = 0
                closing = False
                for index in range(len(line)):
                    if line[index] == '[' and not closing:
                        brackets += 1
                        level += 1
                    elif line[index] == ']':
                        closing = True
                        brackets -= 1
                    else:
                        closing = True
                        if line[index] not in valid_chars + "'":
                            print()
                            print("ERROR: Problem (1) parsing '{}' invalid character in \nline {}: {}. \nValid chars: {}".format(os.path.basename(filename), linenu, line, valid_chars))
                            return config
                if brackets != 0:
                    print()
                    print("ERROR: Problem parsing '{}' unbalanced brackets in line {}: {}".format(filename, linenu, line))
                    return config
                #
                if comment_in_line > -1:
                    print()
                    print("ERROR: Problem parsing '{}' \nunhandled comment {} in \nline {}: {}. \nValid chars: {}".format(os.path.basename(filename), comment, linenu, line, valid_chars))
                #
                name = line.strip("[]")
                name = _strip_quotes(name)
                if level - offset == 1:
                    if name not in config:
                        config[name] = collections.OrderedDict()
                    item = config[name]
                    parents = collections.OrderedDict()
                    parents[level] = item
                else:
                    if level - 1 not in parents:
                        offset = level - 1
                        if name not in config:
                            config[name] = collections.OrderedDict()
                        item = config[name]
                        parents = collections.OrderedDict()
                        parents[level] = item
                    else:
                        parent = parents[level - 1]
                        if name not in parent:
                            parent[name] = collections.OrderedDict()
                        item = parent[name]
                        parents[level] = item

            else:  # attribute
                lastline_was_comment = False
                attr, __, value = line.partition('=')
                comm = ''
                if '##' in value:
                    value, __, comm  = value.partition('##')
                    value = _strip_quotes(value)
                    value = value + '    ## ' + comm.strip()
#                print("= attr >{}<, value >{}<, comment >{}<".format(attr, value, comm))
                if not value:
                    continue
                attr = attr.strip()
                if not set(attr).issubset(valid_set):
                    print()
                    print("line: '{}'".format(line))
                    print("ERROR: Problem (2) parsing '{}' invalid character in line {}: {}. Valid characters are: {}".format(filename, linenu, attr, valid_chars))
                    continue
                if '|' in value:
                    item[attr] = [_strip_quotes(x) for x in value.split('|')]
                else:
                    svalue = _handle_multiline_string(_strip_quotes(value))
                    try:
                        ivalue = int(svalue)
                        item[attr] = ivalue
                    except:
                        item[attr] = svalue.replace('\t', ' ')

        return config


# ##################################################################################
#   YAML handling routines
#

def _yaml_save_roundtrip(filename, data):
    """
    Dump yaml using the RoundtripDumper and correct linespacing in output file
    """

    sdata = yaml.dump(data, Dumper=yaml.RoundTripDumper, version=yaml_version, indent=indent_spaces, block_seq_indent=2, width=32768, allow_unicode=True)

    ldata = sdata.split('\n')
    rdata = []
    for index, line in enumerate(ldata):
        # Fix for ruamel.yaml handling: Reinsert empty line before comment of next section
        if len(line.lstrip()) > 0 and line.lstrip()[0] == '#':
            indentcomment = len(line) - len(line.lstrip(' '))
            indentprevline = len(ldata[index-1]) - len(ldata[index-1].lstrip(' '))
            if indentprevline - indentcomment >= 2*indent_spaces:
                rdata.append('')
            rdata.append(line)
        # Fix for ruamel.yaml handling: Remove empty line with spaces that have been inserted
        elif line.strip() == '' and line != '':
            if ldata[index-1] != '':
                rdata.append(line)
        else:
            rdata.append(line)

    sdata = '\n'.join(rdata)
    if sdata[0] == '\n':
        sdata =sdata[1:]

    with open(filename+'.yaml', 'w') as outfile:
        outfile.write( sdata )



def yaml_save(filename, data):
    """
    ***Converter Special ***

    Save contents of an OrderedDict structure to a yaml file

    :param filename: name of the yaml file to save to
    :param data: OrderedDict to save
    """

    sdata = convert_yaml(data)

    print(", saving to '{}'".format(os.path.basename(filename)+'.yaml'))
    if store_raw_output == True:
        with open(filename+'_raw.yaml', 'w') as outfile:
            outfile.write( sdata )

    # Test if roundtrip gives the same result
    data = yaml.load(sdata, yaml.RoundTripLoader)
    _yaml_save_roundtrip(filename, data)


def convert_yaml(data):
    """
    ***Converter Special ***

    Convert data structure to yaml format

    :param data: OrderedDict to convert
    :return: yaml formated data
    """

    ordered = (type(data).__name__ == 'OrderedDict')
    if ordered:
        sdata = _ordered_dump(data, Dumper=yaml.SafeDumper, version=yaml_version, indent=indent_spaces, block_seq_indent=2, width=32768, allow_unicode=True, default_flow_style=False)
    else:
        sdata = yaml.dump(data, Dumper=yaml.SafeDumper, indent=indent_spaces, block_seq_indent=2, width=32768, allow_unicode=True, default_flow_style=False)
    sdata = _format_yaml_dump(sdata)

    return sdata


def _format_yaml_dump(data):
    """
    ***Converter Special ***

    Format yaml-dump to make file more readable
    (yaml structure must be dumped to a stream before using this function)
    | Currently does the following:
    | - Add an empty line before a new item

    :param data: string to format

    :return: formatted string
    """

    data = data.replace('\n\n', '\n')
    ldata = data.split('\n')
    rdata = []

    for index, line in enumerate(ldata):
        if len(line) > 0:
            # Handle inline-comments from converter
            if line.find('##') > -1 and line.find(": '") > -1 and line[-1:] == "'":
                line = line.replace('##', '#')
                line = line.replace(": '", ": ")
                line = line[:-1]

            # Handle comments from converter
            if line.find('comment') > -1 and line.find(':') > line.find('comment'):
#                print('comment-line>', line, '<')
                indent = len(line) - len(line.lstrip(' '))
                if ldata[index+1][-1:] == ':':
                    indent = len(ldata[index+1]) - len(ldata[index+1].lstrip(' '))
                if line.find(': "|') > -1:
                    line = line[:-1]
                    line = line.replace(': "|', ': |')
                else:
                    line = line.replace(': ', ': |\\n', 1)
#                print('# ' + line[line.find("|\\n")+3:])
                line = " "*indent + '# ' + line[line.find("|\\n")+3:]
                line = line.replace('>**<', '')
                line = line.replace('\\n', '\n'+" "*indent + '# ')

            # Handle newlines for multiline string-attributes ruamel.yaml
            if line.find(': "|') > -1 and line[-1:] == '"' and line.find('\\n') > -1:
                indent = len(line) - len(line.lstrip(' ')) + indent_spaces
                line = line[:-1]
                line = line.replace(': "|', ': |')
                line = line.replace('\\n', '\n'+" "*indent)

        rdata.append(line)


    ldata = rdata
    rdata = []
    for index, line in enumerate(ldata):
        if len(line.lstrip()) > 0 and  line.lstrip()[0] == '#' and ldata[index+1][-1:] == ':':
            rdata.append('')
            rdata.append(line)

        # Insert empty line before section (key w/o a value)
        elif line[-1:] == ':':
            if not (len(ldata[index-1].lstrip()) > 0 and ldata[index-1].lstrip()[0] == '#'):
                # no empty line before list attributes
                if ldata[index+1].strip()[0] != '-':
                    rdata.append('')
                rdata.append(line)
            else:
                rdata.append(line)
        else:
            rdata.append(line)

    fdata = '\n'.join(rdata)
    if fdata[0] == '\n':
        fdata = fdata[1:]
    return fdata


def _ordered_dump(data, stream=None, Dumper=yaml.Dumper, **kwds):
    """
    Ordered yaml dumper
    Use this instead ot yaml.Dumper/yaml.SaveDumper to get an Ordereddict

    :param stream: stream to write to
    :param Dumper: yaml-dumper to use
    :**kwds: Additional keywords

    :return: OrderedDict structure
    """

    # usage example: ordered_dump(data, Dumper=yaml.SafeDumper)
    class OrderedDumper(Dumper):
        pass
    def _dict_representer(dumper, data):
        return dumper.represent_mapping(
            yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG,
            data.items())
    OrderedDumper.add_representer(OrderedDict, _dict_representer)
    return yaml.dump(data, stream, OrderedDumper, **kwds)



"""
Example of simulating a reflectometry experiment
with a rough sample using BornAgain.

"""
import bornagain as ba
from bornagain import deg, angstrom, nm


def get_sample():
    """
    Defines sample and returns it
    """

    # creating materials
    m_ambient = ba.MaterialBySLD("Ambient", 0.0, 0.0)
    m_ti = ba.MaterialBySLD("Ti", -1.9493e-06, 0.0)
    m_ni = ba.MaterialBySLD("Ni", 9.4245e-06, 0.0)
    m_substrate = ba.MaterialBySLD("SiSubstrate", 2.0704e-06, 0.0)

    # creating layers
    ambient_layer = ba.Layer(m_ambient)
    ti_layer = ba.Layer(m_ti, 30 * angstrom)
    ni_layer = ba.Layer(m_ni, 70 * angstrom)
    substrate_layer = ba.Layer(m_substrate)

    # defining roughness
    roughness = ba.LayerRoughness()
    roughness.setSigma(1.0 * nm)

    # creating multilayer
    multi_layer = ba.MultiLayer()
    multi_layer.addLayer(ambient_layer)
    for i in range(10):
        multi_layer.addLayerWithTopRoughness(ti_layer, roughness)
        multi_layer.addLayerWithTopRoughness(ni_layer, roughness)
    multi_layer.addLayerWithTopRoughness(substrate_layer, roughness)

    return multi_layer


def get_simulation(scan_size=500):
    """
    Defines and returns a specular simulation.
    """
    simulation = ba.SpecularSimulation()
    scan = ba.AngularSpecScan(1.54 * angstrom, scan_size,
                              0.0 * deg, 2.0 * deg)
    simulation.setScan(scan)
    return simulation


def run_simulation():
    """
    Runs simulation and returns its result.
    """
    sample = get_sample()
    simulation = get_simulation()
    simulation.setSample(sample)
    simulation.runSimulation()
    return simulation.result()


if __name__ == '__main__':
    results = run_simulation()
    ba.plot_simulation_result(results)

#!/usr/bin/python
# -*- coding: utf-8 -*-

# (c) 2012, David "DaviXX" CHANIAL <david.chanial@gmail.com>
# (c) 2014, James Tanner <tanner.jc@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#

DOCUMENTATION = '''
---
module: sysctl
short_description: Manage entries in sysctl.conf.
description:
    - This module manipulates sysctl entries and optionally performs a C(/sbin/sysctl -p) after changing them.
version_added: "1.0"
options:
    name:
        description:
            - The dot-separated path (aka I(key)) specifying the sysctl variable.
        required: true
        default: null
        aliases: [ 'key' ]
    value:
        description:
            - Desired value of the sysctl key.
        required: false
        default: null
        aliases: [ 'val' ]
    state:
        description:
            - Whether the entry should be present or absent in the sysctl file.
        choices: [ "present", "absent" ]
        default: present
    ignoreerrors:
        description:
            - Use this option to ignore errors about unknown keys.
        choices: [ "yes", "no" ]
        default: no
    reload:
        description:
            - If C(yes), performs a I(/sbin/sysctl -p) if the C(sysctl_file) is
              updated. If C(no), does not reload I(sysctl) even if the
              C(sysctl_file) is updated.
        choices: [ "yes", "no" ]
        default: "yes"
    sysctl_file:
        description:
            - Specifies the absolute path to C(sysctl.conf), if not C(/etc/sysctl.conf).
        required: false
        default: /etc/sysctl.conf
    sysctl_set:
        description:
            - Verify token value with the sysctl command and set with -w if necessary
        choices: [ "yes", "no" ]
        required: false
        version_added: 1.5
        default: False
notes: []
requirements: []
author: David "DaviXX" CHANIAL <david.chanial@gmail.com>
'''

EXAMPLES = '''
# Set vm.swappiness to 5 in /etc/sysctl.conf
- sysctl: name=vm.swappiness value=5 state=present

# Remove kernel.panic entry from /etc/sysctl.conf
- sysctl: name=kernel.panic state=absent sysctl_file=/etc/sysctl.conf

# Set kernel.panic to 3 in /tmp/test_sysctl.conf
- sysctl: name=kernel.panic value=3 sysctl_file=/tmp/test_sysctl.conf reload=no

# Set ip fowarding on in /proc and do not reload the sysctl file
- sysctl: name="net.ipv4.ip_forward" value=1 sysctl_set=yes

# Set ip forwarding on in /proc and in the sysctl file and reload if necessary
- sysctl: name="net.ipv4.ip_forward" value=1 sysctl_set=yes state=present reload=yes
'''

# ==============================================================

import os
import tempfile
import re

class SysctlModule(object):

    def __init__(self, module):
        self.module = module 
        self.args = self.module.params

        self.sysctl_cmd = self.module.get_bin_path('sysctl', required=True)
        self.sysctl_file = self.args['sysctl_file']

        self.proc_value = None  # current token value in proc fs
        self.file_value = None  # current token value in file
        self.file_lines = []    # all lines in the file
        self.file_values = {}   # dict of token values

        self.changed = False    # will change occur
        self.set_proc = False   # does sysctl need to set value
        self.write_file = False # does the sysctl file need to be reloaded

        self.process()

    # ==============================================================
    #   LOGIC
    # ==============================================================

    def process(self):

        # Whitespace is bad
        self.args['name'] = self.args['name'].strip()
        self.args['value'] = self._parse_value(self.args['value'])

        thisname = self.args['name']

        # get the current proc fs value
        self.proc_value = self.get_token_curr_value(thisname)

        # get the currect sysctl file value
        self.read_sysctl_file()
        if thisname not in self.file_values:
            self.file_values[thisname] = None

        # update file contents with desired token/value
        self.fix_lines()

        # what do we need to do now?
        if self.file_values[thisname] is None and self.args['state'] == "present":
            self.changed = True
            self.write_file = True
        elif self.file_values[thisname] is None and self.args['state'] == "absent":
            self.changed = False
        elif self.file_values[thisname] != self.args['value']:
            self.changed = True
            self.write_file = True

        # use the sysctl command or not?
        if self.args['sysctl_set']:            
            if self.proc_value is None:
                self.changed = True
            elif not self._values_is_equal(self.proc_value, self.args['value']):
                self.changed = True 
                self.set_proc = True

        # Do the work
        if not self.module.check_mode:
            if self.write_file:
                self.write_sysctl()
            if self.write_file and self.args['reload']:
                self.reload_sysctl()
            if self.set_proc:
                self.set_token_value(self.args['name'], self.args['value'])

    def _values_is_equal(self, a, b):
        """Expects two string values. It will split the string by whitespace
        and compare each value. It will return True if both lists are the same,
        contain the same elements and the same order."""
        if a is None or b is None:
            return False

        a = a.split()
        b = b.split()

        if len(a) != len(b):
            return False

        return len([i for i, j in zip(a, b) if i == j]) == len(a)

    def _parse_value(self, value):
        if value is None:
            return ''
        elif value.lower() in BOOLEANS_TRUE:
            return '1'
        elif value.lower() in BOOLEANS_FALSE:
            return '0'
        else:
            return value.strip()

    # ==============================================================
    #   SYSCTL COMMAND MANAGEMENT
    # ==============================================================

    # Use the sysctl command to find the current value 
    def get_token_curr_value(self, token):
        thiscmd = "%s -e -n %s" % (self.sysctl_cmd, token)
        rc,out,err = self.module.run_command(thiscmd)    
        if rc != 0:
            return None
        else:
            return out

    # Use the sysctl command to set the current value
    def set_token_value(self, token, value):
        if len(value.split()) > 0:
            value = '"' + value + '"'
        thiscmd = "%s -w %s=%s" % (self.sysctl_cmd, token, value)
        rc,out,err = self.module.run_command(thiscmd)
        if rc != 0:
            self.module.fail_json(msg='setting %s failed: %s' % (token, out + err))
        else:
            return rc

    # Run sysctl -p
    def reload_sysctl(self):
        # do it
        if get_platform().lower() == 'freebsd':
            # freebsd doesn't support -p, so reload the sysctl service
            rc,out,err = self.module.run_command('/etc/rc.d/sysctl reload')
        else:
            # system supports reloading via the -p flag to sysctl, so we'll use that
            sysctl_args = [self.sysctl_cmd, '-p', self.sysctl_file]
            if self.args['ignoreerrors']:
                sysctl_args.insert(1, '-e')
            
            rc,out,err = self.module.run_command(sysctl_args)

        if rc != 0:            
            self.module.fail_json(msg="Failed to reload sysctl: %s" % str(out) + str(err))

    # ==============================================================
    #   SYSCTL FILE MANAGEMENT
    # ==============================================================

    # Get the token value from the sysctl file
    def read_sysctl_file(self):

        lines = []            
        if os.path.isfile(self.sysctl_file):
            try:
                f = open(self.sysctl_file, "r")
                lines = f.readlines()
                f.close()
            except IOError, e:
                self.module.fail_json(msg="Failed to open %s: %s" % (self.sysctl_file, str(e)))

        for line in lines:
            line = line.strip()
            self.file_lines.append(line)

            # don't split empty lines or comments
            if not line or line.startswith("#"):
                continue 

            k, v = line.split('=',1)
            k = k.strip()
            v = v.strip()
            self.file_values[k] = v.strip()

    # Fix the value in the sysctl file content
    def fix_lines(self):
        checked = []
        self.fixed_lines = []
        for line in self.file_lines:
            if not line.strip() or line.strip().startswith("#"):
                self.fixed_lines.append(line)
                continue
            tmpline = line.strip()            
            k, v = line.split('=',1)
            k = k.strip()
            v = v.strip()
            if k not in checked:
                checked.append(k)
                if k == self.args['name']:
                    if self.args['state'] == "present":
                        new_line = "%s=%s\n" % (k, self.args['value'])
                        self.fixed_lines.append(new_line)                    
                else:
                    new_line = "%s=%s\n" % (k, v)
                    self.fixed_lines.append(new_line)                    

        if self.args['name'] not in checked and self.args['state'] == "present":
            new_line = "%s=%s\n" % (self.args['name'], self.args['value'])
            self.fixed_lines.append(new_line)                    

    # Completely rewrite the sysctl file
    def write_sysctl(self):
        # open a tmp file
        fd, tmp_path = tempfile.mkstemp('.conf', '.ansible_m_sysctl_', os.path.dirname(self.sysctl_file))
        f = open(tmp_path,"w")
        try:
            for l in self.fixed_lines:
                f.write(l.strip() + "\n")
        except IOError, e:
            self.module.fail_json(msg="Failed to write to file %s: %s" % (tmp_path, str(e)))
        f.flush()
        f.close()

        # replace the real one
        self.module.atomic_move(tmp_path, self.sysctl_file) 


# ==============================================================
# main

def main():

    # defining module
    module = AnsibleModule(
        argument_spec = dict(
            name = dict(aliases=['key'], required=True),
            value = dict(aliases=['val'], required=False),
            state = dict(default='present', choices=['present', 'absent']),
            reload = dict(default=True, type='bool'),
            sysctl_set = dict(default=False, type='bool'),
            ignoreerrors = dict(default=False, type='bool'),
            sysctl_file = dict(default='/etc/sysctl.conf')
        ),
        supports_check_mode=True
    )

    result = SysctlModule(module)    

    module.exit_json(changed=result.changed)
    sys.exit(0)

# import module snippets
from ansible.module_utils.basic import *
main()

# -*- coding: utf-8 -*-
# Copyright (c) 2015, Vispy Development Team.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.

"""
Material components are modular shader components used for modifying fragment
colors to change the visual's appearance.

These generally create a function in the fragment shader that accepts a vec4
color as its only argument and returns a modified vec4 color.
"""

from __future__ import division

from .component import VisualComponent
from ..shaders import Varying


class GridContourComponent(VisualComponent):
    """
    Draw grid lines across a surface.
    """

    SHADERS = dict(
        frag_color="""
            vec4 grid_contour(vec4 color) {
                if ( mod($pos.x, $spacing.x) < 0.005 ||
                    mod($pos.y, $spacing.y) < 0.005 ||
                    mod($pos.z, $spacing.z) < 0.005 ) {
                return color + 0.7 * (vec4(1,1,1,1) - color);
                }
                else {
                    return color;
                }
            }
        """,
        vert_post_hook="""
            void grid_contour_support() {
                $output_pos = local_position();
            }
        """)

    def __init__(self, spacing):
        super(GridContourComponent, self).__init__()
        self.spacing = spacing
        
        # Create Varying to connect vertex / fragment shaders
        var = Varying('pos', dtype='vec4')
        self._funcs['frag_color']['pos'] = var
        self._funcs['vert_post_hook']['output_pos'] = var

    @property
    def color(self):
        return self._color

    @color.setter
    def color(self, c):
        self._color = c

    def activate(self, program, mode):
        ff = self._funcs['frag_color']
        ff['spacing'] = self.spacing  # uniform vec3


class ShadingComponent(VisualComponent):
    """
    Phong reflection and shading material.
    """

    SHADERS = dict(
        frag_color="""
            vec4 shading(vec4 color) {
                vec3 norm = normalize($normal().xyz);
                vec3 light = normalize($light_direction.xyz);
                float p = dot(light, norm);
                p = (p < 0. ? 0. : p);
                vec4 diffuse = $light_color * p;
                diffuse.a = 1.0;
                p = dot(reflect(light, norm), vec3(0,0,1));
                if (p < 0.0) {
                    p = 0.0;
                }
                vec4 specular = $light_color * 5.0 * pow(p, 100.);
                return color * ($ambient + diffuse) + specular;
            }
        """)

    def __init__(self, normal_comp, lights, ambient=0.2):
        super(ShadingComponent, self).__init__()
        self.normal_comp = normal_comp
        self._deps = [normal_comp]
        self.lights = lights
        self.ambient = ambient

    def activate(self, program, mode):
        # Normals are generated by output of another component
        ff = self._funcs['frag_color']
        ff['normal'] = self.normal_comp.normal_shader()

        # TODO: add support for multiple lights
        ff['light_direction'] = tuple(self.lights[0][0][:3]) + (1,)  # u vec4
        ff['light_color'] = tuple(self.lights[0][1][:3]) + (1,)  # u vec4
        ff['ambient'] = self.ambient  # u float

#! /usr/bin/env python
# Licensed to Big Data Genomics (BDG) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The BDG licenses this file
# to you 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.

"""Exposes top-level Luigi Tasks associated with ETLing the datasets."""

# these classes must accept a "config" parameter which takes the json file

from eggo.dag import VCF2ADAMTask, BAM2ADAMTask


if __name__ == '__main__':
    from luigi import run
    run()

#!/usr/bin/python
# -*- coding: utf-8 -*-

"""
EDBOWebApiConnector
Author: Eldar Aliiev
Email: e.aliiev@vnmu.edu.ua
"""

import json
import time
import requests
from requests.adapters import HTTPAdapter
from . import config as config
from .helper import EDBOWebApiHelper


class EDBOWebApiConnector(object):
    """EDBOWebApiConnector - class which implements connection
    and method execution with EDBO RESTfull API.

    Attributes:
        url_prefix  Path to RESTful API server.
    """

    # Build url to RESTful server
    url_prefix = '{0:s}/data/EDEBOWebApi'.format(config.EDBO_SERVER)

    def __init__(self, username: str = config.EDBO_USER, password: str = config.EDBO_PASSWORD):
        """Initialize connect and login into RESTful API server.
        :param username: Username (Default=from config file)
        :param password: Method data (Default=from config file)
        :type username: str
        :type password: str
        """
        # Initialize status
        self._status = None

        # Initialize execution_time
        self._execution_time = 0

        # Is user logged in
        self._is_logged_in = False

        # Initialize client session
        self._session = requests.Session()

        # Set default headers to own
        self._session.headers.update(self.default_headers)

        # Mount RESTful API server to our session
        self._session.mount(
            config.EDBO_SERVER,
            HTTPAdapter(max_retries=config.CONNECTION_RETRIES)
        )

        # Login into server
        self.__login(username, password)

    def __del__(self):
        """End of session"""
        # Check if user is logged in and logout if true
        if self._is_logged_in:
            # Logout from server
            self.__logout()

    @property
    def internal_methods(self):
        return [
            'auth/logout'
        ]

    @property
    def status(self) -> int:
        """Return status of last request
        :return: Status of last method execution
        :rtype: int
        """
        return self._status

    @property
    def execution_time(self) -> float:
        """Return execution time of last request
        :return: Time of last method execution
        :rtype: float
        """
        return self._execution_time

    @property
    def default_headers(self) -> dict:
        """Default request headers
        :return: Default request headers such as user-agent, referer and etc
        :rtype: dict
        """
        return {
            'Origin': config.EDBO_SERVER,
            'Referer': config.EDBO_SERVER,
            'User-Agent': config.USER_AGENT,
        }

    def __login(self, username: str = config.EDBO_USER, password: str = config.EDBO_PASSWORD):
        """Login request to RESTful API"""
        EDBOWebApiHelper.echo(u'Вхід в систему...')
        try:
            # Try to send authorization request
            response = self._session.post(
                self.url_prefix + '/oauth/token',
                data={
                    'grant_type': 'password',
                    'username': username,
                    'password': password,
                    'app_key': config.EDBO_APPLICATION_KEY,
                },
                headers=self.default_headers
            )

            # Check if authorization is successful
            if response.status_code == 200:
                # Catch session start time
                self._session_start_time = time.time()

                # Catch last response status code
                self._status = response.status_code

                # Logged in
                self._is_logged_in = True

                # Add OAuth header to session
                self._session.headers.update({
                    'authorization': 'Bearer ' + response.json().get('access_token', None),
                })

                EDBOWebApiHelper.echo(
                    u'Вхід успішний, вітаю {0:s}!'.format(config.EDBO_USER),
                    color='green'
                )
            elif response.status_code == 400:
                # Incorrect login data
                EDBOWebApiHelper.echo(
                    response.json().get('error', u'Трапилася невідома помилка!'),
                    color='red',
                    force_exit=True
                )
            else:
                # Fail if login is unsuccessful
                EDBOWebApiHelper.echo(
                    u'Не вдалося авторизуватися в системі!',
                    color='red',
                    force_exit=True
                )

        except requests.exceptions.ConnectionError:
            # Server is unavailable
            EDBOWebApiHelper.echo(
                u'Не вдалося встановити зв\'язок з сервером!',
                color='red',
                force_exit=True
            )

    def __logout(self):
        """Logout from server"""
        EDBOWebApiHelper.echo(u'Вихід з системи...', color='red')
        # Logout from server
        if self._is_logged_in:
            self.execute('auth/logout', json_format=False)

        if self.status == 204:
            # Logged out
            self._is_logged_in = False

    def execute(self, url: str, data: dict = None, headers: dict = None, json_format: bool = True):
        """Send request to RESTful server.
        :param url: Path to RESTful method
        :param data: Method data (Default=empty)
        :param headers: Default headers (Default=empty)
        :param json_format: Return results dictionary or object (Default=True)
        :type url: str
        :type data: dict
        :type headers: dict
        :type json_format: bool
        :returns: Result of method execution
        :rtype: dict, object
        """
        # Check if session is not expired (15min)
        if url not in self.internal_methods and int(time.time() - self._session_start_time) > config.RELOGIN_AFTER:
            EDBOWebApiHelper.echo(u'Сесія добігає кінця, поновлення...')
            # Login again
            self.__login()

        # Wait between methods execution
        time.sleep(config.EXECUTION_TIMEOUT)

        # Try to execute method
        for _ in range(0, config.CONNECTION_RETRIES):
            try:
                EDBOWebApiHelper.echo(
                    u'Виконання методу {0:s}...'.format(url)
                )

                # Catch start of execution
                execution_start = time.time()

                # Send request to RESTful server
                response = self._session.post(
                    '{0:s}/api/{1:s}'.format(self.url_prefix, url),
                    data if data is not None else {'': ''},
                    headers if headers is not None else {}
                )

                # Catch end of execution
                execution_end = time.time()
            except requests.exceptions.ConnectionError:
                EDBOWebApiHelper.echo(
                    u'Виконання методу {0:s} завершено невдало, повторна спроба... [{1:d}]'.format(
                        url,
                        response.status_code
                    ),
                    color='red'
                )
                # Retry if unsuccessful
                continue

            # Save last execution time
            self._execution_time = execution_end - execution_start

            # Save last status code
            self._status = response.status_code

            if self.status == 401:
                # Login again and retry
                self.__login()
                continue

            # Check if server return data
            if self.status in (200, 204, 500):
                try:
                    if json_format:
                        response = response.json()

                    EDBOWebApiHelper.echo(
                        u'Виконання методу {0:s} завершено. [{1:d}][{2:.3f}s]'.format(
                            url,
                            self._status,
                            self._execution_time
                        ),
                        color='green'
                    )

                    return response
                except json.decoder.JSONDecodeError as exc:
                    EDBOWebApiHelper.echo(
                        u'Виконання методу {0:s} завершено невдало, повторна спроба...[{1:d}]: {2:s}'.format(
                            url,
                            self._status,
                            str(exc)
                        ),
                        color='red'
                    )
                    # Retry if unsuccessful
                    continue

                # Execution done
                break
            else:
                EDBOWebApiHelper.echo(
                    u'Виконання методу {0:s} завершено невдало, повторна спроба... [{1:d}]'.format(
                        url,
                        self._status
                    ),
                    color='red'
                )
                # Retry if unsuccessful
                continue

#!/usr/bin/env python2
# Copyright (c) 2014 The Bitcoin Core developers
# Copyright (c) 2018 The Zencash developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
from test_framework.test_framework import BitcoinTestFramework
from test_framework.authproxy import JSONRPCException
from test_framework.util import assert_equal, initialize_chain_clean, \
    start_nodes, start_node, connect_nodes, stop_node, stop_nodes, \
    sync_blocks, sync_mempools, connect_nodes_bi, wait_bitcoinds, p2p_port, check_json_precision
import traceback
import os,sys
import shutil
from random import randint
from decimal import Decimal
import logging

import time
class blockdelay(BitcoinTestFramework):

    alert_filename = None

    def setup_chain(self, split=False):
        print("Initializing test directory "+self.options.tmpdir)
        initialize_chain_clean(self.options.tmpdir, 5)
        self.alert_filename = os.path.join(self.options.tmpdir, "alert.txt")
        with open(self.alert_filename, 'w'):
            pass  # Just open then close to create zero-length file

    def setup_network(self, split=False):
        self.nodes = []

        # -exportdir option means we must provide a valid path to the destination folder for wallet backups
        ed0 = "-exportdir=" + self.options.tmpdir + "/node0"
        ed1 = "-exportdir=" + self.options.tmpdir + "/node1"
        ed2 = "-exportdir=" + self.options.tmpdir + "/node2"
        ed3 = "-exportdir=" + self.options.tmpdir + "/node3"
        '''
        extra_args = [["-debug","-keypool=100", "-alertnotify=echo %s >> \"" + self.alert_filename + "\"", ed0],
            ["-debug", "-keypool=100", "-alertnotify=echo %s >> \"" + self.alert_filename + "\"", ed1],
            ["-debug", "-keypool=100", "-alertnotify=echo %s >> \"" + self.alert_filename + "\"", ed2],
            ["-debug", "-keypool=100", "-alertnotify=echo %s >> \"" + self.alert_filename + "\"", ed3]]
        '''

        #self.nodes = start_nodes(4, self.options.tmpdir, extra_args)
        self.nodes = start_nodes(4, self.options.tmpdir)


        if not split:
            connect_nodes_bi(self.nodes, 1, 2)
            sync_blocks(self.nodes[1:3])
            sync_mempools(self.nodes[1:3])

        connect_nodes_bi(self.nodes, 0, 1)
        connect_nodes_bi(self.nodes, 2, 3)
        self.is_network_split = split
        self.sync_all()

    def disconnect_nodes(self, from_connection, node_num):
        ip_port = "127.0.0.1:"+str(p2p_port(node_num))
        from_connection.disconnectnode(ip_port)
        # poll until version handshake complete to avoid race conditions
        # with transaction relaying
        while any(peer['version'] == 0 for peer in from_connection.getpeerinfo()):
            time.sleep(0.1)

    def split_network(self):
        # Split the network of four nodes into nodes 0/1 and 2/3.
        assert not self.is_network_split
        self.disconnect_nodes(self.nodes[1], 2)
        self.disconnect_nodes(self.nodes[2], 1)
        self.is_network_split = True


    def join_network(self):
        #Join the (previously split) network halves together.
        assert self.is_network_split
        connect_nodes_bi(self.nodes, 0, 3)
        connect_nodes_bi(self.nodes, 3, 0)
        #sync_blocks(self.nodes[0:3],1,True)
        #sync_mempools(self.nodes[1:3])
        self.sync_all()
        self.is_network_split = False

    def dump_ordered_tips(self, tip_list):
        sorted_x = sorted(tip_list, key=lambda k: k['status'])
        c = 0
        for y in sorted_x:
            if (c == 0):
                print y
            else:
                print " ",y
            c = 1

    def mark_logs(self, msg):
        for x in self.nodes:
            x.dbg_log(msg)

    def sync_longest_fork(self, wait=1, limit_loop=0):

        '''
           Wait until all the nodes have the same length for the longest fork.
        '''
        rpc_connections = self.nodes
        loop_num = 0
        max_len = 0
        max_len_tot = 0

        while True:
            max_len_tot = 0

            if limit_loop > 0:
                loop_num += 1
                if loop_num > limit_loop:
                    break

            for x in rpc_connections:

                max_len = 0
                y = x.getchaintips()

                for j in y:
                    h = j['height']
                    max_len = max(max_len, h)

                max_len_tot += max_len

            if max_len_tot == max_len*len(rpc_connections):
                break

            time.sleep(wait)


    def run_test(self):
        blocks = []
        self.bl_count = 0

        blocks.append(self.nodes[0].getblockhash(0))
        print("\n\nGenesis block is: " + blocks[0])
#        raw_input("press enter to start..")
        try:
            print "\nChecking finality of block (%d) [%s]" % (0, blocks[0])
            print "  Node0 has: %d" % self.nodes[0].getblockfinalityindex(blocks[0])
            print
        except JSONRPCException,e:
            errorString = e.error['message']
            print errorString
        '''
        '''

        print("\n\nGenerating initial blockchain 104 blocks")
        blocks.extend(self.nodes[0].generate(101)) # block height 1
        #print blocks[len(blocks)-1]
        self.sync_all()
        blocks.extend(self.nodes[1].generate(1)) # block height 2
        #print blocks[len(blocks)-1]
        self.sync_all()
        blocks.extend(self.nodes[2].generate(1)) # block height 3
        #print blocks[len(blocks)-1]
        self.sync_all()
        blocks.extend(self.nodes[3].generate(1)) # block height 4
        print "104) ", blocks[len(blocks)-1]
        self.sync_all()
        print("\nBlocks generated")

# Node(0): [0]->..->[104]
#   |
# Node(1): [0]->..->[104]
#   |
# Node(2): [0]->..->[104]
#   |
# Node(3): [0]->..->[104]

        print("\n\nSplit network")
        self.split_network()
        print("The network is split")

        print("\nNode0 sends 3.0 coins to Node1\n")
        # Node0 sends 3.0 coins to Node1
        self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 3.0)
        time.sleep(1)

        # Main chain
        print("\n\nGenerating 2 parallel chains with different length")

        bl = []
        print("\nGenerating 12 honest blocks")
        for i in range (0, 5):
            blocks.extend(self.nodes[0].generate(1)) # block height 105 -6 -7 -8 - 9 - 10
            bl.append(blocks[len(blocks)-1])
            print "%2d) %s" % ((i+105), bl[i])
        self.sync_all()
        for i in range (5, 12):
            blocks.extend(self.nodes[1].generate(1)) # block height 111-12-13-14-15-16
            bl.append(blocks[len(blocks)-1])
            print "%2d) %s" % ((i+105), bl[i])
        last_main_blockhash=blocks[len(blocks)-1]
        first_main_blockhash=bl[0]
        self.sync_all()
        print("Honest block generated")

        # check node1 balance has changed
        assert self.nodes[1].getbalance() == 3.0
        print "\nNode1 balance:", self.nodes[1].getbalance()

        assert self.nodes[0].getbestblockhash() == last_main_blockhash

#   Node(0): [0]->..->[104]->[105h]...->[116h]
#   /
# Node(1): [0]->..->[104]->[105h]...->[116h]
#
#
# Node(2): [0]->..->[104]
#   \
#   Node(3): [0]->..->[104]

        # Malicious nodes mining privately faster
        print("\nGenerating 13 malicious blocks")
        self.nodes[2].generate(10) # block height 105 - 6 -7 -8 -9-10 -11 12 13 14
        self.sync_all()
        self.nodes[3].generate(3) # block height 115 - 16 - 17
        self.sync_all()
        print("Malicious blocks generated")

        for i in range(0, 4):
            print "Node%d  ---" % i
            self.dump_ordered_tips(self.nodes[i].getchaintips())
            print "---"
#

#   Node(0): [0]->..->[104]->[105h]...->[116h]
#   /
# Node(1): [0]->..->[104]->[105h]...->[116h]
#
#
# Node(2): [0]->..->[104]->[105m]...->[117m]
#   \
#   Node(3): [0]->..->[104]->[105m]...->[117m]

        print("\n\nJoin network")
        self.mark_logs("Joining network")
#        raw_input("press enter to join the netorks..")
        self.join_network()
        self.sync_longest_fork(1, 10);

        print("\nNetwork joined")

        for i in range(0, 4):
            print "Node%d  ---" % i
            self.dump_ordered_tips(self.nodes[i].getchaintips())
            print "---"

        print("\nTesting if the current chain is still the honest chain")
        assert self.nodes[0].getbestblockhash() == last_main_blockhash
        print("Confirmed: malicious chain is under penalty")

        print "\nChecking finality of first honest block [%s]" %  first_main_blockhash
        for i in range(0, 4):
            try:
                print "  Node%d sees:"  % i
                print "      finality: %d" % self.nodes[i].getblockfinalityindex(first_main_blockhash)
                print
            except JSONRPCException,e:
                errorString = e.error['message']
                print "      " + errorString
                print

#   +-------Node(0): [0]->..->[104]->[105h]...->[116h]   <<==ACTIVE
#   |         /                  \
#   |        /                    +->[105m]...->[117m]
#   |       /
#   |     Node(1): [0]->..->[104]->[105h]...->[116h]   <<==ACTIVE
#   |                          \
#   |                           +->[105m]...->[117m]
#   |
#   |     Node(2): [0]->..->[104]->[105m]...->[117m]   <<==ACTIVE
#   |        \
#   |         \
#   |          \
#   +-------Node(3): [0]->..->[104]->[105m]...->[117m]   <<==ACTIVE
#                                \
#                                 +->[105h]...->[116h]

#        raw_input("press enter to generate 64 malicious blocks..")

        print("\nGenerating 64 malicious blocks")
        self.mark_logs("Generating 64 malicious blocks")
        self.nodes[3].generate(64)
        print("Malicious blocks generated")

        self.sync_longest_fork(1, 10);

        for i in range(0, 4):
            print "Node%d  ---" % i
            self.dump_ordered_tips(self.nodes[i].getchaintips())
            print "---"


        print("\nTesting if the current chain is still the honest chain")
        assert self.nodes[0].getbestblockhash() == last_main_blockhash
        print("Confirmed: malicious chain is under penalty")

        # check node1 balance has not changed
        assert self.nodes[1].getbalance() == 3.0
        print "\nNode1 balance is still the same:", self.nodes[1].getbalance()


#   +-------Node(0): [0]->..->[104]->[105h]...->[116h]                       <<==ACTIVE
#   |         /                  \
#   |        /                    +->[105m]...->[117m]->[118m]->..->[181m]
#   |       /
#   |     Node(1): [0]->..->[104]->[105h]...->[116h]                         <<==ACTIVE
#   |                          \
#   |                           +->[105m]...->[117m]->[118m]->..->[181m]
#   |
#   |     Node(2): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]     <<==ACTIVE
#   |        \
#   |         \
#   |          \
#   +-------Node(3): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]   <<==ACTIVE
#                                \
#                                 +->[105h]...->[116h]

#        raw_input("press enter to generate 65 honest blocks..")

        print("\nGenerating 65 more honest blocks")
        self.mark_logs("Generating 65 more honest blocks")
        self.nodes[0].generate(65)
        print("Honest blocks generated")
        sync_blocks(self.nodes, 1, True, 5)

#   +-------Node(0): [0]->..->[104]->[105h]...->[116h]->[117h]->..->[181h]   <<==ACTIVE
#   |         /                  \
#   |        /                    +->[105m]...->[117m]->[118m]->..->[181m]
#   |       /
#   |     Node(1): [0]->..->[104]->[105h]...->[116h]->[117h]->..->[181h]   <<==ACTIVE
#   |                          \
#   |                           +->[105m]...->[117m]->[118m]->..->[181m]
#   |
#   |     Node(2): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]   <<==ACTIVE
#   |        \
#   |         \
#   |          \
#   +-------Node(3): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]   <<==ACTIVE
#                                \
#                                 +->[105h]...->[116h]->[117h]->..->[181h]

        for i in range(0, 4):
            print "Node%d  ---" % i
            self.dump_ordered_tips(self.nodes[i].getchaintips())
            print "---"

#        raw_input("press enter to generate 1 more malicious blocks which will cause the attack to succeed..")

        print("\nGenerating 1 more malicious block")
        self.mark_logs("Generating 1 more malicious block ")
        last_malicious_blockhash=self.nodes[3].generate(1)[0]
        print("Malicious block generated:")
        print last_malicious_blockhash

        print("\n\nWaiting that all network nodes are synced with same chain length")
        sync_blocks(self.nodes, 1, True, 5)

        print("Network nodes are synced")

        for i in range(0, 4):
            print "Node%d  ---" % i
            self.dump_ordered_tips(self.nodes[i].getchaintips())
            print "---"

        print("\nTesting if all the nodes/chains have the same best tip")
        assert (self.nodes[0].getbestblockhash() == self.nodes[1].getbestblockhash()
                == self.nodes[2].getbestblockhash() == self.nodes[3].getbestblockhash())
        print("Confirmed: all the nodes have the same best tip")

        print("\nTesting if the current chain switched to the malicious chain")
        assert self.nodes[0].getbestblockhash() == last_malicious_blockhash
        print("Confirmed: malicious chain is the best chain")

#   +-------Node(0): [0]->..->[104]->[105h]...->[116h]->[117h]->..->[181h]
#   |         /                  \
#   |        /                    +->[105m]...->[117m]->[118m]->..->[181m]->[182m]  <<==ACTIVE!
#   |       /
#   |     Node(1): [0]->..->[104]->[105h]...->[116h]->[117h]->..->[181h]
#   |                          \
#   |                           +->[105m]...->[117m]->[118m]->..->[181m]->[182m]    <<==ACTIVE!
#   |
#   |     Node(2): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]->[182m]    <<==ACTIVE
#   |        \
#   |         \
#   |          \
#   +-------Node(3): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]->[182m]  <<==ACTIVE
#                                \
#                                 +->[105h]...->[116h]->[117h]->..->[181h]

        # check node1 balance has been erased
        assert self.nodes[1].getbalance() == 0.0
        print "\nNode1 balance has been erased!:", self.nodes[1].getbalance()

#        raw_input("press enter to connect a brand new node..")

        # Connect a fifth node from scratch and update
        s = "Connecting a new node"
        print(s)
        self.mark_logs(s)
        self.nodes.append(start_node(4, self.options.tmpdir))
        connect_nodes_bi(self.nodes, 4, 3)
        connect_nodes_bi(self.nodes, 3, 4)
        sync_blocks(self.nodes, 1, True, 5)

        for i in range(0, 5):
            print "Node%d  ---" % i
            self.dump_ordered_tips(self.nodes[i].getchaintips())
            print "---"

        print("\nNode0 generating 1 new blocks")
        self.mark_logs("Node0 generating 1 new blocks")
        self.nodes[0].generate(1)
        print("New blocks generated")
        sync_blocks(self.nodes, 1, True, 5)

        for i in range(0, 5):
            print "Node%d  ---" % i
            self.dump_ordered_tips(self.nodes[i].getchaintips())
            print "---"

        # check node1 balance has been restored
        assert self.nodes[1].getbalance() == 3.0
        print "Node1 balance has been restored: ", self.nodes[1].getbalance()

#   +-------Node(0): [0]->..->[104]->[105h]...->[116h]->[117h]->..->[181h]
#   |         /                  \
#   |        /                    +->[105m]...->[117m]->[118m]->..->[181m]->[182m]->[183m]  <<==ACTIVE!
#   |       /
#   |     Node(1): [0]->..->[104]->[105h]...->[116h]->[117h]->..->[181h]
#   |                          \
#   |                           +->[105m]...->[117m]->[118m]->..->[181m]->[182m]->[183m]    <<==ACTIVE!
#   |
#   |     Node(2): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]->[182m]->[183m]    <<==ACTIVE
#   |        \
#   |         \
#   |          \
#   +---------Node(3): [0]->..->[104]->[105m]...->[117m]->[118m]->..->[181m]->[182m]->[183m]  <<==ACTIVE
#               |                  \
#               |                   +->[105h]...->[116h]->[117h]->..->[181h]
#               |
#               |
#             Node(4): [0]->..- ..     ...     ...     ...     ...     ...      ... ->[183m]  <<==ACTIVE

if __name__ == '__main__':
    blockdelay().main()

# Opus/UrbanSim urban simulation software.
# Copyright (C) 2005-2009 University of Washington
# See opus_core/LICENSE 

from opus_core.tests import opus_unittest
from opus_core.datasets.dataset_pool import DatasetPool
from opus_core.storage_factory import StorageFactory
from numpy import array
from opus_core.tests.utils.variable_tester import VariableTester

class Tests(opus_unittest.OpusTestCase):
    def test_my_inputs(self):
        tester = VariableTester(
            __file__,
            package_order=['urbansim_parcel','urbansim'],
            test_data={
                "job":{
                    "job_id":array([1, 2, 3, 4, 5, 6, 7, 8]),
                    "building_id":array([1, 2, 2, 2, 3, 3, 4, 5]),
                    },
                "building":{
                    "building_id":array([1,2,3,4,5]),
                    "parcel_id":  array([1,1,2,3,4])
                    },
                "parcel":{
                     "parcel_id":array([1,2,3,4]),
                     "zone_id":  array([1,3,2,2]),
                     "parcel_sqft":array([0.1, 0.2, 0.4, 0.3]) * 43560.0,                     
                 },
                "zone":{
                     "zone_id":array([1,2,3]),
                 }             
                 
           }
        )
        
        should_be = array([1, 1, 1, 1, 2, 2, 3, 4])

        tester.test_is_close_for_variable_defined_by_this_module(self, should_be)
if __name__=='__main__':
    opus_unittest.main()

#!/usr/bin/env python

#  Copyright (c) 2014, Facebook, Inc.
#  All rights reserved.
#
#  This source code is licensed under the BSD-style license found in the
#  LICENSE file in the root directory of this source tree. An additional grant
#  of patent rights can be found in the PATENTS file in the same directory.

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import os
import shutil
import time
import unittest

# osquery-specific testing utils
import test_base
import utils

class AdditionalFeatureTests(test_base.ProcessGenerator, unittest.TestCase):
    def test_query_packs(self):
        query_pack_path = test_base.CONFIG_DIR + "/test_pack.conf"
        utils.write_config({
            "queries": {
                "simple_test": {
                    "query": "select * from time",
                    "interval": 60,
                },
                "simple_test2": {
                    "query": "select * from time",
                    "interval": 60,
                    "platform": "does_not_exist",
                }
            }
        }, path=query_pack_path)

        # Get a daemon process, loaded with the default test configuration.
        # We'll add a config override (overwrite) for the "packs" key.
        # THis will point a single pack at the config written above.
        daemon = self._run_daemon(overwrite={
            "packs": {
                "test_pack": query_pack_path
            }
        })
        self.assertTrue(daemon.isAlive())

        # Introspect into the daemon's query packs.
        client = test_base.EXClient(daemon.options["extensions_socket"])
        test_base.expectTrue(client.open)
        self.assertTrue(client.open())
        em = client.getEM()

        # Every query from the pack(s) is added to the packs table.
        result = em.query("select * from osquery_packs")
        self.assertEqual(len(result.response), 2)

        # Only the applicable queries are added to the schedule.
        # There will be len(pack_queries) - 1 since "simple_test2" is bound
        # to an unknown/non-existing platform.
        result = em.query("select * from osquery_schedule")
        self.assertEqual(len(result.response), 1)
        daemon.kill()

if __name__ == '__main__':
    module = test_base.Tester()

    # Find and import the thrift-generated python interface
    test_base.loadThriftFromBuild(test_base.ARGS.build)

    module.run()

import time

import gevent
from gevent import monkey
monkey.patch_all()

from util import RateLimit


# Time is around limit +/- 0.05 sec
def around(t, limit):
    return t >= limit - 0.05 and t <= limit + 0.05


class ExampleClass(object):
    def __init__(self):
        self.counted = 0
        self.last_called = None

    def count(self, back="counted"):
        self.counted += 1
        self.last_called = back
        return back


class TestRateLimit:
    def testCall(self):
        obj1 = ExampleClass()
        obj2 = ExampleClass()

        s = time.time()
        assert RateLimit.call("counting", allowed_again=0.1, func=obj1.count) == "counted"
        assert around(time.time() - s, 0.0)  # First allow to call instantly
        assert obj1.counted == 1

        # Call again
        assert not RateLimit.isAllowed("counting", 0.1)
        assert RateLimit.isAllowed("something else", 0.1)
        assert RateLimit.call("counting", allowed_again=0.1, func=obj1.count) == "counted"
        assert around(time.time() - s, 0.1)  # Delays second call within interval
        assert obj1.counted == 2

        # Call 3 times async
        s = time.time()
        assert obj2.counted == 0
        threads = [
            gevent.spawn(lambda: RateLimit.call("counting", allowed_again=0.1, func=obj2.count)),  # Instant
            gevent.spawn(lambda: RateLimit.call("counting", allowed_again=0.1, func=obj2.count)),  # 0.1s delay
            gevent.spawn(lambda: RateLimit.call("counting", allowed_again=0.1, func=obj2.count))   # 0.2s delay
        ]
        gevent.joinall(threads)
        assert [thread.value for thread in threads] == ["counted", "counted", "counted"]
        assert around(time.time() - s, 0.2)

        # No queue = instant again
        s = time.time()
        assert RateLimit.isAllowed("counting", 0.1)
        assert RateLimit.call("counting", allowed_again=0.1, func=obj2.count) == "counted"
        assert around(time.time() - s, 0.0)

        assert obj2.counted == 4

    def testCallAsync(self):
        obj1 = ExampleClass()
        obj2 = ExampleClass()

        s = time.time()
        RateLimit.callAsync("counting async", allowed_again=0.1, func=obj1.count, back="call #1").join()
        assert obj1.counted == 1  # First instant
        assert around(time.time() - s, 0.0)

        # After that the calls delayed
        s = time.time()
        t1 = RateLimit.callAsync("counting async", allowed_again=0.1, func=obj1.count, back="call #2")  # Dumped by the next call
        time.sleep(0.03)
        t2 = RateLimit.callAsync("counting async", allowed_again=0.1, func=obj1.count, back="call #3")  # Dumped by the next call
        time.sleep(0.03)
        t3 = RateLimit.callAsync("counting async", allowed_again=0.1, func=obj1.count, back="call #4")  # Will be called
        assert obj1.counted == 1  # Delay still in progress: Not called yet
        t3.join()
        assert t3.value == "call #4"
        assert around(time.time() - s, 0.1)

        # Only the last one called
        assert obj1.counted == 2
        assert obj1.last_called == "call #4"

        # Allowed again instantly
        assert RateLimit.isAllowed("counting async", 0.1)
        s = time.time()
        RateLimit.callAsync("counting async", allowed_again=0.1, func=obj1.count, back="call #5").join()
        assert obj1.counted == 3
        assert around(time.time() - s, 0.0)
        assert not RateLimit.isAllowed("counting async", 0.1)
        time.sleep(0.11)
        assert RateLimit.isAllowed("counting async", 0.1)

import os

from django.core.exceptions import SuspiciousOperation
from django.utils._os import safe_join

from django.db import connection

from django.core.files.storage import FileSystemStorage
from django.contrib.staticfiles.storage import StaticFilesStorage

__all__ = (
    'TenantStorageMixin',
    'TenantFileSystemStorage',
    'TenantStaticFilesStorage',
)


class TenantStorageMixin(object):
    """
    Mixin that can be combined with other Storage backends to colocate media
    for all tenants in distinct subdirectories.

    Using rewriting rules at the reverse proxy we can determine which content
    gets served up, while any code interactions will account for the multiple
    tenancy of the project.
    """
    def path(self, name):
        """
        Look for files in subdirectory of MEDIA_ROOT using the tenant's
        domain_url value as the specifier.
        """
        if name is None:
            name = ''
        try:
            location = safe_join(self.location, connection.tenant.domain_url)
        except AttributeError:
            location = self.location
        try:
            path = safe_join(location, name)
        except ValueError:
            raise SuspiciousOperation(
                "Attempted access to '%s' denied." % name)
        return os.path.normpath(path)


class TenantFileSystemStorage(TenantStorageMixin, FileSystemStorage):
    """
    Implementation that extends core Django's FileSystemStorage.
    """


class TenantStaticFilesStorage(TenantStorageMixin, StaticFilesStorage):
    """
    Implementation that extends core Django's StaticFilesStorage.
    """

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

from __future__ import print_function

# change those symbols to whatever you prefer
symbols = {'ahead of': '↑', 'behind': '↓', 'prehash':':'}

from subprocess import Popen, PIPE

import sys
gitsym = Popen(['git', 'symbolic-ref', 'HEAD'], stdout=PIPE, stderr=PIPE)
branch, error = gitsym.communicate()

error_string = error.decode('utf-8')

if 'fatal: Not a git repository' in error_string:
	sys.exit(0)

branch = branch.strip()[11:]

res, err = Popen(['git','diff','--name-status'], stdout=PIPE, stderr=PIPE).communicate()
err_string = err.decode('utf-8')
if 'fatal' in err_string:
	sys.exit(0)
changed_files = [namestat[0] for namestat in res.splitlines()]
staged_files = [namestat[0] for namestat in Popen(['git','diff', '--staged','--name-status'], stdout=PIPE).communicate()[0].splitlines()]
nb_changed = len(changed_files) - changed_files.count('U')
nb_U = staged_files.count('U')
nb_staged = len(staged_files) - nb_U
staged = str(nb_staged)
conflicts = str(nb_U)
changed = str(nb_changed)
nb_untracked = len(Popen(['git','ls-files','--others','--exclude-standard'],stdout=PIPE).communicate()[0].splitlines())
untracked = str(nb_untracked)
if not nb_changed and not nb_staged and not nb_U and not nb_untracked:
	clean = '1'
else:
	clean = '0'

remote = ''

if not branch: # not on any branch
	branch = symbols['prehash']+ Popen(['git','rev-parse','--short','HEAD'], stdout=PIPE).communicate()[0][:-1]
else:
	remote_name = Popen(['git','config','branch.%s.remote' % branch], stdout=PIPE).communicate()[0].strip()
	if remote_name:
		merge_name = Popen(['git','config','branch.%s.merge' % branch], stdout=PIPE).communicate()[0].strip()
		if remote_name == '.': # local
			remote_ref = merge_name
		else:
			remote_ref = 'refs/remotes/%s/%s' % (remote_name, merge_name[11:])
		revgit = Popen(['git', 'rev-list', '--left-right', '%s...HEAD' % remote_ref],stdout=PIPE, stderr=PIPE)
		revlist = revgit.communicate()[0]
		if revgit.poll(): # fallback to local
			revlist = Popen(['git', 'rev-list', '--left-right', '%s...HEAD' % merge_name],stdout=PIPE, stderr=PIPE).communicate()[0]
		behead = revlist.splitlines()
		ahead = len([x for x in behead if x[0]=='>'])
		behind = len(behead) - ahead
		if behind:
			remote += '%s%s' % (symbols['behind'], behind)
		if ahead:
			remote += '%s%s' % (symbols['ahead of'], ahead)

out = '\n'.join([
	str(branch),
	remote,
	staged,
	conflicts,
	changed,
	untracked,
	clean])
print(out)


#!/usr/bin/env python
# Author: Zion Orent <zorent@ics.com>
# Copyright (c) 2015 Intel Corporation.
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

from __future__ import print_function
import time, sys, atexit
from upm import pyupm_isd1820 as upmIsd1820

def main():
    # Instantiate a ISD1820 on digital pins 2 (play) and 3 (record)
    # This example was tested on the Grove Recorder.
    myRecorder = upmIsd1820.ISD1820(2, 3)

    doRecord = False

    if len(sys.argv) > 1:
        doRecord = True

    # This lets you run code on exit,
    # including functions from myRecorder
    def exitHandler():
        # turn off whatever we were doing.
        if (doRecord):
            myRecorder.record(False)
        else:
            myRecorder.play(False)
        print("Exiting")
        sys.exit(0)

    # Register exit handlers
    atexit.register(exitHandler)

    # if an argument was specified (any argument), go into record mode,
    # else playback a previously recorded sample

    print("Supply any argument to the command line to record.")
    print("Running this example without arguments will play back any ")
    print("previously recorded sound.")
    print("There is approximately 10 seconds of recording time.\n")

    # depending on what was selected, do it, and sleep for 15 seconds
    if (doRecord):
        myRecorder.record(True)
    else:
        myRecorder.play(True)

    # There are about 10 seconds of recording/playback time, so we will
    # sleep for a little extra time.
    print("Sleeping for 15 seconds...")
    time.sleep(15)

    # exitHandler runs automatically

if __name__ == '__main__':
    main()

from com.playonlinux.framework import SetupWizard, WineShortcut, Environment

import unittest, os
import com.playonlinux.core.python.JsonCodec as json

class TestCreateShortcut(unittest.TestCase):
    def testCreateShortcut(self):
        setupWizard = SetupWizard("Mock setup wizard")
        setupWizard.init()

        WineShortcut.wizard(setupWizard).withName("Shortcut name")\
            .withExecutableName("winecfg")\
            .withArguments(["argument 1", "argument 2"])\
            .withWineDebug("-all")\
            .withWorkingDirectory("Working directory")\
            .withWinePrefix("Wine prefix")\
            .create()

        shortcuts = Environment.getShortcutsPath()
        shortcut = os.path.join(shortcuts, "Shortcut name")

        shortcutFileContent = open(shortcut, "r").read()

        shortcutJson = json.loads(shortcutFileContent)

        self.assertEquals("com.playonlinux.library.shortcuts.WineShortcut", shortcutJson["@class"])
        self.assertEquals("-all", shortcutJson["wineDebug"])
        self.assertEquals("Wine prefix", shortcutJson["winePrefix"])
        self.assertEquals("Working directory", shortcutJson["workingDirectory"])
        self.assertEquals("winecfg", shortcutJson["executableName"])
        self.assertEquals("argument 1", shortcutJson["arguments"][0])
        self.assertEquals("argument 2", shortcutJson["arguments"][1])

        setupWizard.close()


from tests import mock
import time

from pyglet.media.threads import PlayerWorker


def test_worker_add_remove_players():
    worker = PlayerWorker()
    player1 = mock.MagicMock()
    player1.get_write_size.return_value = 0
    type(player1).min_buffer_size = mock.PropertyMock(return_value=512)
    player2 = mock.MagicMock()
    player2.get_write_size.return_value = 0
    type(player2).min_buffer_size = mock.PropertyMock(return_value=512)

    worker.start()
    try:
        worker.add(player1)
        worker.add(player2)
        worker.remove(player1)
        worker.remove(player2)
        worker.remove(player2)
    finally:
        worker.stop()


def test_worker_refill_player():
    worker = PlayerWorker()
    worker.start()

    try:
        player = mock.MagicMock()
        player.get_write_size.return_value = 1024
        type(player).min_buffer_size = mock.PropertyMock(return_value=512)
        worker.add(player)

        for _ in range(10):
            if player.get_write_size.called:
                break
            time.sleep(.1)

        worker.remove(player)
        player.refill.assert_called_with(1024)

    finally:
        worker.stop()


def test_worker_do_not_refill_player():
    worker = PlayerWorker()
    worker.start()

    try:
        player = mock.MagicMock()
        player.get_write_size.return_value = 104
        type(player).min_buffer_size = mock.PropertyMock(return_value=512)
        worker.add(player)

        for _ in range(10):
            if player.get_write_size.called:
                break
            time.sleep(.1)

        worker.remove(player)
        assert not player.refill.called

    finally:
        worker.stop()


def test_worker_refill_multiple_players_refill_multiple():
    worker = PlayerWorker()
    worker.start()

    try:
        player1 = mock.MagicMock()
        player1.get_write_size.return_value = 1024
        type(player1).min_buffer_size = mock.PropertyMock(return_value=512)
        worker.add(player1)

        player2 = mock.MagicMock()
        player2.get_write_size.return_value = 768
        type(player2).min_buffer_size = mock.PropertyMock(return_value=512)
        worker.add(player2)

        for _ in range(10):
            if player1.get_write_size.called and player2.get_write_size.called:
                break
            time.sleep(.1)

        player1.refill.assert_called_with(1024)
        player2.refill.assert_called_with(768)

    finally:
        worker.stop()


#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Getting Things GNOME! - a personal organizer for the GNOME desktop
# Copyright(c) 2008-2013 - Lionel Dricot & Bertrand Rousseau
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation, either version 3 of the License, or(at your option) any later
# version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program.  If not, see <http://www.gnu.org/licenses/>.
# -----------------------------------------------------------------------------

from distutils.core import setup
from glob import glob
from subprocess import call
import os
import sys

from GTG import info


def find_packages():
    """ Generate list of all packages """
    packages = []
    for package, __, files in os.walk('GTG'):
        # Package has to have init file
        if '__init__.py' not in files:
            continue
        # Convert filepath to package name
        package = package.replace(os.path.sep, '.')
        packages.append(package)
    return packages


def find_package_data():
    """ Generate list of data files within a package """
    packages = {
        package.replace('.', os.path.sep) for package in find_packages()}
    package_data = {}

    for folder, __, files in os.walk('GTG'):
        # Find package
        closest_package = folder
        while closest_package and closest_package not in packages:
            # Try one level up
            closest_package = os.path.dirname(closest_package)

        if not closest_package:
            continue

        allowed_extensions = [
            '', '.gtg-plugin', '.png', '.svg', '.ui', '.html', '.tex', '.txt']
        is_this_package = folder == closest_package
        if not is_this_package:
            allowed_extensions.append('.py')

        for filename in files:
            ext = os.path.splitext(filename)[-1]
            if ext not in allowed_extensions:
                continue

            # Find path relative to package
            filename = os.path.join(folder, filename)
            assert filename.startswith(closest_package)
            filename = filename[len(closest_package + os.path.sep):]

            # Assign data file to package name
            package_name = closest_package.replace(os.path.sep, '.')
            if package_name in package_data:
                package_data[package_name].append(filename)
            else:
                package_data[package_name] = [filename]

    return package_data


def compile_mo_files():
    """ Compile all .po files into .mo files """
    mo_files = []
    mo_dir = os.path.join('build', 'po')
    for po_file in glob('po/*.po'):
        lang = os.path.splitext(os.path.basename(po_file))[0]
        mo_file = os.path.join(mo_dir, lang, 'gtg.mo')
        target_dir = os.path.dirname(mo_file)
        if not os.path.isdir(target_dir):
            os.makedirs(target_dir)

        try:
            return_code = call(['msgfmt', '-o', mo_file, po_file])
        except OSError:
            sys.stderr.write(
                'Translation not available, please install gettext\n')
            break

        if return_code:
            raise Warning('Error when building locales')
            continue

        install_folder = os.path.join('share', 'locale', lang, 'LC_MESSAGES')
        mo_files.append((install_folder, [mo_file]))

    return mo_files


def find_icons(src_folder, dest_folder, allowed_extensions):
    """ Find all icons in the folder """
    data_list = []

    for folder, __, files in os.walk(src_folder):
        assert folder.startswith(src_folder)
        install_folder = dest_folder + folder[len(src_folder):]
        file_list = []
        for filename in files:
            ext = os.path.splitext(filename)[-1]
            if ext in allowed_extensions:
                filename = os.path.join(folder, filename)
                file_list.append(filename)

        if file_list:
            data_list.append((install_folder, file_list))

    return data_list


def find_user_help():
    """ Find all files for user help """
    help_files = []

    for folder, __, files in os.walk('docs/userdoc'):
        folders = folder.split(os.path.sep)[2:]
        if not folders:
            continue
        folders.insert(1, 'gtg')
        install_folder = os.path.join('share', 'help', *folders)

        help_files.append((
            install_folder,
            [os.path.join(folder, filename) for filename in files],
        ))

    return help_files


def find_data_files():
    """ Generate list of data files for installing in share folder """
    data_files = []

    # .mo files
    data_files.extend(compile_mo_files())

    # Icons
    data_files.extend(
        find_icons('data/icons', 'share/icons', ['.png', '.svg']))

    # User docs
    data_files.extend(find_user_help())

    # Generate man files and include them
    os.system('sphinx-build -b man docs/source build/docs')
    data_files.append(('share/man/man1', glob('build/docs/*.1')))

    # Misc files
    data_files.extend([
        ('share/applications', ['data/gtg.desktop']),
        ('share/appdata/', ['data/gtg.appdata.xml']),
        ('share/dbus-1/services', ['data/org.gnome.GTG.service']),
        ('share/gtg/', ['data/gtcli_bash_completion']),
    ])

    return data_files


setup(
    name='gtg',
    version=info.VERSION,
    url=info.URL,
    author='The GTG Team',
    author_email=info.EMAIL,
    description=info.SHORT_DESCRIPTION,
    packages=find_packages(),
    package_data=find_package_data(),
    scripts=['GTG/gtg', 'GTG/gtcli', 'GTG/gtg_new_task'],
    data_files=find_data_files(),
)

# -*- coding: utf-8 -*-
#
# This file is part of Glances.
#
# Copyright (C) 2015 Nicolargo <nicolas@nicolargo.com>
#
# Glances is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Glances is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

"""The stats manager."""

import collections
import os
import re
import sys
import threading

from glances.core.glances_globals import exports_path, plugins_path, sys_path
from glances.core.glances_logging import logger

# SNMP OID regexp pattern to short system name dict
oid_to_short_system_name = {'.*Linux.*': 'linux',
                            '.*Darwin.*': 'mac',
                            '.*BSD.*': 'bsd',
                            '.*Windows.*': 'windows',
                            '.*Cisco.*': 'cisco',
                            '.*VMware ESXi.*': 'esxi',
                            '.*NetApp.*': 'netapp'}


class GlancesStats(object):

    """This class stores, updates and gives stats."""

    def __init__(self, config=None, args=None):
        # Set the argument instance
        self.args = args

        # Set the config instance
        self.config = config

        # Init the plugin list dict
        self._plugins = collections.defaultdict(dict)
        # Load the plugins
        self.load_plugins(args=args)

        # Init the export modules list dict
        self._exports = collections.defaultdict(dict)
        # Load the plugins
        self.load_exports(args=args)

        # Load the limits
        self.load_limits(config)

    def __getattr__(self, item):
        """Overwrite the getattr method in case of attribute is not found.

        The goal is to dynamically generate the following methods:
        - getPlugname(): return Plugname stat in JSON format
        """
        # Check if the attribute starts with 'get'
        if item.startswith('get'):
            # Get the plugin name
            plugname = item[len('get'):].lower()
            # Get the plugin instance
            plugin = self._plugins[plugname]
            if hasattr(plugin, 'get_stats'):
                # The method get_stats exist, return it
                return getattr(plugin, 'get_stats')
            else:
                # The method get_stats is not found for the plugin
                raise AttributeError(item)
        else:
            # Default behavior
            raise AttributeError(item)

    def load_plugins(self, args=None):
        """Load all plugins in the 'plugins' folder."""
        header = "glances_"
        for item in os.listdir(plugins_path):
            if (item.startswith(header) and
                    item.endswith(".py") and
                    item != (header + "plugin.py")):
                # Import the plugin
                plugin = __import__(os.path.basename(item)[:-3])
                # Add the plugin to the dictionary
                # The key is the plugin name
                # for example, the file glances_xxx.py
                # generate self._plugins_list["xxx"] = ...
                plugin_name = os.path.basename(item)[len(header):-3].lower()
                if plugin_name == 'help':
                    self._plugins[plugin_name] = plugin.Plugin(args=args, config=self.config)
                else:
                    self._plugins[plugin_name] = plugin.Plugin(args=args)
        # Log plugins list
        logger.debug("Available plugins list: {0}".format(self.getAllPlugins()))

    def load_exports(self, args=None):
        """Load all exports module in the 'exports' folder."""
        if args is None:
            return False
        header = "glances_"
        # Transform the arguments list into a dict
        # The aim is to chec if the export module should be loaded
        args_var = vars(locals()['args'])
        for item in os.listdir(exports_path):
            export_name = os.path.basename(item)[len(header):-3].lower()
            if (item.startswith(header) and
                    item.endswith(".py") and
                    item != (header + "export.py") and
                    item != (header + "history.py") and
                    args_var['export_' + export_name] is not None and
                    args_var['export_' + export_name] is not False):
                # Import the export module
                export_module = __import__(os.path.basename(item)[:-3])
                # Add the export to the dictionary
                # The key is the module name
                # for example, the file glances_xxx.py
                # generate self._exports_list["xxx"] = ...
                self._exports[export_name] = export_module.Export(args=args, config=self.config)
        # Log plugins list
        logger.debug("Available exports modules list: {0}".format(self.getAllExports()))
        return True

    def getAllPlugins(self):
        """Return the plugins list."""
        return [p for p in self._plugins]

    def getAllExports(self):
        """Return the exports modules list."""
        return [p for p in self._exports]

    def load_limits(self, config=None):
        """Load the stats limits."""
        # For each plugins, call the init_limits method
        for p in self._plugins:
            # logger.debug("Load limits for %s" % p)
            self._plugins[p].load_limits(config)

    def update(self):
        """Wrapper method to update the stats."""
        # For standalone and server modes
        # For each plugins, call the update method
        for p in self._plugins:
            # logger.debug("Update %s stats" % p)
            self._plugins[p].update()

    def export(self, input_stats=None):
        """Export all the stats.

        Each export module is ran in a dedicated thread.
        """
        # threads = []
        input_stats = input_stats or {}

        for e in self._exports:
            logger.debug("Export stats using the %s module" % e)
            thread = threading.Thread(target=self._exports[e].update,
                                      args=(input_stats,))
            # threads.append(thread)
            thread.start()

    def getAll(self):
        """Return all the stats (list)."""
        return [self._plugins[p].get_raw() for p in self._plugins]

    def getAllAsDict(self):
        """Return all the stats (dict)."""
        # Python > 2.6
        # {p: self._plugins[p].get_raw() for p in self._plugins}
        ret = {}
        for p in self._plugins:
            ret[p] = self._plugins[p].get_raw()
        return ret

    def getAllLimits(self):
        """Return the plugins limits list."""
        return [self._plugins[p].limits for p in self._plugins]

    def getAllLimitsAsDict(self):
        """Return all the stats limits (dict)."""
        ret = {}
        for p in self._plugins:
            ret[p] = self._plugins[p].limits
        return ret

    def getAllViews(self):
        """Return the plugins views."""
        return [self._plugins[p].get_views() for p in self._plugins]

    def getAllViewsAsDict(self):
        """Return all the stats views (dict)."""
        ret = {}
        for p in self._plugins:
            ret[p] = self._plugins[p].get_views()
        return ret

    def get_plugin_list(self):
        """Return the plugin list."""
        return self._plugins

    def get_plugin(self, plugin_name):
        """Return the plugin name."""
        if plugin_name in self._plugins:
            return self._plugins[plugin_name]
        else:
            return None

    def end(self):
        """End of the Glances stats."""
        # Close the export module
        for e in self._exports:
            self._exports[e].exit()


class GlancesStatsServer(GlancesStats):

    """This class stores, updates and gives stats for the server."""

    def __init__(self, config=None):
        # Init the stats
        GlancesStats.__init__(self, config)

        # Init the all_stats dict used by the server
        # all_stats is a dict of dicts filled by the server
        self.all_stats = collections.defaultdict(dict)

    def update(self, input_stats=None):
        """Update the stats."""
        input_stats = input_stats or {}

        # Force update of all the stats
        GlancesStats.update(self)

        # Build all_stats variable (concatenation of all the stats)
        self.all_stats = self._set_stats(input_stats)

    def _set_stats(self, input_stats):
        """Set the stats to the input_stats one."""
        # Build the all_stats with the get_raw() method of the plugins
        ret = collections.defaultdict(dict)
        for p in self._plugins:
            ret[p] = self._plugins[p].get_raw()
        return ret

    def getAll(self):
        """Return the stats as a list."""
        return self.all_stats

    def getAllAsDict(self):
        """Return the stats as a dict."""
        # Python > 2.6
        # return {p: self.all_stats[p] for p in self._plugins}
        ret = {}
        for p in self._plugins:
            ret[p] = self.all_stats[p]
        return ret


class GlancesStatsClient(GlancesStats):

    """This class stores, updates and gives stats for the client."""

    def __init__(self, config=None, args=None):
        """Init the GlancesStatsClient class."""
        # Init the plugin list dict
        self._plugins = collections.defaultdict(dict)

        # Init the configuration
        self.config = config

        # Init the arguments
        self.args = args

        # Init the export modules list dict
        self._exports = collections.defaultdict(dict)
        # Load the plugins
        self.load_exports(args=args)

    def set_plugins(self, input_plugins):
        """Set the plugin list according to the Glances server."""
        header = "glances_"
        for item in input_plugins:
            # Import the plugin
            plugin = __import__(header + item)
            # Add the plugin to the dictionary
            # The key is the plugin name
            # for example, the file glances_xxx.py
            # generate self._plugins_list["xxx"] = ...
            logger.debug("Server uses {0} plugin".format(item))
            self._plugins[item] = plugin.Plugin()
        # Restoring system path
        sys.path = sys_path

    def update(self, input_stats):
        """Update all the stats."""
        # For Glances client mode
        for p in input_stats:
            # Update plugin stats with items sent by the server
            self._plugins[p].set_stats(input_stats[p])
            # Update the views for the updated stats
            self._plugins[p].update_views()


class GlancesStatsClientSNMP(GlancesStats):

    """This class stores, updates and gives stats for the SNMP client."""

    def __init__(self, config=None, args=None):
        # Init the plugin list dict
        self._plugins = collections.defaultdict(dict)

        # Init the configuration
        self.config = config

        # Init the arguments
        self.args = args

        # OS name is used because OID is differents between system
        self.os_name = None

        # Load plugins
        self.load_plugins(args=self.args)

        # Init the export modules list dict
        self._exports = collections.defaultdict(dict)
        # Load the plugins
        self.load_exports(args=args)

    def check_snmp(self):
        """Chek if SNMP is available on the server."""
        # Import the SNMP client class
        from glances.core.glances_snmp import GlancesSNMPClient

        # Create an instance of the SNMP client
        clientsnmp = GlancesSNMPClient(host=self.args.client,
                                       port=self.args.snmp_port,
                                       version=self.args.snmp_version,
                                       community=self.args.snmp_community,
                                       user=self.args.snmp_user,
                                       auth=self.args.snmp_auth)

        # If we cannot grab the hostname, then exit...
        ret = clientsnmp.get_by_oid("1.3.6.1.2.1.1.5.0") != {}
        if ret:
            # Get the OS name (need to grab the good OID...)
            oid_os_name = clientsnmp.get_by_oid("1.3.6.1.2.1.1.1.0")
            try:
                self.system_name = self.get_system_name(oid_os_name['1.3.6.1.2.1.1.1.0'])
                logger.info("SNMP system name detected: {0}".format(self.system_name))
            except KeyError:
                self.system_name = None
                logger.warning("Cannot detect SNMP system name")

        return ret

    def get_system_name(self, oid_system_name):
        """Get the short os name from the OS name OID string."""
        short_system_name = None

        if oid_system_name == '':
            return short_system_name

        # Find the short name in the oid_to_short_os_name dict
        try:
            iteritems = oid_to_short_system_name.iteritems()
        except AttributeError:
            # Correct issue #386
            iteritems = oid_to_short_system_name.items()
        for r, v in iteritems:
            if re.search(r, oid_system_name):
                short_system_name = v
                break

        return short_system_name

    def update(self):
        """Update the stats using SNMP."""
        # For each plugins, call the update method
        for p in self._plugins:
            # Set the input method to SNMP
            self._plugins[p].input_method = 'snmp'
            self._plugins[p].short_system_name = self.system_name
            try:
                self._plugins[p].update()
            except Exception as e:
                logger.error("Update {0} failed: {1}".format(p, e))

from django.core import signing
from django.http import HttpResponseBadRequest
from django.template import Origin, TemplateDoesNotExist
from django.template.engine import Engine
from django.template.response import SimpleTemplateResponse
from django.utils.safestring import mark_safe

from debug_toolbar.decorators import require_show_toolbar


@require_show_toolbar
def template_source(request):
    """
    Return the source of a template, syntax-highlighted by Pygments if
    it's available.
    """
    template_origin_name = request.GET.get("template_origin", None)
    if template_origin_name is None:
        return HttpResponseBadRequest('"template_origin" key is required')
    try:
        template_origin_name = signing.loads(template_origin_name)
    except Exception:
        return HttpResponseBadRequest('"template_origin" is invalid')
    template_name = request.GET.get("template", template_origin_name)

    final_loaders = []
    loaders = Engine.get_default().template_loaders

    for loader in loaders:
        if loader is not None:
            # When the loader has loaders associated with it,
            # append those loaders to the list. This occurs with
            # django.template.loaders.cached.Loader
            if hasattr(loader, "loaders"):
                final_loaders += loader.loaders
            else:
                final_loaders.append(loader)

    for loader in final_loaders:
        origin = Origin(template_origin_name)
        try:
            source = loader.get_contents(origin)
            break
        except TemplateDoesNotExist:
            pass
    else:
        source = "Template Does Not Exist: {}".format(template_origin_name)

    try:
        from pygments import highlight
        from pygments.lexers import HtmlDjangoLexer
        from pygments.formatters import HtmlFormatter

        source = highlight(source, HtmlDjangoLexer(), HtmlFormatter())
        source = mark_safe(source)
        source.pygmentized = True
    except ImportError:
        pass

    # Using SimpleTemplateResponse avoids running global context processors.
    return SimpleTemplateResponse(
        "debug_toolbar/panels/template_source.html",
        {"source": source, "template_name": template_name},
    )

# -*- coding: utf-8 -*-

from urllib import urlencode

from openerp.addons.web import http
from openerp.addons.web.http import request
from openerp.tools.mail import html_sanitize


class WebsiteEmailDesigner(http.Controller):

    @http.route('/website_mail/email_designer', type='http', auth="user", website=True)
    def index(self, model, res_id, template_model=None, **kw):
        if not model or not model in request.registry or not res_id:
            return request.redirect('/')
        model_fields = request.registry[model]._fields
        if 'body' not in model_fields and 'body_html' not in model_fields or \
           'email' not in model_fields and 'email_from' not in model_fields or \
           'name' not in model_fields and 'subject' not in model_fields:
            return request.redirect('/')
        res_id = int(res_id)
        obj_ids = request.registry[model].exists(request.cr, request.uid, [res_id], context=request.context)
        if not obj_ids:
            return request.redirect('/')
        # try to find fields to display / edit -> as t-field is static, we have to limit
        # the available fields to a given subset
        email_from_field = 'email'
        if 'email_from' in model_fields:
            email_from_field = 'email_from'
        subject_field = 'name'
        if 'subject' in model_fields:
            subject_field = 'subject'
        body_field = 'body'
        if 'body_html' in model_fields:
            body_field = 'body_html'

        cr, uid, context = request.cr, request.uid, request.context
        record = request.registry[model].browse(cr, uid, res_id, context=context)

        values = {
            'record': record,
            'templates': None,
            'model': model,
            'res_id': res_id,
            'email_from_field': email_from_field,
            'subject_field': subject_field,
            'body_field': body_field,
        }

        if getattr(record, body_field):
            values['mode'] = 'email_designer'
        else:
            if kw.get('enable_editor'):
                kw.pop('enable_editor')
                fragments = dict(model=model, res_id=res_id, **kw)
                if template_model:
                    fragments['template_model'] = template_model
                return request.redirect('/website_mail/email_designer?%s' % urlencode(fragments))
            values['mode'] = 'email_template'

        tmpl_obj = request.registry['email.template']
        if template_model:
            tids = tmpl_obj.search(cr, uid, [('model', '=', template_model)], context=context)
        else:
            tids = tmpl_obj.search(cr, uid, [], context=context)
        templates = tmpl_obj.browse(cr, uid, tids, context=context)
        values['templates'] = templates
        values['html_sanitize'] = html_sanitize

        return request.website.render("website_mail.email_designer", values)

    @http.route(['/website_mail/snippets'], type='json', auth="user", website=True)
    def snippets(self):
        return request.website._render('website_mail.email_designer_snippets')

from __future__ import unicode_literals

from calendar import monthrange
from datetime import date

from django.contrib.auth.decorators import login_required
from django.shortcuts import render
from django.views.generic.dates import ArchiveIndexView

from braces.views import LoginRequiredMixin

from budget.models import Budget
from transaction.models import Transaction


class SummaryArchiveView(LoginRequiredMixin, ArchiveIndexView):
    model = Transaction
    template_name = "summary/list.html"
    date_field = 'date'
    date_list_period = 'month'
    queryset = Transaction.active.all()
    allow_empty = True

summary_list = SummaryArchiveView.as_view()


@login_required
def summary_year(request, year):
    start_date = date(int(year), 1, 1)
    end_date = date(int(year), 12, 31)

    try:
        budget = Budget.active.most_current_for_date(end_date)
        estimates_and_transactions, actual_total = budget.estimates_and_transactions(start_date, end_date)

    except Budget.DoesNotExist:
        budget = None
        estimates_and_transactions = None
        actual_total = None

    context = {'start_date': start_date,
               'budget': budget,
               'actual_total': actual_total,
               'estimates_and_transactions': estimates_and_transactions}

    return render(request, 'summary/year.html', context)


@login_required
def summary_month(request, year, month):
    start_date = date(int(year), int(month), 1)
    _, last_day_of_month = monthrange(int(year), int(month))
    end_date = date(int(year), int(month), last_day_of_month)

    try:
        budget = Budget.active.most_current_for_date(end_date)
        estimates_and_transactions, actual_total = budget.estimates_and_transactions(start_date, end_date)

    except Budget.DoesNotExist:
        budget = None
        estimates_and_transactions = None
        actual_total = None

    context = {'start_date': start_date,
               'estimates_and_transactions': estimates_and_transactions,
               'actual_total': actual_total,
               'budget': budget}

    return render(request, 'summary/month.html', context)

"""Functions that handle alignment, padding, widths, etc."""

import re
import unicodedata

from terminaltables.terminal_io import terminal_size

RE_COLOR_ANSI = re.compile(r'(\033\[[\d;]+m)')


def visible_width(string):
    """Get the visible width of a unicode string.

    Some CJK unicode characters are more than one byte unlike ASCII and latin unicode characters.

    From: https://github.com/Robpol86/terminaltables/pull/9

    :param str string: String to measure.

    :return: String's width.
    :rtype: int
    """
    if '\033' in string:
        string = RE_COLOR_ANSI.sub('', string)

    # Convert to unicode.
    try:
        string = string.decode('u8')
    except (AttributeError, UnicodeEncodeError):
        pass

    width = 0
    for char in string:
        if unicodedata.east_asian_width(char) in ('F', 'W'):
            width += 2
        else:
            width += 1

    return width


def align_and_pad_cell(string, align, inner_dimensions, padding, space=' '):
    """Align a string horizontally and vertically. Also add additional padding in both dimensions.

    :param str string: Input string to operate on.
    :param tuple align: Tuple that contains one of left/center/right and/or top/middle/bottom.
    :param tuple inner_dimensions: Width and height ints to expand string to without padding.
    :param iter padding: Number of space chars for left, right, top, and bottom (4 ints).
    :param str space: Character to use as white space for resizing/padding (use single visible chars only).

    :return: Padded cell split into lines.
    :rtype: list
    """
    if not hasattr(string, 'splitlines'):
        string = str(string)

    # Handle trailing newlines or empty strings, str.splitlines() does not satisfy.
    lines = string.splitlines() or ['']
    if string.endswith('\n'):
        lines.append('')

    # Vertically align and pad.
    if 'bottom' in align:
        lines = ([''] * (inner_dimensions[1] - len(lines) + padding[2])) + lines + ([''] * padding[3])
    elif 'middle' in align:
        delta = inner_dimensions[1] - len(lines)
        lines = ([''] * (delta // 2 + delta % 2 + padding[2])) + lines + ([''] * (delta // 2 + padding[3]))
    else:
        lines = ([''] * padding[2]) + lines + ([''] * (inner_dimensions[1] - len(lines) + padding[3]))

    # Horizontally align and pad.
    for i, line in enumerate(lines):
        new_width = inner_dimensions[0] + len(line) - visible_width(line)
        if 'right' in align:
            lines[i] = line.rjust(padding[0] + new_width, space) + (space * padding[1])
        elif 'center' in align:
            lines[i] = (space * padding[0]) + line.center(new_width, space) + (space * padding[1])
        else:
            lines[i] = (space * padding[0]) + line.ljust(new_width + padding[1], space)

    return lines


def max_dimensions(table_data, padding_left=0, padding_right=0, padding_top=0, padding_bottom=0):
    """Get maximum widths of each column and maximum height of each row.

    :param iter table_data: List of list of strings (unmodified table data).
    :param int padding_left: Number of space chars on left side of cell.
    :param int padding_right: Number of space chars on right side of cell.
    :param int padding_top: Number of empty lines on top side of cell.
    :param int padding_bottom: Number of empty lines on bottom side of cell.

    :return: 4-item tuple of n-item lists. Inner column widths and row heights, outer column widths and row heights.
    :rtype: tuple
    """
    inner_widths = [0] * (max(len(r) for r in table_data) if table_data else 0)
    inner_heights = [0] * len(table_data)

    # Find max width and heights.
    for j, row in enumerate(table_data):
        for i, cell in enumerate(row):
            if not hasattr(cell, 'count') or not hasattr(cell, 'splitlines'):
                cell = str(cell)
            if not cell:
                continue
            inner_heights[j] = max(inner_heights[j], cell.count('\n') + 1)
            inner_widths[i] = max(inner_widths[i], *[visible_width(l) for l in cell.splitlines()])

    # Calculate with padding.
    outer_widths = [padding_left + i + padding_right for i in inner_widths]
    outer_heights = [padding_top + i + padding_bottom for i in inner_heights]

    return inner_widths, inner_heights, outer_widths, outer_heights


def column_max_width(inner_widths, column_number, outer_border, inner_border, padding):
    """Determine the maximum width of a column based on the current terminal width.

    :param iter inner_widths: List of widths (no padding) for each column.
    :param int column_number: The column number to query.
    :param int outer_border: Sum of left and right outer border visible widths.
    :param int inner_border: Visible width of the inner border character.
    :param int padding: Total padding per cell (left + right padding).

    :return: The maximum width the column can be without causing line wrapping.
    """
    column_count = len(inner_widths)
    terminal_width = terminal_size()[0]

    # Count how much space padding, outer, and inner borders take up.
    non_data_space = outer_border
    non_data_space += inner_border * (column_count - 1)
    non_data_space += column_count * padding

    # Exclude selected column's width.
    data_space = sum(inner_widths) - inner_widths[column_number]

    return terminal_width - data_space - non_data_space


def table_width(outer_widths, outer_border, inner_border):
    """Determine the width of the entire table including borders and padding.

    :param iter outer_widths: List of widths (with padding) for each column.
    :param int outer_border: Sum of left and right outer border visible widths.
    :param int inner_border: Visible width of the inner border character.

    :return: The width of the table.
    :rtype: int
    """
    column_count = len(outer_widths)

    # Count how much space outer and inner borders take up.
    non_data_space = outer_border
    if column_count:
        non_data_space += inner_border * (column_count - 1)

    # Space of all columns and their padding.
    data_space = sum(outer_widths)
    return data_space + non_data_space

# coding: utf-8
from flask.ext.mail import Mail

from quokka.core.db import db
from quokka.core.cache import cache
from quokka.core.admin import configure_admin

from . import (generic, babel, blueprints, error_handlers, context_processors,
               template_filters, before_request, views, themes, fixtures,
               oauthlib, weasyprint, security)


def configure_extensions(app, admin):
    cache.init_app(app)
    babel.configure(app)
    generic.configure(app)
    Mail(app)
    error_handlers.configure(app)
    db.init_app(app)

    themes.configure(app, db)  # Themes should be configured after db

    context_processors.configure(app)
    template_filters.configure(app)

    security.configure(app, db)

    fixtures.configure(app, db)
    blueprints.load_from_packages(app)
    blueprints.load_from_folder(app)

    # enable .pdf support for posts
    weasyprint.configure(app)

    configure_admin(app, admin)

    if app.config.get('DEBUG_TOOLBAR_ENABLED'):
        try:
            from flask_debugtoolbar import DebugToolbarExtension
            DebugToolbarExtension(app)
        except:
            pass

    before_request.configure(app)
    views.configure(app)

    oauthlib.configure(app)

    if app.config.get('SENTRY_ENABLED', False):
        from .sentry import configure
        configure(app)

    return app


def configure_extensions_min(app, admin):
    db.init_app(app)
    security.init_app(app, db)
    return app

# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""A more advanced example, of building an RNN-based time series model."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import functools
from os import path
import tempfile

import numpy
import tensorflow as tf

from tensorflow.contrib.timeseries.python.timeseries import estimators as ts_estimators
from tensorflow.contrib.timeseries.python.timeseries import model as ts_model
from tensorflow.contrib.timeseries.python.timeseries import state_management

try:
  import matplotlib  # pylint: disable=g-import-not-at-top
  matplotlib.use("TkAgg")  # Need Tk for interactive plots.
  from matplotlib import pyplot  # pylint: disable=g-import-not-at-top
  HAS_MATPLOTLIB = True
except ImportError:
  # Plotting requires matplotlib, but the unit test running this code may
  # execute in an environment without it (i.e. matplotlib is not a build
  # dependency). We'd still like to test the TensorFlow-dependent parts of this
  # example.
  HAS_MATPLOTLIB = False

_MODULE_PATH = path.dirname(__file__)
_DATA_FILE = path.join(_MODULE_PATH, "data/multivariate_periods.csv")


class _LSTMModel(ts_model.SequentialTimeSeriesModel):
  """A time series model-building example using an RNNCell."""

  def __init__(self, num_units, num_features, exogenous_feature_columns=None,
               dtype=tf.float32):
    """Initialize/configure the model object.

    Note that we do not start graph building here. Rather, this object is a
    configurable factory for TensorFlow graphs which are run by an Estimator.

    Args:
      num_units: The number of units in the model's LSTMCell.
      num_features: The dimensionality of the time series (features per
        timestep).
      exogenous_feature_columns: A list of `tf.feature_column`s representing
          features which are inputs to the model but are not predicted by
          it. These must then be present for training, evaluation, and
          prediction.
      dtype: The floating point data type to use.
    """
    super(_LSTMModel, self).__init__(
        # Pre-register the metrics we'll be outputting (just a mean here).
        train_output_names=["mean"],
        predict_output_names=["mean"],
        num_features=num_features,
        exogenous_feature_columns=exogenous_feature_columns,
        dtype=dtype)
    self._num_units = num_units
    # Filled in by initialize_graph()
    self._lstm_cell = None
    self._lstm_cell_run = None
    self._predict_from_lstm_output = None

  def initialize_graph(self, input_statistics=None):
    """Save templates for components, which can then be used repeatedly.

    This method is called every time a new graph is created. It's safe to start
    adding ops to the current default graph here, but the graph should be
    constructed from scratch.

    Args:
      input_statistics: A math_utils.InputStatistics object.
    """
    super(_LSTMModel, self).initialize_graph(input_statistics=input_statistics)
    with tf.variable_scope("", use_resource=True):
      # Use ResourceVariables to avoid race conditions.
      self._lstm_cell = tf.nn.rnn_cell.LSTMCell(num_units=self._num_units)
      # Create templates so we don't have to worry about variable reuse.
      self._lstm_cell_run = tf.make_template(
          name_="lstm_cell",
          func_=self._lstm_cell,
          create_scope_now_=True)
      # Transforms LSTM output into mean predictions.
      self._predict_from_lstm_output = tf.make_template(
          name_="predict_from_lstm_output",
          func_=functools.partial(tf.layers.dense, units=self.num_features),
          create_scope_now_=True)

  def get_start_state(self):
    """Return initial state for the time series model."""
    return (
        # Keeps track of the time associated with this state for error checking.
        tf.zeros([], dtype=tf.int64),
        # The previous observation or prediction.
        tf.zeros([self.num_features], dtype=self.dtype),
        # The most recently seen exogenous features.
        tf.zeros(self._get_exogenous_embedding_shape(), dtype=self.dtype),
        # The state of the RNNCell (batch dimension removed since this parent
        # class will broadcast).
        [tf.squeeze(state_element, axis=0)
         for state_element
         in self._lstm_cell.zero_state(batch_size=1, dtype=self.dtype)])

  def _filtering_step(self, current_times, current_values, state, predictions):
    """Update model state based on observations.

    Note that we don't do much here aside from computing a loss. In this case
    it's easier to update the RNN state in _prediction_step, since that covers
    running the RNN both on observations (from this method) and our own
    predictions. This distinction can be important for probabilistic models,
    where repeatedly predicting without filtering should lead to low-confidence
    predictions.

    Args:
      current_times: A [batch size] integer Tensor.
      current_values: A [batch size, self.num_features] floating point Tensor
        with new observations.
      state: The model's state tuple.
      predictions: The output of the previous `_prediction_step`.
    Returns:
      A tuple of new state and a predictions dictionary updated to include a
      loss (note that we could also return other measures of goodness of fit,
      although only "loss" will be optimized).
    """
    state_from_time, prediction, exogenous, lstm_state = state
    with tf.control_dependencies(
        [tf.assert_equal(current_times, state_from_time)]):
      # Subtract the mean and divide by the variance of the series.  Slightly
      # more efficient if done for a whole window (using the normalize_features
      # argument to SequentialTimeSeriesModel).
      transformed_values = self._scale_data(current_values)
      # Use mean squared error across features for the loss.
      predictions["loss"] = tf.reduce_mean(
          (prediction - transformed_values) ** 2, axis=-1)
      # Keep track of the new observation in model state. It won't be run
      # through the LSTM until the next _imputation_step.
      new_state_tuple = (current_times, transformed_values,
                         exogenous, lstm_state)
    return (new_state_tuple, predictions)

  def _prediction_step(self, current_times, state):
    """Advance the RNN state using a previous observation or prediction."""
    _, previous_observation_or_prediction, exogenous, lstm_state = state
    # Update LSTM state based on the most recent exogenous and endogenous
    # features.
    inputs = tf.concat([previous_observation_or_prediction, exogenous],
                       axis=-1)
    lstm_output, new_lstm_state = self._lstm_cell_run(
        inputs=inputs, state=lstm_state)
    next_prediction = self._predict_from_lstm_output(lstm_output)
    new_state_tuple = (current_times, next_prediction,
                       exogenous, new_lstm_state)
    return new_state_tuple, {"mean": self._scale_back_data(next_prediction)}

  def _imputation_step(self, current_times, state):
    """Advance model state across a gap."""
    # Does not do anything special if we're jumping across a gap. More advanced
    # models, especially probabilistic ones, would want a special case that
    # depends on the gap size.
    return state

  def _exogenous_input_step(
      self, current_times, current_exogenous_regressors, state):
    """Save exogenous regressors in model state for use in _prediction_step."""
    state_from_time, prediction, _, lstm_state = state
    return (state_from_time, prediction,
            current_exogenous_regressors, lstm_state)


def train_and_predict(
    csv_file_name=_DATA_FILE, training_steps=200, estimator_config=None,
    export_directory=None):
  """Train and predict using a custom time series model."""
  # Construct an Estimator from our LSTM model.
  categorical_column = tf.feature_column.categorical_column_with_hash_bucket(
      key="categorical_exogenous_feature", hash_bucket_size=16)
  exogenous_feature_columns = [
      # Exogenous features are not part of the loss, but can inform
      # predictions. In this example the features have no extra information, but
      # are included as an API example.
      tf.feature_column.numeric_column(
          "2d_exogenous_feature", shape=(2,)),
      tf.feature_column.embedding_column(
          categorical_column=categorical_column, dimension=10)]
  estimator = ts_estimators.TimeSeriesRegressor(
      model=_LSTMModel(
          num_features=5,
          num_units=128,
          exogenous_feature_columns=exogenous_feature_columns),
      optimizer=tf.compat.v1.train.AdamOptimizer(0.001),
      config=estimator_config,
      # Set state to be saved across windows.
      state_manager=state_management.ChainingStateManager())
  reader = tf.contrib.timeseries.CSVReader(
      csv_file_name,
      column_names=((tf.contrib.timeseries.TrainEvalFeatures.TIMES,)
                    + (tf.contrib.timeseries.TrainEvalFeatures.VALUES,) * 5
                    + ("2d_exogenous_feature",) * 2
                    + ("categorical_exogenous_feature",)),
      # Data types other than for `times` need to be specified if they aren't
      # float32. In this case one of our exogenous features has string dtype.
      column_dtypes=((tf.int64,) + (tf.float32,) * 7 + (tf.string,)))
  train_input_fn = tf.contrib.timeseries.RandomWindowInputFn(
      reader, batch_size=4, window_size=32)
  estimator.train(input_fn=train_input_fn, steps=training_steps)
  evaluation_input_fn = tf.contrib.timeseries.WholeDatasetInputFn(reader)
  evaluation = estimator.evaluate(input_fn=evaluation_input_fn, steps=1)
  # Predict starting after the evaluation
  predict_exogenous_features = {
      "2d_exogenous_feature": numpy.concatenate(
          [numpy.ones([1, 100, 1]), numpy.zeros([1, 100, 1])],
          axis=-1),
      "categorical_exogenous_feature": numpy.array(
          ["strkey"] * 100)[None, :, None]}
  (predictions,) = tuple(estimator.predict(
      input_fn=tf.contrib.timeseries.predict_continuation_input_fn(
          evaluation, steps=100,
          exogenous_features=predict_exogenous_features)))
  times = evaluation["times"][0]
  observed = evaluation["observed"][0, :, :]
  predicted_mean = numpy.squeeze(numpy.concatenate(
      [evaluation["mean"][0], predictions["mean"]], axis=0))
  all_times = numpy.concatenate([times, predictions["times"]], axis=0)

  # Export the model in SavedModel format. We include a bit of extra boilerplate
  # for "cold starting" as if we didn't have any state from the Estimator, which
  # is the case when serving from a SavedModel. If Estimator output is
  # available, the result of "Estimator.evaluate" can be passed directly to
  # `tf.contrib.timeseries.saved_model_utils.predict_continuation` as the
  # `continue_from` argument.
  with tf.Graph().as_default():
    filter_feature_tensors, _ = evaluation_input_fn()
    with tf.train.MonitoredSession() as session:
      # Fetch the series to "warm up" our state, which will allow us to make
      # predictions for its future values. This is just a dictionary of times,
      # values, and exogenous features mapping to numpy arrays. The use of an
      # input_fn is just a convenience for the example; they can also be
      # specified manually.
      filter_features = session.run(filter_feature_tensors)
  if export_directory is None:
    export_directory = tempfile.mkdtemp()
  input_receiver_fn = estimator.build_raw_serving_input_receiver_fn()
  export_location = estimator.export_saved_model(export_directory,
                                                 input_receiver_fn)
  # Warm up and predict using the SavedModel
  with tf.Graph().as_default():
    with tf.compat.v1.Session() as session:
      signatures = tf.saved_model.loader.load(
          session, [tf.saved_model.tag_constants.SERVING], export_location)
      state = tf.contrib.timeseries.saved_model_utils.cold_start_filter(
          signatures=signatures, session=session, features=filter_features)
      saved_model_output = (
          tf.contrib.timeseries.saved_model_utils.predict_continuation(
              continue_from=state, signatures=signatures,
              session=session, steps=100,
              exogenous_features=predict_exogenous_features))
      # The exported model gives the same results as the Estimator.predict()
      # call above.
      numpy.testing.assert_allclose(
          predictions["mean"],
          numpy.squeeze(saved_model_output["mean"], axis=0))
  return times, observed, all_times, predicted_mean


def main(unused_argv):
  if not HAS_MATPLOTLIB:
    raise ImportError(
        "Please install matplotlib to generate a plot from this example.")
  (observed_times, observations,
   all_times, predictions) = train_and_predict()
  pyplot.axvline(99, linestyle="dotted")
  observed_lines = pyplot.plot(
      observed_times, observations, label="Observed", color="k")
  predicted_lines = pyplot.plot(
      all_times, predictions, label="Predicted", color="b")
  pyplot.legend(handles=[observed_lines[0], predicted_lines[0]],
                loc="upper left")
  pyplot.show()


if __name__ == "__main__":
  tf.compat.v1.app.run(main=main)

#!/usr/bin/env python

"""

Goes through locale files and gives a breakdown of percentage
translated by app for each locale.

Requires:

* polib

For usage help, type::

   $ python l10n_completion.py --help

"""

import json
import os
import sys
import time
from optparse import OptionParser

import polib


USAGE = 'usage: %prog [OPTIONS] LOCALES-DIR FULL-OUTPUT-FILE SUMMARY-OUTPUT-FILE'


def get_language(fn):
    """Given a filename, returns the locale it applies to"""
    # FIXME - this expects the fn to be '.../XX/LC_MESSAGES/messages.po'
    return fn.split(os.sep)[-3]


def get_locale_files(localedir):
    """Given a locale dir, returns a list of all .po files in that tree"""
    po_files = []
    for root, dirs, files in os.walk(localedir):
        po_files.extend(
            [os.path.join(root, fn) for fn in files
             if fn.endswith('.po')])

    return po_files


def get_completion_data_for_file(fn):
    """Parses .po file and returns completion data for that .po file

    :returns: dict with keys total, translated and percent

    """
    app_to_translations = {}

    lang = get_language(fn)

    try:
        pofile = polib.pofile(fn)
    except IOError as ioe:
        print 'Error opening file: {fn}'.format(fn=fn)
        print ioe.message
        return 1

    for poentry in pofile:
        if poentry.obsolete:
            continue

        for occ in poentry.occurrences:
            path = occ[0].split(os.sep)
            if path[0] == 'kitsune':
                path = path[1]
            else:
                path = 'vendor/' + path[2]
            app_to_translations.setdefault(
                path, []).append(poentry.translated())

    all_total = 0
    all_translated = 0

    data = {}
    for app, tr_list in app_to_translations.items():
        total = len(tr_list)
        translated = len([tr for tr in tr_list if tr])

        data[app] = {
            'total': total,
            'translated': translated,
        }

        all_total += total
        all_translated += translated

    return {
        lang: {
            'total': all_total,
            'translated': all_translated,
            'apps': data
        }
    }


def merge_trees(data, new_data):
    """Merges values from second tree into the first

    This takes care to add values of the same key where appropriate.

    """
    for key, val in new_data.items():
        if isinstance(val, dict):
            if key not in data:
                data[key] = new_data[key]
            else:
                merge_trees(data[key], new_data[key])

        else:
            if key not in data:
                data[key] = val
            else:
                data[key] = data[key] + val


def calculate_percents(data):
    """Traverses a tree and calculates percents at appropriate levels"""
    # calculate the percent for this node if appropriate
    if 'translated' in data and 'total' in data:
        total = float(data['total'])
        translated = float(data['translated'])
        data['percent'] = int(translated / total * 100)

    # traverse the tree to calculate additional percents
    for key, val in data.items():
        if isinstance(val, dict):
            calculate_percents(val)


def get_completion_data(locale_files):
    """Given a list of .po files, returns a dict of all completion data

    :returns: dict: locale -> completion data

    """
    data = {}

    for fn in locale_files:
        new_data = get_completion_data_for_file(fn)
        merge_trees(data, new_data)

    calculate_percents(data)

    return data


def main(argv):
    parser = OptionParser(usage=USAGE)
    parser.add_option(
        '--truncate',
        action='store', type='int', dest='truncate', default=0)

    (options, args) = parser.parse_args(argv)

    if len(args) != 3:
        parser.error('Incorrect number of args.')
        return 1

    locales_dir = args[0]
    full_file = args[1]
    summary_file = args[2]

    # Get list of locales dirs
    locale_files = get_locale_files(locales_dir)

    # Generate completion data
    new_data = [
        {
            'created': time.time(),
            'locales': get_completion_data(locale_files)
        }
    ]
    data = new_data

    if os.path.exists(full_file):
        with open(full_file, 'rb') as fp:
            old_data = json.load(fp)

        old_data.append(new_data[0])
        data = old_data

    if options.truncate and len(data) > options.truncate:
        data = data[len(data) - options.truncate:]

    with open(full_file, 'wb') as fp:
        json.dump(data, fp)

    # Remove all the apps data for the summary file.
    for locale in new_data[0]['locales'].values():
        locale.pop('apps', None)

    # The summary file gets no historic data. Sorry.
    with open(summary_file, 'wb') as fp:
        json.dump(new_data[0], fp)


if __name__ == '__main__':
    sys.exit(main(sys.argv[1:]))

#!/usr/bin/python
# (c) 2018, NetApp, Inc
# GNU General Public License v3.0+ (see COPYING or
# https://www.gnu.org/licenses/gpl-3.0.txt)

'''
Element Software Node Drives
'''
from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'certified'}


DOCUMENTATION = '''

module: na_elementsw_drive

short_description: NetApp Element Software Manage Node Drives
extends_documentation_fragment:
    - netapp.solidfire
version_added: '2.7'
author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
description:
    - Add, Erase or Remove drive for nodes on Element Software Cluster.

options:
    drive_id:
        description:
        - Drive ID or Serial Name of Node drive.
        - If not specified, add and remove action will be performed on all drives of node_id

    state:
        description:
        - Element SW Storage Drive operation state.
        - present - To add drive of node to participate in cluster data storage.
        - absent  - To remove the drive from being part of active cluster.
        - clean   - Clean-up any residual data persistent on a *removed* drive in a secured method.
        choices: ['present', 'absent', 'clean']
        default: 'present'

    node_id:
        description:
        - ID or Name of cluster node.
        required: true

    force_during_upgrade:
        description:
        - Flag to force drive operation during upgrade.
        type: 'bool'

    force_during_bin_sync:
        description:
        - Flag to force during a bin sync operation.
        type: 'bool'
'''

EXAMPLES = """
   - name: Add drive with status available to cluster
     tags:
     - elementsw_add_drive
     na_element_drive:
       hostname: "{{ elementsw_hostname }}"
       username: "{{ elementsw_username }}"
       password: "{{ elementsw_password }}"
       state: present
       drive_id: scsi-SATA_SAMSUNG_MZ7LM48S2UJNX0J3221807
       force_during_upgrade: false
       force_during_bin_sync: false
       node_id: sf4805-meg-03

   - name: Remove active drive from cluster
     tags:
     - elementsw_remove_drive
     na_element_drive:
       hostname: "{{ elementsw_hostname }}"
       username: "{{ elementsw_username }}"
       password: "{{ elementsw_password }}"
       state: absent
       force_during_upgrade: false
       node_id: sf4805-meg-03
       drive_id: scsi-SATA_SAMSUNG_MZ7LM48S2UJNX0J321208

   - name: Secure Erase drive
     tags:
     - elemensw_clean_drive
     na_elementsw_drive:
       hostname: "{{ elementsw_hostname }}"
       username: "{{ elementsw_username }}"
       password: "{{ elementsw_password }}"
       state: clean
       drive_id: scsi-SATA_SAMSUNG_MZ7LM48S2UJNX0J432109
       node_id: sf4805-meg-03

   - name: Add all the drives of a node to cluster
     tags:
     - elementsw_add_node
     na_elementsw_drive:
       hostname: "{{ elementsw_hostname }}"
       username: "{{ elementsw_username }}"
       password: "{{ elementsw_password }}"
       state: present
       force_during_upgrade: false
       force_during_bin_sync: false
       node_id: sf4805-meg-03

"""


RETURN = """

msg:
    description: Success message
    returned: success
    type: string

"""
import traceback

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils._text import to_native
import ansible.module_utils.netapp as netapp_utils

HAS_SF_SDK = netapp_utils.has_sf_sdk()


class ElementSWDrive(object):
    """
    Element Software Storage Drive operations
    """

    def __init__(self):
        self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
        self.argument_spec.update(dict(
            state=dict(required=False, choices=['present', 'absent', 'clean'], default='present'),
            drive_id=dict(required=False, type='str'),
            node_id=dict(required=True, type='str'),
            force_during_upgrade=dict(required=False, type='bool'),
            force_during_bin_sync=dict(required=False, type='bool')
        ))

        self.module = AnsibleModule(
            argument_spec=self.argument_spec,
            supports_check_mode=True
        )

        input_params = self.module.params

        self.state = input_params['state']
        self.drive_id = input_params['drive_id']
        self.node_id = input_params['node_id']
        self.force_during_upgrade = input_params['force_during_upgrade']
        self.force_during_bin_sync = input_params['force_during_bin_sync']

        if HAS_SF_SDK is False:
            self.module.fail_json(
                msg="Unable to import the SolidFire Python SDK")
        else:
            self.sfe = netapp_utils.create_sf_connection(module=self.module)

    def get_node_id(self):
        """
            Get Node ID
            :description: Find and retrieve node_id from the active cluster

            :return: node_id (None if not found)
            :rtype: node_id
        """
        if self.node_id is not None:
            list_nodes = self.sfe.list_active_nodes()
            for current_node in list_nodes.nodes:
                if self.node_id == str(current_node.node_id):
                    return current_node.node_id
                elif current_node.name == self.node_id:
                    self.node_id = current_node.node_id
                    return current_node.node_id
        self.node_id = None
        return self.node_id

    def get_drives_listby_status(self):
        """
            Capture list of drives based on status for a given node_id
            :description: Capture list of active, failed and available drives from a given node_id

            :return: None
        """
        if self.node_id is not None:
            list_drives = self.sfe.list_drives()
            for drive in list_drives.drives:
                if drive.node_id == self.node_id:
                    if drive.status in ['active', 'failed']:
                        self.active_drives[drive.serial] = drive.drive_id
                    elif drive.status == "available":
                        self.available_drives[drive.serial] = drive.drive_id
        return None

    def get_active_drives(self, drive_id=None):
        """
        return a list of active drives
        if drive_id is specified, only [] or [drive_id] is returned
        else all available drives for this node are returned
        """
        action_list = list()
        if self.drive_id is not None:
            if self.drive_id in self.active_drives.values():
                action_list.append(int(self.drive_id))
            if self.drive_id in self.active_drives:
                action_list.append(self.active_drives[self.drive_id])
        else:
            action_list.extend(self.active_drives.values())

        return action_list

    def get_available_drives(self, drive_id=None):
        """
        return a list of available drives (not active)
        if drive_id is specified, only [] or [drive_id] is returned
        else all available drives for this node are returned
        """
        action_list = list()
        if self.drive_id is not None:
            if self.drive_id in self.available_drives.values():
                action_list.append(int(self.drive_id))
            if self.drive_id in self.available_drives:
                action_list.append(self.available_drives[self.drive_id])
        else:
            action_list.extend(self.available_drives.values())

        return action_list

    def add_drive(self, drives=None):
        """
        Add Drive available for Cluster storage expansion
        """
        try:
            self.sfe.add_drives(drives,
                                force_during_upgrade=self.force_during_upgrade,
                                force_during_bin_sync=self.force_during_bin_sync)
        except Exception as exception_object:
            self.module.fail_json(msg='Error add drive to cluster  %s' % (to_native(exception_object)),
                                  exception=traceback.format_exc())

    def remove_drive(self, drives=None):
        """
        Remove Drive active in Cluster
        """
        try:
            self.sfe.remove_drives(drives,
                                   force_during_upgrade=self.force_during_upgrade)
        except Exception as exception_object:
            self.module.fail_json(msg='Error remove drive from cluster  %s' % (to_native(exception_object)),
                                  exception=traceback.format_exc())

    def secure_erase(self, drives=None):
        """
        Secure Erase any residual data existing on a drive
        """
        try:
            self.sfe.secure_erase_drives(drives)
        except Exception as exception_object:
            self.module.fail_json(msg='Error clean data from drive %s' % (to_native(exception_object)),
                                  exception=traceback.format_exc())

    def apply(self):
        """
        Check, process and initiate Drive operation
        """
        changed = False
        result_message = None
        self.active_drives = {}
        self.available_drives = {}
        action_list = []
        self.get_node_id()
        self.get_drives_listby_status()

        if self.module.check_mode is False and self.node_id is not None:
            if self.state == "present":
                action_list = self.get_available_drives(self.drive_id)
                if len(action_list) > 0:
                    self.add_drive(action_list)
                    changed = True
                elif self.drive_id is not None and (self.drive_id in self.active_drives.values() or self.drive_id in self.active_drives):
                    changed = False  # No action, so setting changed to false
                elif self.drive_id is None and len(self.active_drives) > 0:
                    changed = False  # No action, so setting changed to false
                else:
                    self.module.fail_json(msg='Error - no drive(s) in available state on node to be included in cluster')

            elif self.state == "absent":
                action_list = self.get_active_drives(self.drive_id)
                if len(action_list) > 0:
                    self.remove_drive(action_list)
                    changed = True

            elif self.state == "clean":
                action_list = self.get_available_drives(self.drive_id)
                if len(action_list) > 0:
                    self.secure_erase(action_list)
                    changed = True
                else:
                    self.module.fail_json(msg='Error - no drive(s) in available state on node to be cleaned')

        else:
            result_message = "Skipping changes, No change requested"
        self.module.exit_json(changed=changed, msg=result_message)


def main():
    """
    Main function
    """

    na_elementsw_drive = ElementSWDrive()
    na_elementsw_drive.apply()


if __name__ == '__main__':
    main()

import unittest
from test import support

class DictSetTest(unittest.TestCase):

    def test_constructors_not_callable(self):
        kt = type({}.keys())
        self.assertRaises(TypeError, kt, {})
        self.assertRaises(TypeError, kt)
        it = type({}.items())
        self.assertRaises(TypeError, it, {})
        self.assertRaises(TypeError, it)
        vt = type({}.values())
        self.assertRaises(TypeError, vt, {})
        self.assertRaises(TypeError, vt)

    def test_dict_keys(self):
        d = {1: 10, "a": "ABC"}
        keys = d.keys()
        self.assertEqual(len(keys), 2)
        self.assertEqual(set(keys), {1, "a"})
        self.assertEqual(keys, {1, "a"})
        self.assertNotEqual(keys, {1, "a", "b"})
        self.assertNotEqual(keys, {1, "b"})
        self.assertNotEqual(keys, {1})
        self.assertNotEqual(keys, 42)
        self.assertIn(1, keys)
        self.assertIn("a", keys)
        self.assertNotIn(10, keys)
        self.assertNotIn("Z", keys)
        self.assertEqual(d.keys(), d.keys())
        e = {1: 11, "a": "def"}
        self.assertEqual(d.keys(), e.keys())
        del e["a"]
        self.assertNotEqual(d.keys(), e.keys())

    def test_dict_items(self):
        d = {1: 10, "a": "ABC"}
        items = d.items()
        self.assertEqual(len(items), 2)
        self.assertEqual(set(items), {(1, 10), ("a", "ABC")})
        self.assertEqual(items, {(1, 10), ("a", "ABC")})
        self.assertNotEqual(items, {(1, 10), ("a", "ABC"), "junk"})
        self.assertNotEqual(items, {(1, 10), ("a", "def")})
        self.assertNotEqual(items, {(1, 10)})
        self.assertNotEqual(items, 42)
        self.assertIn((1, 10), items)
        self.assertIn(("a", "ABC"), items)
        self.assertNotIn((1, 11), items)
        self.assertNotIn(1, items)
        self.assertNotIn((), items)
        self.assertNotIn((1,), items)
        self.assertNotIn((1, 2, 3), items)
        self.assertEqual(d.items(), d.items())
        e = d.copy()
        self.assertEqual(d.items(), e.items())
        e["a"] = "def"
        self.assertNotEqual(d.items(), e.items())

    def test_dict_mixed_keys_items(self):
        d = {(1, 1): 11, (2, 2): 22}
        e = {1: 1, 2: 2}
        self.assertEqual(d.keys(), e.items())
        self.assertNotEqual(d.items(), e.keys())

    def test_dict_values(self):
        d = {1: 10, "a": "ABC"}
        values = d.values()
        self.assertEqual(set(values), {10, "ABC"})
        self.assertEqual(len(values), 2)

    def test_dict_repr(self):
        d = {1: 10, "a": "ABC"}
        self.assertIsInstance(repr(d), str)
        r = repr(d.items())
        self.assertIsInstance(r, str)
        self.assertTrue(r == "dict_items([('a', 'ABC'), (1, 10)])" or
                        r == "dict_items([(1, 10), ('a', 'ABC')])")
        r = repr(d.keys())
        self.assertIsInstance(r, str)
        self.assertTrue(r == "dict_keys(['a', 1])" or
                        r == "dict_keys([1, 'a'])")
        r = repr(d.values())
        self.assertIsInstance(r, str)
        self.assertTrue(r == "dict_values(['ABC', 10])" or
                        r == "dict_values([10, 'ABC'])")

    def test_keys_set_operations(self):
        d1 = {'a': 1, 'b': 2}
        d2 = {'b': 3, 'c': 2}
        d3 = {'d': 4, 'e': 5}
        self.assertEqual(d1.keys() & d1.keys(), {'a', 'b'})
        self.assertEqual(d1.keys() & d2.keys(), {'b'})
        self.assertEqual(d1.keys() & d3.keys(), set())
        self.assertEqual(d1.keys() & set(d1.keys()), {'a', 'b'})
        self.assertEqual(d1.keys() & set(d2.keys()), {'b'})
        self.assertEqual(d1.keys() & set(d3.keys()), set())

        self.assertEqual(d1.keys() | d1.keys(), {'a', 'b'})
        self.assertEqual(d1.keys() | d2.keys(), {'a', 'b', 'c'})
        self.assertEqual(d1.keys() | d3.keys(), {'a', 'b', 'd', 'e'})
        self.assertEqual(d1.keys() | set(d1.keys()), {'a', 'b'})
        self.assertEqual(d1.keys() | set(d2.keys()), {'a', 'b', 'c'})
        self.assertEqual(d1.keys() | set(d3.keys()),
                         {'a', 'b', 'd', 'e'})

        self.assertEqual(d1.keys() ^ d1.keys(), set())
        self.assertEqual(d1.keys() ^ d2.keys(), {'a', 'c'})
        self.assertEqual(d1.keys() ^ d3.keys(), {'a', 'b', 'd', 'e'})
        self.assertEqual(d1.keys() ^ set(d1.keys()), set())
        self.assertEqual(d1.keys() ^ set(d2.keys()), {'a', 'c'})
        self.assertEqual(d1.keys() ^ set(d3.keys()),
                         {'a', 'b', 'd', 'e'})

        self.assertEqual(d1.keys() - d1.keys(), set())
        self.assertEqual(d1.keys() - d2.keys(), {'a'})
        self.assertEqual(d1.keys() - d3.keys(), {'a', 'b'})
        self.assertEqual(d1.keys() - set(d1.keys()), set())
        self.assertEqual(d1.keys() - set(d2.keys()), {'a'})
        self.assertEqual(d1.keys() - set(d3.keys()), {'a', 'b'})

        self.assertFalse(d1.keys().isdisjoint(d1.keys()))
        self.assertFalse(d1.keys().isdisjoint(d2.keys()))
        self.assertFalse(d1.keys().isdisjoint(list(d2.keys())))
        self.assertFalse(d1.keys().isdisjoint(set(d2.keys())))
        self.assertTrue(d1.keys().isdisjoint({'x', 'y', 'z'}))
        self.assertTrue(d1.keys().isdisjoint(['x', 'y', 'z']))
        self.assertTrue(d1.keys().isdisjoint(set(['x', 'y', 'z'])))
        self.assertTrue(d1.keys().isdisjoint(set(['x', 'y'])))
        self.assertTrue(d1.keys().isdisjoint(['x', 'y']))
        self.assertTrue(d1.keys().isdisjoint({}))
        self.assertTrue(d1.keys().isdisjoint(d3.keys()))

        de = {}
        self.assertTrue(de.keys().isdisjoint(set()))
        self.assertTrue(de.keys().isdisjoint([]))
        self.assertTrue(de.keys().isdisjoint(de.keys()))
        self.assertTrue(de.keys().isdisjoint([1]))

    def test_items_set_operations(self):
        d1 = {'a': 1, 'b': 2}
        d2 = {'a': 2, 'b': 2}
        d3 = {'d': 4, 'e': 5}
        self.assertEqual(
            d1.items() & d1.items(), {('a', 1), ('b', 2)})
        self.assertEqual(d1.items() & d2.items(), {('b', 2)})
        self.assertEqual(d1.items() & d3.items(), set())
        self.assertEqual(d1.items() & set(d1.items()),
                         {('a', 1), ('b', 2)})
        self.assertEqual(d1.items() & set(d2.items()), {('b', 2)})
        self.assertEqual(d1.items() & set(d3.items()), set())

        self.assertEqual(d1.items() | d1.items(),
                         {('a', 1), ('b', 2)})
        self.assertEqual(d1.items() | d2.items(),
                         {('a', 1), ('a', 2), ('b', 2)})
        self.assertEqual(d1.items() | d3.items(),
                         {('a', 1), ('b', 2), ('d', 4), ('e', 5)})
        self.assertEqual(d1.items() | set(d1.items()),
                         {('a', 1), ('b', 2)})
        self.assertEqual(d1.items() | set(d2.items()),
                         {('a', 1), ('a', 2), ('b', 2)})
        self.assertEqual(d1.items() | set(d3.items()),
                         {('a', 1), ('b', 2), ('d', 4), ('e', 5)})

        self.assertEqual(d1.items() ^ d1.items(), set())
        self.assertEqual(d1.items() ^ d2.items(),
                         {('a', 1), ('a', 2)})
        self.assertEqual(d1.items() ^ d3.items(),
                         {('a', 1), ('b', 2), ('d', 4), ('e', 5)})

        self.assertEqual(d1.items() - d1.items(), set())
        self.assertEqual(d1.items() - d2.items(), {('a', 1)})
        self.assertEqual(d1.items() - d3.items(), {('a', 1), ('b', 2)})
        self.assertEqual(d1.items() - set(d1.items()), set())
        self.assertEqual(d1.items() - set(d2.items()), {('a', 1)})
        self.assertEqual(d1.items() - set(d3.items()), {('a', 1), ('b', 2)})

        self.assertFalse(d1.items().isdisjoint(d1.items()))
        self.assertFalse(d1.items().isdisjoint(d2.items()))
        self.assertFalse(d1.items().isdisjoint(list(d2.items())))
        self.assertFalse(d1.items().isdisjoint(set(d2.items())))
        self.assertTrue(d1.items().isdisjoint({'x', 'y', 'z'}))
        self.assertTrue(d1.items().isdisjoint(['x', 'y', 'z']))
        self.assertTrue(d1.items().isdisjoint(set(['x', 'y', 'z'])))
        self.assertTrue(d1.items().isdisjoint(set(['x', 'y'])))
        self.assertTrue(d1.items().isdisjoint({}))
        self.assertTrue(d1.items().isdisjoint(d3.items()))

        de = {}
        self.assertTrue(de.items().isdisjoint(set()))
        self.assertTrue(de.items().isdisjoint([]))
        self.assertTrue(de.items().isdisjoint(de.items()))
        self.assertTrue(de.items().isdisjoint([1]))

    def test_recursive_repr(self):
        d = {}
        d[42] = d.values()
        self.assertRaises(RuntimeError, repr, d)


def test_main():
    support.run_unittest(DictSetTest)

if __name__ == "__main__":
    test_main()

import unittest

import os
import tempfile
from zipfile import ZipFile, ZipInfo

from utils import jar_utils
from utils.features import JarFeature

#
# https://security.openstack.org/guidelines/dg_using-temporary-files-securely.html
#

class JarUtilsTests(unittest.TestCase):

    def setUp(self):
        pass

    def tearDown(self):
        pass

    def test_get_jar_features(self):
        tmpdir = tempfile.mkdtemp()
        jar_file_name = 'myfile.jar'

        # Ensure the file is read/write by the creator only
        saved_umask = os.umask(0077)

        path = os.path.join(tmpdir, jar_file_name)
        try:
            with ZipFile(path, "w") as myjar:
                myjar.writestr(ZipInfo('first.class',(1980,1,1,1,1,1)), "first secrets!")
                myjar.writestr(ZipInfo('second.class',(1980,1,1,1,1,1)), "second secrets!")
                myjar.writestr(ZipInfo('second.txt',(1980,1,1,1,1,1)), "second secrets!")

            jars = list(jar_utils.crawl_jar_files(root_dir=tmpdir))
            print jars
            jar_feature = jars[0][1]
            assert 'myfile.jar' == jar_feature.name
            assert '48ac85a26ffa7ff5cefdd5c73a9fb888' == jar_feature.jarhash
            assert ['ddc6eff37020aa858e26b1ba8a49ee0e',
                    'cbe2a13eb99c1c8ac5f30d0a04f8c492'] == jar_feature.hashes
            assert 'jar' == jars[0][2]

        except IOError as e:
            print 'IOError'
        finally:
            os.remove(path)
            os.umask(saved_umask)
            os.rmdir(tmpdir)

# -*- coding: utf-8 -*-
"""
Unit tests for the localization of emails sent by instructor.api methods.
"""

from django.core import mail
from django.core.urlresolvers import reverse
from nose.plugins.attrib import attr

from courseware.tests.factories import InstructorFactory
from lang_pref import LANGUAGE_KEY
from student.models import CourseEnrollment
from student.tests.factories import UserFactory
from openedx.core.djangoapps.user_api.preferences.api import set_user_preference
from xmodule.modulestore.tests.factories import CourseFactory
from xmodule.modulestore.tests.django_utils import SharedModuleStoreTestCase


@attr('shard_1')
class TestInstructorAPIEnrollmentEmailLocalization(SharedModuleStoreTestCase):
    """
    Test whether the enroll, unenroll and beta role emails are sent in the
    proper language, i.e: the student's language.
    """
    @classmethod
    def setUpClass(cls):
        super(TestInstructorAPIEnrollmentEmailLocalization, cls).setUpClass()
        cls.course = CourseFactory.create()

    def setUp(self):
        super(TestInstructorAPIEnrollmentEmailLocalization, self).setUp()

        # Platform language is English, instructor's language is Chinese,
        # student's language is French, so the emails should all be sent in
        # French.
        self.instructor = InstructorFactory(course_key=self.course.id)
        set_user_preference(self.instructor, LANGUAGE_KEY, 'zh-cn')
        self.client.login(username=self.instructor.username, password='test')

        self.student = UserFactory.create()
        set_user_preference(self.student, LANGUAGE_KEY, 'fr')

    def update_enrollement(self, action, student_email):
        """
        Update the current student enrollment status.
        """
        url = reverse('students_update_enrollment', kwargs={'course_id': self.course.id.to_deprecated_string()})
        args = {'identifiers': student_email, 'email_students': 'true', 'action': action, 'reason': 'testing'}
        response = self.client.post(url, args)
        return response

    def check_outbox_is_french(self):
        """
        Check that the email outbox contains exactly one message for which both
        the message subject and body contain a certain French string.
        """
        return self.check_outbox(u"Vous avez été")

    def check_outbox(self, expected_message):
        """
        Check that the email outbox contains exactly one message for which both
        the message subject and body contain a certain string.
        """
        self.assertEqual(1, len(mail.outbox))
        self.assertIn(expected_message, mail.outbox[0].subject)
        self.assertIn(expected_message, mail.outbox[0].body)

    def test_enroll(self):
        self.update_enrollement("enroll", self.student.email)

        self.check_outbox_is_french()

    def test_unenroll(self):
        CourseEnrollment.enroll(
            self.student,
            self.course.id
        )
        self.update_enrollement("unenroll", self.student.email)

        self.check_outbox_is_french()

    def test_set_beta_role(self):
        url = reverse('bulk_beta_modify_access', kwargs={'course_id': self.course.id.to_deprecated_string()})
        self.client.post(url, {'identifiers': self.student.email, 'action': 'add', 'email_students': 'true'})

        self.check_outbox_is_french()

    def test_enroll_unsubscribed_student(self):
        # Student is unknown, so the platform language should be used
        self.update_enrollement("enroll", "newuser@hotmail.com")
        self.check_outbox("You have been")

#! /usr/bin/env python
import os
import re
import sys
import time
import random
import logging
import tempfile
import subprocess
import shutil
import argparse

# params overwrite priority:
#   for default:
#       default_params < blackbox|whitebox_default_params < args
#   for simple:
#       simple_default_params < blackbox|whitebox_simple_default_params < args

default_params = {
    "block_size": 16384,
    "cache_size": 1048576,
    "use_clock_cache": "false",
    "delpercent": 5,
    "destroy_db_initially": 0,
    "disable_wal": 0,
    "allow_concurrent_memtable_write": 0,
    "iterpercent": 10,
    "max_background_compactions": 20,
    "max_bytes_for_level_base": 10485760,
    "max_key": 100000000,
    "max_write_buffer_number": 3,
    "memtablerep": "prefix_hash",
    "mmap_read": lambda: random.randint(0, 1),
    "open_files": 500000,
    "prefix_size": 7,
    "prefixpercent": 5,
    "progress_reports": 0,
    "readpercent": 45,
    "reopen": 20,
    "sync": 0,
    "target_file_size_base": 2097152,
    "target_file_size_multiplier": 2,
    "threads": 32,
    "verify_checksum": 1,
    "write_buffer_size": 4 * 1024 * 1024,
    "writepercent": 35,
    "log2_keys_per_lock": 2,
    "subcompactions": lambda: random.randint(1, 4),
    "use_merge": lambda: random.randint(0, 1),
    "use_full_merge_v1": lambda: random.randint(0, 1),
}


def get_dbname(test_name):
    test_tmpdir = os.environ.get("TEST_TMPDIR")
    if test_tmpdir is None or test_tmpdir == "":
        dbname = tempfile.mkdtemp(prefix='rocksdb_crashtest_' + test_name)
    else:
        dbname = test_tmpdir + "/rocksdb_crashtest_" + test_name
        shutil.rmtree(dbname, True)
    return dbname

blackbox_default_params = {
    # total time for this script to test db_stress
    "duration": 6000,
    # time for one db_stress instance to run
    "interval": 120,
    # since we will be killing anyway, use large value for ops_per_thread
    "ops_per_thread": 100000000,
    "set_options_one_in": 10000,
    "test_batches_snapshots": 1,
}

whitebox_default_params = {
    "duration": 10000,
    "log2_keys_per_lock": 10,
    "nooverwritepercent": 1,
    "ops_per_thread": 200000,
    "test_batches_snapshots": lambda: random.randint(0, 1),
    "write_buffer_size": 4 * 1024 * 1024,
    "subcompactions": lambda: random.randint(1, 4),
    "random_kill_odd": 888887,
}

simple_default_params = {
    "block_size": 16384,
    "cache_size": 1048576,
    "use_clock_cache": "false",
    "column_families": 1,
    "delpercent": 5,
    "destroy_db_initially": 0,
    "disable_wal": 0,
    "allow_concurrent_memtable_write": lambda: random.randint(0, 1),
    "iterpercent": 10,
    "max_background_compactions": 1,
    "max_bytes_for_level_base": 67108864,
    "max_key": 100000000,
    "max_write_buffer_number": 3,
    "memtablerep": "skip_list",
    "mmap_read": lambda: random.randint(0, 1),
    "prefix_size": 0,
    "prefixpercent": 0,
    "progress_reports": 0,
    "readpercent": 50,
    "reopen": 20,
    "sync": 0,
    "target_file_size_base": 16777216,
    "target_file_size_multiplier": 1,
    "test_batches_snapshots": 0,
    "threads": 32,
    "verify_checksum": 1,
    "write_buffer_size": 32 * 1024 * 1024,
    "writepercent": 35,
    "subcompactions": lambda: random.randint(1, 4),
}

blackbox_simple_default_params = {
    "duration": 6000,
    "interval": 120,
    "open_files": -1,
    "ops_per_thread": 100000000,
    "set_options_one_in": 0,
    "test_batches_snapshots": 0,
}

whitebox_simple_default_params = {
    "duration": 10000,
    "log2_keys_per_lock": 10,
    "nooverwritepercent": 1,
    "open_files": 500000,
    "ops_per_thread": 200000,
    "write_buffer_size": 32 * 1024 * 1024,
    "subcompactions": lambda: random.randint(1, 4),
}


def finalize_and_sanitize(src_params):
    dest_params = dict([(k,  v() if callable(v) else v)
                        for (k, v) in src_params.items()])
    if dest_params.get("allow_concurrent_memtable_write", 1) == 1:
        dest_params["memtablerep"] = "skip_list"
    return dest_params


def gen_cmd_params(args):
    params = {}

    if args.simple:
        params.update(simple_default_params)
        if args.test_type == 'blackbox':
            params.update(blackbox_simple_default_params)
        if args.test_type == 'whitebox':
            params.update(whitebox_simple_default_params)

    if not args.simple:
        params.update(default_params)
        if args.test_type == 'blackbox':
            params.update(blackbox_default_params)
        if args.test_type == 'whitebox':
            params.update(whitebox_default_params)

    for k, v in vars(args).items():
        if v is not None:
            params[k] = v
    return params


def gen_cmd(params):
    cmd = ['./db_stress'] + [
        '--{0}={1}'.format(k, v)
        for k, v in finalize_and_sanitize(params).items()
        if k not in set(['test_type', 'simple', 'duration', 'interval',
                         'random_kill_odd'])
        and v is not None]
    return cmd


# This script runs and kills db_stress multiple times. It checks consistency
# in case of unsafe crashes in RocksDB.
def blackbox_crash_main(args):
    cmd_params = gen_cmd_params(args)
    dbname = get_dbname('blackbox')
    exit_time = time.time() + cmd_params['duration']

    print("Running blackbox-crash-test with \n"
          + "interval_between_crash=" + str(cmd_params['interval']) + "\n"
          + "total-duration=" + str(cmd_params['duration']) + "\n"
          + "threads=" + str(cmd_params['threads']) + "\n"
          + "ops_per_thread=" + str(cmd_params['ops_per_thread']) + "\n"
          + "write_buffer_size=" + str(cmd_params['write_buffer_size']) + "\n"
          + "subcompactions=" + str(cmd_params['subcompactions']) + "\n")

    while time.time() < exit_time:
        run_had_errors = False
        killtime = time.time() + cmd_params['interval']

        cmd = gen_cmd(dict(cmd_params.items() + {'db': dbname}.items()))

        child = subprocess.Popen(cmd, stderr=subprocess.PIPE)
        print("Running db_stress with pid=%d: %s\n\n"
              % (child.pid, ' '.join(cmd)))

        stop_early = False
        while time.time() < killtime:
            if child.poll() is not None:
                print("WARNING: db_stress ended before kill: exitcode=%d\n"
                      % child.returncode)
                stop_early = True
                break
            time.sleep(1)

        if not stop_early:
            if child.poll() is not None:
                print("WARNING: db_stress ended before kill: exitcode=%d\n"
                      % child.returncode)
            else:
                child.kill()
                print("KILLED %d\n" % child.pid)
                time.sleep(1)  # time to stabilize after a kill

        while True:
            line = child.stderr.readline().strip()
            if line != '' and not line.startswith('WARNING'):
                run_had_errors = True
                print('stderr has error message:')
                print('***' + line + '***')
            else:
                break

        if run_had_errors:
            sys.exit(2)

        time.sleep(1)  # time to stabilize before the next run

    # we need to clean up after ourselves -- only do this on test success
    shutil.rmtree(dbname, True)


# This python script runs db_stress multiple times. Some runs with
# kill_random_test that causes rocksdb to crash at various points in code.
def whitebox_crash_main(args):
    cmd_params = gen_cmd_params(args)
    dbname = get_dbname('whitebox')

    cur_time = time.time()
    exit_time = cur_time + cmd_params['duration']
    half_time = cur_time + cmd_params['duration'] / 2

    print("Running whitebox-crash-test with \n"
          + "total-duration=" + str(cmd_params['duration']) + "\n"
          + "threads=" + str(cmd_params['threads']) + "\n"
          + "ops_per_thread=" + str(cmd_params['ops_per_thread']) + "\n"
          + "write_buffer_size=" + str(cmd_params['write_buffer_size']) + "\n"
          + "subcompactions=" + str(cmd_params['subcompactions']) + "\n")

    total_check_mode = 4
    check_mode = 0
    kill_random_test = cmd_params['random_kill_odd']
    kill_mode = 0

    while time.time() < exit_time:
        if check_mode == 0:
            additional_opts = {
                # use large ops per thread since we will kill it anyway
                "ops_per_thread": 100 * cmd_params['ops_per_thread'],
            }
            # run with kill_random_test, with three modes.
            # Mode 0 covers all kill points. Mode 1 covers less kill points but
            # increases change of triggering them. Mode 2 covers even less
            # frequent kill points and further increases triggering change.
            if kill_mode == 0:
                additional_opts.update({
                    "kill_random_test": kill_random_test,
                })
            elif kill_mode == 1:
                additional_opts.update({
                    "kill_random_test": (kill_random_test / 10 + 1),
                    "kill_prefix_blacklist": "WritableFileWriter::Append,"
                    + "WritableFileWriter::WriteBuffered",
                })
            elif kill_mode == 2:
                # TODO: May need to adjust random odds if kill_random_test
                # is too small.
                additional_opts.update({
                    "kill_random_test": (kill_random_test / 5000 + 1),
                    "kill_prefix_blacklist": "WritableFileWriter::Append,"
                    "WritableFileWriter::WriteBuffered,"
                    "PosixMmapFile::Allocate,WritableFileWriter::Flush",
                })
            # Run kill mode 0, 1 and 2 by turn.
            kill_mode = (kill_mode + 1) % 3
        elif check_mode == 1:
            # normal run with universal compaction mode
            additional_opts = {
                "kill_random_test": None,
                "ops_per_thread": cmd_params['ops_per_thread'],
                "compaction_style": 1,
            }
        elif check_mode == 2:
            # normal run with FIFO compaction mode
            # ops_per_thread is divided by 5 because FIFO compaction
            # style is quite a bit slower on reads with lot of files
            additional_opts = {
                "kill_random_test": None,
                "ops_per_thread": cmd_params['ops_per_thread'] / 5,
                "compaction_style": 2,
            }
        else:
            # normal run
            additional_opts = additional_opts = {
                "kill_random_test": None,
                "ops_per_thread": cmd_params['ops_per_thread'],
            }

        cmd = gen_cmd(dict(cmd_params.items() + additional_opts.items()
                           + {'db': dbname}.items()))

        print "Running:" + ' '.join(cmd) + "\n"

        popen = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                                 stderr=subprocess.STDOUT)
        stdoutdata, stderrdata = popen.communicate()
        retncode = popen.returncode
        msg = ("check_mode={0}, kill option={1}, exitcode={2}\n".format(
               check_mode, additional_opts['kill_random_test'], retncode))
        print msg
        print stdoutdata

        expected = False
        if additional_opts['kill_random_test'] is None and (retncode == 0):
            # we expect zero retncode if no kill option
            expected = True
        elif additional_opts['kill_random_test'] is not None and retncode < 0:
            # we expect negative retncode if kill option was given
            expected = True

        if not expected:
            print "TEST FAILED. See kill option and exit code above!!!\n"
            sys.exit(1)

        stdoutdata = stdoutdata.lower()
        errorcount = (stdoutdata.count('error') -
                      stdoutdata.count('got errors 0 times'))
        print "#times error occurred in output is " + str(errorcount) + "\n"

        if (errorcount > 0):
            print "TEST FAILED. Output has 'error'!!!\n"
            sys.exit(2)
        if (stdoutdata.find('fail') >= 0):
            print "TEST FAILED. Output has 'fail'!!!\n"
            sys.exit(2)

        # First half of the duration, keep doing kill test. For the next half,
        # try different modes.
        if time.time() > half_time:
            # we need to clean up after ourselves -- only do this on test
            # success
            shutil.rmtree(dbname, True)
            check_mode = (check_mode + 1) % total_check_mode

        time.sleep(1)  # time to stabilize after a kill


def main():
    parser = argparse.ArgumentParser(description="This script runs and kills \
        db_stress multiple times")
    parser.add_argument("test_type", choices=["blackbox", "whitebox"])
    parser.add_argument("--simple", action="store_true")

    all_params = dict(default_params.items()
                      + blackbox_default_params.items()
                      + whitebox_default_params.items()
                      + simple_default_params.items()
                      + blackbox_simple_default_params.items()
                      + whitebox_simple_default_params.items())

    for k, v in all_params.items():
        parser.add_argument("--" + k, type=type(v() if callable(v) else v))
    args = parser.parse_args()

    if args.test_type == 'blackbox':
        blackbox_crash_main(args)
    if args.test_type == 'whitebox':
        whitebox_crash_main(args)

if __name__ == '__main__':
    main()

from sfepy.base.base import *

##
# c: 31.07.2007, r: 27.03.2008
def fix_scalar_in_el( mat, n_el, dtype, default = 1.0 ):
##     print '>>>', mat
    if mat is None:
        out = nm.empty( (n_el, 1, 1, 1), dtype = dtype )
        out.fill( default )
    elif nm.isscalar( mat ):
        out = nm.empty( (n_el, 1, 1, 1), dtype = dtype )
        out.fill( mat )
    elif isinstance( mat, nm.ndarray ):
        if mat.size == n_el:
            out = mat.reshape( n_el, 1, 1, 1 )
        else:
            out = nm.empty( (n_el, 1, 1, 1), dtype = dtype )
            out.fill( mat )
    else:
        print 'unknown mat type!'
        print mat
        raise ValueError
        
    return out

##
# c: 27.03.2008, r: 27.03.2008
def fix_scalar_constant( mat, dtype ):
    out = None
    if nm.isscalar( mat ):
        out = dtype( mat )
    elif isinstance( mat, nm.ndarray ):
        if mat.size == 1:
            out = dtype( mat )
    return out

##
# c: 19.12.2007, r: 01.04.2008
def choose_scalar_or_in_el( mat, dtype, fun1, fun2 ):
    if nm.isscalar( mat ):
        out = dtype( mat ), fun1
    elif isinstance( mat, nm.ndarray ):
        if mat.ndim == 0:
            out = dtype( mat ), fun1
        else:
            out = mat, fun2
    return out

##
# c: 05.03.2008, r: 05.03.2008
def fix_mat_qp_shape( mat_qp, n_el ):
    """Ensures that mat_qp.shape is (n_el, n_qp, *, *)."""
    if mat_qp.ndim == 3:
        mat_qp = mat_qp[...,nm.newaxis]
    if mat_qp.shape[0] == 1:
        mat_qp = nm.tile( mat_qp, (n_el, 1, 1, 1) )
    return mat_qp

def fix_mat_shape( mat, n_qp ):
    """Tiles mat to qp."""
    if mat.ndim == 2:
        mat = nm.tile( mat, (n_qp, 1, 1) )
    return mat

# Copyright David Abrahams 2004. Distributed under the Boost
# Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
'''
>>> from data_members_ext import *

        ---- Test static data members ---

>>> v = Var('slim shady')

>>> Var.ro2a.x
0
>>> Var.ro2b.x
0
>>> Var.rw2a.x
0
>>> Var.rw2b.x
0
>>> v.ro2a.x
0
>>> v.ro2b.x
0
>>> v.rw2a.x
0
>>> v.rw2b.x
0
>>> Var.rw2a.x = 777
>>> Var.ro2a.x
777
>>> Var.ro2b.x
777
>>> Var.rw2a.x
777
>>> Var.rw2b.x
777
>>> v.ro2a.x
777
>>> v.ro2b.x
777
>>> v.rw2a.x
777
>>> v.rw2b.x
777
>>> Var.rw2b = Y(888)

>>> y = Y(99)
>>> y.q = True
>>> y.q
True
>>> y.q = False
>>> y.q
False

>>> Var.ro2a.x
888
>>> Var.ro2b.x
888
>>> Var.rw2a.x
888
>>> Var.rw2b.x
888
>>> v.ro2a.x
888
>>> v.ro2b.x
888
>>> v.rw2a.x
888
>>> v.rw2b.x
888
>>> v.rw2b.x = 999
>>> Var.ro2a.x
999
>>> Var.ro2b.x
999
>>> Var.rw2a.x
999
>>> Var.rw2b.x
999
>>> v.ro2a.x
999
>>> v.ro2b.x
999
>>> v.rw2a.x
999
>>> v.rw2b.x
999


>>> Var.ro1a
0
>>> Var.ro1b
0
>>> Var.rw1a
0
>>> Var.rw1b
0
>>> v.ro1a
0
>>> v.ro1b
0
>>> v.rw1a
0
>>> v.rw1b
0
>>> Var.rw1a = 777
>>> Var.ro1a
777
>>> Var.ro1b
777
>>> Var.rw1a
777
>>> Var.rw1b
777
>>> v.ro1a
777
>>> v.ro1b
777
>>> v.rw1a
777
>>> v.rw1b
777
>>> Var.rw1b = 888
>>> Var.ro1a
888
>>> Var.ro1b
888
>>> Var.rw1a
888
>>> Var.rw1b
888
>>> v.ro1a
888
>>> v.ro1b
888
>>> v.rw1a
888
>>> v.rw1b
888
>>> v.rw1b = 999
>>> Var.ro1a
999
>>> Var.ro1b
999
>>> Var.rw1a
999
>>> Var.rw1b
999
>>> v.ro1a
999
>>> v.ro1b
999
>>> v.rw1a
999
>>> v.rw1b
999



        -----------------
        
>>> x = X(42)
>>> x.x
42
>>> try: x.x = 77
... except AttributeError: pass
... else: print 'no error'

>>> x.fair_value
42.0
>>> y = Y(69)
>>> y.x
69
>>> y.x = 77
>>> y.x
77

>>> v = Var("pi")
>>> v.value = 3.14
>>> v.name
'pi'
>>> v.name2
'pi'

>>> v.get_name1()
'pi'

>>> v.get_name2()
'pi'

>>> v.y.x
6
>>> v.y.x = -7
>>> v.y.x
-7

>>> v.name3
'pi'


'''

def run(args = None):
    import sys
    import doctest

    if args is not None:
        sys.argv = args
    return doctest.testmod(sys.modules.get(__name__))
    
if __name__ == '__main__':
    print "running..."
    import sys
    status = run()[0]
    if (status == 0): print "Done."
    sys.exit(status)

# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""ResNet50 model definition compatible with TensorFlow's eager execution.

Reference [Deep Residual Learning for Image
Recognition](https://arxiv.org/abs/1512.03385)

Adapted from tf.keras.applications.ResNet50. A notable difference is that the
model here outputs logits while the Keras model outputs probability.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import functools

import tensorflow as tf
import tensorflow.contrib.eager as tfe


class _IdentityBlock(tfe.Network):
  """_IdentityBlock is the block that has no conv layer at shortcut.

  Args:
    kernel_size: the kernel size of middle conv layer at main path
    filters: list of integers, the filters of 3 conv layer at main path
    stage: integer, current stage label, used for generating layer names
    block: 'a','b'..., current block label, used for generating layer names
    data_format: data_format for the input ('channels_first' or
      'channels_last').
  """

  def __init__(self, kernel_size, filters, stage, block, data_format):
    super(_IdentityBlock, self).__init__(name='')
    filters1, filters2, filters3 = filters

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'
    bn_axis = 1 if data_format == 'channels_first' else 3

    self.conv2a = self.track_layer(
        tf.layers.Conv2D(
            filters1, (1, 1),
            name=conv_name_base + '2a',
            data_format=data_format))
    self.bn2a = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a'))

    self.conv2b = self.track_layer(
        tf.layers.Conv2D(
            filters2,
            kernel_size,
            padding='same',
            data_format=data_format,
            name=conv_name_base + '2b'))
    self.bn2b = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b'))

    self.conv2c = self.track_layer(
        tf.layers.Conv2D(
            filters3, (1, 1),
            name=conv_name_base + '2c',
            data_format=data_format))
    self.bn2c = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c'))

  def call(self, input_tensor, training=False):
    x = self.conv2a(input_tensor)
    x = self.bn2a(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2b(x)
    x = self.bn2b(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2c(x)
    x = self.bn2c(x, training=training)

    x += input_tensor
    return tf.nn.relu(x)


class _ConvBlock(tfe.Network):
  """_ConvBlock is the block that has a conv layer at shortcut.

  Args:
      kernel_size: the kernel size of middle conv layer at main path
      filters: list of integers, the filterss of 3 conv layer at main path
      stage: integer, current stage label, used for generating layer names
      block: 'a','b'..., current block label, used for generating layer names
      data_format: data_format for the input ('channels_first' or
        'channels_last').
      strides: strides for the convolution. Note that from stage 3, the first
       conv layer at main path is with strides=(2,2), and the shortcut should
       have strides=(2,2) as well.
  """

  def __init__(self,
               kernel_size,
               filters,
               stage,
               block,
               data_format,
               strides=(2, 2)):
    super(_ConvBlock, self).__init__(name='')
    filters1, filters2, filters3 = filters

    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'
    bn_axis = 1 if data_format == 'channels_first' else 3

    self.conv2a = self.track_layer(
        tf.layers.Conv2D(
            filters1, (1, 1),
            strides=strides,
            name=conv_name_base + '2a',
            data_format=data_format))
    self.bn2a = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2a'))

    self.conv2b = self.track_layer(
        tf.layers.Conv2D(
            filters2,
            kernel_size,
            padding='same',
            name=conv_name_base + '2b',
            data_format=data_format))
    self.bn2b = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2b'))

    self.conv2c = self.track_layer(
        tf.layers.Conv2D(
            filters3, (1, 1),
            name=conv_name_base + '2c',
            data_format=data_format))
    self.bn2c = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '2c'))

    self.conv_shortcut = self.track_layer(
        tf.layers.Conv2D(
            filters3, (1, 1),
            strides=strides,
            name=conv_name_base + '1',
            data_format=data_format))
    self.bn_shortcut = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name=bn_name_base + '1'))

  def call(self, input_tensor, training=False):
    x = self.conv2a(input_tensor)
    x = self.bn2a(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2b(x)
    x = self.bn2b(x, training=training)
    x = tf.nn.relu(x)

    x = self.conv2c(x)
    x = self.bn2c(x, training=training)

    shortcut = self.conv_shortcut(input_tensor)
    shortcut = self.bn_shortcut(shortcut, training=training)

    x += shortcut
    return tf.nn.relu(x)


class ResNet50(tfe.Network):
  """Instantiates the ResNet50 architecture.

  Args:
    data_format: format for the image. Either 'channels_first' or
      'channels_last'.  'channels_first' is typically faster on GPUs while
      'channels_last' is typically faster on CPUs. See
      https://www.tensorflow.org/performance/performance_guide#data_formats
    name: Prefix applied to names of variables created in the model.
    trainable: Is the model trainable? If true, performs backward
        and optimization after call() method.
    include_top: whether to include the fully-connected layer at the top of the
      network.
    pooling: Optional pooling mode for feature extraction when `include_top`
      is `False`.
      - `None` means that the output of the model will be the 4D tensor
          output of the last convolutional layer.
      - `avg` means that global average pooling will be applied to the output of
          the last convolutional layer, and thus the output of the model will be
          a 2D tensor.
      - `max` means that global max pooling will be applied.
    classes: optional number of classes to classify images into, only to be
      specified if `include_top` is True.

  Raises:
      ValueError: in case of invalid argument for data_format.
  """

  def __init__(self,
               data_format,
               name=None,
               trainable=True,
               include_top=True,
               pooling=None,
               classes=1000):
    super(ResNet50, self).__init__(name='')

    valid_channel_values = ('channels_first', 'channels_last')
    if data_format not in valid_channel_values:
      raise ValueError('Unknown data_format: %s. Valid values: %s' %
                       (data_format, valid_channel_values))
    self.include_top = include_top

    def conv_block(filters, stage, block, strides=(2, 2)):
      l = _ConvBlock(
          3,
          filters,
          stage=stage,
          block=block,
          data_format=data_format,
          strides=strides)
      return self.track_layer(l)

    def id_block(filters, stage, block):
      l = _IdentityBlock(
          3, filters, stage=stage, block=block, data_format=data_format)
      return self.track_layer(l)

    self.conv1 = self.track_layer(
        tf.layers.Conv2D(
            64, (7, 7),
            strides=(2, 2),
            data_format=data_format,
            padding='same',
            name='conv1'))
    bn_axis = 1 if data_format == 'channels_first' else 3
    self.bn_conv1 = self.track_layer(
        tf.layers.BatchNormalization(axis=bn_axis, name='bn_conv1'))
    self.max_pool = self.track_layer(
        tf.layers.MaxPooling2D((3, 3), strides=(2, 2), data_format=data_format))

    self.l2a = conv_block([64, 64, 256], stage=2, block='a', strides=(1, 1))
    self.l2b = id_block([64, 64, 256], stage=2, block='b')
    self.l2c = id_block([64, 64, 256], stage=2, block='c')

    self.l3a = conv_block([128, 128, 512], stage=3, block='a')
    self.l3b = id_block([128, 128, 512], stage=3, block='b')
    self.l3c = id_block([128, 128, 512], stage=3, block='c')
    self.l3d = id_block([128, 128, 512], stage=3, block='d')

    self.l4a = conv_block([256, 256, 1024], stage=4, block='a')
    self.l4b = id_block([256, 256, 1024], stage=4, block='b')
    self.l4c = id_block([256, 256, 1024], stage=4, block='c')
    self.l4d = id_block([256, 256, 1024], stage=4, block='d')
    self.l4e = id_block([256, 256, 1024], stage=4, block='e')
    self.l4f = id_block([256, 256, 1024], stage=4, block='f')

    self.l5a = conv_block([512, 512, 2048], stage=5, block='a')
    self.l5b = id_block([512, 512, 2048], stage=5, block='b')
    self.l5c = id_block([512, 512, 2048], stage=5, block='c')

    self.avg_pool = self.track_layer(
        tf.layers.AveragePooling2D(
            (7, 7), strides=(7, 7), data_format=data_format))

    if self.include_top:
      self.fc1000 = self.track_layer(
          tf.layers.Dense(classes, name='fc1000'))
    else:
      reduction_indices = [1, 2] if data_format == 'channels_last' else [2, 3]
      reduction_indices = tf.constant(reduction_indices)
      if pooling == 'avg':
        self.global_pooling = functools.partial(
            tf.reduce_mean,
            reduction_indices=reduction_indices,
            keep_dims=False)
      elif pooling == 'max':
        self.global_pooling = functools.partial(
            tf.reduce_max, reduction_indices=reduction_indices, keep_dims=False)
      else:
        self.global_pooling = None

  def call(self, input_tensor, training=False):
    x = self.conv1(input_tensor)
    x = self.bn_conv1(x, training=training)
    x = tf.nn.relu(x)
    x = self.max_pool(x)

    x = self.l2a(x, training=training)
    x = self.l2b(x, training=training)
    x = self.l2c(x, training=training)

    x = self.l3a(x, training=training)
    x = self.l3b(x, training=training)
    x = self.l3c(x, training=training)
    x = self.l3d(x, training=training)

    x = self.l4a(x, training=training)
    x = self.l4b(x, training=training)
    x = self.l4c(x, training=training)
    x = self.l4d(x, training=training)
    x = self.l4e(x, training=training)
    x = self.l4f(x, training=training)

    x = self.l5a(x, training=training)
    x = self.l5b(x, training=training)
    x = self.l5c(x, training=training)

    x = self.avg_pool(x)

    if self.include_top:
      return self.fc1000(tf.layers.flatten(x))
    elif self.global_pooling:
      return self.global_pooling(x)
    else:
      return x

cisco_881 = {
    'device_type': 'cisco_ios',
    'ip':   '10.10.10.227',
    'username': 'test1',
    'password': 'password',
    'secret': 'secret',
    'verbose': False,
}

cisco_asa = {
    'device_type': 'cisco_asa',
    'ip':   '10.10.10.226',
    'username': 'admin',
    'password': 'password',
    'secret': 'secret',
    'verbose': False,
}

arista_veos_sw1 = {
    'device_type': 'arista_eos',
    'ip':   '10.10.10.227',
    'username': 'admin1',
    'password': 'password',
    'secret': '',
    'port': 8222,
    'verbose': False,
}

arista_veos_sw2 = {
    'device_type': 'arista_eos',
    'ip':   '10.10.10.227',
    'username': 'admin1',
    'password': 'password',
    'secret': '',
    'port': 8322,
    'verbose': False,
}

arista_veos_sw3 = {
    'device_type': 'arista_eos',
    'ip':   '10.10.10.227',
    'username': 'admin1',
    'password': 'password',
    'secret': '',
    'port': 8422,
    'verbose': False,
}

arista_veos_sw4 = {
    'device_type': 'arista_eos',
    'ip':   '10.10.10.227',
    'username': 'admin1',
    'password': 'password',
    'secret': '',
    'port': 8522,
    'verbose': False,
}

hp_procurve = {
    'device_type': 'hp_procurve',
    'ip':   '10.10.10.227',
    'username': 'admin',
    'password': 'password',
    'secret': '',
    'port': 9922,
    'verbose': False,
}

hp_comware = {
    'device_type': 'hp_comware',
    'ip':   '192.168.112.11',
    'username': 'admin',
    'password': 'admin',
    'port': 22,
    'verbose': False,
}

brocade_vdx = {
    'device_type': 'brocade_vdx',
    'ip':   '10.254.8.8',
    'username': 'admin',
    'password': 'password',
    'port': 22,
    'verbose': False,
}


all_devices = [
    cisco_881,
    cisco_asa,
    arista_veos_sw1,
    arista_veos_sw2,
    arista_veos_sw3,
    arista_veos_sw4,
    hp_procurve,
    hp_comware,
    brocade_vdx,
]


import logging
from pyvisdk.exceptions import InvalidArgumentError

########################################
# Automatically generated, do not edit.
########################################

log = logging.getLogger(__name__)

def DrsRuleViolationEvent(vim, *args, **kwargs):
    '''This event records when a virtual machine violates a DRS rule.'''
    
    obj = vim.client.factory.create('ns0:DrsRuleViolationEvent')

    # do some validation checking...
    if (len(args) + len(kwargs)) < 5:
        raise IndexError('Expected at least 6 arguments got: %d' % len(args))

    required = [ 'template', 'chainId', 'createdTime', 'key', 'userName' ]
    optional = [ 'changeTag', 'computeResource', 'datacenter', 'ds', 'dvs',
        'fullFormattedMessage', 'host', 'net', 'vm', 'dynamicProperty', 'dynamicType' ]

    for name, arg in zip(required+optional, args):
        setattr(obj, name, arg)

    for name, value in kwargs.items():
        if name in required + optional:
            setattr(obj, name, value)
        else:
            raise InvalidArgumentError("Invalid argument: %s.  Expected one of %s" % (name, ", ".join(required + optional)))

    return obj
    
#!/usr/bin/env python2
# Copyright (c) 2014-2015 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.

from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *

from binascii import a2b_hex, b2a_hex
from hashlib import sha256
from struct import pack


def check_array_result(object_array, to_match, expected):
    """
    Pass in array of JSON objects, a dictionary with key/value pairs
    to match against, and another dictionary with expected key/value
    pairs.
    """
    num_matched = 0
    for item in object_array:
        all_match = True
        for key,value in to_match.items():
            if item[key] != value:
                all_match = False
        if not all_match:
            continue
        for key,value in expected.items():
            if item[key] != value:
                raise AssertionError("%s : expected %s=%s"%(str(item), str(key), str(value)))
            num_matched = num_matched+1
    if num_matched == 0:
        raise AssertionError("No objects matched %s"%(str(to_match)))

def b2x(b):
    return b2a_hex(b).decode('ascii')

# NOTE: This does not work for signed numbers (set the high bit) or zero (use b'\0')
def encodeUNum(n):
    s = bytearray(b'\1')
    while n > 127:
        s[0] += 1
        s.append(n % 256)
        n //= 256
    s.append(n)
    return bytes(s)

def varlenEncode(n):
    if n < 0xfd:
        return pack('<B', n)
    if n <= 0xffff:
        return b'\xfd' + pack('<H', n)
    if n <= 0xffffffff:
        return b'\xfe' + pack('<L', n)
    return b'\xff' + pack('<Q', n)

def dblsha(b):
    return sha256(sha256(b).digest()).digest()

def genmrklroot(leaflist):
    cur = leaflist
    while len(cur) > 1:
        n = []
        if len(cur) & 1:
            cur.append(cur[-1])
        for i in range(0, len(cur), 2):
            n.append(dblsha(cur[i] + cur[i+1]))
        cur = n
    return cur[0]

def template_to_bytes(tmpl, txlist):
    blkver = pack('<L', tmpl['version'])
    mrklroot = genmrklroot(list(dblsha(a) for a in txlist))
    timestamp = pack('<L', tmpl['curtime'])
    nonce = b'\0\0\0\0'
    blk = blkver + a2b_hex(tmpl['previousblockhash'])[::-1] + mrklroot + timestamp + a2b_hex(tmpl['bits'])[::-1] + nonce
    blk += varlenEncode(len(txlist))
    for tx in txlist:
        blk += tx
    return blk

def template_to_hex(tmpl, txlist):
    return b2x(template_to_bytes(tmpl, txlist))

def assert_template(node, tmpl, txlist, expect):
    rsp = node.getblocktemplate({'data':template_to_hex(tmpl, txlist),'mode':'proposal'})
    if rsp != expect:
        raise AssertionError('unexpected: %s' % (rsp,))

class GetBlockTemplateProposalTest(BitcoinTestFramework):
    '''
    Test block proposals with getblocktemplate.
    '''

    def run_test(self):
        node = self.nodes[0]
        node.generate(1) # Mine a block to leave initial block download
        tmpl = node.getblocktemplate()
        if 'coinbasetxn' not in tmpl:
            rawcoinbase = encodeUNum(tmpl['height'])
            rawcoinbase += b'\x01-'
            hexcoinbase = b2x(rawcoinbase)
            hexoutval = b2x(pack('<Q', tmpl['coinbasevalue']))
            tmpl['coinbasetxn'] = {'data': '01000000' + '01' + '0000000000000000000000000000000000000000000000000000000000000000ffffffff' + ('%02x' % (len(rawcoinbase),)) + hexcoinbase + 'fffffffe' + '01' + hexoutval + '00' + '00000000'}
        txlist = list(bytearray(a2b_hex(a['data'])) for a in (tmpl['coinbasetxn'],) + tuple(tmpl['transactions']))

        # Test 0: Capability advertised
        assert('proposal' in tmpl['capabilities'])

        # NOTE: This test currently FAILS (regtest mode doesn't enforce block height in coinbase)
        ## Test 1: Bad height in coinbase
        #txlist[0][4+1+36+1+1] += 1
        #assert_template(node, tmpl, txlist, 'FIXME')
        #txlist[0][4+1+36+1+1] -= 1

        # Test 2: Bad input hash for gen tx
        txlist[0][4+1] += 1
        assert_template(node, tmpl, txlist, 'bad-cb-missing')
        txlist[0][4+1] -= 1

        # Test 3: Truncated final tx
        lastbyte = txlist[-1].pop()
        assert_raises(JSONRPCException, assert_template, node, tmpl, txlist, 'n/a')
        txlist[-1].append(lastbyte)

        # Test 4: Add an invalid tx to the end (duplicate of gen tx)
        txlist.append(txlist[0])
        assert_template(node, tmpl, txlist, 'bad-txns-duplicate')
        txlist.pop()

        # Test 5: Add an invalid tx to the end (non-duplicate)
        txlist.append(bytearray(txlist[0]))
        txlist[-1][4+1] = b'\xff'
        assert_template(node, tmpl, txlist, 'bad-txns-inputs-missingorspent')
        txlist.pop()

        # Test 6: Future tx lock time
        txlist[0][-4:] = b'\xff\xff\xff\xff'
        assert_template(node, tmpl, txlist, 'bad-txns-nonfinal')
        txlist[0][-4:] = b'\0\0\0\0'

        # Test 7: Bad tx count
        txlist.append(b'')
        assert_raises(JSONRPCException, assert_template, node, tmpl, txlist, 'n/a')
        txlist.pop()

        # Test 8: Bad bits
        realbits = tmpl['bits']
        tmpl['bits'] = '1c0000ff'  # impossible in the real world
        assert_template(node, tmpl, txlist, 'bad-diffbits')
        tmpl['bits'] = realbits

        # Test 9: Bad merkle root
        rawtmpl = template_to_bytes(tmpl, txlist)
        rawtmpl[4+32] = (rawtmpl[4+32] + 1) % 0x100
        rsp = node.getblocktemplate({'data':b2x(rawtmpl),'mode':'proposal'})
        if rsp != 'bad-txnmrklroot':
            raise AssertionError('unexpected: %s' % (rsp,))

        # Test 10: Bad timestamps
        realtime = tmpl['curtime']
        tmpl['curtime'] = 0x7fffffff
        assert_template(node, tmpl, txlist, 'time-too-new')
        tmpl['curtime'] = 0
        assert_template(node, tmpl, txlist, 'time-too-old')
        tmpl['curtime'] = realtime

        # Test 11: Valid block
        assert_template(node, tmpl, txlist, None)

        # Test 12: Orphan block
        tmpl['previousblockhash'] = 'ff00' * 16
        assert_template(node, tmpl, txlist, 'inconclusive-not-best-prevblk')

if __name__ == '__main__':
    GetBlockTemplateProposalTest().main()

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# (c) 2015, Darren Worrall <darren@iweb.co.uk>
# (c) 2015, René Moser <mail@renemoser.net>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.

DOCUMENTATION = '''
---
module: cs_loadbalancer_rule
short_description: Manages load balancer rules on Apache CloudStack based clouds.
description:
    - Add, update and remove load balancer rules.
version_added: '2.0'
author:
    - "Darren Worrall (@dazworrall)"
    - "René Moser (@resmo)"
options:
  name:
    description:
      - The name of the load balancer rule.
    required: true
  description:
    description:
      - The description of the load balancer rule.
    required: false
    default: null
  algorithm:
    description:
      - Load balancer algorithm
      - Required when using C(state=present).
    required: false
    choices: [ 'source', 'roundrobin', 'leastconn' ]
    default: 'source'
  private_port:
    description:
      - The private port of the private ip address/virtual machine where the network traffic will be load balanced to.
      - Required when using C(state=present).
      - Can not be changed once the rule exists due API limitation.
    required: false
    default: null
  public_port:
    description:
      - The public port from where the network traffic will be load balanced from.
      - Required when using C(state=present).
      - Can not be changed once the rule exists due API limitation.
    required: true
    default: null
  ip_address:
    description:
      - Public IP address from where the network traffic will be load balanced from.
    required: true
    aliases: [ 'public_ip' ]
  open_firewall:
    description:
      - Whether the firewall rule for public port should be created, while creating the new rule.
      - Use M(cs_firewall) for managing firewall rules.
    required: false
    default: false
  cidr:
    description:
      - CIDR (full notation) to be used for firewall rule if required.
    required: false
    default: null
  protocol:
    description:
      - The protocol to be used on the load balancer
    required: false
    default: null
  project:
    description:
      - Name of the project the load balancer IP address is related to.
    required: false
    default: null
  state:
    description:
      - State of the rule.
    required: true
    default: 'present'
    choices: [ 'present', 'absent' ]
  domain:
    description:
      - Domain the rule is related to.
    required: false
    default: null
  account:
    description:
      - Account the rule is related to.
    required: false
    default: null
  zone:
    description:
      - Name of the zone in which the rule shoud be created.
      - If not set, default zone is used.
    required: false
    default: null
extends_documentation_fragment: cloudstack
'''

EXAMPLES = '''
# Create a load balancer rule
- local_action:
    module: cs_loadbalancer_rule
    name: balance_http
    public_ip: 1.2.3.4
    algorithm: leastconn
    public_port: 80
    private_port: 8080

# update algorithm of an existing load balancer rule
- local_action:
    module: cs_loadbalancer_rule
    name: balance_http
    public_ip: 1.2.3.4
    algorithm: roundrobin
    public_port: 80
    private_port: 8080

# Delete a load balancer rule
- local_action:
    module: cs_loadbalancer_rule
    name: balance_http
    public_ip: 1.2.3.4
    state: absent
'''

RETURN = '''
---
id:
  description: UUID of the rule.
  returned: success
  type: string
  sample: a6f7a5fc-43f8-11e5-a151-feff819cdc9f
zone:
  description: Name of zone the rule is related to.
  returned: success
  type: string
  sample: ch-gva-2
project:
  description: Name of project the rule is related to.
  returned: success
  type: string
  sample: Production
account:
  description: Account the rule is related to.
  returned: success
  type: string
  sample: example account
domain:
  description: Domain the rule is related to.
  returned: success
  type: string
  sample: example domain
algorithm:
  description: Load balancer algorithm used.
  returned: success
  type: string
  sample: "source"
cidr:
  description: CIDR to forward traffic from.
  returned: success
  type: string
  sample: ""
name:
  description: Name of the rule.
  returned: success
  type: string
  sample: "http-lb"
description:
  description: Description of the rule.
  returned: success
  type: string
  sample: "http load balancer rule"
protocol:
  description: Protocol of the rule.
  returned: success
  type: string
  sample: "tcp"
public_port:
  description: Public port.
  returned: success
  type: string
  sample: 80
private_port:
  description: Private IP address.
  returned: success
  type: string
  sample: 80
public_ip:
  description: Public IP address.
  returned: success
  type: string
  sample: "1.2.3.4"
tags:
  description: List of resource tags associated with the rule.
  returned: success
  type: dict
  sample: '[ { "key": "foo", "value": "bar" } ]'
state:
  description: State of the rule.
  returned: success
  type: string
  sample: "Add"
'''

# import cloudstack common
from ansible.module_utils.cloudstack import *

class AnsibleCloudStackLBRule(AnsibleCloudStack):

    def __init__(self, module):
        super(AnsibleCloudStackLBRule, self).__init__(module)
        self.returns = {
            'publicip': 'public_ip',
            'algorithm': 'algorithm',
            'cidrlist': 'cidr',
            'protocol': 'protocol',
        }
        # these values will be casted to int
        self.returns_to_int = {
            'publicport': 'public_port',
            'privateport': 'private_port',
        }


    def get_rule(self, **kwargs):
        rules = self.cs.listLoadBalancerRules(**kwargs)
        if rules:
            return rules['loadbalancerrule'][0]


    def _get_common_args(self):
        return {
            'account': self.get_account(key='name'),
            'domainid': self.get_domain(key='id'),
            'projectid': self.get_project(key='id'),
            'zoneid': self.get_zone(key='id'),
            'publicipid': self.get_ip_address(key='id'),
            'name': self.module.params.get('name'),
        }


    def present_lb_rule(self):
        missing_params = []
        for required_params in [
            'algorithm',
            'private_port',
            'public_port',
        ]:
            if not self.module.params.get(required_params):
                missing_params.append(required_params)
        if missing_params:
            self.module.fail_json(msg="missing required arguments: %s" % ','.join(missing_params))

        args = self._get_common_args()
        rule = self.get_rule(**args)
        if rule:
            rule = self._update_lb_rule(rule)
        else:
            rule = self._create_lb_rule(rule)

        if rule:
            rule = self.ensure_tags(resource=rule, resource_type='LoadBalancer')
        return rule


    def _create_lb_rule(self, rule):
        self.result['changed'] = True
        if not self.module.check_mode:
            args = self._get_common_args()
            args['algorithm']   = self.module.params.get('algorithm')
            args['privateport'] = self.module.params.get('private_port')
            args['publicport']  = self.module.params.get('public_port')
            args['cidrlist']    = self.module.params.get('cidr')
            args['description'] = self.module.params.get('description')
            args['protocol']    = self.module.params.get('protocol')
            res = self.cs.createLoadBalancerRule(**args)
            if 'errortext' in res:
                self.module.fail_json(msg="Failed: '%s'" % res['errortext'])

            poll_async = self.module.params.get('poll_async')
            if poll_async:
                rule = self.poll_job(res, 'loadbalancer')
        return rule


    def _update_lb_rule(self, rule):
        args                = {}
        args['id']          = rule['id']
        args['algorithm']   = self.module.params.get('algorithm')
        args['description'] = self.module.params.get('description')
        if self.has_changed(args, rule):
            self.result['changed'] = True
            if not self.module.check_mode:
                res = self.cs.updateLoadBalancerRule(**args)
                if 'errortext' in res:
                    self.module.fail_json(msg="Failed: '%s'" % res['errortext'])

                poll_async = self.module.params.get('poll_async')
                if poll_async:
                    rule = self.poll_job(res, 'loadbalancer')
        return rule


    def absent_lb_rule(self):
        args = self._get_common_args()
        rule = self.get_rule(**args)
        if rule:
            self.result['changed'] = True
        if rule and not self.module.check_mode:
            res = self.cs.deleteLoadBalancerRule(id=rule['id'])
            if 'errortext' in res:
                self.module.fail_json(msg="Failed: '%s'" % res['errortext'])
            poll_async = self.module.params.get('poll_async')
            if poll_async:
                res = self.poll_job(res, 'loadbalancer')
        return rule


def main():
    argument_spec = cs_argument_spec()
    argument_spec.update(dict(
        name = dict(required=True),
        description = dict(default=None),
        algorithm = dict(choices=['source', 'roundrobin', 'leastconn'], default='source'),
        private_port = dict(type='int', default=None),
        public_port = dict(type='int', default=None),
        protocol = dict(default=None),
        state = dict(choices=['present', 'absent'], default='present'),
        ip_address = dict(required=True, aliases=['public_ip']),
        cidr = dict(default=None),
        project = dict(default=None),
        open_firewall = dict(type='bool', default=False),
        tags = dict(type='list', aliases=['tag'], default=None),
        zone = dict(default=None),
        domain = dict(default=None),
        account = dict(default=None),
        poll_async = dict(type='bool', default=True),
    ))

    module = AnsibleModule(
        argument_spec=argument_spec,
        required_together=cs_required_together(),
        supports_check_mode=True
    )

    try:
        acs_lb_rule = AnsibleCloudStackLBRule(module)

        state = module.params.get('state')
        if state in ['absent']:
            rule = acs_lb_rule.absent_lb_rule()
        else:
            rule = acs_lb_rule.present_lb_rule()

        result = acs_lb_rule.get_result(rule)

    except CloudStackException as e:
        module.fail_json(msg='CloudStackException: %s' % str(e))

    module.exit_json(**result)

# import module snippets
from ansible.module_utils.basic import *
if __name__ == '__main__':
    main()

# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# See license.txt

import frappe, erpnext
from frappe.utils import cint, flt

@frappe.whitelist()
def make_stock_entry(**args):
	'''Helper function to make a Stock Entry

	:item_code: Item to be moved
	:qty: Qty to be moved
	:from_warehouse: Optional
	:to_warehouse: Optional
	:rate: Optional
	:serial_no: Optional
	:batch_no: Optional
	:posting_date: Optional
	:posting_time: Optional
	:do_not_save: Optional flag
	:do_not_submit: Optional flag
	'''
	s = frappe.new_doc("Stock Entry")
	args = frappe._dict(args)

	if args.posting_date or args.posting_time:
		s.set_posting_time = 1

	if args.posting_date:
		s.posting_date = args.posting_date
	if args.posting_time:
		s.posting_time = args.posting_time

	# map names
	if args.from_warehouse:
		args.source = args.from_warehouse
	if args.to_warehouse:
		args.target = args.to_warehouse
	if args.item_code:
		args.item = args.item_code

	if isinstance(args.qty, basestring):
		if '.' in args.qty:
			args.qty = flt(args.qty)
		else:
			args.qty = cint(args.qty)

	# purpose
	if not args.purpose:
		if args.source and args.target:
			s.purpose = "Material Transfer"
		elif args.source:
			s.purpose = "Material Issue"
		else:
			s.purpose = "Material Receipt"
	else:
		s.purpose = args.purpose

	# company
	if not args.company:
		if args.source:
			args.company = frappe.db.get_value('Warehouse', args.source, 'company')
		elif args.target:
			args.company = frappe.db.get_value('Warehouse', args.target, 'company')

	# set vales from test
	if frappe.flags.in_test:
		if not args.company:
			args.company = '_Test Company'
		if not args.item:
			args.item = '_Test Item'

	s.company = args.company or erpnext.get_default_company()
	s.purchase_receipt_no = args.purchase_receipt_no
	s.delivery_note_no = args.delivery_note_no
	s.sales_invoice_no = args.sales_invoice_no
	if not args.cost_center:
		args.cost_center = frappe.get_value('Company', s.company, 'cost_center')

	s.append("items", {
		"item_code": args.item,
		"s_warehouse": args.source,
		"t_warehouse": args.target,
		"qty": args.qty,
		"basic_rate": args.rate or args.basic_rate,
		"conversion_factor": 1.0,
		"serial_no": args.serial_no,
		'batch_no': args.batch_no,
		'cost_center': args.cost_center,
		'expense_account': args.expense_account
	})

	if not args.do_not_save:
		s.insert()
		if not args.do_not_submit:
			s.submit()
	return s

# Copyright (c) 2006-2007 The Regents of The University of Michigan
# Copyright (c) 2009 Advanced Micro Devices, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Ron Dreslinski
#          Brad Beckmann

import m5
from m5.objects import *
from m5.defines import buildEnv
from m5.util import addToPath
import os, optparse, sys

addToPath('../')

from common import Options
from ruby import Ruby

# Get paths we might need.  It's expected this file is in m5/configs/example.
config_path = os.path.dirname(os.path.abspath(__file__))
config_root = os.path.dirname(config_path)
m5_root = os.path.dirname(config_root)

parser = optparse.OptionParser()
Options.addCommonOptions(parser)

parser.add_option("--requests", metavar="N", default=100,
                  help="Stop after N requests")
parser.add_option("-f", "--wakeup_freq", metavar="N", default=10,
                  help="Wakeup every N cycles")
parser.add_option("--test-type", type="choice", default="SeriesGetx",
                  choices = ["SeriesGetx", "SeriesGets", "SeriesGetMixed",
                             "Invalidate"],
                  help = "Type of test")
parser.add_option("--percent-writes", type="int", default=100,
                  help="percentage of accesses that should be writes")

#
# Add the ruby specific and protocol specific options
#
Ruby.define_options(parser)
(options, args) = parser.parse_args()

if args:
     print "Error: script doesn't take any positional arguments"
     sys.exit(1)

#
# Select the direct test generator
#
if options.test_type == "SeriesGetx":
    generator = SeriesRequestGenerator(num_cpus = options.num_cpus,
                                       percent_writes = 100)
elif options.test_type == "SeriesGets":
    generator = SeriesRequestGenerator(num_cpus = options.num_cpus,
                                       percent_writes = 0)
elif options.test_type == "SeriesGetMixed":
    generator = SeriesRequestGenerator(num_cpus = options.num_cpus,
                                       percent_writes = options.percent_writes)
elif options.test_type == "Invalidate":
    generator = InvalidateGenerator(num_cpus = options.num_cpus)
else:
    print "Error: unknown direct test generator"
    sys.exit(1)

# Create the M5 system.
system = System(mem_ranges = [AddrRange(options.mem_size)])


# Create a top-level voltage domain and clock domain
system.voltage_domain = VoltageDomain(voltage = options.sys_voltage)

system.clk_domain = SrcClockDomain(clock = options.sys_clock,
                                   voltage_domain = system.voltage_domain)

# Create the ruby random tester
system.cpu = RubyDirectedTester(requests_to_complete = options.requests,
                                generator = generator)

Ruby.create_system(options, False, system)

# Since Ruby runs at an independent frequency, create a seperate clock
system.ruby.clk_domain = SrcClockDomain(clock = options.ruby_clock,
                                        voltage_domain = system.voltage_domain)

assert(options.num_cpus == len(system.ruby._cpu_ports))

for ruby_port in system.ruby._cpu_ports:
    #
    # Tie the ruby tester ports to the ruby cpu ports
    #
    system.cpu.cpuPort = ruby_port.slave

# -----------------------
# run simulation
# -----------------------

root = Root( full_system = False, system = system )
root.system.mem_mode = 'timing'

# Not much point in this being higher than the L1 latency
m5.ticks.setGlobalFrequency('1ns')

# instantiate configuration
m5.instantiate()

# simulate until program terminates
exit_event = m5.simulate(options.abs_max_tick)

print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()

# coding=utf-8

from __future__ import print_function, unicode_literals

import threading
import traceback

from six.moves.queue import Empty, Queue

from sickbeard import logger
from sickrage.helper.exceptions import ex


class Event(object):
    def __init__(self, type):
        self._type = type

    @property
    def type(self):
        return self._type


class Events(threading.Thread):
    def __init__(self, callback):
        super(Events, self).__init__()
        self.queue = Queue()
        self.daemon = True
        self.callback = callback
        self.name = "EVENT-QUEUE"
        self.stop = threading.Event()

    def put(self, type):
        self.queue.put(type)

    def run(self):
        """
        Actually runs the thread to process events
        """
        try:
            while not self.stop.is_set():
                try:
                    # get event type
                    type = self.queue.get(True, 1)

                    # perform callback if we got a event type
                    self.callback(type)

                    # event completed
                    self.queue.task_done()
                except Empty:
                    type = None

            # exiting thread
            self.stop.clear()
        except Exception as e:
            logger.log("Exception generated in thread " + self.name + ": " + ex(e), logger.ERROR)
            logger.log(repr(traceback.format_exc()), logger.DEBUG)

    # System Events
    class SystemEvent(Event):
        RESTART = "RESTART"
        SHUTDOWN = "SHUTDOWN"

# Create your views here.

from django.shortcuts import render_to_response
from django.http import HttpResponseRedirect
from django.core.context_processors import csrf
from django.contrib.auth.decorators import login_required




from forms import *


@login_required
def userprofile(request,action = False):

    if request.method == 'POST':
        form = UserProfileForm(request.POST, instance=request.user.profile)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect('/accounts/profile/')
    else:
        user = request.user
        profile = user.profile
        #form = UserProfileForm(instance=profile)
    
    args = { "user": user, "profile": profile }

    return render_to_response('registration/profile_base.html',args)

@login_required
def changeinfo(request,action = False):

    if request.method == 'POST':
        form = UserInformation(request.POST, instance=request.user)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect('/accounts/profile/')
    else:
        user = request.user
        form = UserInformation(instance=user)

    args = { "user": user , 'save':'changeInformation/' }
    args.update(csrf(request))
    args['form'] = form
    return render_to_response('registration/form_profile.html',args)



@login_required
def changeprofile(request,action = False):

    user = request.user
    profile = user.profile
    form = UserProfileForm(instance=profile)

    args = { "user": user , 'save':'save' }
    args.update(csrf(request))
    args['form'] = form
    return render_to_response('registration/form_profile.html',args)


@login_required
def changebilling(request,action = False):

    user = request.user
    profile = user.profile
    form = UserProfileForm(instance=profile)

    args = { "user": user , 'save':'save' }
    args.update(csrf(request))
    args['form'] = form
    return render_to_response('registration/form_profile.html',args)

@login_required
def changeshipping(request,action = False):

    if request.method == 'POST':
        form = UserShippingAddress(request.POST, instance=request.user.profile)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect('/accounts/profile/')
    else:
        user = request.user
        profile = user.profile
        form = UserShippingAddress(instance=profile)

    args = { "user": user , 'save':'shippingAddress/' }
    args.update(csrf(request))
    args['form'] = form
    return render_to_response('registration/form_profile.html',args)





RADIX_SYMBOLS = {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9',
                 10: 'a', 11: 'b', 12: 'c', 13: 'd', 14: 'e', 15: 'f', 16: 'g', 17: 'h', 18: 'i', 19: 'j', 20: 'k',
                 21: 'l', 22: 'm', 23: 'n', 24: 'o', 25: 'p', 26: 'q', 27: 'r', 28: 's', 29: 't', 30: 'u', 31: 'v',
                 32: 'w', 33: 'x', 34: 'y', 35: 'z'}


def to_str_rep(num):
    if num.is_nan():
        return num.Js('NaN')
    elif num.is_infinity():
        sign = '-' if num.value<0 else ''
        return num.Js(sign+'Infinity')
    elif isinstance(num.value, long) or num.value.is_integer():  # dont print .0
        return num.Js(unicode(int(num.value)))
    return num.Js(unicode(num.value)) # accurate enough


class NumberPrototype:
    def toString(radix):
        if this.Class!='Number':
            raise this.MakeError('TypeError', 'Number.prototype.valueOf is not generic')
        if radix.is_undefined():
            return to_str_rep(this)
        r = radix.to_int()
        if r==10:
            return to_str_rep(this)
        if r not in xrange(2, 37): 
            raise this.MakeError('RangeError', 'Number.prototype.toString() radix argument must be between 2 and 36')
        num = this.to_int()
        if num < 0:
            num = -num
            sign = '-'
        else:
            sign = ''
        res = ''
        while num:
            s = RADIX_SYMBOLS[num % r]
            num = num / r
            res = s + res
        return sign + (res if res else '0')

    def valueOf():
        if this.Class!='Number':
            raise this.MakeError('TypeError', 'Number.prototype.valueOf is not generic')
        return this.value

    def toLocaleString():
        return this.to_string()

    def toFixed (fractionDigits):
        if this.Class!='Number':
            raise this.MakeError('TypeError', 'Number.prototype.toFixed called on incompatible receiver')
        digs = fractionDigits.to_int()
        if digs<0 or digs>20:
            raise this.MakeError('RangeError', 'toFixed() digits argument must be between 0 and 20')
        elif this.is_infinity():
            return 'Infinity' if this.value>0 else '-Infinity'
        elif this.is_nan():
            return 'NaN'
        return format(this.value, '-.%df'%digs)


    def toExponential (fractionDigits):
        if this.Class!='Number':
            raise this.MakeError('TypeError', 'Number.prototype.toExponential called on incompatible receiver')
        digs = fractionDigits.to_int()
        if digs<0 or digs>20:
            raise this.MakeError('RangeError', 'toFixed() digits argument must be between 0 and 20')
        elif this.is_infinity():
            return 'Infinity' if this.value>0 else '-Infinity'
        elif this.is_nan():
            return 'NaN'
        return format(this.value, '-.%de'%digs)

    def toPrecision (precision):
        if this.Class!='Number':
            raise this.MakeError('TypeError', 'Number.prototype.toPrecision called on incompatible receiver')
        if precision.is_undefined():
            return this.to_String()
        prec = precision.to_int()
        if this.is_nan():
            return 'NaN'
        elif this.is_infinity():
            return 'Infinity' if this.value>0 else '-Infinity'
        digs = prec - len(str(int(this.value)))
        if digs>=0:
            return format(this.value, '-.%df'%digs)
        else:
            return format(this.value, '-.%df'%(prec-1))




# coding=utf-8
# Copyright 2021 The Google Research Authors.
#
# 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.

"""Tests for circuit_lib."""

import math

from absl.testing import absltest
from absl.testing import parameterized
import cirq

from bangbang_qaoa import circuit_lib


class CircuitLibTest(parameterized.TestCase):

  def test_generate_x_hamiltonian_exponential(self):
    self.assertCountEqual(
        circuit_lib.generate_x_hamiltonian_exponential(4, 0.5),
        [
            cirq.XPowGate(exponent=-1.0 / math.pi, global_shift=-0.5).on(
                cirq.LineQubit(0)),
            cirq.XPowGate(exponent=-1.0 / math.pi, global_shift=-0.5).on(
                cirq.LineQubit(1)),
            cirq.XPowGate(exponent=-1.0 / math.pi, global_shift=-0.5).on(
                cirq.LineQubit(2)),
            cirq.XPowGate(exponent=-1.0 / math.pi, global_shift=-0.5).on(
                cirq.LineQubit(3)),
        ])

  @parameterized.parameters(
      (
          circuit_lib.HamiltonianType.CONSTRAINT,
          circuit_lib.HamiltonianType.X
      ),
      (
          circuit_lib.HamiltonianType.X,
          circuit_lib.HamiltonianType.CONSTRAINT
      ),
  )
  def test_switch_hamiltonian_type(self, input_type, expected_output):
    self.assertEqual(circuit_lib.switch_hamiltonian_type(input_type),
                     expected_output)

  def test_bangbang_compressor(self):
    compressed_protocol = iter(
        circuit_lib.bangbang_compressor([
            circuit_lib.HamiltonianType.CONSTRAINT,
            circuit_lib.HamiltonianType.CONSTRAINT,
            circuit_lib.HamiltonianType.CONSTRAINT,
            circuit_lib.HamiltonianType.X,
            circuit_lib.HamiltonianType.CONSTRAINT,
            circuit_lib.HamiltonianType.X,
            circuit_lib.HamiltonianType.X,
        ]))

    time, hamiltonian_type = next(compressed_protocol)
    self.assertEqual(time, 3)
    self.assertEqual(hamiltonian_type, circuit_lib.HamiltonianType.CONSTRAINT)

    time, hamiltonian_type = next(compressed_protocol)
    self.assertEqual(time, 1)
    self.assertEqual(hamiltonian_type, circuit_lib.HamiltonianType.X)

    time, hamiltonian_type = next(compressed_protocol)
    self.assertEqual(time, 1)
    self.assertEqual(hamiltonian_type, circuit_lib.HamiltonianType.CONSTRAINT)

    time, hamiltonian_type = next(compressed_protocol)
    self.assertEqual(time, 2)
    self.assertEqual(hamiltonian_type, circuit_lib.HamiltonianType.X)

    with self.assertRaises(StopIteration):
      next(compressed_protocol)

  @parameterized.parameters(
      ([], '[]'),
      ([circuit_lib.HamiltonianType.CONSTRAINT], '[1]'),
      ([circuit_lib.HamiltonianType.X, circuit_lib.HamiltonianType.X], '[0, 0]')
  )
  def test_protocol_to_string(self, protocol, expected_string):
    self.assertEqual(circuit_lib.protocol_to_string(protocol), expected_string)

  @parameterized.parameters(
      ('[]', []),
      ('[1]', [1]),
      ('[0, 0]', [0, 0]),
  )
  def test_string_to_protocol(self, protocol_string, expected_protocol):
    self.assertListEqual(circuit_lib.string_to_protocol(protocol_string),
                         expected_protocol)

if __name__ == '__main__':
  absltest.main()

# -*- coding: utf-8 -*-

from gettext import gettext as _

from bbcalc.utils import KILOGRAMS, POUNDS, MALE, FEMALE, METRIC
from bbcalc.utils.unitconvertor import kg2lb, cm2in

# General constants
MALECOEF = 98.42
FEMALECOEF = 76.76

WAISTCOEF = 4.15
WEIGHTCOEF = 1.082

CALORIESCOEF = 13.83

def bodyfat_calc(waist, weight, waist_unit=METRIC, weight_unit=METRIC, gender=MALE, precision=2):
    """Body Fat calculator

    This formula comes from 'The Bodyfat Guide' by Ron Brown
    """
    if waist_unit == METRIC:
        waist = cm2in(float(waist))
    if weight_unit == METRIC:
        weight = kg2lb(float(weight))
    tmp_waist = float(waist) * WAISTCOEF
    tmp_weight = float(weight) * WEIGHTCOEF
    diff = tmp_weight - tmp_waist;
    if gender == FEMALE:
        lbm = diff + FEMALECOEF;
    else:
        lbm = diff + MALECOEF;
    fatweight = float(weight) - lbm;
    bodyfat = fatweight / float(weight) * 100.0;
    if weight_unit == METRIC:
        factor = POUNDS
    else:
        factor = KILOGRAMS

    bodyfat = round(bodyfat, precision)
    fatweight = round(fatweight / factor, precision)
    lbm = round(lbm / factor, precision)
    calories = round((lbm * factor) * CALORIESCOEF, 0)

    # TODO: Code refactoring
    if gender == MALE:
        if bodyfat < 5.0:
            classification = (_(u'Essential Fat'))
        elif bodyfat > 5.0 and bodyfat < 14.0:
            classification = (_(u'Athletes'))
        elif bodyfat > 14.0 and bodyfat < 18.0:
            classification = (_(u'Fitness'))
        elif bodyfat > 18.0 and bodyfat < 25.0:
            classification = (_(u'Acceptable'))
        elif bodyfat > 25.0:
            classification = (_(u'Obese'))
    else:
        if bodyfat < 14.0:
            classification = (_(u'Essential Fat'))
        elif bodyfat > 14.0 and bodyfat < 21.0:
            classification = (_(u'Athletes'))
        elif bodyfat > 21.0 and bodyfat < 25.0:
            classification = (_(u'Fitness'))
        elif bodyfat > 25.0 and bodyfat < 32.0:
            classification = (_(u'Acceptable'))
        elif bodyfat > 32.0:
            classification = (_(u'Obese'))

    return {'bodyfat' : bodyfat, 'fatweight' : fatweight, 'lbm' : lbm,
            'calories' : calories, 'classification' : classification}

#    Copyright (C) 2011 by 
#    Aric Hagberg <hagberg@lanl.gov>
#    Dan Schult <dschult@colgate.edu>
#    Pieter Swart <swart@lanl.gov>
#    All rights reserved.
#    BSD license.
from itertools import count,repeat
import json
import networkx as nx
__author__ = """Aric Hagberg (hagberg@lanl.gov))"""
__all__ = ['tree_data',
           'tree_graph']

def tree_data(G, root):
    """Return data in tree format that is suitable for JSON serialization
    and use in Javascript documents.

    Parameters
    ----------
    G : NetworkX graph
       G must be an oriented tree

    root : node
       The root of the tree

    Returns
    -------
    data : dict
       A dictionary with node-link formatted data.

    Examples
    --------
    >>> from networkx.readwrite import json_graph
    >>> G = nx.DiGraph([(1,2)])
    >>> data = json_graph.tree_data(G,root=1)

    To serialize with json

    >>> import json
    >>> s = json.dumps(data)
    
    Notes
    -----
    Node attributes are stored in this format but keys 
    for attributes must be strings if you want to serialize with JSON.
    
    Graph and edge attributes are not stored.

    See Also
    --------
    tree_graph, node_link_data, node_link_data
    """
    if not G.number_of_nodes()==G.number_of_edges()+1:
        raise TypeError("G is not a tree.")
    if not G.is_directed():
        raise TypeError("G is not directed")
    def add_children(n, G):
        nbrs = G[n]
        if len(nbrs) == 0:
            return []
        children = []
        for child in nbrs:
            d = dict(id=child, **G.node[child])
            c = add_children(child,G)
            if c:
                d['children'] = c
            children.append(d)
        return children
    data = dict(id=root, **G.node[root])
    data['children'] = add_children(root,G)
    return data

def tree_graph(data):
    """Return graph from tree data format. 

    Parameters
    ----------
    data : dict
        Tree formatted graph data
    
    Returns
    -------
    G : NetworkX DiGraph

    Examples
    --------
    >>> from networkx.readwrite import json_graph
    >>> G = nx.DiGraph([(1,2)])
    >>> data = json_graph.tree_data(G,root=1)
    >>> H = json_graph.tree_graph(data)

    See Also
    --------
    tree_graph, node_link_data, adjacency_data
    """
    graph = nx.DiGraph()
    def add_children(parent, children):
        for data in children:
            child = data['id']
            graph.add_edge(parent, child)
            grandchildren = data.get('children',[])
            if grandchildren:
                add_children(child,grandchildren)
            nodedata = dict((str(k),v) for k,v in data.items() 
                            if k!='id' and k!='children')
            graph.add_node(child,attr_dict=nodedata)
    root = data['id']
    children = data.get('children',[])
    nodedata = dict((k,v) for k,v in data.items() 
                    if k!='id' and k!='children')
    graph.add_node(root, attr_dict=nodedata)
    add_children(root, children)
    return graph

# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os
from errno import EEXIST
from ansible.errors import AnsibleError
from ansible.module_utils._text import to_bytes, to_native, to_text


__all__ = ['unfrackpath', 'makedirs_safe']


def unfrackpath(path, follow=True):
    '''
    Returns a path that is free of symlinks (if follow=True), environment variables, relative path traversals and symbols (~)

    :arg path: A byte or text string representing a path to be canonicalized
    :arg follow: A boolean to indicate of symlinks should be resolved or not
    :raises UnicodeDecodeError: If the canonicalized version of the path
        contains non-utf8 byte sequences.
    :rtype: A text string (unicode on pyyhon2, str on python3).
    :returns: An absolute path with symlinks, environment variables, and tilde
        expanded.  Note that this does not check whether a path exists.

    example::
        '$HOME/../../var/mail' becomes '/var/spool/mail'
    '''

    if follow:
        final_path = os.path.normpath(os.path.realpath(os.path.expanduser(os.path.expandvars(to_bytes(path, errors='surrogate_or_strict')))))
    else:
        final_path = os.path.normpath(os.path.abspath(os.path.expanduser(os.path.expandvars(to_bytes(path, errors='surrogate_or_strict')))))

    return to_text(final_path, errors='surrogate_or_strict')

def makedirs_safe(path, mode=None):
    '''Safe way to create dirs in muliprocess/thread environments.

    :arg path: A byte or text string representing a directory to be created
    :kwarg mode: If given, the mode to set the directory to
    :raises AnsibleError: If the directory cannot be created and does not already exists.
    :raises UnicodeDecodeError: if the path is not decodable in the utf-8 encoding.
    '''

    rpath = unfrackpath(path)
    b_rpath = to_bytes(rpath)
    if not os.path.exists(b_rpath):
        try:
            if mode:
                os.makedirs(b_rpath, mode)
            else:
                os.makedirs(b_rpath)
        except OSError as e:
            if e.errno != EEXIST:
                raise AnsibleError("Unable to create local directories(%s): %s" % (to_native(rpath), to_native(e)))

import unittest

from utilities import *


class UtilitiesTest(unittest.TestCase):

    def test_ansi_to_pitch(self):
        pitch_nums = tuple(ansi_to_pitch(x) for x in (
            25, 35, 40, 50, 60, 80, 100, 120, 140, 160, 180, 200, 240))
        dec_pitch = (0.25, 0.375, 0.5, 0.625, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5, 3.0)

        self.assertTupleEqual(pitch_nums, dec_pitch)

    def test_is_even(self):
        even_test = tuple(is_even(x) for x in (2, 4, 10, 100, 1, 3, 11, 201))

        self.assertTupleEqual(even_test, (True, True, True, True, False, False, False, False))

    def test_get_large_sprocket(self):
        self.assertEqual(get_large_sprocket(12, 24), 24)
        self.assertEqual(get_large_sprocket(24, 12), 24)

    def test_get_small_sprocket(self):
        self.assertEqual(get_small_sprocket(12, 24), 12)
        self.assertEqual(get_small_sprocket(24, 12), 12)

    def test_get_sprocket_od(self):
        self.assertAlmostEqual(get_sprocket_od(24, .375), 3.0734, 4)
        self.assertAlmostEqual(get_sprocket_od(12, .375), 1.6245, 4)

"""The tests for the MQTT JSON light platform.

Configuration with RGB, brightness, color temp, effect, white value and XY:

light:
  platform: mqtt_json
  name: mqtt_json_light_1
  state_topic: "home/rgb1"
  command_topic: "home/rgb1/set"
  brightness: true
  color_temp: true
  effect: true
  rgb: true
  white_value: true
  xy: true

Configuration with RGB, brightness, color temp, effect, white value:

light:
  platform: mqtt_json
  name: mqtt_json_light_1
  state_topic: "home/rgb1"
  command_topic: "home/rgb1/set"
  brightness: true
  color_temp: true
  effect: true
  rgb: true
  white_value: true

Configuration with RGB, brightness, color temp and effect:

light:
  platform: mqtt_json
  name: mqtt_json_light_1
  state_topic: "home/rgb1"
  command_topic: "home/rgb1/set"
  brightness: true
  color_temp: true
  effect: true
  rgb: true

Configuration with RGB, brightness and color temp:

light:
  platform: mqtt_json
  name: mqtt_json_light_1
  state_topic: "home/rgb1"
  command_topic: "home/rgb1/set"
  brightness: true
  rgb: true
  color_temp: true

Configuration with RGB, brightness:

light:
  platform: mqtt_json
  name: mqtt_json_light_1
  state_topic: "home/rgb1"
  command_topic: "home/rgb1/set"
  brightness: true
  rgb: true

Config without RGB:

light:
  platform: mqtt_json
  name: mqtt_json_light_1
  state_topic: "home/rgb1"
  command_topic: "home/rgb1/set"
  brightness: true

Config without RGB and brightness:

light:
  platform: mqtt_json
  name: mqtt_json_light_1
  state_topic: "home/rgb1"
  command_topic: "home/rgb1/set"
"""
import json
import unittest

from homeassistant.setup import setup_component
from homeassistant.const import STATE_ON, STATE_OFF, ATTR_ASSUMED_STATE
import homeassistant.components.light as light
from tests.common import (
    get_test_home_assistant, mock_mqtt_component, fire_mqtt_message,
    assert_setup_component)


class TestLightMQTTJSON(unittest.TestCase):
    """Test the MQTT JSON light."""

    def setUp(self):  # pylint: disable=invalid-name
        """Setup things to be run when tests are started."""
        self.hass = get_test_home_assistant()
        self.mock_publish = mock_mqtt_component(self.hass)

    def tearDown(self):  # pylint: disable=invalid-name
        """Stop everything that was started."""
        self.hass.stop()

    def test_fail_setup_if_no_command_topic(self): \
            # pylint: disable=invalid-name
        """Test if setup fails with no command topic."""
        with assert_setup_component(0):
            assert setup_component(self.hass, light.DOMAIN, {
                light.DOMAIN: {
                    'platform': 'mqtt_json',
                    'name': 'test',
                }
            })
        self.assertIsNone(self.hass.states.get('light.test'))

    def test_no_color_brightness_color_temp_white_val_if_no_topics(self): \
            # pylint: disable=invalid-name
        """Test for no RGB, brightness, color temp, effect, white val or XY."""
        assert setup_component(self.hass, light.DOMAIN, {
            light.DOMAIN: {
                'platform': 'mqtt_json',
                'name': 'test',
                'state_topic': 'test_light_rgb',
                'command_topic': 'test_light_rgb/set',
            }
        })

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)
        self.assertIsNone(state.attributes.get('rgb_color'))
        self.assertIsNone(state.attributes.get('brightness'))
        self.assertIsNone(state.attributes.get('color_temp'))
        self.assertIsNone(state.attributes.get('effect'))
        self.assertIsNone(state.attributes.get('white_value'))
        self.assertIsNone(state.attributes.get('xy_color'))

        fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"ON"}')
        self.hass.block_till_done()

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)
        self.assertIsNone(state.attributes.get('rgb_color'))
        self.assertIsNone(state.attributes.get('brightness'))
        self.assertIsNone(state.attributes.get('color_temp'))
        self.assertIsNone(state.attributes.get('effect'))
        self.assertIsNone(state.attributes.get('white_value'))
        self.assertIsNone(state.attributes.get('xy_color'))

    def test_controlling_state_via_topic(self): \
            # pylint: disable=invalid-name
        """Test the controlling of the state via topic."""
        assert setup_component(self.hass, light.DOMAIN, {
            light.DOMAIN: {
                'platform': 'mqtt_json',
                'name': 'test',
                'state_topic': 'test_light_rgb',
                'command_topic': 'test_light_rgb/set',
                'brightness': True,
                'color_temp': True,
                'effect': True,
                'rgb': True,
                'white_value': True,
                'xy': True,
                'qos': '0'
            }
        })

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)
        self.assertIsNone(state.attributes.get('rgb_color'))
        self.assertIsNone(state.attributes.get('brightness'))
        self.assertIsNone(state.attributes.get('color_temp'))
        self.assertIsNone(state.attributes.get('effect'))
        self.assertIsNone(state.attributes.get('white_value'))
        self.assertIsNone(state.attributes.get('xy_color'))
        self.assertIsNone(state.attributes.get(ATTR_ASSUMED_STATE))

        # Turn on the light, full white
        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"color":{"r":255,"g":255,"b":255,'
                          '"x":0.123,"y":0.123},'
                          '"brightness":255,'
                          '"color_temp":155,'
                          '"effect":"colorloop",'
                          '"white_value":150}')
        self.hass.block_till_done()

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)
        self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
        self.assertEqual(255, state.attributes.get('brightness'))
        self.assertEqual(155, state.attributes.get('color_temp'))
        self.assertEqual('colorloop', state.attributes.get('effect'))
        self.assertEqual(150, state.attributes.get('white_value'))
        self.assertEqual([0.123, 0.123], state.attributes.get('xy_color'))

        # Turn the light off
        fire_mqtt_message(self.hass, 'test_light_rgb', '{"state":"OFF"}')
        self.hass.block_till_done()

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)

        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"brightness":100}')
        self.hass.block_till_done()

        light_state = self.hass.states.get('light.test')
        self.hass.block_till_done()
        self.assertEqual(100,
                         light_state.attributes['brightness'])

        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"color":{"r":125,"g":125,"b":125}}')
        self.hass.block_till_done()

        light_state = self.hass.states.get('light.test')
        self.assertEqual([125, 125, 125],
                         light_state.attributes.get('rgb_color'))

        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"color":{"x":0.135,"y":0.135}}')
        self.hass.block_till_done()

        light_state = self.hass.states.get('light.test')
        self.assertEqual([0.135, 0.135],
                         light_state.attributes.get('xy_color'))

        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"color_temp":155}')
        self.hass.block_till_done()

        light_state = self.hass.states.get('light.test')
        self.assertEqual(155, light_state.attributes.get('color_temp'))

        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"effect":"colorloop"}')
        self.hass.block_till_done()

        light_state = self.hass.states.get('light.test')
        self.assertEqual('colorloop', light_state.attributes.get('effect'))

        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"white_value":155}')
        self.hass.block_till_done()

        light_state = self.hass.states.get('light.test')
        self.assertEqual(155, light_state.attributes.get('white_value'))

    def test_sending_mqtt_commands_and_optimistic(self): \
            # pylint: disable=invalid-name
        """Test the sending of command in optimistic mode."""
        assert setup_component(self.hass, light.DOMAIN, {
            light.DOMAIN: {
                'platform': 'mqtt_json',
                'name': 'test',
                'command_topic': 'test_light_rgb/set',
                'brightness': True,
                'color_temp': True,
                'effect': True,
                'rgb': True,
                'white_value': True,
                'qos': 2
            }
        })

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)
        self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE))

        light.turn_on(self.hass, 'light.test')
        self.hass.block_till_done()

        self.assertEqual(('test_light_rgb/set', '{"state": "ON"}', 2, False),
                         self.mock_publish.mock_calls[-2][1])
        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)

        light.turn_off(self.hass, 'light.test')
        self.hass.block_till_done()

        self.assertEqual(('test_light_rgb/set', '{"state": "OFF"}', 2, False),
                         self.mock_publish.mock_calls[-2][1])
        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)

        light.turn_on(self.hass, 'light.test', rgb_color=[75, 75, 75],
                      brightness=50, color_temp=155, effect='colorloop',
                      white_value=170)
        self.hass.block_till_done()

        self.assertEqual('test_light_rgb/set',
                         self.mock_publish.mock_calls[-2][1][0])
        self.assertEqual(2, self.mock_publish.mock_calls[-2][1][2])
        self.assertEqual(False, self.mock_publish.mock_calls[-2][1][3])
        # Get the sent message
        message_json = json.loads(self.mock_publish.mock_calls[-2][1][1])
        self.assertEqual(50, message_json["brightness"])
        self.assertEqual(155, message_json["color_temp"])
        self.assertEqual('colorloop', message_json["effect"])
        self.assertEqual(75, message_json["color"]["r"])
        self.assertEqual(75, message_json["color"]["g"])
        self.assertEqual(75, message_json["color"]["b"])
        self.assertEqual(170, message_json["white_value"])
        self.assertEqual("ON", message_json["state"])

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)
        self.assertEqual((75, 75, 75), state.attributes['rgb_color'])
        self.assertEqual(50, state.attributes['brightness'])
        self.assertEqual(155, state.attributes['color_temp'])
        self.assertEqual('colorloop', state.attributes['effect'])
        self.assertEqual(170, state.attributes['white_value'])

    def test_flash_short_and_long(self): \
            # pylint: disable=invalid-name
        """Test for flash length being sent when included."""
        assert setup_component(self.hass, light.DOMAIN, {
            light.DOMAIN: {
                'platform': 'mqtt_json',
                'name': 'test',
                'state_topic': 'test_light_rgb',
                'command_topic': 'test_light_rgb/set',
                'flash_time_short': 5,
                'flash_time_long': 15,
                'qos': 0
            }
        })

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)

        light.turn_on(self.hass, 'light.test', flash="short")
        self.hass.block_till_done()

        self.assertEqual('test_light_rgb/set',
                         self.mock_publish.mock_calls[-2][1][0])
        self.assertEqual(0, self.mock_publish.mock_calls[-2][1][2])
        self.assertEqual(False, self.mock_publish.mock_calls[-2][1][3])
        # Get the sent message
        message_json = json.loads(self.mock_publish.mock_calls[-2][1][1])
        self.assertEqual(5, message_json["flash"])
        self.assertEqual("ON", message_json["state"])

        light.turn_on(self.hass, 'light.test', flash="long")
        self.hass.block_till_done()

        self.assertEqual('test_light_rgb/set',
                         self.mock_publish.mock_calls[-2][1][0])
        self.assertEqual(0, self.mock_publish.mock_calls[-2][1][2])
        self.assertEqual(False, self.mock_publish.mock_calls[-2][1][3])
        # Get the sent message
        message_json = json.loads(self.mock_publish.mock_calls[-2][1][1])
        self.assertEqual(15, message_json["flash"])
        self.assertEqual("ON", message_json["state"])

    def test_transition(self):
        """Test for transition time being sent when included."""
        assert setup_component(self.hass, light.DOMAIN, {
            light.DOMAIN: {
                'platform': 'mqtt_json',
                'name': 'test',
                'state_topic': 'test_light_rgb',
                'command_topic': 'test_light_rgb/set',
                'qos': 0
            }
        })

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)

        light.turn_on(self.hass, 'light.test', transition=10)
        self.hass.block_till_done()

        self.assertEqual('test_light_rgb/set',
                         self.mock_publish.mock_calls[-2][1][0])
        self.assertEqual(0, self.mock_publish.mock_calls[-2][1][2])
        self.assertEqual(False, self.mock_publish.mock_calls[-2][1][3])
        # Get the sent message
        message_json = json.loads(self.mock_publish.mock_calls[-2][1][1])
        self.assertEqual(10, message_json["transition"])
        self.assertEqual("ON", message_json["state"])

        # Transition back off
        light.turn_off(self.hass, 'light.test', transition=10)
        self.hass.block_till_done()

        self.assertEqual('test_light_rgb/set',
                         self.mock_publish.mock_calls[-2][1][0])
        self.assertEqual(0, self.mock_publish.mock_calls[-2][1][2])
        self.assertEqual(False, self.mock_publish.mock_calls[-2][1][3])
        # Get the sent message
        message_json = json.loads(self.mock_publish.mock_calls[-2][1][1])
        self.assertEqual(10, message_json["transition"])
        self.assertEqual("OFF", message_json["state"])

    def test_invalid_color_brightness_and_white_values(self): \
            # pylint: disable=invalid-name
        """Test that invalid color/brightness/white values are ignored."""
        assert setup_component(self.hass, light.DOMAIN, {
            light.DOMAIN: {
                'platform': 'mqtt_json',
                'name': 'test',
                'state_topic': 'test_light_rgb',
                'command_topic': 'test_light_rgb/set',
                'brightness': True,
                'rgb': True,
                'white_value': True,
                'qos': '0'
            }
        })

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_OFF, state.state)
        self.assertIsNone(state.attributes.get('rgb_color'))
        self.assertIsNone(state.attributes.get('brightness'))
        self.assertIsNone(state.attributes.get('white_value'))
        self.assertIsNone(state.attributes.get(ATTR_ASSUMED_STATE))

        # Turn on the light
        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"color":{"r":255,"g":255,"b":255},'
                          '"brightness": 255,'
                          '"white_value": 255}')
        self.hass.block_till_done()

        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)
        self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))
        self.assertEqual(255, state.attributes.get('brightness'))
        self.assertEqual(255, state.attributes.get('white_value'))

        # Bad color values
        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"color":{"r":"bad","g":"val","b":"test"}}')
        self.hass.block_till_done()

        # Color should not have changed
        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)
        self.assertEqual([255, 255, 255], state.attributes.get('rgb_color'))

        # Bad brightness values
        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"brightness": "badValue"}')
        self.hass.block_till_done()

        # Brightness should not have changed
        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)
        self.assertEqual(255, state.attributes.get('brightness'))

        # Bad white value
        fire_mqtt_message(self.hass, 'test_light_rgb',
                          '{"state":"ON",'
                          '"white_value": "badValue"}')
        self.hass.block_till_done()

        # White value should not have changed
        state = self.hass.states.get('light.test')
        self.assertEqual(STATE_ON, state.state)
        self.assertEqual(255, state.attributes.get('white_value'))

# Copyright (c) MetaCommunications, Inc. 2003-2005
#
# Distributed under the Boost Software License, Version 1.0. 
# (See accompanying file LICENSE_1_0.txt or copy at 
# http://www.boost.org/LICENSE_1_0.txt)

import difflib
import os
import re
import shutil
import string
import sys



def scan_for_test_cases():
    return [ os.path.join( "test-cases", x ) for x in os.listdir( "test-cases" ) if x != "CVS" ]

def clean_dir( dir ):
    if os.path.exists( dir ):
        shutil.rmtree( dir )
    os.makedirs( dir )

def system( commands ):
    if sys.platform == 'win32':
        f = open( 'tmp.cmd', 'w' )
        f.write( string.join( commands, '\n' ) )
        f.close()
        rc = os.system( 'tmp.cmd' )
        os.unlink( 'tmp.cmd' )
        return rc
    else:
        rc = os.system( '&&'.join( commands ) )
        return rc

def checked_system( commands, valid_return_codes = [ 0 ] ):
    rc = system( commands ) 
    if rc not in [ 0 ] + valid_return_codes:
        raise Exception( 'Command sequence "%s" failed with return code %d' % ( commands, rc ) )
    return rc

def list_recursively( dir ):
    r = []
    for root, dirs, files in os.walk( dir, topdown=False ):
        root = root[ len( dir ) + 1 : ]
        r.extend( [ os.path.join( root, x ) for x in dirs ] )
        r.extend( [ os.path.join( root, x ) for x in files ] )

    return r

def find_process_jam_log():
    root = "../../../"
    
    for root, dirs, files in os.walk( os.path.join( root, "bin.v2" ), topdown=False ):
        if "process_jam_log.exe" in files:
            return os.path.abspath( os.path.normpath( os.path.join( root, "process_jam_log.exe" ) ) )
        if "process_jam_log" in files:
            return os.path.abspath( os.path.normpath( os.path.join( root, "process_jam_log" ) ) )
    return None

def process_jam_log( executable, file, locate_root, results_dir ):
    args = []
    args.append( executable )
    # args.append( '--echo' )
    args.append( '--create-directories' )
    args.append( '--v2' )
    args.append( locate_root )
    args.append( '<' )
    args.append( file )

    cmd = " ".join( args )
    print "Running process_jam_log (%s)" % cmd
    checked_system( [ cmd ] )
    

def read_file( file_path ):
    f = open( file_path )
    try:
        return f.read()
    finally:
        f.close()

def remove_timestamps( log_lines ):
    return [ re.sub( "timestamp=\"[^\"]+\"", "timestamp=\"\"", x ) for x in log_lines ]    

def determine_locate_root( bjam_log ):
    locate_root = None
    f = open( 'bjam.log' )
    try:
        locate_root_re = re.compile( r'locate-root\s+"(.*)"' )
        for l in f.readlines():
            m = locate_root_re.match( l )
            if m:
                locate_root = m.group(1)
                break
    finally:
        f.close()
    return locate_root

def read_file( path ):    
    f = open( path )
    try:
        return f.read()
    finally:
        f.close()

def read_file_lines( path ):    
    f = open( path )
    try:
        return f.readlines()
    finally:
        f.close()

def write_file( path, content ):    
    f = open( path, 'w' )
    try:
        return f.write( content )
    finally:
        f.close()

def write_file_lines( path, content ):    
    f = open( path, 'w' )
    try:
        return f.writelines( content )
    finally:
        f.close()

        
def run_test_cases( test_cases ):
    process_jam_log_executable = find_process_jam_log()
    print 'Found process_jam_log: %s' % process_jam_log_executable
    initial_dir = os.getcwd()
    for test_case in test_cases:
        os.chdir( initial_dir )
        print 'Running test case "%s"' % test_case
        os.chdir( test_case )
        if os.path.exists( "expected" ):
            locate_root = determine_locate_root( 'bjam.log' )
            print 'locate_root: %s' % locate_root
            
            actual_results_dir = os.path.join( test_case, "actual" )
            clean_dir( "actual" )
            os.chdir( "actual" )
            root = os.getcwd()
            i = 0
            while 1:
                if i == 0:
                    bjam_log_file = 'bjam.log'
                else:
                    bjam_log_file = 'bjam.log.%0d' % i
                i += 1
                print 'Looking for %s' % bjam_log_file
                if not os.path.exists( os.path.join( '..', bjam_log_file ) ):
                    print '    does not exists'
                    break
                print '    found'
                write_file_lines(bjam_log_file.replace( 'bjam', 'bjam_' ), 
                                 [ x.replace( locate_root, root  ) for x in read_file_lines( os.path.join( '..', bjam_log_file ) ) ]  )
                
                process_jam_log( executable = process_jam_log_executable
                                 , results_dir = "."
                                 , locate_root = root 
                                 , file=bjam_log_file.replace( 'bjam', 'bjam_' ) )
            
            actual_content = list_recursively( "." )
            actual_content.sort()
            result_xml = []
            for test_log in [ x for x in actual_content if os.path.splitext( x )[1] == '.xml' ]:
                print 'reading %s' % test_log
                result = [ re.sub( r'timestamp="(.*)"', 'timestamp="xxx"', x ) for x in read_file_lines( test_log ) ]
                result_xml.extend( result )
                
            write_file_lines( 'results.xml', result_xml )
            os.chdir( '..' )
            assert read_file( 'expected/results.xml' ) == read_file( 'actual/results.xml' )
            os.chdir( '..' )
        else:
            raise '   Test case "%s" doesn\'t contain the expected results directory ("expected" )' % ( test_case )
        
run_test_cases( scan_for_test_cases() )
# print find_process_jam_log()

import os

import bandicoot_dev as bc
from collections import Counter


def export_antennas(user, directory):
    with open(os.path.join(directory, 'antenna.csv'), 'wb') as f:
        f.write('id,latitude,longitude,interactions\n')
        for id, (lat, lon) in user.antennas.items():
            interactions = sum([1 for r in user.records if r.position.antenna == id])
            f.write("{},{},{},{}\n".format(id, lat, lon, interactions))


def export_transitions(user, directory):
    antennas_id = [r.position.antenna for r in user.records]
    transitions = Counter([(min(i, j), max(i, j)) for (i, j) in zip(antennas_id, antennas_id[1:])])

    with open(os.path.join(directory, 'transitions.csv'), 'wb') as f:
        f.write('source,target,amount\n')
        for (source, target), count in transitions.items():
            if source != target:
                f.write("{},{},{}\n".format(source, target, count))


def export_timeline(user, directory):
    with open(os.path.join(directory, 'timeseries.csv'), 'wb') as f:
        f.write('time,type,duration\n')
        for r in user.records:
            time = r.datetime.strftime('%d-%m-%y %H:%M')
            interaction = ('inc_' if r.direction == 'in' else 'out_') + r.interaction
            duration = r.duration or ''
            f.write("{},{},{}\n".format(time, interaction, duration))


def export_network(user, directory):
    m_texts = bc.network.matrix_directed_weighted(user, 'text')
    m_calls = bc.network.matrix_directed_weighted(user, 'call')
    nb_users = len(m_texts)

    links = []

    for i in range(nb_users):
        for j in range(nb_users):
            source_calls = m_calls[j][i] or 0
            target_calls = m_calls[i][j] or 0
            source_texts = m_texts[j][i] or 0
            target_texts = m_texts[i][j] or 0

            if i < j and source_calls + target_calls + source_texts + target_texts > 0:
                links.append([i, j, (source_calls, target_calls, source_texts, target_texts)])

    names = [user.name] + [i for i in user.network.keys() if i != user.name]
    nodes = set(l[0] for l in links) | set(l[1] for l in links)

    with open(os.path.join(directory, 'nodes.csv'), 'wb') as f:
        f.write('name,no_network_info\n')
        for n in nodes:
            f.write("{},{}\n".format(names[n], int(None in m_texts[n] or None in m_calls[n])))

    compress_ids = dict(zip(nodes, range(len(nodes))))
    with open(os.path.join(directory, 'links.csv'), 'wb') as f:
        f.write('source,target,source_calls,target_calls,source_texts,target_texts\n')

        for i, j, data in links:
            f.write("{},{},{},{},{},{}\n".format(*(compress_ids[i], compress_ids[j]) + data))

import json

########################################################################
class Extension(object):
    """
    represents a service extension
    """
    _typeName = None
    _capabilities = None
    _enabled = None
    _maxUploadFileSize = None
    _allowedUploadFileTypes = None
    _properties = None
    _allowedExtensions = ["naserver", "mobileserver",
                          "kmlserver", "wfsserver",
                          "schematicsserver", "featureserver",
                          "wcsserver", "wmsserver"]
    #----------------------------------------------------------------------
    def __init__(self, typeName,
                 capabilities,
                 enabled,
                 maxUploadFileSize,
                 allowedUploadFileType,
                 properties):
        """Constructor"""
        self._typeName = typeName
        self._capabilities = capabilities
        self._enabled = enabled
        self._maxUploadFileSize = maxUploadFileSize
        self._allowedUploadFileTypes = allowedUploadFileType
        self._properties = properties
    #----------------------------------------------------------------------
    @property
    def properties(self):
        """gets/sets the extension properties"""
        return self._properties
    #----------------------------------------------------------------------
    @properties.setter
    def properties(self, value):
        """gets/sets the extension properties"""
        if isinstance(value, dict):
            self._properties = value
    #----------------------------------------------------------------------
    @property
    def typeName(self):
        """gets the extension type"""
        return self._typeName
    #----------------------------------------------------------------------
    @property
    def capabilities(self):
        """gets/sets the capabilities"""
        return self._capabilities
    #----------------------------------------------------------------------
    @capabilities.setter
    def capabilities(self, value):
        """gets/sets the capabilities"""
        if self._capabilities != value:
            self._capabilities = value
    #----------------------------------------------------------------------
    @property
    def enabled(self):
        """gets/sets the extension is enabled"""
        return self._enabled
    #----------------------------------------------------------------------
    @enabled.setter
    def enabled(self, value):
        """gets/sets the extension is enabled"""
        if isinstance(value, bool):
            self._enabled = value
    #----------------------------------------------------------------------
    @property
    def maxUploadFileSize(self):
        """sets/gets the maxUploadFileSize"""
        return self._maxUploadFileSize
    #----------------------------------------------------------------------
    @maxUploadFileSize.setter
    def maxUploadFileSize(self, value):
        """sets/gets the maxUploadFileSize"""
        if isinstance(value, int):
            self._maxUploadFileSize = value
    #----------------------------------------------------------------------
    @property
    def allowedUploadFileTypes(self):
        """gets/sets the allowedUploadFileTypes"""
        return self._allowedUploadFileTypes
    #----------------------------------------------------------------------
    @allowedUploadFileTypes.setter
    def allowedUploadFileTypes(self, value):
        """gets/sets the allowedUploadFileTypes"""
        self._allowedUploadFileTypes = value
    #----------------------------------------------------------------------
    def __str__(self):
        """returns the object as JSON"""
        return json.dumps({
            "typeName": self._typeName,
            "capabilities": self._capabilities,
            "enabled": self._enabled,
            "maxUploadFileSize": self._maxUploadFileSize,
            "allowedUploadFileTypes": self._allowedUploadFileTypes,
            "properties": self._properties
        })
    #----------------------------------------------------------------------
    @property
    def value(self):
        """returns the object as a dictionary"""
        return json.loads(str(self))

    #----------------------------------------------------------------------
    @staticmethod
    def fromJSON(value):
        """returns the object from json string or dictionary"""
        if isinstance(value, str):
            value = json.loads(value)
        elif isinstance(value, dict): pass
        else:
            raise AttributeError("Invalid input")
        return Extension(typeName=value['typeName'],
                         capabilities=value['capabilities'],
                         enabled=value['enabled'] == "true",
                         maxUploadFileSize=value['maxUploadFileSize'],
                         allowedUploadFileType=value['allowedUploadFileTypes'],
                         properties=value['properties'])
########################################################################
class ClusterProtocol(object):
    """
    The clustering protocol defines a channel which is used by server
    machines within a cluster to communicate with each other. A server
    machine will communicate with its peers information about the status of
    objects running within it for load balancing and fault tolerance.
    ArcGIS Server supports the TCP clustering protocols where server
    machines communicate with each other over a TCP channel (port).

    Inputs:
       tcpClusterPort - The port to use when configuring a TCP based
       protocol. By default, the server will pick up the next value in the
       assigned ports on all machines.
    """
    _tcpClusterPort = None
    #----------------------------------------------------------------------
    def __init__(self, tcpClusterPort):
        """Constructor"""
        self._tcpClusterPort = int(tcpClusterPort)
    #----------------------------------------------------------------------
    @property
    def tcpClusterPort(self):
        """
        The port to use when configuring a TCP based protocol. By default,
        the server will pick up the next value in the assigned ports on
        all machines.
        """
        return self._tcpClusterPort
    #----------------------------------------------------------------------
    def __str__(self):
        """"""
        return json.dumps({
            "tcpClusterPort" : self._tcpClusterPort
        })
    #----------------------------------------------------------------------
    @property
    def value(self):
        """
        returns the tcpClusterPort as a dictionary
        """
        return {
            "tcpClusterPort" : self._tcpClusterPort
        }







# -*- coding: utf-8 -*-

"""
/***************************************************************************
Name                 : DB Manager
Description          : Database manager plugin for QGIS
Date                 : May 23, 2011
copyright            : (C) 2011 by Giuseppe Sucameli
email                : brush.tyler@gmail.com

The content of this file is based on
- PG_Manager by Martin Dobias (GPLv2 license)
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
"""

from PyQt4.QtGui import QDialog

from .ui.ui_DlgDbError import Ui_DbManagerDlgDbError as Ui_Dialog
from .db_plugins.plugin import DbError


class DlgDbError(QDialog, Ui_Dialog):

    def __init__(self, e, parent=None):
        QDialog.__init__(self, parent)
        self.setupUi(self)

        def sanitize(txt):
            return "" if txt is None else "<pre>" + txt.replace('<', '&lt;') + "</pre>"

        if isinstance(e, DbError):
            self.setQueryMessage(sanitize(e.msg), sanitize(e.query))
        else:
            self.setMessage(sanitize(e.msg))

    def setMessage(self, msg):
        self.txtErrorMsg.setHtml(msg)
        self.stackedWidget.setCurrentIndex(0)

    def setQueryMessage(self, msg, query):
        self.txtQueryErrorMsg.setHtml(msg)
        self.txtQuery.setHtml(query)
        self.stackedWidget.setCurrentIndex(1)

    @staticmethod
    def showError(e, parent=None):
        dlg = DlgDbError(e, parent)
        dlg.exec_()

# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.  All Rights Reserved
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish, dis-
# tribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the fol-
# lowing conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#
from boto.exception import JSONResponseError


class PipelineDeletedException(JSONResponseError):
    pass


class InvalidRequestException(JSONResponseError):
    pass


class TaskNotFoundException(JSONResponseError):
    pass


class PipelineNotFoundException(JSONResponseError):
    pass


class InternalServiceError(JSONResponseError):
    pass

from __future__ import unicode_literals

from io import BytesIO
from unittest import skipUnless
from xml.dom import minidom
import zipfile

from django.conf import settings
from django.contrib.gis.geos import HAS_GEOS
from django.contrib.gis.tests.utils import HAS_SPATIAL_DB
from django.contrib.sites.models import Site
from django.test import TestCase, modify_settings, override_settings

if HAS_GEOS:
    from .models import City, Country


@modify_settings(INSTALLED_APPS={'append': ['django.contrib.sites', 'django.contrib.sitemaps']})
@override_settings(ROOT_URLCONF='django.contrib.gis.tests.geoapp.urls')
@skipUnless(HAS_GEOS and HAS_SPATIAL_DB, "Geos and spatial db are required.")
class GeoSitemapTest(TestCase):

    def setUp(self):
        super(GeoSitemapTest, self).setUp()
        Site(id=settings.SITE_ID, domain="example.com", name="example.com").save()

    def assertChildNodes(self, elem, expected):
        "Taken from syndication/tests.py."
        actual = set(n.nodeName for n in elem.childNodes)
        expected = set(expected)
        self.assertEqual(actual, expected)

    def test_geositemap_kml(self):
        "Tests KML/KMZ geographic sitemaps."
        for kml_type in ('kml', 'kmz'):
            doc = minidom.parseString(self.client.get('/sitemaps/%s.xml' % kml_type).content)

            # Ensuring the right sitemaps namespace is present.
            urlset = doc.firstChild
            self.assertEqual(urlset.getAttribute('xmlns'), 'http://www.sitemaps.org/schemas/sitemap/0.9')

            urls = urlset.getElementsByTagName('url')
            self.assertEqual(2, len(urls))  # Should only be 2 sitemaps.
            for url in urls:
                self.assertChildNodes(url, ['loc'])

                # Getting the relative URL since we don't have a real site.
                kml_url = url.getElementsByTagName('loc')[0].childNodes[0].data.split('http://example.com')[1]

                if kml_type == 'kml':
                    kml_doc = minidom.parseString(self.client.get(kml_url).content)
                elif kml_type == 'kmz':
                    # Have to decompress KMZ before parsing.
                    buf = BytesIO(self.client.get(kml_url).content)
                    zf = zipfile.ZipFile(buf)
                    self.assertEqual(1, len(zf.filelist))
                    self.assertEqual('doc.kml', zf.filelist[0].filename)
                    kml_doc = minidom.parseString(zf.read('doc.kml'))

                # Ensuring the correct number of placemarks are in the KML doc.
                if 'city' in kml_url:
                    model = City
                elif 'country' in kml_url:
                    model = Country
                self.assertEqual(model.objects.count(), len(kml_doc.getElementsByTagName('Placemark')))

# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests and benchmarks for creating RPC clusters on localhost."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import time

import numpy as np

from tensorflow.python.client import session as session_lib
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.ops import partitioned_variables
from tensorflow.python.ops import variable_scope
from tensorflow.python.ops import variables
from tensorflow.python.platform import test
from tensorflow.python.training import device_setter


class CreateLocalClusterTest(test.TestCase):

  def testCreateLocalCluster(self):
    workers, _ = test.create_local_cluster(num_workers=2, num_ps=2)
    worker_sessions = [session_lib.Session(w.target) for w in workers]
    with ops.device("/job:ps/task:0"):
      var0 = variables.Variable(0.0)
    with ops.device("/job:ps/task:1"):
      var1 = variables.Variable(1.0)
    worker_sessions[0].run([var0.initializer, var1.initializer])
    with ops.device("/job:ps/task:0"):
      var2 = variables.Variable(2.0)
    with ops.device("/job:ps/task:1"):
      var3 = variables.Variable(3.0)
    worker_sessions[1].run([var2.initializer, var3.initializer])

    # Read values back in the opposite session
    self.assertAllEqual(0.0, var0.eval(session=worker_sessions[1]))
    self.assertAllEqual(1.0, var1.eval(session=worker_sessions[1]))
    self.assertAllEqual(2.0, var2.eval(session=worker_sessions[0]))
    self.assertAllEqual(3.0, var3.eval(session=worker_sessions[0]))


class CreateLocalClusterBenchmark(test.Benchmark):

  def benchmarkCreateLocalCluster(self):
    deltas = []
    iters = 5
    for _ in range(iters):
      start_time = time.time()
      test.create_local_cluster(num_workers=1, num_ps=10)
      end_time = time.time()
      deltas.append(end_time - start_time)

    median_deltas = np.median(deltas)
    print("\n\nbenchmark_create_local_cluster_1_worker_10_ps.  "
          "iterations: %d, median wall time: %g\n\n" % (iters, median_deltas))
    self.report_benchmark(
        iters=iters,
        wall_time=median_deltas,
        name="benchmark_create_local_cluster_1_worker_10_ps")


class PartitionedVariablesBenchmark(test.Benchmark):

  def benchmark_create_1000_partitions_with_100_parameter_servers(self):
    workers, _ = test.create_local_cluster(num_workers=1, num_ps=100)
    worker_sessions = [session_lib.Session(w.target) for w in workers]
    worker = worker_sessions[0]
    partition_sizes = (1, 512, 1024 * 32, 1024 * 128)

    partitioned = []

    for partition_size in partition_sizes:
      # max_shard_bytes is 4, shape is 1000*partition_size float32s which should
      # partition into 1000 shards, each containing partition_size float32s.
      print("Building partitioned variable with %d floats per partition" %
            partition_size)
      with ops.device(device_setter.replica_device_setter(ps_tasks=100)):
        partitioned_ix = variable_scope.get_variable(
            "partitioned_%d" % partition_size,
            shape=[1000 * partition_size],
            dtype=dtypes.float32,
            # Each partition to have exactly N float32s
            partitioner=partitioned_variables.variable_axis_size_partitioner(
                max_shard_bytes=4 * partition_size))
        # Concatenates along axis 0
        partitioned.append(ops.convert_to_tensor(partitioned_ix))

    variables.global_variables_initializer().run(session=worker)

    for ix, partition_size in enumerate(partition_sizes):
      print("Running benchmark having partitions with %d floats" %
            partition_size)
      self.run_op_benchmark(
          worker,
          partitioned[ix],
          name=("read_concat_1000_partitions_from_"
                "100_parameter_servers_partsize_%d_floats" % partition_size))


if __name__ == "__main__":
  test.main()

import os
import sys
import unittest

from cobbler import utils
from tests.cli.imports.import_base import CobblerImportTest
from tests.cli.imports.import_base import create_import_func

class Test_RedHat_Imports(CobblerImportTest):
   """
   Tests imports of various distros
   """
   pass

distros = [
 {"name":"rhel58-x86_64", "desc":"RHEL 5.8 x86_64", "path":"/vagrant/distros/rhel58_x86_64"},
 {"name":"rhel63-x86_64", "desc":"RHEL 6.3 x86_64", "path":"/vagrant/distros/rhel63_x86_64"},
 {"name":"centos63-x86_64", "desc":"CentOS 6.3 x86_64", "path":"/vagrant/distros/centos63_x86_64"},
 {"name":"sl62-x86_64", "desc":"Scientific Linux 6.2 x86_64", "path":"/vagrant/distros/sl62_x86_64"},
 {"name":"f16-x86_64", "desc":"Fedora 16 x86_64", "path":"/vagrant/distros/f16_x86_64"},
 {"name":"f17-x86_64", "desc":"Fedora 17 x86_64", "path":"/vagrant/distros/f17_x86_64"},
 {"name":"f18-x86_64", "desc":"Fedora 18 x86_64", "path":"/vagrant/distros/f18_x86_64"},
]

for i in range(0,len(distros)):
   test_func = create_import_func(distros[i])
   test_func.__name__ = 'test_redhat_%02d_import_%s' % (i,distros[i]["name"])
   test_func.__doc__ = "Import of %s" % distros[i]["desc"]
   setattr(Test_RedHat_Imports, test_func.__name__, test_func)
   del test_func

# -*- encoding: utf-8 -*-
#################################################################################
#
#    Copyright (C) 2009  Renato Lima - Akretion
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
#################################################################################

{
    'name': 'Brazilian - Accounting',
    'category': 'Localization/Account Charts',
    'description': """
Base module for the Brazilian localization
==========================================

This module consists in:

 - Generic Brazilian chart of accounts
 - Brazilian taxes such as:

        - IPI
        - ICMS
        - PIS
        - COFINS
        - ISS
        - IR
        - IRPJ
        - CSLL

 - Tax Situation Code (CST) required for the electronic fiscal invoicing (NFe)

The field tax_discount has also been added in the account.tax.template and account.tax objects to allow the proper computation of some Brazilian VATs such as ICMS. The chart of account creation wizard has been extended to propagate those new data properly.

It's important to note however that this module lack many implementations to use OpenERP properly in Brazil. Those implementations (such as the electronic fiscal Invoicing which is already operational) are brought by more than 15 additional modules of the Brazilian Launchpad localization project https://launchpad.net/openerp.pt-br-localiz and their dependencies in the extra addons branch. Those modules aim at not breaking with the remarkable OpenERP modularity, this is why they are numerous but small. One of the reasons for maintaining those modules apart is that Brazilian Localization leaders need commit rights agility to complete the localization as companies fund the remaining legal requirements (such as soon fiscal ledgers, accounting SPED, fiscal SPED and PAF ECF that are still missing as September 2011). Those modules are also strictly licensed under AGPL V3 and today don't come with any additional paid permission for online use of 'private modules'.""",
    'license': 'AGPL-3',
    'author': 'Akretion, OpenERP Brasil',
    'website': 'http://openerpbrasil.org',
    'version': '0.6',
    'depends': ['account','account_chart'],
    'init_xml': [        
        'data/account.account.type.csv',
        'data/account.tax.code.template.csv',
        'data/account.account.template.csv',
        'data/l10n_br_account_chart_template.xml',
        'data/account_tax_template.xml',
        'data/l10n_br_data.xml',
        'security/ir.model.access.csv',
                ],
    'update_xml': [
        'account_view.xml',
        'l10n_br_view.xml',
    ],
    'installable': True,
    'certificate' : '001280994939126801405',
}

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

"""Python 'base64_codec' Codec - base64 content transfer encoding.

This codec de/encodes from bytes to bytes.

Written by Marc-Andre Lemburg (mal@lemburg.com).
"""

import codecs
import base64

### Codec APIs

def base64_encode(input, errors='strict'):
    assert errors == 'strict'
    return (base64.encodebytes(input), len(input))

def base64_decode(input, errors='strict'):
    assert errors == 'strict'
    return (base64.decodebytes(input), len(input))

class Codec(codecs.Codec):
    def encode(self, input, errors='strict'):
        return base64_encode(input, errors)
    def decode(self, input, errors='strict'):
        return base64_decode(input, errors)

class IncrementalEncoder(codecs.IncrementalEncoder):
    def encode(self, input, final=False):
        assert self.errors == 'strict'
        return base64.encodebytes(input)

class IncrementalDecoder(codecs.IncrementalDecoder):
    def decode(self, input, final=False):
        assert self.errors == 'strict'
        return base64.decodebytes(input)

class StreamWriter(Codec, codecs.StreamWriter):
    charbuffertype = bytes

class StreamReader(Codec, codecs.StreamReader):
    charbuffertype = bytes

### encodings module API

def getregentry():
    return codecs.CodecInfo(
        name='base64',
        encode=base64_encode,
        decode=base64_decode,
        incrementalencoder=IncrementalEncoder,
        incrementaldecoder=IncrementalDecoder,
        streamwriter=StreamWriter,
        streamreader=StreamReader,
        _is_text_encoding=False,
    )

from django.core.urlresolvers import reverse
from django.shortcuts import redirect
from kolibri.auth.models import DeviceOwner


ALLOWED_PATH_LIST = [
    "facility-list",
    "deviceowner-list",
    "kolibri:setupwizardplugin:setupwizard",
    "task-localdrive",
    "task-startremoteimport",
    "task-list",
    "session-list"
]


class SetupWizardMiddleware():
    """
    display the superuser creation app if no superuser exists.
    """
    deviceowner_already_created = False

    def process_request(self, request):
        # If a DeviceOwner has already been created, no need to do anything here
        self.deviceowner_already_created = self.deviceowner_already_created or DeviceOwner.objects.exists()
        if self.deviceowner_already_created:
            if request.path.startswith(reverse("kolibri:setupwizardplugin:setupwizard")):
                return redirect(reverse("kolibri:learnplugin:learn"))
            return

        # Don't redirect for URLs that are required for the setup wizard
        allowed_paths = [reverse(name) for name in ALLOWED_PATH_LIST]
        if any(request.path.startswith(path_prefix) for path_prefix in allowed_paths):
            return

        # If we've gotten this far, we want to redirect to the setup wizard
        return redirect(reverse("kolibri:setupwizardplugin:setupwizard"))

from __future__ import absolute_import, unicode_literals

from django.contrib.sessions.models import Session
from django.core.management.base import NoArgsCommand

from ... import backend
from ...utils import total_seconds

try:  # Django >= 1.4
    from django.utils import timezone
except ImportError:  # Django < 1.4
    from datetime import datetime as timezone


class Command(NoArgsCommand):
    help = 'copy django orm sessions to redis'

    def handle_noargs(self, *args, **kwargs):
        sessions = Session.objects.filter(expire_date__gt=timezone.now())
        count = sessions.count()
        counter = 1

        self.stdout.write('sessions to copy %d\n' % count)

        for session in sessions:
            self.stdout.write('processing %d of %d\n' % (counter, count))

            expire_in = session.expire_date - timezone.now()
            expire_in = round(total_seconds(expire_in))

            if expire_in < 0:
                continue

            backend.delete(session.session_key)

            backend.save(
                session.session_key,
                expire_in,
                session.session_data,
                False
            )

            counter += 1

# -*- coding: utf-8 -*-
#
# 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.

from setuptools import setup, find_packages, Command
from setuptools.command.test import test as TestCommand

import imp
import logging
import os
import pip
import sys

logger = logging.getLogger(__name__)

# Kept manually in sync with airflow.__version__
version = imp.load_source(
    'airflow.version', os.path.join('airflow', 'version.py')).version

PY3 = sys.version_info[0] == 3

class Tox(TestCommand):
    user_options = [('tox-args=', None, "Arguments to pass to tox")]
    def initialize_options(self):
        TestCommand.initialize_options(self)
        self.tox_args = ''
    def finalize_options(self):
        TestCommand.finalize_options(self)
        self.test_args = []
        self.test_suite = True
    def run_tests(self):
        #import here, cause outside the eggs aren't loaded
        import tox
        errno = tox.cmdline(args=self.tox_args.split())
        sys.exit(errno)


class CleanCommand(Command):
    """Custom clean command to tidy up the project root."""
    user_options = []
    def initialize_options(self):
        pass
    def finalize_options(self):
        pass
    def run(self):
        os.system('rm -vrf ./build ./dist ./*.pyc ./*.tgz ./*.egg-info')


def git_version(version):
    """
    Return a version to identify the state of the underlying git repo. The version will
    indicate whether the head of the current git-backed working directory is tied to a
    release tag or not : it will indicate the former with a 'release:{version}' prefix
    and the latter with a 'dev0' prefix. Following the prefix will be a sha of the current
    branch head. Finally, a "dirty" suffix is appended to indicate that uncommitted changes
    are present.
    """
    repo = None
    try:
        import git
        repo = git.Repo('.git')
    except ImportError:
        logger.warning('gitpython not found: Cannot compute the git version.')
        return ''
    except Exception as e:
        logger.warning('Cannot compute the git version. {}'.format(e))
        return ''
    if repo:
        sha = repo.head.commit.hexsha
        if repo.is_dirty():
            return '.dev0+{sha}.dirty'.format(sha=sha)
        # commit is clean
        return '.release:{version}+{sha}'.format(version=version, sha=sha)
    else:
        return 'no_git_version'


def write_version(filename=os.path.join(*['airflow',
                                          'git_version'])):
    text = "{}".format(git_version(version))
    with open(filename, 'w') as a:
        a.write(text)

async = [
    'greenlet>=0.4.9',
    'eventlet>= 0.9.7',
    'gevent>=0.13'
]
azure = ['azure-storage>=0.34.0']
sendgrid = ['sendgrid>=5.2.0']
celery = [
    'celery>=4.0.2',
    'flower>=0.7.3'
]
cgroups = [
    'cgroupspy>=0.1.4',
]
crypto = ['cryptography>=0.9.3']
dask = [
    'distributed>=1.15.2, <2'
    ]
databricks = ['requests>=2.5.1, <3']
datadog = ['datadog>=0.14.0']
doc = [
    'sphinx>=1.2.3',
    'sphinx-argparse>=0.1.13',
    'sphinx-rtd-theme>=0.1.6',
    'Sphinx-PyPI-upload>=0.2.1'
]
docker = ['docker-py>=1.6.0']
druid = ['pydruid>=0.4.1']
emr = ['boto3>=1.0.0']
gcp_api = [
    'httplib2',
    'google-api-python-client>=1.5.0, <1.6.0',
    'oauth2client>=2.0.2, <2.1.0',
    'PyOpenSSL',
    'google-cloud-dataflow>=2.2.0',
    'pandas-gbq'
]
hdfs = ['snakebite>=2.7.8']
webhdfs = ['hdfs[dataframe,avro,kerberos]>=2.0.4']
jenkins = ['python-jenkins>=0.4.15']
jira = ['JIRA>1.0.7']
hive = [
    'hive-thrift-py>=0.0.1',
    'pyhive>=0.1.3',
    'impyla>=0.13.3',
    'unicodecsv>=0.14.1'
]
jdbc = ['jaydebeapi>=1.1.1']
mssql = ['pymssql>=2.1.1', 'unicodecsv>=0.14.1']
mysql = ['mysqlclient>=1.3.6']
rabbitmq = ['librabbitmq>=1.6.1']
oracle = ['cx_Oracle>=5.1.2']
postgres = ['psycopg2-binary>=2.7.4']
ssh = ['paramiko>=2.1.1', 'pysftp>=0.2.9']
salesforce = ['simple-salesforce>=0.72']
s3 = ['boto3>=1.0.0']
samba = ['pysmbclient>=0.1.3']
slack = ['slackclient>=1.0.0']
statsd = ['statsd>=3.0.1, <4.0']
vertica = ['vertica-python>=0.5.1']
ldap = ['ldap3>=0.9.9.1']
kerberos = ['pykerberos>=1.1.13',
            'requests_kerberos>=0.10.0',
            'thrift_sasl>=0.2.0',
            'snakebite[kerberos]>=2.7.8']
password = [
    'bcrypt>=2.0.0',
    'flask-bcrypt>=0.7.1',
]
github_enterprise = ['Flask-OAuthlib>=0.9.1']
qds = ['qds-sdk>=1.9.6']
cloudant = ['cloudant>=0.5.9,<2.0'] # major update coming soon, clamp to 0.x
redis = ['redis>=2.10.5']
kubernetes = ['kubernetes>=3.0.0',
              'cryptography>=2.0.0']
snowflake = ['snowflake-connector-python>=1.5.2',
             'snowflake-sqlalchemy>=1.1.0']
zendesk = ['zdesk']

all_dbs = postgres + mysql + hive + mssql + hdfs + vertica + cloudant + druid
devel = [
    'click',
    'freezegun',
    'jira',
    'lxml>=3.3.4',
    'mock',
    'moto==1.1.19',
    'nose',
    'nose-ignore-docstring==0.2',
    'nose-timer',
    'parameterized',
    'qds-sdk>=1.9.6',
    'rednose',
    'paramiko',
    'pysftp',
    'requests_mock'
]
devel_minreq = devel + kubernetes + mysql + doc + password + s3 + cgroups
devel_hadoop = devel_minreq + hive + hdfs + webhdfs + kerberos
devel_all = (sendgrid + devel + all_dbs + doc + samba + s3 + slack + crypto + oracle +
             docker + ssh + kubernetes + celery + azure + redis + gcp_api + datadog +
             zendesk + jdbc + ldap + kerberos + password + webhdfs + jenkins +
             druid + snowflake)

# Snakebite & Google Cloud Dataflow are not Python 3 compatible :'(
if PY3:
    devel_ci = [package for package in devel_all if package not in
                ['snakebite>=2.7.8', 'snakebite[kerberos]>=2.7.8',
                 'google-cloud-dataflow>=2.2.0']]
else:
    devel_ci = devel_all

def do_setup():
    write_version()
    setup(
        name='apache-airflow',
        description='Programmatically author, schedule and monitor data pipelines',
        license='Apache License 2.0',
        version=version,
        packages=find_packages(exclude=['tests*']),
        package_data={'': ['airflow/alembic.ini', "airflow/git_version"]},
        include_package_data=True,
        zip_safe=False,
        scripts=['airflow/bin/airflow'],
        install_requires=[
            'alembic>=0.8.3, <0.9',
            'bleach==2.1.2',
            'configparser>=3.5.0, <3.6.0',
            'croniter>=0.3.17, <0.4',
            'dill>=0.2.2, <0.3',
            'flask>=0.12, <0.13',
            'flask-appbuilder>=1.9.6, <2.0.0',
            'flask-admin==1.4.1',
            'flask-caching>=1.3.3, <1.4.0',
            'flask-login==0.2.11',
            'flask-swagger==0.2.13',
            'flask-wtf>=0.14, <0.15',
            'funcsigs==1.0.0',
            'future>=0.16.0, <0.17',
            'gitpython>=2.0.2',
            'gunicorn>=19.4.0, <20.0',
            'iso8601>=0.1.12',
            'jinja2>=2.7.3, <2.9.0',
            'lxml>=3.6.0, <4.0',
            'markdown>=2.5.2, <3.0',
            'pandas>=0.17.1, <1.0.0',
            'pendulum==1.4.4',
            'psutil>=4.2.0, <5.0.0',
            'pygments>=2.0.1, <3.0',
            'python-daemon>=2.1.1, <2.2',
            'python-dateutil>=2.3, <3',
            'python-nvd3==0.15.0',
            'requests>=2.5.1, <3',
            'setproctitle>=1.1.8, <2',
            'sqlalchemy>=1.1.15, <1.2.0',
            'sqlalchemy-utc>=0.9.0',
            'tabulate>=0.7.5, <0.8.0',
            'thrift>=0.9.2',
            'tzlocal>=1.4',
            'werkzeug>=0.14.1, <0.15.0',
            'zope.deprecation>=4.0, <5.0',
        ],
        setup_requires=[
            'docutils>=0.14, <1.0',
        ],
        extras_require={
            'all': devel_all,
            'devel_ci': devel_ci,
            'all_dbs': all_dbs,
            'async': async,
            'azure': azure,
            'celery': celery,
            'cgroups': cgroups,
            'cloudant': cloudant,
            'crypto': crypto,
            'dask': dask,
            'databricks': databricks,
            'datadog': datadog,
            'devel': devel_minreq,
            'devel_hadoop': devel_hadoop,
            'doc': doc,
            'docker': docker,
            'druid': druid,
            'emr': emr,
            'gcp_api': gcp_api,
            'github_enterprise': github_enterprise,
            'hdfs': hdfs,
            'hive': hive,
            'jdbc': jdbc,
            'kerberos': kerberos,
            'ldap': ldap,
            'mssql': mssql,
            'mysql': mysql,
            'oracle': oracle,
            'password': password,
            'postgres': postgres,
            'qds': qds,
            'rabbitmq': rabbitmq,
            's3': s3,
            'salesforce': salesforce,
            'samba': samba,
            'sendgrid' : sendgrid,
            'slack': slack,
            'ssh': ssh,
            'statsd': statsd,
            'vertica': vertica,
            'webhdfs': webhdfs,
            'jira': jira,
            'redis': redis,
            'kubernetes': kubernetes,
            'snowflake': snowflake
        },
        classifiers=[
            'Development Status :: 5 - Production/Stable',
            'Environment :: Console',
            'Environment :: Web Environment',
            'Intended Audience :: Developers',
            'Intended Audience :: System Administrators',
            'License :: OSI Approved :: Apache Software License',
            'Programming Language :: Python :: 2.7',
            'Programming Language :: Python :: 3.4',
            'Topic :: System :: Monitoring',
        ],
        author='Apache Software Foundation',
        author_email='dev@airflow.incubator.apache.org',
        url='http://airflow.incubator.apache.org/',
        download_url=(
            'https://dist.apache.org/repos/dist/release/incubator/airflow/' + version),
        cmdclass={
            'test': Tox,
            'extra_clean': CleanCommand,
        },
    )


if __name__ == "__main__":
    do_setup()

# Copyright 2010 United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration.
# All Rights Reserved.
# Copyright (c) 2010 Citrix Systems, Inc.
#
#    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.

"""
Helper methods to deal with images.
"""

import re

from oslo.utils import strutils

from nova.openstack.common._i18n import _


class QemuImgInfo(object):
    BACKING_FILE_RE = re.compile((r"^(.*?)\s*\(actual\s+path\s*:"
                                  r"\s+(.*?)\)\s*$"), re.I)
    TOP_LEVEL_RE = re.compile(r"^([\w\d\s\_\-]+):(.*)$")
    SIZE_RE = re.compile(r"(\d*\.?\d+)(\w+)?(\s*\(\s*(\d+)\s+bytes\s*\))?",
                         re.I)

    def __init__(self, cmd_output=None):
        details = self._parse(cmd_output or '')
        self.image = details.get('image')
        self.backing_file = details.get('backing_file')
        self.file_format = details.get('file_format')
        self.virtual_size = details.get('virtual_size')
        self.cluster_size = details.get('cluster_size')
        self.disk_size = details.get('disk_size')
        self.snapshots = details.get('snapshot_list', [])
        self.encrypted = details.get('encrypted')

    def __str__(self):
        lines = [
            'image: %s' % self.image,
            'file_format: %s' % self.file_format,
            'virtual_size: %s' % self.virtual_size,
            'disk_size: %s' % self.disk_size,
            'cluster_size: %s' % self.cluster_size,
            'backing_file: %s' % self.backing_file,
        ]
        if self.snapshots:
            lines.append("snapshots: %s" % self.snapshots)
        if self.encrypted:
            lines.append("encrypted: %s" % self.encrypted)
        return "\n".join(lines)

    def _canonicalize(self, field):
        # Standardize on underscores/lc/no dash and no spaces
        # since qemu seems to have mixed outputs here... and
        # this format allows for better integration with python
        # - i.e. for usage in kwargs and such...
        field = field.lower().strip()
        for c in (" ", "-"):
            field = field.replace(c, '_')
        return field

    def _extract_bytes(self, details):
        # Replace it with the byte amount
        real_size = self.SIZE_RE.search(details)
        if not real_size:
            raise ValueError(_('Invalid input value "%s".') % details)
        magnitude = real_size.group(1)
        unit_of_measure = real_size.group(2)
        bytes_info = real_size.group(3)
        if bytes_info:
            return int(real_size.group(4))
        elif not unit_of_measure:
            return int(magnitude)
        return strutils.string_to_bytes('%s%sB' % (magnitude, unit_of_measure),
                                        return_int=True)

    def _extract_details(self, root_cmd, root_details, lines_after):
        real_details = root_details
        if root_cmd == 'backing_file':
            # Replace it with the real backing file
            backing_match = self.BACKING_FILE_RE.match(root_details)
            if backing_match:
                real_details = backing_match.group(2).strip()
        elif root_cmd in ['virtual_size', 'cluster_size', 'disk_size']:
            # Replace it with the byte amount (if we can convert it)
            if root_details == 'None':
                real_details = 0
            else:
                real_details = self._extract_bytes(root_details)
        elif root_cmd == 'file_format':
            real_details = real_details.strip().lower()
        elif root_cmd == 'snapshot_list':
            # Next line should be a header, starting with 'ID'
            if not lines_after or not lines_after.pop(0).startswith("ID"):
                msg = _("Snapshot list encountered but no header found!")
                raise ValueError(msg)
            real_details = []
            # This is the sprintf pattern we will try to match
            # "%-10s%-20s%7s%20s%15s"
            # ID TAG VM SIZE DATE VM CLOCK (current header)
            while lines_after:
                line = lines_after[0]
                line_pieces = line.split()
                if len(line_pieces) != 6:
                    break
                # Check against this pattern in the final position
                # "%02d:%02d:%02d.%03d"
                date_pieces = line_pieces[5].split(":")
                if len(date_pieces) != 3:
                    break
                lines_after.pop(0)
                real_details.append({
                    'id': line_pieces[0],
                    'tag': line_pieces[1],
                    'vm_size': line_pieces[2],
                    'date': line_pieces[3],
                    'vm_clock': line_pieces[4] + " " + line_pieces[5],
                })
        return real_details

    def _parse(self, cmd_output):
        # Analysis done of qemu-img.c to figure out what is going on here
        # Find all points start with some chars and then a ':' then a newline
        # and then handle the results of those 'top level' items in a separate
        # function.
        #
        # TODO(harlowja): newer versions might have a json output format
        #                 we should switch to that whenever possible.
        #                 see: http://bit.ly/XLJXDX
        contents = {}
        lines = [x for x in cmd_output.splitlines() if x.strip()]
        while lines:
            line = lines.pop(0)
            top_level = self.TOP_LEVEL_RE.match(line)
            if top_level:
                root = self._canonicalize(top_level.group(1))
                if not root:
                    continue
                root_details = top_level.group(2).strip()
                details = self._extract_details(root, root_details, lines)
                contents[root] = details
        return contents

#
# gdb helper commands and functions for Linux kernel debugging
#
#  kernel log buffer dump
#
# Copyright (c) Siemens AG, 2011, 2012
#
# Authors:
#  Jan Kiszka <jan.kiszka@siemens.com>
#
# This work is licensed under the terms of the GNU GPL version 2.
#

import gdb

from linux import utils


class LxDmesg(gdb.Command):
    """Print Linux kernel log buffer."""

    def __init__(self):
        super(LxDmesg, self).__init__("lx-dmesg", gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        log_buf_addr = int(str(gdb.parse_and_eval("log_buf")).split()[0], 16)
        log_first_idx = int(gdb.parse_and_eval("log_first_idx"))
        log_next_idx = int(gdb.parse_and_eval("log_next_idx"))
        log_buf_len = int(gdb.parse_and_eval("log_buf_len"))

        inf = gdb.inferiors()[0]
        start = log_buf_addr + log_first_idx
        if log_first_idx < log_next_idx:
            log_buf_2nd_half = -1
            length = log_next_idx - log_first_idx
            log_buf = inf.read_memory(start, length)
        else:
            log_buf_2nd_half = log_buf_len - log_first_idx
            log_buf = inf.read_memory(start, log_buf_2nd_half) + \
                inf.read_memory(log_buf_addr, log_next_idx)

        pos = 0
        while pos < log_buf.__len__():
            length = utils.read_u16(log_buf[pos + 8:pos + 10])
            if length == 0:
                if log_buf_2nd_half == -1:
                    gdb.write("Corrupted log buffer!\n")
                    break
                pos = log_buf_2nd_half
                continue

            text_len = utils.read_u16(log_buf[pos + 10:pos + 12])
            text = log_buf[pos + 16:pos + 16 + text_len]
            time_stamp = utils.read_u64(log_buf[pos:pos + 8])

            for line in memoryview(text).tobytes().splitlines():
                gdb.write("[{time:12.6f}] {line}\n".format(
                    time=time_stamp / 1000000000.0,
                    line=line))

            pos += length


LxDmesg()

# -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# 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.
#
import warnings
from typing import Callable, Dict, Optional, Sequence, Tuple

from google.api_core import grpc_helpers   # type: ignore
from google.api_core import gapic_v1       # type: ignore
import google.auth                         # type: ignore
from google.auth import credentials as ga_credentials  # type: ignore
from google.auth.transport.grpc import SslCredentials  # type: ignore

import grpc  # type: ignore

from google.ads.googleads.v6.resources.types import detail_placement_view
from google.ads.googleads.v6.services.types import detail_placement_view_service
from .base import DetailPlacementViewServiceTransport, DEFAULT_CLIENT_INFO


class DetailPlacementViewServiceGrpcTransport(DetailPlacementViewServiceTransport):
    """gRPC backend transport for DetailPlacementViewService.

    Service to fetch Detail Placement views.

    This class defines the same methods as the primary client, so the
    primary client can load the underlying transport implementation
    and call it.

    It sends protocol buffers over the wire using gRPC (which is built on
    top of HTTP/2); the ``grpcio`` package must be installed.
    """
    def __init__(self, *,
            host: str = 'googleads.googleapis.com',
            credentials: ga_credentials.Credentials = None,
            credentials_file: str = None,
            scopes: Sequence[str] = None,
            channel: grpc.Channel = None,
            api_mtls_endpoint: str = None,
            client_cert_source: Callable[[], Tuple[bytes, bytes]] = None,
            ssl_channel_credentials: grpc.ChannelCredentials = None,
            quota_project_id: Optional[str] = None,
            client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
            ) -> None:
        """Instantiate the transport.

        Args:
            host (Optional[str]):
                 The hostname to connect to.
            credentials (Optional[google.auth.credentials.Credentials]): The
                authorization credentials to attach to requests. These
                credentials identify the application to the service; if none
                are specified, the client will attempt to ascertain the
                credentials from the environment.
                This argument is ignored if ``channel`` is provided.
            credentials_file (Optional[str]): A file with credentials that can
                be loaded with :func:`google.auth.load_credentials_from_file`.
                This argument is ignored if ``channel`` is provided.
            scopes (Optional(Sequence[str])): A list of scopes. This argument is
                ignored if ``channel`` is provided.
            channel (Optional[grpc.Channel]): A ``Channel`` instance through
                which to make calls.
            api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
                If provided, it overrides the ``host`` argument and tries to create
                a mutual TLS channel with client SSL credentials from
                ``client_cert_source`` or applicatin default SSL credentials.
            client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
                Deprecated. A callback to provide client SSL certificate bytes and
                private key bytes, both in PEM format. It is ignored if
                ``api_mtls_endpoint`` is None.
            ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
                for grpc channel. It is ignored if ``channel`` is provided.
            quota_project_id (Optional[str]): An optional project to use for billing
                and quota.
            client_info (google.api_core.gapic_v1.client_info.ClientInfo):
                The client info used to send a user-agent string along with
                API requests. If ``None``, then default info will be used.
                Generally, you only need to set this if you're developing
                your own client library.

        Raises:
          google.auth.exceptions.MutualTLSChannelError: If mutual TLS transport
              creation failed for any reason.
        """
        self._ssl_channel_credentials = ssl_channel_credentials

        if channel:
            # Sanity check: Ensure that channel and credentials are not both
            # provided.
            credentials = False

            # If a channel was explicitly provided, set it.
            self._grpc_channel = channel
            self._ssl_channel_credentials = None
        elif api_mtls_endpoint:
            warnings.warn("api_mtls_endpoint and client_cert_source are deprecated", DeprecationWarning)

            host = api_mtls_endpoint if ":" in api_mtls_endpoint else api_mtls_endpoint + ":443"

            if credentials is None:
                credentials, _ = google.auth.default(scopes=self.AUTH_SCOPES, quota_project_id=quota_project_id)

            # Create SSL credentials with client_cert_source or application
            # default SSL credentials.
            if client_cert_source:
                cert, key = client_cert_source()
                ssl_credentials = grpc.ssl_channel_credentials(
                    certificate_chain=cert, private_key=key
                )
            else:
                ssl_credentials = SslCredentials().ssl_credentials

            # create a new channel. The provided one is ignored.
            self._grpc_channel = type(self).create_channel(
                host,
                credentials=credentials,
                credentials_file=credentials_file,
                ssl_credentials=ssl_credentials,
                scopes=scopes or self.AUTH_SCOPES,
                quota_project_id=quota_project_id,
                options=[
                    ("grpc.max_send_message_length", -1),
                    ("grpc.max_receive_message_length", -1),
                ],
            )
            self._ssl_channel_credentials = ssl_credentials
        else:
            host = host if ":" in host else host + ":443"

            if credentials is None:
                credentials, _ = google.auth.default(scopes=self.AUTH_SCOPES)

            # create a new channel. The provided one is ignored.
            self._grpc_channel = type(self).create_channel(
                host,
                credentials=credentials,
                ssl_credentials=ssl_channel_credentials,
                scopes=self.AUTH_SCOPES,
                options=[
                    ("grpc.max_send_message_length", -1),
                    ("grpc.max_receive_message_length", -1),
                ],
            )

        self._stubs = {}  # type: Dict[str, Callable]

        # Run the base constructor.
        super().__init__(
            host=host,
            credentials=credentials,
            client_info=client_info,
        )

    @classmethod
    def create_channel(cls,
                       host: str = 'googleads.googleapis.com',
                       credentials: ga_credentials.Credentials = None,
                       scopes: Optional[Sequence[str]] = None,
                       **kwargs) -> grpc.Channel:
        """Create and return a gRPC channel object.
        Args:
            address (Optionsl[str]): The host for the channel to use.
            credentials (Optional[~.Credentials]): The
                authorization credentials to attach to requests. These
                credentials identify this application to the service. If
                none are specified, the client will attempt to ascertain
                the credentials from the environment.
            scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
                service. These are only used when credentials are not specified and
                are passed to :func:`google.auth.default`.
            kwargs (Optional[dict]): Keyword arguments, which are passed to the
                channel creation.
        Returns:
            grpc.Channel: A gRPC channel object.
        """
        return grpc_helpers.create_channel(
            host,
            credentials=credentials,
            scopes=scopes or cls.AUTH_SCOPES,
            **kwargs
        )

    @property
    def grpc_channel(self) -> grpc.Channel:
        """Return the channel designed to connect to this service.
        """
        return self._grpc_channel

    @property
    def get_detail_placement_view(self) -> Callable[
            [detail_placement_view_service.GetDetailPlacementViewRequest],
            detail_placement_view.DetailPlacementView]:
        r"""Return a callable for the get detail placement view method over gRPC.

        Returns the requested Detail Placement view in full
        detail.

        Returns:
            Callable[[~.GetDetailPlacementViewRequest],
                    ~.DetailPlacementView]:
                A function that, when called, will call the underlying RPC
                on the server.
        """
        # Generate a "stub function" on-the-fly which will actually make
        # the request.
        # gRPC handles serialization and deserialization, so we just need
        # to pass in the functions for each.
        if 'get_detail_placement_view' not in self._stubs:
            self._stubs['get_detail_placement_view'] = self.grpc_channel.unary_unary(
                '/google.ads.googleads.v6.services.DetailPlacementViewService/GetDetailPlacementView',
                request_serializer=detail_placement_view_service.GetDetailPlacementViewRequest.serialize,
                response_deserializer=detail_placement_view.DetailPlacementView.deserialize,
            )
        return self._stubs['get_detail_placement_view']


__all__ = (
    'DetailPlacementViewServiceGrpcTransport',
)

#! /usr/bin/python

import os
import re
import sys
import platform
import uuid
from xml.dom import minidom

# necessary so that setup finds the resources
# before we import setup, we need to find the src directory


def source_folders():
    for dir_ in sorted([p for p in os.listdir()
                 if re.match("openmolar-\d\.\d\.\d", p)]):
        if os.path.isdir(dir_):
            yield os.path.abspath(dir_)


path = os.path.abspath(os.path.dirname(__file__))
EXE_PATH = os.path.join(path, "dist", "openmolar.exe")
if not os.path.isfile(EXE_PATH):
    sys.exit("Cannot find %s!\nQUITTING" % EXE_PATH)

# this script should be run on windows, but I test on debian.
if platform.system() == "Windows":
    OUTFILE = os.path.join(path, "openmolar.wxs")
    os.chdir(path)
    os.chdir("../")
    SRCDIR = list(source_folders())[-1]
else:
    print("WARNING - THIS SCRIPT SHOULD BE RUN ON WINDOWS")
    SRCDIR = "/home/neil/openmolar/openmolar1"
    OUTFILE = os.path.join(path, "openmolar_debian.wxs")

os.chdir(SRCDIR)
sys.path.insert(0, SRCDIR)   # for correct path to setup.py
sys.path.insert(0, os.path.join(SRCDIR, "src")) # for corect path to version.py

import setup
from openmolar.settings.version import VERSION

'''
this module generates our wix file.
usage is make_wxs.py > openmolar.wxs
'''

print("running make_wxs\nutilising DATA_FILES from %s" % setup.__file__)

# NEVER CHANGE THIS!!!
UPGRADE_GUID = "3E52AFB20C5511E6B04339339F36C610"


m = re.match("(\d+).(\d+).(\d+)-", VERSION)
if not m:
    sys.exit("VERSION %s should be in the form x.x.x-foo\nQUITTING" % VERSION)

version_digits = m.groups()
VERSION = "%s.%s.%s.0" % version_digits

RESOURCES_PATH = os.path.abspath(os.path.join(SRCDIR, "src", "openmolar",
                                              "resources"))

ICON_PATH = os.path.join(RESOURCES_PATH, "icons", "openmolar.ico")
DIALOG_BITMAP_PATH = os.path.join(RESOURCES_PATH, 'win_install_dialog.bmp')
BANNER_BITMAP_PATH = os.path.join(RESOURCES_PATH, 'win_install_banner.bmp')

LICENSE_PATH = os.path.abspath(os.path.join(path, "license.rtf"))

EXIT_MESSAGE = '''Thank you for installing OpenMolar.

Please join the openmolar community and contribute
to the documentation, the source code or
internationalisation.

Find out more at http://openmolar.com'''


def _template():

    '''
    This is a function so that vim folds the nasty big string!
    '''

    template = r'''
    <Product Id="*" UpgradeCode="{{ UPGRADE_GUID }}"
    Name="OpenMolar" Version="{{ VERSION }}"
    Manufacturer="OpenMolar" Language="1033">
        <Package InstallerVersion="200" Compressed="yes" Comments="Windows Installer Package for OpenMolar"/>
        <Media Id="1" Cabinet="openmolar.cab" EmbedCab="yes"/>

        <WixVariable Id="WixUILicenseRtf" Value="{{ LICENSE_RTF }}" />

        <!-- Define icons (ID should not be longer than 18 chars and must end with ".exe") -->
        <Icon Id="Icon.exe" SourceFile="{{ ICON }}"/>

        <!-- Set properties for add/remove programs -->
        <Property Id="ARPPRODUCTICON" Value="Icon.exe"/>
        <Property Id="ARPHELPLINK" Value="http://openmolar.com"/>
        <Property Id="ARPURLINFOABOUT" Value="http://openmolar.com"/>
        <Property Id="ARPNOREPAIR" Value="1"/>
        <Upgrade Id="{{ UPGRADE_GUID }}">
            <UpgradeVersion Minimum="{{ VERSION }}" OnlyDetect="yes" Property="NEWERVERSIONDETECTED"/>
            <UpgradeVersion Minimum="0.0.0" Maximum="{{ VERSION }}"
            IncludeMinimum="yes" IncludeMaximum="no" Property="OLDERVERSIONBEINGUPGRADED"/>
        </Upgrade>
        <Condition Message="A newer version of this software is already installed.">
            NOT NEWERVERSIONDETECTED
        </Condition>
        <Directory Id="TARGETDIR" Name="SourceDir">
            <Directory Id="ProgramFilesFolder">

                <Directory Id="INSTALLDIR" Name="OpenMolar">
                    <Component Id="MainExecutable" Guid="63C30814-E8BF-4C22-B551-63ADAD252774">
                        <File Id="OpenMolar.exe" Source="{{ EXE_PATH }}" KeyPath="yes" Checksum="yes">
                        </File>
                    </Component>

                    <Directory Id="LocaleDIR" Name="locale">
                    {{ LOCALE_FILES }}
                    </Directory>

                    <Directory Id="ResourcesDIR" Name="resources">
                    {{ RESOURCE_FILES }}
                    </Directory>

                </Directory>
            </Directory>

            <Directory Id="ProgramMenuFolder">
                <Directory Id="ProgramMenuSubfolder" Name="OpenMolar">
                    <Component Id="ApplicationShortcuts" Guid="34486FA2-FF2D-433F-B0E9-5DEA3BE1732F">
                        <Shortcut Id="ApplicationShortcut1" Name="Openmolar" Description="Dental Practice Management Suite"
                                    Target="[INSTALLDIR]openmolar.exe" WorkingDirectory="INSTALLDIR"/>
                        <RegistryValue Root="HKCU" Key="Software\OpenMolar\OpanMolar"
                                    Name="installed" Type="integer" Value="1" KeyPath="yes"/>
                        <RemoveFolder Id="ProgramMenuSubfolder" On="uninstall"/>
                    </Component>
                </Directory>
            </Directory>
        </Directory>

      <InstallExecuteSequence>
         <RemoveExistingProducts After="InstallValidate"/>
      </InstallExecuteSequence>

        <Feature Id="DefaultFeature" Level="1">
            <ComponentRef Id="MainExecutable"/>
            <ComponentRef Id="ApplicationShortcuts"/>
            {{ COMPONENT_REFS }}
        </Feature>

        <!-- Define the UI to use - NOTE this requires extra arguments when
        usng light.exe -->

        <WixVariable Id="WixUIDialogBmp" Value="{{ DIALOG_BITMAP_PATH }}" />
        <WixVariable Id="WixUIBannerBmp" Value="{{ BANNER_BITMAP_PATH }}" />
        <UIRef Id="WixUI_Minimal" />
        <UIRef Id="WixUI_ErrorProgressText" />

        <Property Id="WIXUI_EXITDIALOGOPTIONALTEXT"
        Value="{{ EXIT_MESSAGE }}"
        />

        </Product>'''

    return ('<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">\n'
            '%s\n</Wix>\n' % template)


def locale_files():
    '''
    iterate over the files usually installed by setup.py and add to the file
    '''
    folder_no, file_no = 0, 0
    data =''
    component_refs = ""
    for folder, files in setup.DATA_FILES:
        if "locale" not in folder:
            continue
        folder_no += 1
        dirname = os.path.split(folder)[1]
        if dirname != "locale":  # files are not in a subfolder
            data += '<Directory Id="locale_subdir%s" Name="%s">\n' % (
                folder_no, dirname)
        for file_ in files:
            file_no += 1
            guid = uuid.uuid1().hex.upper()
            ref = "locale_component%d" % file_no
            data += ('<Component Id="%s" Guid="%s">\n'
                     '<File Id="locale_file%d" Source="%s" '
                     'KeyPath="yes" Checksum="yes" />\n'
                     '</Component>\n' % (ref, guid, file_no, file_))
            component_refs += '<ComponentRef Id="%s" />\n' % ref
        if dirname != "locale":  # files are not in a subfolder
            data += "</Directory>\n\n"

    return data, component_refs


def resource_files():
    '''
    iterate over the files usually installed by setup.py and add to the file
    '''
    folder_no, file_no = 0, 0
    data =''
    component_refs = ""
    for folder, files in setup.DATA_FILES:
        if "resources" not in folder:
            continue
        folder_no += 1
        dirname = os.path.split(folder)[1]
        if dirname != "resources":  # files are not in a subfolder
            data += ('<Directory Id="resource_folder%s" Name="%s">\n' % (
                folder_no, dirname))
        for file_ in files:
            file_no += 1
            guid = uuid.uuid1().hex.upper()
            ref = "resource_component%d" % file_no
            data += ('<Component Id="%s" Guid="%s">\n'
                     '<File Id="resource_file%d" Source="%s" '
                     'KeyPath="yes" Checksum="yes" />\n'
                     '</Component>\n' % (ref, guid, file_no, file_))
            component_refs += '<ComponentRef Id="%s" />\n' % ref
        if dirname != "resources":  # files are not in a subfolder
            data += "</Directory>\n\n"

    return data, component_refs


def main():
    t = _template().replace("{{ VERSION }}", VERSION)
    t = t.replace("{{ LICENSE_RTF }}", LICENSE_PATH)
    t = t.replace("{{ ICON }}", ICON_PATH)
    t = t.replace("{{ DIALOG_BITMAP_PATH }}", DIALOG_BITMAP_PATH)
    t = t.replace("{{ BANNER_BITMAP_PATH }}", BANNER_BITMAP_PATH)
    t = t.replace("{{ EXE_PATH }}", EXE_PATH)
    t = t.replace("{{ EXIT_MESSAGE }}", EXIT_MESSAGE)
    t = t.replace("{{ UPGRADE_GUID }}", UPGRADE_GUID)
    locale_components, locale_refs = locale_files()
    t = t.replace("{{ LOCALE_FILES }}", locale_components)
    resource_components, resource_refs = resource_files()
    t = t.replace("{{ RESOURCE_FILES }}", resource_components)
    t = t.replace("{{ COMPONENT_REFS }}", locale_refs + resource_refs)
    return t


def prettify(xml):
    '''
    default minidom.toprettyxml produces way too many blank lines.
    '''
    d = minidom.parseString(xml)
    prettyxml = d.toprettyxml(indent=' '*2, encoding="UTF-8").decode("UTF-8")
    xml_lines = prettyxml.split('\n')
    return '\n'.join([line for line in xml_lines if line.strip()])


if __name__ == "__main__":
    xml_ = main()
    f = open(OUTFILE, "w")
    f.write(prettify(xml_))
    f.close()

#   Copyright 2011 OpenStack Foundation
#
#   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.

import os.path
import traceback

import webob
from webob import exc

from nova.api.openstack import common
from nova.api.openstack import extensions
from nova.api.openstack import wsgi
from nova import compute
from nova.compute import vm_states
from nova import exception
from nova.openstack.common.gettextutils import _
from nova.openstack.common import log as logging

LOG = logging.getLogger(__name__)

# States usable in resetState action
state_map = dict(active=vm_states.ACTIVE, error=vm_states.ERROR)


def authorize(context, action_name):
    action = 'admin_actions:%s' % action_name
    extensions.extension_authorizer('compute', action)(context)


class AdminActionsController(wsgi.Controller):
    def __init__(self, *args, **kwargs):
        super(AdminActionsController, self).__init__(*args, **kwargs)
        self.compute_api = compute.API()

    # TODO(bcwaldon): These action names should be prefixed with 'os-'

    @wsgi.action('pause')
    def _pause(self, req, id, body):
        """Permit Admins to pause the server."""
        ctxt = req.environ['nova.context']
        authorize(ctxt, 'pause')
        try:
            server = self.compute_api.get(ctxt, id, want_objects=True)
            self.compute_api.pause(ctxt, server)
        except exception.InstanceInvalidState as state_error:
            common.raise_http_conflict_for_instance_invalid_state(state_error,
                    'pause')
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("Compute.api::pause %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('unpause')
    def _unpause(self, req, id, body):
        """Permit Admins to unpause the server."""
        ctxt = req.environ['nova.context']
        authorize(ctxt, 'unpause')
        try:
            server = self.compute_api.get(ctxt, id, want_objects=True)
            self.compute_api.unpause(ctxt, server)
        except exception.InstanceInvalidState as state_error:
            common.raise_http_conflict_for_instance_invalid_state(state_error,
                    'unpause')
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("Compute.api::unpause %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('suspend')
    def _suspend(self, req, id, body):
        """Permit admins to suspend the server."""
        context = req.environ['nova.context']
        authorize(context, 'suspend')
        try:
            server = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.suspend(context, server)
        except exception.InstanceInvalidState as state_error:
            common.raise_http_conflict_for_instance_invalid_state(state_error,
                    'suspend')
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("compute.api::suspend %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('resume')
    def _resume(self, req, id, body):
        """Permit admins to resume the server from suspend."""
        context = req.environ['nova.context']
        authorize(context, 'resume')
        try:
            server = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.resume(context, server)
        except exception.InstanceInvalidState as state_error:
            common.raise_http_conflict_for_instance_invalid_state(state_error,
                    'resume')
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("compute.api::resume %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('migrate')
    def _migrate(self, req, id, body):
        """Permit admins to migrate a server to a new host."""
        context = req.environ['nova.context']
        authorize(context, 'migrate')
        try:
            instance = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.resize(req.environ['nova.context'], instance)
        except exception.InstanceInvalidState as state_error:
            common.raise_http_conflict_for_instance_invalid_state(state_error,
                    'migrate')
        except Exception as e:
            LOG.exception(_("Error in migrate %s"), e)
            raise exc.HTTPBadRequest()
        return webob.Response(status_int=202)

    @wsgi.action('resetNetwork')
    def _reset_network(self, req, id, body):
        """Permit admins to reset networking on a server."""
        context = req.environ['nova.context']
        authorize(context, 'resetNetwork')
        try:
            instance = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.reset_network(context, instance)
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("Compute.api::reset_network %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('injectNetworkInfo')
    def _inject_network_info(self, req, id, body):
        """Permit admins to inject network info into a server."""
        context = req.environ['nova.context']
        authorize(context, 'injectNetworkInfo')
        try:
            instance = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.inject_network_info(context, instance)
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("Compute.api::inject_network_info %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('lock')
    def _lock(self, req, id, body):
        """Lock a server instance."""
        context = req.environ['nova.context']
        authorize(context, 'lock')
        try:
            instance = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.lock(context, instance)
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("Compute.api::lock %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('unlock')
    def _unlock(self, req, id, body):
        """Unlock a server instance."""
        context = req.environ['nova.context']
        authorize(context, 'unlock')
        try:
            instance = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.unlock(context, instance)
        except exception.PolicyNotAuthorized as e:
            raise webob.exc.HTTPForbidden(explanation=e.format_message())
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("Compute.api::unlock %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)

    @wsgi.action('createBackup')
    def _create_backup(self, req, id, body):
        """Backup a server instance.

        Images now have an `image_type` associated with them, which can be
        'snapshot' or the backup type, like 'daily' or 'weekly'.

        If the image_type is backup-like, then the rotation factor can be
        included and that will cause the oldest backups that exceed the
        rotation factor to be deleted.

        """
        context = req.environ["nova.context"]
        authorize(context, 'createBackup')

        try:
            entity = body["createBackup"]
        except (KeyError, TypeError):
            raise exc.HTTPBadRequest(_("Malformed request body"))

        try:
            image_name = entity["name"]
            backup_type = entity["backup_type"]
            rotation = entity["rotation"]

        except KeyError as missing_key:
            msg = _("createBackup entity requires %s attribute") % missing_key
            raise exc.HTTPBadRequest(explanation=msg)

        except TypeError:
            msg = _("Malformed createBackup entity")
            raise exc.HTTPBadRequest(explanation=msg)

        try:
            rotation = int(rotation)
        except ValueError:
            msg = _("createBackup attribute 'rotation' must be an integer")
            raise exc.HTTPBadRequest(explanation=msg)
        if rotation < 0:
            msg = _("createBackup attribute 'rotation' must be greater "
                    "than or equal to zero")
            raise exc.HTTPBadRequest(explanation=msg)

        props = {}
        metadata = entity.get('metadata', {})
        common.check_img_metadata_properties_quota(context, metadata)
        try:
            props.update(metadata)
        except ValueError:
            msg = _("Invalid metadata")
            raise exc.HTTPBadRequest(explanation=msg)

        try:
            instance = self.compute_api.get(context, id, want_objects=True)
        except exception.NotFound:
            raise exc.HTTPNotFound(_("Instance not found"))

        try:
            image = self.compute_api.backup(context, instance, image_name,
                    backup_type, rotation, extra_properties=props)
        except exception.InstanceInvalidState as state_error:
            common.raise_http_conflict_for_instance_invalid_state(state_error,
                    'createBackup')

        resp = webob.Response(status_int=202)

        # build location of newly-created image entity if rotation is not zero
        if rotation > 0:
            image_id = str(image['id'])
            image_ref = os.path.join(req.application_url, 'images', image_id)
            resp.headers['Location'] = image_ref

        return resp

    @wsgi.action('os-migrateLive')
    def _migrate_live(self, req, id, body):
        """Permit admins to (live) migrate a server to a new host."""
        context = req.environ["nova.context"]
        authorize(context, 'migrateLive')

        try:
            block_migration = body["os-migrateLive"]["block_migration"]
            disk_over_commit = body["os-migrateLive"]["disk_over_commit"]
            host = body["os-migrateLive"]["host"]
        except (TypeError, KeyError):
            msg = _("host, block_migration and disk_over_commit must "
                    "be specified for live migration.")
            raise exc.HTTPBadRequest(explanation=msg)

        try:
            instance = self.compute_api.get(context, id, want_objects=True)
            self.compute_api.live_migrate(context, instance, block_migration,
                                          disk_over_commit, host)
        except (exception.ComputeServiceUnavailable,
                exception.InvalidHypervisorType,
                exception.UnableToMigrateToSelf,
                exception.DestinationHypervisorTooOld) as ex:
            raise exc.HTTPBadRequest(explanation=ex.format_message())
        except Exception:
            if host is None:
                msg = _("Live migration of instance %s to another host "
                        "failed") % id
            else:
                msg = _("Live migration of instance %(id)s to host %(host)s "
                        "failed") % {'id': id, 'host': host}
            LOG.exception(msg)
            # Return messages from scheduler
            raise exc.HTTPBadRequest(explanation=msg)

        return webob.Response(status_int=202)

    @wsgi.action('os-resetState')
    def _reset_state(self, req, id, body):
        """Permit admins to reset the state of a server."""
        context = req.environ["nova.context"]
        authorize(context, 'resetState')

        # Identify the desired state from the body
        try:
            state = state_map[body["os-resetState"]["state"]]
        except (TypeError, KeyError):
            msg = _("Desired state must be specified.  Valid states "
                    "are: %s") % ', '.join(sorted(state_map.keys()))
            raise exc.HTTPBadRequest(explanation=msg)

        try:
            instance = self.compute_api.get(context, id, want_objects=True)
            instance.vm_state = state
            instance.task_state = None
            instance.save(admin_state_reset=True)
        except exception.InstanceNotFound:
            raise exc.HTTPNotFound(_("Server not found"))
        except Exception:
            readable = traceback.format_exc()
            LOG.exception(_("Compute.api::resetState %s"), readable)
            raise exc.HTTPUnprocessableEntity()
        return webob.Response(status_int=202)


class Admin_actions(extensions.ExtensionDescriptor):
    """Enable admin-only server actions

    Actions include: pause, unpause, suspend, resume, migrate,
    resetNetwork, injectNetworkInfo, lock, unlock, createBackup
    """

    name = "AdminActions"
    alias = "os-admin-actions"
    namespace = "http://docs.openstack.org/compute/ext/admin-actions/api/v1.1"
    updated = "2011-09-20T00:00:00+00:00"

    def get_controller_extensions(self):
        controller = AdminActionsController()
        extension = extensions.ControllerExtension(self, 'servers', controller)
        return [extension]

# -*- encoding: utf-8 -*-

from mock import Mock

from pygithub3.core.client import Client
from pygithub3.core.result import smart, normal, base
from pygithub3.tests.utils.core import (TestCase, mock_paginate_github_in_GET,
    request, mock_no_paginate_github_in_GET, MockPaginate)


class ResultInitMixin(object):

    def setUp(self):
        self.c = Client()
        self.get_request = Mock(side_effect=self.mock)
        self.resource_loads = request.resource.loads
        self.c.get = self.get_request
        self.r = smart.Result(smart.Method(self.c.get, request))

    def tearDown(self):
        self.resource_loads.reset_mock()  # It mocks class method


class TestSmartResultWithPaginate(ResultInitMixin, TestCase):

    @property
    def mock(self):
        return mock_paginate_github_in_GET

    def test_iteration_CALLS(self):
        self.assertEqual(self.get_request.call_count, 0)
        self.assertEqual(self.resource_loads.call_count, 0)
        list(self.r)
        self.get_request.assert_called_once_with(request, page=1)
        self.assertEqual(self.resource_loads.call_count, 1)

    def test_consumed_are_Pages(self):
        pages_that_are_Pages = len(
            filter(lambda page: isinstance(page, base.Page), list(self.r)))
        self.assertEqual(pages_that_are_Pages, 3, 'There are not 3 Pages objs')

    def test_all_iteration_CALLS(self):
        self.r.all()
        self.assertEqual(self.get_request.call_count, 3)
        self.assertEqual(self.resource_loads.call_count, 3)

    def test_CACHE_with_renew_iterations(self):
        self.r.all()
        self.r.all()
        self.assertEqual(self.get_request.call_count, 3)
        self.assertEqual(len(self.r.getter.cache), 3)
        self.assertEqual(self.resource_loads.call_count, 3)

    def test_ITERATOR_calls(self):
        self.r.iterator()
        self.assertEqual(self.get_request.call_count, 0)
        self.assertEqual(self.resource_loads.call_count, 0)


class TestSmartResultWithoutPaginate(ResultInitMixin, TestCase):

    @property
    def mock(self):
        return mock_no_paginate_github_in_GET

    def test_iteration_stop_at_1(self):
        self.r.next()
        self.assertRaises(StopIteration, self.r.next)

    def test_get_only_1page(self):
        self.r.all()
        self.assertEqual(self.get_request.call_count, 1)
        self.assertEqual(self.resource_loads.call_count, 1)


class TestNormalResult(TestSmartResultWithPaginate, TestCase):

    @property
    def mock(self):
        return MockPaginate()

    def setUp(self):
        super(TestNormalResult, self).setUp()
        self.r = normal.Result(normal.Method(self.c.get, request))

    def test_iteration_CALLS(self):
        self.assertEqual(self.get_request.call_count, 0)
        self.assertEqual(self.resource_loads.call_count, 0)
        list(self.r)
        self.assertEqual(self.get_request.call_count, 3)
        self.assertEqual(self.resource_loads.call_count, 3)

    """ Inherit tests. They share behaviour
        def test_consumed_are_Pages(self):
        def test_all_iteration_CALLS(self):
        def test_CACHE_with_renew_iterations(self):
        def test_ITERATOR_calls(self):
    """

from base64 import b64decode
import hashlib, os, re
import binascii, array
from Crypto.Cipher import AES
from config.header import Header
from config.constant import *
from config.write_output import print_debug, print_output
from config.moduleInfo import ModuleInfo

# From https://github.com/mitsuhiko/python-pbkdf2
from pbkdf2 import pbkdf2_bin

class Jitsi(ModuleInfo):
	def __init__(self):
		options = {'command': '-j', 'action': 'store_true', 'dest': 'jitsi', 'help': 'jitsi'}
		suboptions = [{'command': '-ma', 'action': 'store', 'dest': 'master_pwd', 'help': 'enter the master password manually', 'title': 'Advanced jitsi option'}]
		ModuleInfo.__init__(self, 'jitsi', 'chats', options, suboptions)

		self.keylen = 32
		self.iterations = 1024
		self.padding = '\f'
		self.account_id = ''
		self.master_password_used = False
		self.masterpass = ' '
		
	def get_salt(self):
		salt_array = [12, 10, 15, 14, 11, 14, 14, 15]
		salt = array.array('b', salt_array)
		hexsalt = binascii.hexlify(salt)
		return binascii.unhexlify(hexsalt)
	
	def get_path(self):
		directory = '~/.jitsi'
		directory = os.path.expanduser(directory) + os.sep + 'sip-communicator.properties'
		
		if os.path.exists(directory):
			return directory
		else:
			return 'JITSI_NOT_EXISTS'

		
	def get_info(self, file_properties):
		values = {}
		
		f = open(file_properties,'r')
		line = f.readline()
		
		
		cpt = 0
		pwdFound = []
		while line:
			if 'ACCOUNT_UID' in line:
				m = re.match(r"(.*)ACCOUNT_UID=(.*$)",line)
				if m:
					# password found
					if cpt > 0:
						pwdFound.append(values)
						cpt = 0
	
					values = {}
					values['Account id'] = m.group(2)
					cpt += 1
				
			if 'ENCRYPTED_PASSWORD' in line:
				m = re.match(r"(.*)ENCRYPTED_PASSWORD=(.*$)",line)
				if m:
					values['Password'] = self.decrypt_password(m.group(2)).replace('\x06', '')
					cpt += 1
				
			if 'credentialsstorage.MASTER' in line:
				m = re.match(r"(.*)credentialsstorage.MASTER=(.*$)",line)
				if m:
					values['Masterpass used'] = True
					self.master_password_used = True
				
			line = f.readline()
		
		if len(values) != 0:
			pwdFound.append(values)
		
		# print the results
		print_output('Jitsi', pwdFound)
		f.close()
		
	def decrypt_password(self, encrypted_pass):
		salt = self.get_salt()
		
		if self.master_password_used and constant.jitsi_masterpass:
			self.masterpass = constant.jitsi_masterpass
		elif self.master_password_used and not constant.jitsi_masterpass:
			return '[!] A master password is used, the password cannot be decrypted. Provide a masterpassword using the -ma option'
		
		# --- Decrypting the password ---
		# generate hash
		secret = pbkdf2_bin(bytes(self.masterpass), salt, self.iterations, self.keylen, hashfunc=hashlib.sha1)
		
		# decrypt password
		cipher = AES.new(secret)
		plaintext = cipher.decrypt(b64decode(encrypted_pass)).rstrip(self.padding)
		
		return plaintext
	
	# main function
	def run(self):
		# print the title
		Header().title_info('Jitsi')
		
		file_properties = self.get_path()
		if file_properties == 'JITSI_NOT_EXISTS':
			print_debug('INFO', 'Jitsi not installed.')
		
		else:
			self.get_info(file_properties)



# Collect facts related to LSB (Linux Standard Base)
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os

from ansible.module_utils.facts.utils import get_file_lines
from ansible.module_utils.facts.collector import BaseFactCollector


class LSBFactCollector(BaseFactCollector):
    name = 'lsb'
    _fact_ids = set()

    def _lsb_release_bin(self, lsb_path, module):
        lsb_facts = {}

        if not lsb_path:
            return lsb_facts

        rc, out, err = module.run_command([lsb_path, "-a"], errors='surrogate_then_replace')
        if rc != 0:
            return lsb_facts

        for line in out.splitlines():
            if len(line) < 1 or ':' not in line:
                continue
            value = line.split(':', 1)[1].strip()

            if 'LSB Version:' in line:
                lsb_facts['release'] = value
            elif 'Distributor ID:' in line:
                lsb_facts['id'] = value
            elif 'Description:' in line:
                lsb_facts['description'] = value
            elif 'Release:' in line:
                lsb_facts['release'] = value
            elif 'Codename:' in line:
                lsb_facts['codename'] = value

        return lsb_facts

    def _lsb_release_file(self, etc_lsb_release_location):
        lsb_facts = {}

        if not os.path.exists(etc_lsb_release_location):
            return lsb_facts

        for line in get_file_lines(etc_lsb_release_location):
            value = line.split('=', 1)[1].strip()

            if 'DISTRIB_ID' in line:
                lsb_facts['id'] = value
            elif 'DISTRIB_RELEASE' in line:
                lsb_facts['release'] = value
            elif 'DISTRIB_DESCRIPTION' in line:
                lsb_facts['description'] = value
            elif 'DISTRIB_CODENAME' in line:
                lsb_facts['codename'] = value

        return lsb_facts

    def collect(self, module=None, collected_facts=None):
        facts_dict = {}
        lsb_facts = {}

        if not module:
            return facts_dict

        lsb_path = module.get_bin_path('lsb_release')

        # try the 'lsb_release' script first
        if lsb_path:
            lsb_facts = self._lsb_release_bin(lsb_path,
                                              module=module)

        # no lsb_release, try looking in /etc/lsb-release
        if not lsb_facts:
            lsb_facts = self._lsb_release_file('/etc/lsb-release')

        if lsb_facts and 'release' in lsb_facts:
            lsb_facts['major_release'] = lsb_facts['release'].split('.')[0]

        facts_dict['lsb'] = lsb_facts
        return facts_dict

#!/usr/bin/env python
# coding=utf-8
###############################################################################

import os
import sys
import unittest
import inspect
import traceback
import optparse
import logging
import configobj

try:
    import cPickle as pickle
except ImportError:
    import pickle as pickle

try:
    from cStringIO import StringIO
except ImportError:
    from StringIO import StringIO

try:
    from setproctitle import setproctitle
except ImportError:
    setproctitle = None

sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__))))
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),
                                             'src')))
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__),
                                             'src', 'collectors')))


def run_only(func, predicate):
    if predicate():
        return func
    else:
        def f(arg):
            pass
        return f


def get_collector_config(key, value):
    config = configobj.ConfigObj()
    config['server'] = {}
    config['server']['collectors_config_path'] = ''
    config['collectors'] = {}
    config['collectors']['default'] = {}
    config['collectors']['default']['hostname_method'] = "uname_short"
    config['collectors'][key] = value
    return config


class CollectorTestCase(unittest.TestCase):

    def setDocExample(self, collector, metrics, defaultpath=None):
        if not len(metrics):
            return False

        filePath = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                                'docs', 'collectors-' + collector + '.md')

        if not os.path.exists(filePath):
            return False

        if not os.access(filePath, os.W_OK):
            return False

        if not os.access(filePath, os.R_OK):
            return False

        try:
            fp = open(filePath, 'Ur')
            content = fp.readlines()
            fp.close()

            fp = open(filePath, 'w')
            for line in content:
                if line.strip() == '__EXAMPLESHERE__':
                    for metric in sorted(metrics.iterkeys()):

                        metricPath = 'servers.hostname.'

                        if defaultpath:
                            metricPath += defaultpath + '.'

                        metricPath += metric

                        metricPath = metricPath.replace('..', '.')
                        fp.write('%s %s\n' % (metricPath, metrics[metric]))
                else:
                    fp.write(line)
            fp.close()

        except IOError:
            return False
        return True

    def getFixtureDirPath(self):
        path = os.path.join(
            os.path.dirname(inspect.getfile(self.__class__)),
            'fixtures')
        return path

    def getFixturePath(self, fixture_name):
        path = os.path.join(self.getFixtureDirPath(),
                            fixture_name)
        if not os.access(path, os.R_OK):
            print "Missing Fixture " + path
        return path

    def getFixture(self, fixture_name):
        try:
            f = open(self.getFixturePath(fixture_name), 'r')
            data = StringIO(f.read())
            return data
        finally:
            f.close()

    def getFixtures(self):
        fixtures = []
        for root, dirnames, filenames in os.walk(self.getFixtureDirPath()):
            fixtures.append(os.path.join(root, dirnames, filenames))
        return fixtures

    def getPickledResults(self, results_name):
        try:
            f = open(self.getFixturePath(results_name), 'r')
            data = pickle.load(f)
            return data
        finally:
            f.close()

    def setPickledResults(self, results_name, data):
        pickle.dump(data, open(self.getFixturePath(results_name), "w+b"))

    def assertUnpublished(self, mock, key, value, expected_value=0):
        return self.assertPublished(mock, key, value, expected_value)

    def assertPublished(self, mock, key, value, expected_value=1):
        if type(mock) is list:
            for m in mock:
                calls = (filter(lambda x: x[0][0] == key, m.call_args_list))
                if len(calls) > 0:
                    break
        else:
            calls = filter(lambda x: x[0][0] == key, mock.call_args_list)

        actual_value = len(calls)
        message = '%s: actual number of calls %d, expected %d' % (
            key, actual_value, expected_value)

        self.assertEqual(actual_value, expected_value, message)

        if expected_value:
            actual_value = calls[0][0][1]
            expected_value = value
            precision = 0

            if isinstance(value, tuple):
                expected_value, precision = expected_value

            message = '%s: actual %r, expected %r' % (key,
                                                      actual_value,
                                                      expected_value)

            if precision is not None:
                self.assertAlmostEqual(float(actual_value),
                                       float(expected_value),
                                       places=precision,
                                       msg=message)
            else:
                self.assertEqual(actual_value, expected_value, message)

    def assertUnpublishedMany(self, mock, dict, expected_value=0):
        return self.assertPublishedMany(mock, dict, expected_value)

    def assertPublishedMany(self, mock, dict, expected_value=1):
        for key, value in dict.iteritems():
            self.assertPublished(mock, key, value, expected_value)

        if type(mock) is list:
            for m in mock:
                m.reset_mock()
        else:
            mock.reset_mock()

    def assertUnpublishedMetric(self, mock, key, value, expected_value=0):
        return self.assertPublishedMetric(mock, key, value, expected_value)

    def assertPublishedMetric(self, mock, key, value, expected_value=1):
        calls = filter(lambda x: x[0][0].path.find(key) != -1,
                       mock.call_args_list)

        actual_value = len(calls)
        message = '%s: actual number of calls %d, expected %d' % (
            key, actual_value, expected_value)

        self.assertEqual(actual_value, expected_value, message)

        actual_value = calls[0][0][0].value
        expected_value = value
        precision = 0

        if isinstance(value, tuple):
            expected_value, precision = expected_value

        message = '%s: actual %r, expected %r' % (key,
                                                  actual_value,
                                                  expected_value)

        if precision is not None:
            self.assertAlmostEqual(float(actual_value),
                                   float(expected_value),
                                   places=precision,
                                   msg=message)
        else:
            self.assertEqual(actual_value, expected_value, message)

    def assertUnpublishedMetricMany(self, mock, dict, expected_value=0):
        return self.assertPublishedMetricMany(mock, dict, expected_value)

    def assertPublishedMetricMany(self, mock, dict, expected_value=1):
        for key, value in dict.iteritems():
            self.assertPublishedMetric(mock, key, value, expected_value)

        mock.reset_mock()

collectorTests = {}


def getCollectorTests(path):
    for f in os.listdir(path):
        cPath = os.path.abspath(os.path.join(path, f))

        if (os.path.isfile(cPath)
                and len(f) > 3
                and f[-3:] == '.py'
                and f[0:4] == 'test'):
            sys.path.append(os.path.dirname(cPath))
            sys.path.append(os.path.dirname(os.path.dirname(cPath)))
            modname = f[:-3]
            try:
                # Import the module
                collectorTests[modname] = __import__(modname,
                                                     globals(),
                                                     locals(),
                                                     ['*'])
            except Exception:
                print "Failed to import module: %s. %s" % (
                    modname, traceback.format_exc())
                continue

    for f in os.listdir(path):
        cPath = os.path.abspath(os.path.join(path, f))
        if os.path.isdir(cPath):
            getCollectorTests(cPath)

###############################################################################

if __name__ == "__main__":
    if setproctitle:
        setproctitle('test.py')

    # Disable log output for the unit tests
    log = logging.getLogger("diamond")
    log.addHandler(logging.StreamHandler(sys.stderr))
    log.disabled = True

    # Initialize Options
    parser = optparse.OptionParser()
    parser.add_option("-c",
                      "--collector",
                      dest="collector",
                      default="",
                      help="Run a single collector's unit tests")
    parser.add_option("-v",
                      "--verbose",
                      dest="verbose",
                      default=1,
                      action="count",
                      help="verbose")

    # Parse Command Line Args
    (options, args) = parser.parse_args()

    cPath = os.path.abspath(os.path.join(os.path.dirname(__file__),
                                         'src',
                                         'collectors',
                                         options.collector))

    dPath = os.path.abspath(os.path.join(os.path.dirname(__file__),
                                         'src',
                                         'diamond'))

    getCollectorTests(cPath)
    getCollectorTests(dPath)

    loader = unittest.TestLoader()
    tests = []
    for test in collectorTests:
        for name, c in inspect.getmembers(collectorTests[test],
                                          inspect.isclass):
            if not issubclass(c, unittest.TestCase):
                continue
            tests.append(loader.loadTestsFromTestCase(c))
    suite = unittest.TestSuite(tests)
    results = unittest.TextTestRunner(verbosity=options.verbose).run(suite)

    results = str(results)
    results = results.replace('>', '').split()[1:]
    resobj = {}
    for result in results:
        result = result.split('=')
        resobj[result[0]] = int(result[1])

    if resobj['failures'] > 0:
        sys.exit(1)
    if resobj['errors'] > 0:
        sys.exit(2)

    sys.exit(0)

import django.http
from django.test import TestCase
from nose.plugins.attrib import attr
import json

import lms.lib.comment_client
import django_comment_client.middleware as middleware


@attr('shard_1')
class AjaxExceptionTestCase(TestCase):
    def setUp(self):
        super(AjaxExceptionTestCase, self).setUp()
        self.a = middleware.AjaxExceptionMiddleware()
        self.request1 = django.http.HttpRequest()
        self.request0 = django.http.HttpRequest()
        self.exception1 = lms.lib.comment_client.CommentClientRequestError('{}', 401)
        self.exception2 = lms.lib.comment_client.CommentClientRequestError('Foo!', 404)
        self.exception0 = lms.lib.comment_client.CommentClient500Error("Holy crap the server broke!")
        self.request1.META['HTTP_X_REQUESTED_WITH'] = "XMLHttpRequest"
        self.request0.META['HTTP_X_REQUESTED_WITH'] = "SHADOWFAX"

    def test_process_exception(self):
        response1 = self.a.process_exception(self.request1, self.exception1)
        self.assertIsInstance(response1, middleware.JsonError)
        self.assertEqual(self.exception1.status_code, response1.status_code)
        self.assertEqual(
            {"errors": json.loads(self.exception1.message)},
            json.loads(response1.content)
        )

        response2 = self.a.process_exception(self.request1, self.exception2)
        self.assertIsInstance(response2, middleware.JsonError)
        self.assertEqual(self.exception2.status_code, response2.status_code)
        self.assertEqual(
            {"errors": [self.exception2.message]},
            json.loads(response2.content)
        )

        self.assertIsNone(self.a.process_exception(self.request1, self.exception0))
        self.assertIsNone(self.a.process_exception(self.request0, self.exception1))
        self.assertIsNone(self.a.process_exception(self.request0, self.exception0))

"""
Unittests for creating a course in an chosen modulestore
"""
import unittest
import ddt
from django.core.management import CommandError, call_command

from contentstore.management.commands.create_course import Command
from xmodule.modulestore import ModuleStoreEnum
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
from xmodule.modulestore.django import modulestore


class TestArgParsing(unittest.TestCase):
    """
    Tests for parsing arguments for the `create_course` management command
    """
    def setUp(self):
        super(TestArgParsing, self).setUp()

        self.command = Command()

    def test_no_args(self):
        errstring = "create_course requires 5 arguments"
        with self.assertRaisesRegexp(CommandError, errstring):
            self.command.handle('create_course')

    def test_invalid_store(self):
        with self.assertRaises(CommandError):
            self.command.handle("foo", "user@foo.org", "org", "course", "run")

    def test_xml_store(self):
        with self.assertRaises(CommandError):
            self.command.handle(ModuleStoreEnum.Type.xml, "user@foo.org", "org", "course", "run")

    def test_nonexistent_user_id(self):
        errstring = "No user 99 found"
        with self.assertRaisesRegexp(CommandError, errstring):
            self.command.handle("split", "99", "org", "course", "run")

    def test_nonexistent_user_email(self):
        errstring = "No user fake@example.com found"
        with self.assertRaisesRegexp(CommandError, errstring):
            self.command.handle("mongo", "fake@example.com", "org", "course", "run")


@ddt.ddt
class TestCreateCourse(ModuleStoreTestCase):
    """
    Unit tests for creating a course in either old mongo or split mongo via command line
    """

    def setUp(self):
        super(TestCreateCourse, self).setUp(create_user=True)

    @ddt.data(ModuleStoreEnum.Type.mongo, ModuleStoreEnum.Type.split)
    def test_all_stores_user_email(self, store):
        call_command(
            "create_course",
            store,
            str(self.user.email),
            "org", "course", "run"
        )
        new_key = modulestore().make_course_key("org", "course", "run")
        self.assertTrue(
            modulestore().has_course(new_key),
            "Could not find course in {}".format(store)
        )
        # pylint: disable=protected-access
        self.assertEqual(store, modulestore()._get_modulestore_for_courselike(new_key).get_modulestore_type())

# Django settings for Photo_Gallery project.
import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


DEBUG = True
TEMPLATE_DEBUG = DEBUG

ADMINS = (
    # ('Your Name', 'your_email@example.com'),
)

MANAGERS = ADMINS

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),                      # Or path to database file if using sqlite3.
        # The following settings are not used with sqlite3:
        'USER': '',
        'PASSWORD': '',
        'HOST': '',                      # Empty for localhost through domain sockets or '127.0.0.1' for localhost through TCP.
        'PORT': '',                      # Set to empty string for default.
    }
}

# Hosts/domain names that are valid for this site; required if DEBUG is False
# See https://docs.djangoproject.com/en/1.5/ref/settings/#allowed-hosts
ALLOWED_HOSTS = []

# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# In a Windows environment this must be set to your system time zone.
TIME_ZONE = 'America/Chicago'

# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'

SITE_ID = 1

# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True

# If you set this to False, Django will not format dates, numbers and
# calendars according to the current locale.
USE_L10N = True

# If you set this to False, Django will not use timezone-aware datetimes.
USE_TZ = True

# Absolute filesystem path to the directory that will hold user-uploaded files.
# Example: "/var/www/example.com/media/"
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

# URL that handles the media served from MEDIA_ROOT. Make sure to use a
# trailing slash.
# Examples: "http://example.com/media/", "http://media.example.com/"
MEDIA_URL = '/media/'

# Absolute path to the directory static files should be collected to.
# Don't put anything in this directory yourself; store your static files
# in apps' "static/" subdirectories and in STATICFILES_DIRS.
# Example: "/var/www/example.com/static/"
STATIC_ROOT = ''

# URL prefix for static files.
# Example: "http://example.com/static/", "http://static.example.com/"
STATIC_URL = '/static/'

# Additional locations of static files
STATICFILES_DIRS = (
    # Put strings here, like "/home/html/static" or "C:/www/django/static".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
)

# List of finder classes that know how to find static files in
# various locations.
STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
#    'django.contrib.staticfiles.finders.DefaultStorageFinder',
)

# Make this unique, and don't share it with anybody.
SECRET_KEY = '9pty7e1$enkp@3rc^w=&5_6)tn^_8e#2x-tz$q^(v)4hegj27v'

# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
    'django.template.loaders.filesystem.Loader',
    'django.template.loaders.app_directories.Loader',
#     'django.template.loaders.eggs.Loader',
)

MIDDLEWARE_CLASSES = (
    'django.middleware.common.CommonMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    # Uncomment the next line for simple clickjacking protection:
    # 'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

ROOT_URLCONF = 'Photo_Gallery.urls'

# Python dotted path to the WSGI application used by Django's runserver.
WSGI_APPLICATION = 'Photo_Gallery.wsgi.application'

TEMPLATE_DIRS = (
    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
    os.path.join(BASE_DIR, 'templates'),
)

INSTALLED_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # Uncomment the next line to enable the admin:
    'django.contrib.admin',
    # Uncomment the next line to enable admin documentation:
    # 'django.contrib.admindocs',
    'gallery',
    'easy_thumbnails',

)

SESSION_SERIALIZER = 'django.contrib.sessions.serializers.JSONSerializer'

# A sample logging configuration. The only tangible logging
# performed by this configuration is to send an email to
# the site admins on every HTTP 500 error when DEBUG=False.
# See http://docs.djangoproject.com/en/dev/topics/logging for
# more details on how to customize your logging configuration.
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse'
        }
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'class': 'django.utils.log.AdminEmailHandler'
        }
    },
    'loggers': {
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': True,
        },
    }
}


import json
import pytz
from dateutil import parser
from dateutil.relativedelta import relativedelta
import datetime
import os.path
import requests
from bs4 import BeautifulSoup
BASE_URL = "https://www.espn.com"

## General functions
def retry_request(url, headers={}):
    """Get a url and return the request, try it up to 3 times if it fails initially"""
    session = requests.Session()
    session.mount("http://", requests.adapters.HTTPAdapter(max_retries=3))
    res = session.get(url=url, allow_redirects=True, headers=headers)
    session.close()
    return res

def get_soup(res):
    return BeautifulSoup(res.text, "lxml")

def get_new_json(url, headers={}):
    print(url)
    res = retry_request(url, headers)
    if res.status_code == 200:
        return res.json()
    else:
        print("ERROR:", res.status_code)
        return {"error_code": res.status_code, "error_msg": "URL Error"}

def get_new_html_soup(url, headers={}):
    print(url)
    res = retry_request(url, headers)
    if res.status_code == 200:
        return get_soup(res)
    else:
        print("ERROR: ESPN", res.status_code)
        return {"error_code": res.status_code, "error_msg": "ESPN Error"}

## Get constants
def get_date_leagues():
    return ["mlb","nba","ncb","ncw","wnba","nhl"]

def get_week_leagues():
    return ["nfl","ncf"]

def get_ncb_groups():
    return [50,55,56,100]

def get_ncw_groups():
    return [50,55,100]

def get_ncf_groups():
    return [80,81]

def get_leagues():
    """ Return a list of supported leagues """
    return get_week_leagues() + get_date_leagues()

def get_html_boxscore_leagues():
    return ["nhl"]

def get_no_scoreboard_json_leagues():
    """ Scoreboard json isn't easily available for some leagues, have to grab the game_ids from sportscenter_api url """
    return ["wnba", "nhl"]

def get_sport(league):
    if league in ["nba","wnba","ncb","ncw"]:
        return "basketball"
    elif league in ["mlb"]:
        return "baseball"
    elif league in ["nfl","ncf"]:
        return "football"
    elif league in ["nhl"]:
        return "hockey"

## Get urls
def get_sportscenter_api_url(sport, league, dates):
    return "https://sportscenter.api.espn.com/apis/v1/events?sport={}&league={}&dates={}".format(sport, league, dates)

def get_date_scoreboard_url(league, date, group=None):
    """ Return a scoreboard url for a league that uses dates (nonfootball)"""
    if league in get_date_leagues():
        if league == "nhl":
            return "{}/{}/scoreboard?date={}".format(BASE_URL, league, date)
        else:
            if group == None:
                return "{}/{}/scoreboard/_/date/{}?xhr=1".format(BASE_URL, league, date)
            else:
                return "{}/{}/scoreboard/_/group/{}/date/{}?xhr=1".format(BASE_URL, league, group, date)
    else:
        raise ValueError("League must be {} to get date scoreboard url".format(get_date_leagues()))

def get_week_scoreboard_url(league, season_year, season_type, week, group=None):
    """ Return a scoreboard url for a league that uses weeks (football)"""
    if league in get_week_leagues():
        if group == None:
            return "{}/{}/scoreboard/_/year/{}/seasontype/{}/week/{}?xhr=1".format(BASE_URL, league, season_year, season_type, week)
        else:
            return "{}/{}/scoreboard/_/group/{}/year/{}/seasontype/{}/week/{}?xhr=1".format(BASE_URL, league, group, season_year, season_type, week)
    else:
        raise ValueError("League must be {} to get week scoreboard url".format(get_week_leagues()))

def get_game_url(url_type, league, espn_id):
    valid_url_types = ["recap", "boxscore", "playbyplay", "conversation", "gamecast"]
    if url_type not in valid_url_types:
        raise ValueError("Unknown url_type for get_game_url. Valid url_types are {}".format(valid_url_types))
    return "{}/{}/{}?gameId={}&xhr=1".format(BASE_URL, league, url_type, espn_id)

def get_current_scoreboard_urls(league, offset=0):
    """ Return a list of the current scoreboard urls for a league 
    For date leagues optional offset is in days
    For week leagues optional offseet is in weeks """
    urls = []
    if league in get_date_leagues():
        date_str = (datetime.datetime.now() + relativedelta(days=+offset)).strftime("%Y%m%d")
        if league == "ncb":
            for group in get_ncb_groups():
                urls.append(get_date_scoreboard_url(league, date_str, group))
        elif league == "ncw":
            for group in get_ncw_groups():
                urls.append(get_date_scoreboard_url(league, date_str, group))
        else:
            urls.append(get_date_scoreboard_url(league, date_str))
        return urls
    elif league in get_week_leagues():
        # need to add timezone to now to compare with timezoned entry datetimes later
        dt = datetime.datetime.now(pytz.utc) + relativedelta(weeks=+offset)
        # guess the league season_year
        if dt.month > 2:
            guessed_season_year = dt.year
        else:
            guessed_season_year = dt.year - 1
        calendar = get_calendar(league, guessed_season_year)
        for season_type in calendar:
            if 'entries' in season_type:
                for entry in season_type['entries']:
                    if dt >= parser.parse(entry['startDate']) and dt <= parser.parse(entry['endDate']):
                        if league == "ncf":
                            for group in get_ncf_groups():
                                urls.append(get_week_scoreboard_url(league, guessed_season_year, season_type['value'], entry['value'], group))
                        else:
                            urls.append(get_week_scoreboard_url(league, guessed_season_year, season_type['value'], entry['value']))
        return urls
    else:
        raise ValueError("Unknown league for get_current_scoreboard_urls")

def get_all_scoreboard_urls(league, season_year):
    """ Return a list of all scoreboard urls for a given league and season year """
    urls = []
    if league in get_date_leagues():
        start_datetime, end_datetime = get_season_start_end_datetimes(league, season_year)
        while start_datetime < end_datetime:
            if league == "ncb":
                for group in get_ncb_groups():
                    urls.append(get_date_scoreboard_url(league, start_datetime.strftime("%Y%m%d"), group))
            elif league == "ncw":
                for group in get_ncw_groups():
                    urls.append(get_date_scoreboard_url(league, start_datetime.strftime("%Y%m%d"), group))
            else:
                urls.append(get_date_scoreboard_url(league, start_datetime.strftime("%Y%m%d")))
            start_datetime += relativedelta(days=+1)
        return urls
    elif league in get_week_leagues():
        calendar = get_calendar(league, season_year)
        for season_type in calendar:
            if 'entries' in season_type:
                for entry in season_type['entries']:
                    if league == "ncf":
                        for group in get_ncf_groups():
                            urls.append(get_week_scoreboard_url(league, season_year, season_type['value'], entry['value'], group))
                    else:
                        urls.append(get_week_scoreboard_url(league, season_year, season_type['value'], entry['value']))
        return urls
    else:
        raise ValueError("Unknown league for get_all_scoreboard_urls")

## Get stuff from URL or filenames
def get_league_from_url(url):
    return url.split('.com/')[1].split('/')[0]

def get_date_from_scoreboard_url(url):
    league = get_league_from_url(url)
    if league == "nhl":
        return url.split("?date=")[1].split("&")[0]
    else:
        return url.split('/')[-1].split('?')[0]

def get_data_type_from_url(url):
    """ Guess and return the data_type based on the url """
    data_type = None
    valid_data_types = ["scoreboard", "recap", "boxscore", "playbyplay", "conversation", "gamecast"]
    for valid_data_type in valid_data_types:
        if valid_data_type in url:
            data_type = valid_data_type
            break
    if data_type == None:
        raise ValueError("Unknown data_type for url. Url must contain one of {}".format(valid_data_types))
    return data_type

def get_filename_ext(filename):
    if filename.endswith(".json"):
        return "json"
    elif filename.endswith(".html"):
        return "html"
    else:
        raise ValueError("Uknown filename extension for {}".format(filename))

## Get requests helpers
def get_season_start_end_datetimes_helper(url):
    # TODO use cached replies if scoreboard url is older than 1 year
    scoreboard = get_url(url)
    return parser.parse(scoreboard['content']['sbData']['leagues'][0]['calendarStartDate']), parser.parse(scoreboard['content']['sbData']['leagues'][0]['calendarEndDate'])

def get_season_start_end_datetimes(league, season_year):
    """ Guess a random date in a leagues season and return its calendar start and end dates, only non football adheres to this format"""
    if league == "mlb":
        return get_season_start_end_datetimes_helper(get_date_scoreboard_url(league, str(season_year) + "0415"))
    elif league == "nba":
        return get_season_start_end_datetimes_helper(get_date_scoreboard_url(league, str(season_year - 1) + "1101"))
    elif league == "ncb" or league == "ncw":
        return get_season_start_end_datetimes_helper(get_date_scoreboard_url(league, str(season_year - 1) + "1130"))
    elif league == "wnba":
        # hardcode wnba start end dates, assumed to be April 20 thru Oct 31
        return datetime.datetime(season_year,4,20, tzinfo=pytz.timezone("US/Eastern")).astimezone(pytz.utc), datetime.datetime(season_year,10,31, tzinfo=pytz.timezone("US/Eastern")).astimezone(pytz.utc)
    elif league == "nhl":
        # hardcode nhl start end dates, assumed to be Oct 1 thru June 30
        return datetime.datetime(season_year-1,10,1, tzinfo=pytz.timezone("US/Eastern")).astimezone(pytz.utc), datetime.datetime(season_year,6,30, tzinfo=pytz.timezone("US/Eastern")).astimezone(pytz.utc)
    else:
        raise ValueError("League must be {} to get season start and end datetimes".format(get_date_leagues()))

def create_filename_ext(league, data_type):
    """ Get a filename extension (either .html or .json depending on league and data_type) """
    if league in get_html_boxscore_leagues() and data_type == "boxscore":
        return "html"
    else:
        return "json"

def get_filename(cached_json_path, league, data_type, url):
    """ Build a full filename with directories for given league, data_type and url"""
    # add slash if necessary to cached_json_path
    if cached_json_path[-1] != "/":
        cached_json_path += "/"
    dir_path = cached_json_path + "/" + league + "/" + data_type + "/"
    # create a league directory and data_type directory in cached_json if doesn't already exist
    if not os.path.exists(dir_path):
        os.makedirs(dir_path)
    # create filename with / replaced with |
    filename = dir_path + url.replace('/','|')
    ext = "." + create_filename_ext(league, data_type)
    if filename.endswith(ext) == False:
        filename = filename + ext
    return filename

def get_cached(filename):
    """ Return cached json if it exists """
    data = None
    if os.path.isfile(filename):
        ext = get_filename_ext(filename)
        if ext == "json":
            with open(filename) as json_data:
                data = json.load(json_data)
        elif ext == "html":
            data = BeautifulSoup(open(filename), "lxml") 
    return data

## Get requests
def get_teams(league):
    """ Returns a list of teams with ids and names """
    teams = []
    if league == "ncf":
        # espn's college football teams page only lists fbs
        # need to grab teams from standings page instead if want all the fbs and fcs teams
        for division in ["fbs","fcs-i-aa"]:
            url = BASE_URL + "/college-football/standings/_/view/" + division
            print(url)
            soup = get_soup(retry_request(url))
            selector = ".hide-mobile"
            team_divs = soup.select(selector)
            for team_div in team_divs:
                teams.append({'id': team_div.find("a")['href'].split('/')[-2], 'name': team_div.text})
    else:
        url = BASE_URL + "/" + league + "/teams"
        print(url)
        soup = get_soup(retry_request(url))
        if league == "wnba":
            selector = "div.pl3"
        else:
            selector = "div.mt3"
        team_divs = soup.select(selector)
        for team_div in team_divs:
            teams.append({'id': team_div.find("a")['href'].split('/')[-2], 'name': team_div.find("h2").text})
    return teams

def get_standings(league, season_year, college_division=None):
    standings = {"conferences": {}}
    if league in ["nhl","nfl","mlb","nba","wnba","ncf","ncb","ncw"]:
        if league == "ncf" and college_division == None:
            # default to fbs
            college_division = "fbs"
        if college_division:
            valid_college_divisions = ["fbs", "fcs", "fcs-i-aa", "d2", "d3"]
            if college_division == "fcs":
                college_division = "fcs-i-aa"
            if college_division in valid_college_divisions:
                url = "{}/{}/standings/_/season/{}/view/{}".format(BASE_URL, league, season_year, college_division)
            else:
                raise ValueError("College division must be none or {}".format(",".join(valid_college_divisions)))
        elif league in ["wnba"]:
            url = "{}/{}/standings/_/season/{}/group/conference".format(BASE_URL, league, season_year)
        else:
            url = "{}/{}/standings/_/season/{}/group/division".format(BASE_URL, league, season_year)
        print(url)
        soup = get_soup(retry_request(url))
        standings_divs = soup.find_all("div", class_="standings__table")

        for i in range(len(standings_divs)):
            conference_name = standings_divs[i].find("div", class_="Table__Title").text
            standings["conferences"][conference_name] = {"divisions": {}}
            division = "" # default blank division name
            teams_table = standings_divs[i].find("table", class_="Table--fixed-left")
            trs = teams_table.find_all("tr")
            for tr in trs:
                if "subgroup-headers" in tr["class"]:
                    division = tr.text # replace default blank division name
                    standings["conferences"][conference_name]["divisions"][division] = {"teams": []}
                elif tr.text != "":
                    if division == "" and standings["conferences"][conference_name]["divisions"] == {}:
                        standings["conferences"][conference_name]["divisions"][division] = {"teams": []}
                    team = {}
                    team_span_tag = tr.find("td", class_="Table__TD").find("span", class_="hide-mobile")
                    team_a_tag = team_span_tag.find("a")
                    if team_a_tag is None:
                        # some teams are now defunct with no espn links
                        team["name"] = team_span_tag.text.strip()
                        team["abbr"] = ""
                    else:
                        team["name"] = team_a_tag.text
                        if league in ["ncf","ncb","ncw"]:
                            team["abbr"] = team_a_tag["href"].split("/id/")[1].split("/")[0].upper()
                        else:
                            team["abbr"] = team_a_tag["href"].split("/name/")[1].split("/")[0].upper()
                    standings["conferences"][conference_name]["divisions"][division]["teams"].append(team)

    return standings
                
def get_calendar(league, date_or_season_year):
    """ Return a calendar for a league and season_year"""
    if league in get_week_leagues():
        url = get_week_scoreboard_url(league, date_or_season_year, 2, 1)
    elif league in get_date_leagues():
        url = get_date_scoreboard_url(league, date_or_season_year)
    # TODO use cached replies for older urls
    return get_url(url)['content']['calendar']

def get_url(url, cached_path=None):
    """ Retrieve an ESPN JSON data or HTML BeautifulSoup, either from cache or make new request """
    data_type = get_data_type_from_url(url)
    league = get_league_from_url(url)
    if data_type == "scoreboard":
        # for wnba and nhl we'll use a different api to retrieve game_ids and basic game data
        if league in get_no_scoreboard_json_leagues():
            url = get_sportscenter_api_url(get_sport(league), league, get_date_from_scoreboard_url(url))
    return get_cached_url(url, league, data_type, cached_path)

def get_cached_url(url, league, data_type, cached_path, headers={}):
    """ get_url helper if want to specify the league and datatype (for non espn.com links) """
    if cached_path:
        filename = get_filename(cached_path, league, data_type, url)
        data = get_cached(filename)
    else:
        data = None
    if data == None:
        ext = create_filename_ext(league, data_type)
        if ext == "json":
            data = get_new_json(url, headers)
            # dont cache if got an ESPN internal 500 error
            if cached_path and "error_code" not in data:
                with open(filename, 'w') as f:
                    json.dump(data, f, ensure_ascii=False, indent=2, sort_keys=True)
        elif ext == "html":
            data = get_new_html_soup(url, headers)
            if cached_path and "error_code" not in data:
                with open(filename, 'w') as f:
                    f.write(data.prettify())
    return data


#!/usr/bin/env python
#
# Copyright (C) 2013 Martin Owens
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 3.0 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library.
#
"""
Test frequency calculations
"""

import os
import sys

sys.path.insert(0, '../')

import unittest
from crontab import CronTab, PY3
try:
    from test import test_support
except ImportError:
    from test import support as test_support

if PY3:
    unicode = str

START_TAB = """
"""

class FrequencyTestCase(unittest.TestCase):
    """Test basic functionality of crontab."""
    def setUp(self):
        self.crontab = CronTab(tab=START_TAB.strip())
        self.job = self.crontab.new(command='freq')

    def test_00_slice_frequency(self):
        """Each Slice Frequency"""
        # Make sure some of these overlap
        self.job.setall("13-16,14-15 6,*/3 2,3,4 * *")
        self.assertEqual(len(self.job[0]), 4)
        self.assertEqual(len(self.job[1]), 8)
        self.assertEqual(len(self.job[2]), 3)
        self.assertEqual(len(self.job[3]), 12)
        self.assertEqual(len(self.job[4]), 7)

    def test_01_per_day(self):
        """Frequency per Day"""
        self.job.setall("21-29 10-14 * * *")
        self.assertEqual(len(self.job[0]), 9)
        self.assertEqual(len(self.job[1]), 5)
        self.assertEqual(self.job.frequency_per_day(), 45)

    def test_02_days_per_year(self):
        """Frequency in Days per Year"""
        self.job.setall("* * * * *")
        self.assertEqual(self.job.frequency_per_year(year=2010), 365)
        self.assertEqual(self.job.frequency_per_year(year=2012), 366)
        self.job.setall("1 1 11-20 1,4,6,8 0,6")
        self.assertEqual(len(self.job[2]), 10)
        self.assertEqual(len(self.job[3]), 4)
        self.assertEqual(len(self.job[4]), 2)
        self.assertEqual(self.job.frequency_per_year(year=2013), 11)
        self.assertEqual(self.job.frequency_per_year(year=2010), 12)

    def test_03_job(self):
        """Once Yearly"""
        self.job.setall("0 0 1 1 *")
        self.assertEqual(self.job.frequency(year=2010), 1)

    def test_04_twice(self):
        """Twice Yearly"""
        self.job.setall("0 0 1 1,6 *")
        self.assertEqual(self.job.frequency(year=2010), 2)

    def test_05_thrice(self):
        """Thrice Yearly"""
        self.job.setall("0 0 1 1,3,6 *")
        self.assertEqual(self.job.frequency(year=2010), 3)

    def test_06_quart(self):
        """Four Yearly"""
        self.job.setall("0 0 1 */3 *")
        self.assertEqual(self.job.frequency(year=2010), 4)

    def test_07_monthly(self):
        """Once a month"""
        self.job.setall("0 0 1 * *")
        self.assertEqual(self.job.frequency(year=2010), 12)

    def test_08_six_monthly(self):
        """Six a month"""
        self.job.setall("0 0 1,2,3,4,5,6 * *")
        self.assertEqual(self.job.frequency(year=2010), 72)

    def test_09_every_day(self):
        """Every Day"""
        self.job.setall("0 0 * * *")
        self.assertEqual(self.job.frequency(year=2010), 365)

    def test_10_every_hour(self):
        """Every Hour"""
        self.job.setall("0 * * * *")
        self.assertEqual(self.job.frequency(year=2010), 8760)

    def test_11_every_other_hour(self):
        """Every Other Hour"""
        self.job.setall("0 */2 * * *")
        self.assertEqual(self.job.frequency(year=2010), 4380)

    def test_12_every_minute(self):
        """Every Minute"""
        self.job.setall("* * * * *")
        self.assertEqual(self.job.frequency(year=2010), 525600)

    def test_13_enum(self):
        """Enumerations"""
        self.job.setall("0 0 * * MON-WED")
        self.assertEqual(self.job.frequency(year=2010), 156)
        self.job.setall("0 0 * JAN-MAR *")
        self.assertEqual(self.job.frequency(year=2010), 90)

    def test_14_all(self):
        """Test Maximum"""
        self.job.setall("* * * * *")
        self.assertEqual(self.job.frequency(2010), 525600)
        self.assertEqual(self.job.frequency_per_year(year=2010), 365)
        self.assertEqual(self.job.frequency_per_day(), 1440)
        self.job.setall("*")
        self.assertEqual(self.job.frequency_per_day(), 1440)
        self.assertEqual(self.job.frequency_per_year(year=2010), 365)
        self.assertEqual(self.job.frequency(2010), 525600)

    def test_15_compare(self):
        """Compare Times"""
        job = self.crontab.new(command='match')
        job.setall("*/2 * * * *")
        self.assertEqual(job.slices, "*/2 * * * *")
        self.assertEqual(job.slices, ["*/2"])
        self.assertLess(job, ["*"])
        self.assertGreater(job, "*/3")

    def test_16_frequency_per_hour(self):
        """Count per hour"""
        job = self.crontab.new(command='per_hour')
        job.setall("*/2 * * * *")
        self.assertEqual(job.frequency_per_hour(), 30)

if __name__ == '__main__':
    test_support.run_unittest(
       FrequencyTestCase,
    )

#!/usr/bin/python
# -*- coding: utf-8 -*-

#######################################################################
###                                              Diálogo de definición de molinos, UI_grinder                                                  ###
#######################################################################

from PyQt4 import QtCore, QtGui

from equipment.solids import Grinder
from UI import UI_corriente
from equipment import parents
from lib import unidades
from tools import costIndex
from UI.widgets import Entrada_con_unidades


BondIndex={   'Mineral de uranio': 17.93,
                        'Escoria': 15.76,
                        'Ferrocromo': 8.87,
                        'Grafito': 45.03,
                        'Magnesita': 16.8,
                        'Mineral de plata': 17.3,
                        'Molibdeno': 12.97,
                        'Ferromanganeso': 7.77,
                        'Arenisca': 11.53,
                        'Arcilla': 7.1,
                        'Mineral de níquel': 11.88,
                        'Mineral de estaño': 10.81,
                        'Mineral de titanio': 11.88,
                        'Silicato sódico': 13.0,
                        'Granito': 14.39,
                        'Coque': 20.7,
                        'Taconita': 14.87,
                        'Hematita especular': 15.4,
                        'Arena de silicato': 16.46,
                        'Coque de petróleo': 73.8,
                        'Gneiss': 20.13,
                        'Carburo de silicio': 26.17,
                        'Mineral de zinc': 12.42,
                        'Granate': 12.37,
                        'Caliza': 11.61,
                        'Basalto': 20.41,
                        'Carbón': 11.37,
                        'Gabro': 18.45,
                        'Dolomita': 11.31,
                        'Coque de petróleo líquido': 38.6,
                        'Mineral de plomo-zinc': 11.35,
                        'Sal potásica': 8.23,
                        'Andesita': 22.13,
                        'Arcilla calcinada': 1.43,
                        'Ilmenita': 13.11,
                        'Mineral de hierro': 15.44,
                        'Mica': 134.5,
                        'Hematita': 12.68,
                        'Fosfato fertilizante': 13.03,
                        'Cemento en bruto': 10.57,
                        'Bauxita': 9.45,
                        'Mineral de plomo': 11.4,
                        'Trapp': 21.1,
                        'Cristal': 3.08,
                        'Sienita': 14.9,
                        'Coral': 10.16,
                        'Roca fosfática': 10.13,
                        'Caliza para cemento': 10.18,
                        'Silicato': 13.53,
                        'Aljez': 8.16,
                        'Mineral de cromo': 9.6,
                        'Feldespato': 11.67,
                        'Mineral de cobre': 13.13,
                        'Pizarra bituminosa': 18.1,
                        'Cerámica': 15.53,
                        'Pirita': 8.9,
                        'Mineral de manganeso': 12.46,
                        'Pirrotina': 9.57,
                        'Cianita': 18.87,
                        'Grava': 25.17,
                        'Ferrosilicio': 12.83,
                        'Sílex': 26.16,
                        'Pizarra, mineral': 16.4,
                        'Limanita': 8.45,
                        'Barita': 6.24,
                        'Esmeril': 58.18,
                        'Escoria de hornos de hierro': 12.16,
                        'Mineral de oro': 14.83,
                        'Pumita': 11.93,
                        'Rutilo': 12.12,
                        'Espodumena': 13.7,
                        'Fluorita': 9.76,
                        'Clinker de cemento': 13.49,
                        'Sinterizado': 8.77,
                        'Galena': 10.19,
                        'Magnetita': 10.21,
                        'Cuarcita': 12.18,
                        'Oolita': 11.33,
                        'Pizarra, roca': 13.83,
                        'Mineral de potasio': 8.88,
                        'Diorita': 19.4,
                        'Cuarzo': 12.77}

class UI_equipment(parents.UI_equip):
    """Diálogo de definición de molinos trituradores de sólidos"""

    def __init__(self, entrada=None, parent=None):
        """entrada: Parametro opcional de clase corriente que indica la corriente de entrada en kla tubería"""
        super(UI_equipment, self).__init__(Grinder, entrada=False, salida=False, parent=parent)
        self.entrada=entrada

        #Pestaña entrada
        self.Entrada= UI_corriente.Ui_corriente(entrada)
        self.Entrada.Changed.connect(self.cambiar_entrada)
        self.tabWidget.insertTab(0, self.Entrada, QtGui.QApplication.translate("equipment", "Entrada", None, QtGui.QApplication.UnicodeUTF8))

        #Pestaña calculo
        gridLayout_Calculo = QtGui.QGridLayout(self.tabCalculo)
        gridLayout_Calculo.addWidget(QtGui.QLabel(QtGui.QApplication.translate("equipment", "Índice de trabajo de bond:", None, QtGui.QApplication.UnicodeUTF8)), 1, 0, 1, 1)
        self.Material=QtGui.QComboBox()
        self.Material.addItem(QtGui.QApplication.translate("equipment", "Definido por el usuario", None, QtGui.QApplication.UnicodeUTF8))
        for key in sorted(BondIndex.keys()):
            self.Material.addItem(key)
        self.Material.currentIndexChanged[str].connect(self.cambiarBondWordIndex)
        gridLayout_Calculo.addWidget(self.Material, 1, 1, 1, 1)
        self.BondWorkIndex=Entrada_con_unidades(float)
        gridLayout_Calculo.addWidget(self.BondWorkIndex, 1, 2, 1, 1)
        gridLayout_Calculo.addItem(QtGui.QSpacerItem(10,10,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding),10,0,1,5)

        #Pestaña costos
        gridLayout_Costos = QtGui.QGridLayout(self.tabCostos)
        gridLayout_Costos.addWidget(QtGui.QLabel(QtGui.QApplication.translate("equipment", "Tipo:", None, QtGui.QApplication.UnicodeUTF8)), 1, 1, 1, 1)
        self.tipo=QtGui.QComboBox()
        self.tipo.addItem(QtGui.QApplication.translate("equipment", "De cono", None, QtGui.QApplication.UnicodeUTF8))
        self.tipo.addItem(QtGui.QApplication.translate("equipment", "Giratorio", None, QtGui.QApplication.UnicodeUTF8))
        self.tipo.addItem(QtGui.QApplication.translate("equipment", "Dentado", None, QtGui.QApplication.UnicodeUTF8))
        self.tipo.addItem(QtGui.QApplication.translate("equipment", "De martillo", None, QtGui.QApplication.UnicodeUTF8))
        self.tipo.addItem(QtGui.QApplication.translate("equipment", "De bolas", None, QtGui.QApplication.UnicodeUTF8))
        self.tipo.addItem(QtGui.QApplication.translate("equipment", "Pulverizador", None, QtGui.QApplication.UnicodeUTF8))
        self.tipo.currentIndexChanged.connect(self.calcularCostos)
        gridLayout_Costos.addWidget(self.tipo, 1, 2, 1, 1)
        gridLayout_Costos.addItem(QtGui.QSpacerItem(10,10,QtGui.QSizePolicy.Fixed,QtGui.QSizePolicy.Fixed),2,1,1,2)

        self.Costos=costIndex.CostData(1.3, 2)
        self.Costos.valueChanged.connect(self.calcularCostos)
        gridLayout_Costos.addWidget(self.Costos,4,1,2,5)

        gridLayout_Costos.addItem(QtGui.QSpacerItem(20,20,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding),6,1,1,6)
        gridLayout_Costos.addItem(QtGui.QSpacerItem(20,20,QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding),10,1,1,6)
        self.groupBox_Costos = QtGui.QGroupBox(QtGui.QApplication.translate("equipment", "Costos calculados", None, QtGui.QApplication.UnicodeUTF8))
        gridLayout_Costos.addWidget(self.groupBox_Costos,7,1,1,6)
        gridLayout_5 = QtGui.QGridLayout(self.groupBox_Costos)
        gridLayout_5.addWidget(QtGui.QLabel(QtGui.QApplication.translate("equipment", "Coste Adquisición:", None, QtGui.QApplication.UnicodeUTF8)),0,1,1,1)
        self.C_adq=Entrada_con_unidades(unidades.Currency, retornar=False, readOnly=True)
        gridLayout_5.addWidget(self.C_adq,0,2,1,1)
        gridLayout_5.addWidget(QtGui.QLabel(QtGui.QApplication.translate("equipment", "Coste Instalación:", None, QtGui.QApplication.UnicodeUTF8)),1,1,1,1)
        self.C_inst=Entrada_con_unidades(unidades.Currency, retornar=False, readOnly=True)
        gridLayout_5.addWidget(self.C_inst,1,2,1,1)

        #Pestaña salida
        self.Salida= UI_corriente.Ui_corriente(readOnly=True)
        self.tabWidget.insertTab(3, self.Salida,QtGui.QApplication.translate("equipment", "Salida", None, QtGui.QApplication.UnicodeUTF8))

        self.tabWidget.setCurrentIndex(0)


    def cambiarBondWordIndex(self, txt):
        try:
            value=BondIndex[str(txt)]
        except KeyError:
            self.BondWorkIndex.setReadOnly(False)
            self.BondWorkIndex.clear()
        else:
            self.BondWorkIndex.setValue(value)
            self.BondWorkIndex.setReadOnly(True)

    def cambiar_entrada(self, corriente):
        selfentrada=corriente
        self.calculo()

    def calculo(self):
        if self.todos_datos():

            self.rellenoSalida()

    def rellenoSalida(self):
        pass

    def todos_datos(self):
        pass

    def calcularCostos(self, factor=None, indiceBase=None, indiceActual=None):
        if self.todos_datos():
            if not factor: factor=self.Costos.factor
            if not indiceBase: indiceBase=self.Costos.Base
            if not indiceActual: indiceActual=self.Costos.Actual
            if self.tipo.currentIndex()==0:
                self.FireHeater.Coste(factor, indiceBase, indiceActual, 0, self.tipobox.currentIndex(), self.material.currentIndex())
            else:
                self.FireHeater.Coste(factor, indiceBase, indiceActual, 1, self.tipocilindrico.currentIndex(), self.material.currentIndex())
            self.C_adq.setValue(self.FireHeater.C_adq.config())
            self.C_inst.setValue(self.FireHeater.C_inst.config())

if __name__ == "__main__":
    import sys
    from lib.corriente import Corriente, Mezcla, Solid
    app = QtGui.QApplication(sys.argv)
    agua=Corriente(300, 1, 3600, Mezcla([62], [1]))
    dialogo = UI_equipment(agua)
    dialogo.show()
    sys.exit(app.exec_())

from pygame import Surface, SRCALPHA

from thorpy.miscgui.functions import debug_msg
from thorpy.miscgui import style
from thorpy.painting.painters.painter import Painter

class BasicFrame(Painter):
    # get_fusion()
        # get_surface()
            # draw()
                # personnals...

    def __init__(self, size=None, color=None, pressed=False, hovered=False,
                 clip=None):
        color = style.DEF_COLOR if color is None else color
        Painter.__init__(self, size=size, clip=clip, pressed=pressed,
                         hovered=hovered)
        self.color = color

    def draw(self):
        if len(self.color) == 3 or self.color[-1] == 255:
            if self.size[0] < 1:
                debug_msg("Width < 1, automatic resize.", self)
                self.size = (1, self.size[1])
            if self.size[1] < 1:
                debug_msg("Height < 1, automatic resize.", self)
                self.size = (self.size[0], 1)
            surface = Surface(self.size).convert()
        elif len(self.color) == 4:
            surface = Surface(self.size, flags=SRCALPHA).convert_alpha()
        else:
            raise Exception("Invalid color attribut")
        surface.fill(self.color)
        return surface

    def get_surface(self):
        surface = self.draw()
        surface.set_clip(self.clip)
        return surface
import logging

from lxml import etree
from pkg_resources import resource_string

from xmodule.x_module import XModule
from xmodule.raw_module import RawDescriptor
from xblock.fields import Scope, String
import textwrap

log = logging.getLogger(__name__)

# Make '_' a no-op so we can scrape strings
_ = lambda text: text


class AnnotatableFields(object):
    data = String(
        help=_("XML data for the annotation"),
        scope=Scope.content,
        default=textwrap.dedent("""
        <annotatable>
            <instructions>
                <p>Enter your (optional) instructions for the exercise in HTML format.</p>
                <p>Annotations are specified by an <code>&lt;annotation&gt;</code> tag which may may have the following attributes:</p>
                <ul class="instructions-template">
                    <li><code>title</code> (optional). Title of the annotation. Defaults to <i>Commentary</i> if omitted.</li>
                    <li><code>body</code> (<b>required</b>). Text of the annotation.</li>
                    <li><code>problem</code> (optional). Numeric index of the problem associated with this annotation. This is a zero-based index, so the first problem on the page would have <code>problem="0"</code>.</li>
                    <li><code>highlight</code> (optional). Possible values: yellow, red, orange, green, blue, or purple. Defaults to yellow if this attribute is omitted.</li>
                </ul>
            </instructions>
            <p>Add your HTML with annotation spans here.</p>
            <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. <annotation title="My title" body="My comment" highlight="yellow" problem="0">Ut sodales laoreet est, egestas gravida felis egestas nec.</annotation> Aenean at volutpat erat. Cras commodo viverra nibh in aliquam.</p>
            <p>Nulla facilisi. <annotation body="Basic annotation example." problem="1">Pellentesque id vestibulum libero.</annotation> Suspendisse potenti. Morbi scelerisque nisi vitae felis dictum mattis. Nam sit amet magna elit. Nullam volutpat cursus est, sit amet sagittis odio vulputate et. Curabitur euismod, orci in vulputate imperdiet, augue lorem tempor purus, id aliquet augue turpis a est. Aenean a sagittis libero. Praesent fringilla pretium magna, non condimentum risus elementum nec. Pellentesque faucibus elementum pharetra. Pellentesque vitae metus eros.</p>
        </annotatable>
        """)
    )
    display_name = String(
        display_name=_("Display Name"),
        help=_("Display name for this module"),
        scope=Scope.settings,
        default=_('Annotation'),
    )


class AnnotatableModule(AnnotatableFields, XModule):
    js = {
        'coffee': [
            resource_string(__name__, 'js/src/javascript_loader.coffee'),
            resource_string(__name__, 'js/src/html/display.coffee'),
            resource_string(__name__, 'js/src/annotatable/display.coffee'),
        ],
        'js': [
            resource_string(__name__, 'js/src/collapsible.js'),
        ]
    }
    js_module_name = "Annotatable"
    css = {'scss': [resource_string(__name__, 'css/annotatable/display.scss')]}
    icon_class = 'annotatable'

    def __init__(self, *args, **kwargs):
        super(AnnotatableModule, self).__init__(*args, **kwargs)

        xmltree = etree.fromstring(self.data)

        self.instructions = self._extract_instructions(xmltree)
        self.content = etree.tostring(xmltree, encoding='unicode')
        self.element_id = self.location.html_id()
        self.highlight_colors = ['yellow', 'orange', 'purple', 'blue', 'green']

    def _get_annotation_class_attr(self, index, el):
        """ Returns a dict with the CSS class attribute to set on the annotation
            and an XML key to delete from the element.
         """

        attr = {}
        cls = ['annotatable-span', 'highlight']
        highlight_key = 'highlight'
        color = el.get(highlight_key)

        if color is not None:
            if color in self.highlight_colors:
                cls.append('highlight-' + color)
            attr['_delete'] = highlight_key
        attr['value'] = ' '.join(cls)

        return {'class': attr}

    def _get_annotation_data_attr(self, index, el):
        """ Returns a dict in which the keys are the HTML data attributes
            to set on the annotation element. Each data attribute has a
            corresponding 'value' and (optional) '_delete' key to specify
            an XML attribute to delete.
        """

        data_attrs = {}
        attrs_map = {
            'body': 'data-comment-body',
            'title': 'data-comment-title',
            'problem': 'data-problem-id'
        }

        for xml_key in attrs_map.keys():
            if xml_key in el.attrib:
                value = el.get(xml_key, '')
                html_key = attrs_map[xml_key]
                data_attrs[html_key] = {'value': value, '_delete': xml_key}

        return data_attrs

    def _render_annotation(self, index, el):
        """ Renders an annotation element for HTML output.  """
        attr = {}
        attr.update(self._get_annotation_class_attr(index, el))
        attr.update(self._get_annotation_data_attr(index, el))

        el.tag = 'span'

        for key in attr.keys():
            el.set(key, attr[key]['value'])
            if '_delete' in attr[key] and attr[key]['_delete'] is not None:
                delete_key = attr[key]['_delete']
                del el.attrib[delete_key]

    def _render_content(self):
        """ Renders annotatable content with annotation spans and returns HTML. """
        xmltree = etree.fromstring(self.content)
        xmltree.tag = 'div'
        if 'display_name' in xmltree.attrib:
            del xmltree.attrib['display_name']

        index = 0
        for el in xmltree.findall('.//annotation'):
            self._render_annotation(index, el)
            index += 1

        return etree.tostring(xmltree, encoding='unicode')

    def _extract_instructions(self, xmltree):
        """ Removes <instructions> from the xmltree and returns them as a string, otherwise None. """
        instructions = xmltree.find('instructions')
        if instructions is not None:
            instructions.tag = 'div'
            xmltree.remove(instructions)
            return etree.tostring(instructions, encoding='unicode')
        return None

    def get_html(self):
        """ Renders parameters to template. """
        context = {
            'display_name': self.display_name_with_default,
            'element_id': self.element_id,
            'instructions_html': self.instructions,
            'content_html': self._render_content()
        }

        return self.system.render_template('annotatable.html', context)


class AnnotatableDescriptor(AnnotatableFields, RawDescriptor):
    module_class = AnnotatableModule
    mako_template = "widgets/raw-edit.html"

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import functools
import logging
import os

import six

from pelican.utils import python_2_unicode_compatible, slugify

logger = logging.getLogger(__name__)


@python_2_unicode_compatible
@functools.total_ordering
class URLWrapper(object):
    def __init__(self, name, settings):
        self.settings = settings
        self._name = name
        self._slug = None
        self._slug_from_name = True

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name
        # if slug wasn't explicitly set, it needs to be regenerated from name
        # so, changing name should reset slug for slugification
        if self._slug_from_name:
            self._slug = None

    @property
    def slug(self):
        if self._slug is None:
            self._slug = slugify(self.name,
                                 self.settings.get('SLUG_SUBSTITUTIONS', ()))
        return self._slug

    @slug.setter
    def slug(self, slug):
        # if slug is expliticly set, changing name won't alter slug
        self._slug_from_name = False
        self._slug = slug

    def as_dict(self):
        d = self.__dict__
        d['name'] = self.name
        d['slug'] = self.slug
        return d

    def __hash__(self):
        return hash(self.slug)

    def _normalize_key(self, key):
        subs = self.settings.get('SLUG_SUBSTITUTIONS', ())
        return six.text_type(slugify(key, subs))

    def __eq__(self, other):
        if isinstance(other, self.__class__):
            return self.slug == other.slug
        if isinstance(other, six.text_type):
            return self.slug == self._normalize_key(other)
        return False

    def __ne__(self, other):
        if isinstance(other, self.__class__):
            return self.slug != other.slug
        if isinstance(other, six.text_type):
            return self.slug != self._normalize_key(other)
        return True

    def __lt__(self, other):
        if isinstance(other, self.__class__):
            return self.slug < other.slug
        if isinstance(other, six.text_type):
            return self.slug < self._normalize_key(other)
        return False

    def __str__(self):
        return self.name

    def __repr__(self):
        return '<{} {}>'.format(type(self).__name__, repr(self._name))

    def _from_settings(self, key, get_page_name=False):
        """Returns URL information as defined in settings.

        When get_page_name=True returns URL without anything after {slug} e.g.
        if in settings: CATEGORY_URL="cat/{slug}.html" this returns
        "cat/{slug}" Useful for pagination.

        """
        setting = "%s_%s" % (self.__class__.__name__.upper(), key)
        value = self.settings[setting]
        if not isinstance(value, six.string_types):
            logger.warning('%s is set to %s', setting, value)
            return value
        else:
            if get_page_name:
                return os.path.splitext(value)[0].format(**self.as_dict())
            else:
                return value.format(**self.as_dict())

    page_name = property(functools.partial(_from_settings, key='URL',
                         get_page_name=True))
    url = property(functools.partial(_from_settings, key='URL'))
    save_as = property(functools.partial(_from_settings, key='SAVE_AS'))


class Category(URLWrapper):
    pass


class Tag(URLWrapper):
    def __init__(self, name, *args, **kwargs):
        super(Tag, self).__init__(name.strip(), *args, **kwargs)


class Author(URLWrapper):
    pass

"""
Support tool for changing course enrollments.
"""
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse
from django.db import transaction
from django.db.models import Q
from django.http import HttpResponseBadRequest
from django.utils.decorators import method_decorator
from django.views.generic import View
from rest_framework.generics import GenericAPIView
from opaque_keys import InvalidKeyError
from opaque_keys.edx.keys import CourseKey

from course_modes.models import CourseMode
from edxmako.shortcuts import render_to_response
from enrollment.api import get_enrollments, update_enrollment
from enrollment.errors import CourseModeNotFoundError
from lms.djangoapps.support.decorators import require_support_permission
from lms.djangoapps.support.serializers import ManualEnrollmentSerializer
from lms.djangoapps.verify_student.models import VerificationDeadline
from student.models import CourseEnrollment, ManualEnrollmentAudit, ENROLLED_TO_ENROLLED
from util.json_request import JsonResponse


class EnrollmentSupportView(View):
    """
    View for viewing and changing learner enrollments, used by the
    support team.
    """

    @method_decorator(require_support_permission)
    def get(self, request):
        """Render the enrollment support tool view."""
        return render_to_response('support/enrollment.html', {
            'username': request.GET.get('user', ''),
            'enrollmentsUrl': reverse('support:enrollment_list'),
            'enrollmentSupportUrl': reverse('support:enrollment')
        })


class EnrollmentSupportListView(GenericAPIView):
    """
    Allows viewing and changing learner enrollments by support
    staff.
    """

    @method_decorator(require_support_permission)
    def get(self, request, username_or_email):
        """
        Returns a list of enrollments for the given user, along with
        information about previous manual enrollment changes.
        """
        try:
            user = User.objects.get(Q(username=username_or_email) | Q(email=username_or_email))
        except User.DoesNotExist:
            return JsonResponse([])

        enrollments = get_enrollments(user.username)
        for enrollment in enrollments:
            # Folds the course_details field up into the main JSON object.
            enrollment.update(**enrollment.pop('course_details'))
            course_key = CourseKey.from_string(enrollment['course_id'])
            # Add the price of the course's verified mode.
            self.include_verified_mode_info(enrollment, course_key)
            # Add manual enrollment history, if it exists
            enrollment['manual_enrollment'] = self.manual_enrollment_data(enrollment, course_key)
        return JsonResponse(enrollments)

    @method_decorator(require_support_permission)
    def post(self, request, username_or_email):
        """Allows support staff to alter a user's enrollment."""
        try:
            user = User.objects.get(Q(username=username_or_email) | Q(email=username_or_email))
            course_id = request.data['course_id']
            course_key = CourseKey.from_string(course_id)
            old_mode = request.data['old_mode']
            new_mode = request.data['new_mode']
            reason = request.data['reason']
            enrollment = CourseEnrollment.objects.get(user=user, course_id=course_key)
            if enrollment.mode != old_mode:
                return HttpResponseBadRequest(u'User {username} is not enrolled with mode {old_mode}.'.format(
                    username=user.username,
                    old_mode=old_mode
                ))
        except KeyError as err:
            return HttpResponseBadRequest(u'The field {} is required.'.format(err.message))
        except InvalidKeyError:
            return HttpResponseBadRequest(u'Could not parse course key.')
        except (CourseEnrollment.DoesNotExist, User.DoesNotExist):
            return HttpResponseBadRequest(
                u'Could not find enrollment for user {username} in course {course}.'.format(
                    username=username_or_email,
                    course=unicode(course_key)
                )
            )
        try:
            # Wrapped in a transaction so that we can be sure the
            # ManualEnrollmentAudit record is always created correctly.
            with transaction.atomic():
                update_enrollment(user.username, course_id, mode=new_mode)
                manual_enrollment = ManualEnrollmentAudit.create_manual_enrollment_audit(
                    request.user,
                    enrollment.user.email,
                    ENROLLED_TO_ENROLLED,
                    reason=reason,
                    enrollment=enrollment
                )
                return JsonResponse(ManualEnrollmentSerializer(instance=manual_enrollment).data)
        except CourseModeNotFoundError as err:
            return HttpResponseBadRequest(err.message)

    @staticmethod
    def include_verified_mode_info(enrollment_data, course_key):
        """
        Add information about the verified mode for the given
        `course_key`, if that course has a verified mode.

        Args:
          enrollment_data (dict): Dictionary representing a single enrollment.
          course_key (CourseKey): The course which this enrollment belongs to.

        Returns:
          None
        """
        course_modes = enrollment_data['course_modes']
        for mode in course_modes:
            if mode['slug'] == CourseMode.VERIFIED:
                enrollment_data['verified_price'] = mode['min_price']
                enrollment_data['verified_upgrade_deadline'] = mode['expiration_datetime']
                enrollment_data['verification_deadline'] = VerificationDeadline.deadline_for_course(course_key)

    @staticmethod
    def manual_enrollment_data(enrollment_data, course_key):
        """
        Returns serialized information about the manual enrollment
        belonging to this enrollment, if it exists.

        Args:
          enrollment_data (dict): Representation of a single course enrollment.
          course_key (CourseKey): The course for this enrollment.

        Returns:
          None: If no manual enrollment change has been made.
          dict: Serialization of the latest manual enrollment change.
        """
        user = User.objects.get(username=enrollment_data['user'])
        enrollment = CourseEnrollment.get_enrollment(user, course_key)
        manual_enrollment_audit = ManualEnrollmentAudit.get_manual_enrollment(enrollment)
        if manual_enrollment_audit is None:
            return {}
        return ManualEnrollmentSerializer(instance=manual_enrollment_audit).data

#!/usr/bin/env python
# Copyright (c) 2012 Cloudera, Inc. All rights reserved.
#
# 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.
#
# Hdfs access utilities

from xml.etree.ElementTree import parse
from pywebhdfs.webhdfs import PyWebHdfsClient, errors, _raise_pywebhdfs_exception
import getpass
import types
import requests, httplib

class PyWebHdfsClientWithChmod(PyWebHdfsClient):
  def chmod(self, path, permission):
    """Set the permission of 'path' to 'permission' (specified as an octal string, e.g.
    '775'"""
    uri = self._create_uri(path, "SETPERMISSION", permission=permission)
    response = requests.put(uri, allow_redirects=True)
    if not response.status_code == httplib.OK:
      _raise_pywebhdfs_exception(response.status_code, response.text)

    return True

class HdfsConfig(object):
  """Reads an XML configuration file (produced by a mini-cluster) into a dictionary
  accessible via get()"""
  def __init__(self, filename):
    self.conf = {}
    tree = parse(filename)
    for property in tree.getroot().getiterator('property'):
      self.conf[property.find('name').text] = property.find('value').text

  def get(self, key):
    return self.conf.get(key)

def get_hdfs_client_from_conf(conf):
  """Returns a new HTTP client for an HDFS cluster using an HdfsConfig object"""
  hostport = conf.get('dfs.namenode.http-address')
  if hostport is None:
    raise Exception("dfs.namenode.http-address not found in config")
  host, port = hostport.split(":")
  return get_hdfs_client(host=host, port=port)

def __pyweb_hdfs_client_exists(self, path):
  """The PyWebHdfsClient doesn't provide an API to cleanly detect if a file or directory
  exists. This method is bound to each client that is created so tests can simply call
  hdfs_client.exists('path') and get back a bool.
  """
  try:
    self.get_file_dir_status(path)
  except errors.FileNotFound:
    return False
  return True

def get_hdfs_client(host, port, user_name=getpass.getuser()):
  """Returns a new HTTP client for an HDFS cluster using an explict host:port pair"""
  hdfs_client = PyWebHdfsClientWithChmod(host=host, port=port, user_name=user_name)
  # Bind our "exists" method to hdfs_client.exists
  hdfs_client.exists = types.MethodType(__pyweb_hdfs_client_exists, hdfs_client)
  return hdfs_client

#!/usr/bin/env python3

"""
Created on 6 Nov 2018

@author: Bruno Beloff (bruno.beloff@southcoastscience.com)
"""

from scs_core.csv.csv_writer import CSVWriter


# --------------------------------------------------------------------------------------------------------------------

# reference row...
jstr1 = '{"rec": "2016-09-27T13:29:52.947+01:00", "val": {"opc_n2": {"pm1": 1, "pm2p5": 2, "pm10": 3, ' \
        '"per": 4, "bin1": {"a": 5, "b": 6}, "bin2": [7, 8], "mtf1": 9}}}'
print("jstr1: %s" % jstr1)
print("-")

# missing value...
jstr2 = '{"rec": "2016-09-27T13:29:52.947+01:00", "val": {"opc_n2": {"pm1": 1, "pm2p5": 2, "pm10": 3, ' \
        '"bin1": {"a": 5, "b": 6}, "bin2": [7, 8], "mtf1": 9}}}'
print("jstr2: %s" % jstr2)
print("-")

# extra value...
jstr3 = '{"rec": "2016-09-27T13:29:52.947+01:00", "val": {"opc_n2": {"pm1": 1, "pm2p5": 2, "pm10": 3, ' \
        '"per": 4, "xxx": 999, "bin1": {"a": 5, "b": 6}, "bin2": [7, 8], "mtf1": 9}}}'
print("jstr3: %s" % jstr3)
print("=")

# --------------------------------------------------------------------------------------------------------------------

writer = CSVWriter()
print(writer)
print("-")

writer.write(jstr1)
writer.write(jstr2)
writer.write(jstr3)
print("-")

print(writer)

# -*- coding: utf-8 -*-
#
# Empear Enterprise Edition documentation build configuration file, created by
# sphinx-quickstart on Thu Jun 23 16:50:32 2016.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
# import os
# import sys
# sys.path.insert(0, os.path.abspath('.'))

# -- General configuration ------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'

import os
import subprocess
from datetime import date

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.

def get_git_rev():
    return subprocess.Popen("git rev-parse --short HEAD", shell=True, stdout=subprocess.PIPE).stdout.read().strip()

def get_version():
    version_env = os.environ.get("VERSION")
    if version_env:
        return version_env
    else:
        return get_git_rev()

version = get_version()
# The full version, including alpha/beta/rc tags.
release = version

# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
    'sphinx.ext.todo',
]

numfig = True

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'

# The encoding of source files.
#
# source_encoding = 'utf-8-sig'

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = u'Hyper'
copyright = u'2016-{0} Oskar Wickström'.format(date.today().year)
author = u'Oskar Wickström'

# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None

# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#
# today = ''
#
# Else, today_fmt is used as the format for a strftime call.
#
# today_fmt = '%B %d, %Y'

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = []

# The reST default role (used for this markup: `text`) to use for all
# documents.
#
# default_role = None

# If true, '()' will be appended to :func: etc. cross-reference text.
#
# add_function_parentheses = True

# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#
# add_module_names = True

# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#
# show_authors = False

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'xcode'

# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []

# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False

# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = True


# -- Options for HTML output ----------------------------------------------

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
#

html_theme = 'theme' # use the theme in subdir 'theme'
html_theme_path = ['.'] # make sphinx search for themes in current dir

# Theme options are theme-specific and customize the look and feel of a theme
# further.  For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
}

# The name for this set of Sphinx documents.
# "<project> v<release> documentation" by default.
#
html_title = u'Hyper &mdash; Type-safe, statically checked composition of HTTP servers'

# A shorter title for the navigation bar.  Default is the same as html_title.
#
html_short_title = u'Hyper'

# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#
# html_logo = 'logo.png'

# The name of an image file (relative to this directory) to use as a favicon of
# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#
html_favicon = 'favicon.png'

# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']

# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#
# html_extra_path = []

# If not None, a 'Last updated on:' timestamp is inserted at every page
# bottom, using the given strftime format.
# The empty string is equivalent to '%b %d, %Y'.
#
# html_last_updated_fmt = None

# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#
html_use_smartypants = True

# Custom sidebar templates, maps document names to template names.
#

# Additional templates that should be rendered to pages, maps page names to
# template names.
#
# html_additional_pages = {}

# If false, no module index is generated.
#
html_domain_indices = False

# If false, no index is generated.
#
html_use_index = True

# If true, the index is split into individual pages for each letter.
#
# html_split_index = False

# If true, links to the reST sources are added to the pages.
#
html_show_sourcelink = False

# If true, the reST sources are included in the HTML build as _sources/name. The
# default is True.
html_copy_source = False


# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#
html_show_sphinx = False

# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#
# html_show_copyright = True

# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it.  The value of this option must be the
# base URL from which the finished HTML is served.
#
html_use_opensearch = 'http://hyper.wickstrom.tech'

# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None

# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
#
# html_search_language = 'en'

# A dictionary with options for the search language support, empty by default.
# 'ja' uses this config value.
# 'zh' user can custom change `jieba` dictionary path.
#
# html_search_options = {'type': 'default'}

# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#
# html_search_scorer = 'scorer.js'

# Output file base name for HTML help builder.
htmlhelp_basename = 'Hyper'

# -- Options for LaTeX output ---------------------------------------------

latex_preamble = r'''
\usepackage{lmodern}
\usepackage[T1]{fontenc}
%
\usepackage{fancyhdr}
\fancypagestyle{plain}{%
  \renewcommand{\headrulewidth}{0pt}%
  \fancyhf{}%
  \fancyfoot[C]{\textsf{\thepage}}
}
\pagestyle{fancy}
\fancyhf{}
\fancyhead[C]{\textsf{\bfseries{\leftmark}}}
\fancyfoot[C]{\textsf{\thepage}}
\renewcommand{\footrulewidth}{0pt}
\renewcommand{\headrulewidth}{0pt}
%
\usepackage[font={small,it}]{caption}
\titleformat{\chapter}[display]
  {\normalfont\sffamily\huge\bfseries\color{black}}
  {\chaptertitlename\ \thechapter}{20pt}{\Huge}
\titleformat{\section}
  {\normalfont\sffamily\normalsize\bfseries\color{black}}
  {\thesection}{1em}{}
\titleformat{\subsection}
  {\normalfont\sffamily\normalsize\bfseries\color{black}}
  {\thesubsection}{1em}{}
\titleformat{\subsubsection}
  {\normalfont\sffamily\normalsize\bfseries\color{black}}
  {\thesubsubsection}{1em}{}
\titleformat{\paragraph}{\normalfont\normalsize\slshape}{\theparagraph}{1em}{}
% \hypersetup{colorlinks = false}
%
\usepackage{enumitem}
\setlist[description]{style=nextline}
\renewcommand{\descriptionlabel}[1]{\hspace{\labelsep}\emph{#1}}
'''

latex_title_page = r'''
\begin{titlepage}
    \vspace*{\fill}
    \begin{center}
        \includegraphics[width=0.5\textwidth]{_static/hyper@2x.png}\par
        \vspace{1cm}
        {\Large\text{Type-safe, statically checked composition of HTTP servers}\par}
        \vspace{2cm}
        {\Large\version\par}
        \vspace{2cm}
        {\Large\itshape \today\par}
    \end{center}
    \vspace*{\fill}
\end{titlepage}
'''

latex_elements = {
    # The paper size ('letterpaper' or 'a4paper').
    #
    'papersize': 'a4paper',

    # The font size ('10pt', '11pt' or '12pt').
    #
    'pointsize': '10pt',

    # Additional stuff for the LaTeX preamble.
    #
    'preamble': latex_preamble,

    # Latex figure (float) alignment
    #
    #'figure_align': 'htbp',

    'fontpkg': '',

    'fncychap': '',

    'releasename': 'Version',

    'sphinxsetup': 'verbatimwithframe=false',

    'maketitle': latex_title_page,

}

latex_show_pagerefs = True
latex_show_url = 'footnote'

# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
#  author, documentclass [howto, manual, or own class]).
latex_documents = [
    (master_doc, 'hyper.tex', u'Hyper Documentation',
     u'Oskar Wickström', 'report'),
]

# The name of an image file (relative to this directory) to place at the top of
# the title page.
#
# latex_logo = None

# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#
# latex_use_parts = False

# If true, show page references after internal links.
#
# latex_show_pagerefs = False

# If true, show URL addresses after external links.
#
# latex_show_urls = False

# Documents to append as an appendix to all manuals.
#
# latex_appendices = []

# If false, no module index is generated.
#
# latex_domain_indices = True


# -- Options for manual page output ---------------------------------------

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual /ection).
man_pages = [
    (master_doc, 'Hyper', u'Hyper Documentation',
     [author], 1)
]

# If true, show URL addresses after external links.
#
# man_show_urls = False


# -- Options for Texinfo output -------------------------------------------

# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
#  dir menu entry, description, category)
texinfo_documents = [
    (master_doc, 'Hyper', u'Hyper Documentation',
     author, 'Hyper', 'Type-safe, statically checked composition of HTTP servers',
     'Web'),
]

# Documents to append as an appendix to all manuals.
#
# texinfo_appendices = []

# If false, no module index is generated.
#
# texinfo_domain_indices = True

# How to display URL addresses: 'footnote', 'no', or 'inline'.
#
# texinfo_show_urls = 'footnote'

# If true, do not generate a @detailmenu in the "Top" node's menu.
#
# texinfo_no_detailmenu = False


# -- Options for Epub output ----------------------------------------------

# Bibliographic Dublin Core info.
epub_title = project
epub_author = author
epub_publisher = author
epub_copyright = copyright

# The basename for the epub file. It defaults to the project name.
# epub_basename = project

# The HTML theme for the epub output. Since the default themes are not
# optimized for small screen space, using the same theme for HTML and epub
# output is usually not wise. This defaults to 'epub', a theme designed to save
# visual space.
#
# epub_theme = 'epub'

# The language of the text. It defaults to the language option
# or 'en' if the language is not set.
#
# epub_language = ''

# The scheme of the identifier. Typical schemes are ISBN or URL.
# epub_scheme = ''

# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#
# epub_identifier = ''

# A unique identification for the text.
#
# epub_uid = ''

# A tuple containing the cover image and cover page html template filenames.
#
# epub_cover = ()

# A sequence of (type, uri, title) tuples for the guide element of content.opf.
#
# epub_guide = ()

# HTML files that should be inserted before the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#
# epub_pre_files = []

# HTML files that should be inserted after the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#
# epub_post_files = []

# A list of files that should not be packed into the epub file.
epub_exclude_files = ['search.html']

# The depth of the table of contents in toc.ncx.
#
# epub_tocdepth = 3

# Allow duplicate toc entries.
#
# epub_tocdup = True

# Choose between 'default' and 'includehidden'.
#
# epub_tocscope = 'default'

# Fix unsupported image types using the Pillow.
#
# epub_fix_images = False

# Scale large images.
#
# epub_max_image_width = 0

# How to display URL addresses: 'footnote', 'no', or 'inline'.
#
# epub_show_urls = 'inline'

# If false, no index is generated.
#
# epub_use_index = True

#!/usr/bin/env python
import roslib, rospy
roslib.load_manifest('hil_mix_control')
import sys

import time

from geometry_msgs.msg import PoseWithCovarianceStamped, PoseStamped

from math import pi as PI
from math import atan2, sin, cos, sqrt

from tf.transformations import euler_from_quaternion, quaternion_from_euler



def PoseCallback(posedata):
    # PoseWithCovarianceStamped data from amcl_pose
    global robot_pose # [time, [x,y,yaw]]
    header = posedata.header
    pose = posedata.pose
    if (not robot_pose[0]) or (header.stamp > robot_pose[0]):
        # more recent pose data received
        robot_pose[0] = header.stamp
        # TODO: maybe add covariance check here?
        print('robot position update!')
        euler = euler_from_quaternion([pose.pose.orientation.x, pose.pose.orientation.y, pose.pose.orientation.z, pose.pose.orientation.w]) #roll, pitch, yaw
        robot_pose[1] = [pose.pose.position.x, pose.pose.position.y, euler[2]] # in radians
    return robot_pose



#========================================
global robot_pose
rospy.init_node('amcl_pose_to_Euler')


INITIAL = [10.0, 5.0, PI*0]

robot_pose = [None, INITIAL]
#----------
#publish to
#----------

#----------
#subscribe to
#----------
rospy.Subscriber('amcl_pose', PoseWithCovarianceStamped, PoseCallback)

#----------
#main loop
#----------
t0 = rospy.Time.now()
while not rospy.is_shutdown():
    try:
        t = rospy.Time.now()-t0
        print '----------Time: %.2f----------' %t.to_sec()
        rospy.sleep(10)
        print 'robot pose %s' %str(robot_pose)
    except rospy.ROSInterruptException:
        pass
      


from pybindgen.typehandlers.base import Parameter, ReturnValue, \
    join_ctype_and_name, CodeGenerationError, \
    param_type_matcher, return_type_matcher, CodegenErrorBase, \
    DeclarationsScope, CodeBlock, NotSupportedError, ForwardWrapperBase, ReverseWrapperBase, \
    TypeConfigurationError

from pybindgen.cppclass import ReferenceCountingMethodsPolicy, CppClass, CppClassParameterBase, CppClassReturnValueBase, common_shared_object_return

class Ns3PtrMemoryPolicy(ReferenceCountingMethodsPolicy):
    def __init__(self, class_name):
        """
        Create a memory policy for using ns3::Ptr<> to manage instances of this object.

        :param class_name: the full name of the class, e.g. foo::Bar
        """
        super(Ns3PtrMemoryPolicy, self).__init__('Ref', 'Unref', 'GetReferenceCount')

        self.class_name = class_name
        self.pointer_template = 'ns3::Ptr< %s >'

    def get_pointer_name(self, class_name):
        return self.pointer_template % (class_name,)

    def get_delete_code(self, cpp_class):
        return "self->obj.~Ptr< %s >();" % (cpp_class.full_name,)

    def get_pointer_type(self, class_full_name):
        return self.get_pointer_name(class_full_name) + ' '

    def get_pointer_to_void_name(self, object_name):
        return "::ns3::PeekPointer(%s)" % object_name

    def get_instance_creation_function(self):
        return ns3_ptr_instance_creation_function

    def get_pystruct_init_code(self, cpp_class, obj):
        return "new(&%s->obj) %s;" % (obj, self.get_pointer_name(cpp_class.full_name),)

    def register_ptr_parameter_and_return(self, cls, name):
        class ThisClassNs3PtrParameter(CppClassNs3PtrParameter):
            """Register this C++ class as pass-by-pointer parameter"""
            CTYPES = []
            cpp_class = cls
        cls.ThisClassNs3PtrParameter = ThisClassNs3PtrParameter
        try:
            param_type_matcher.register(self.get_pointer_name(cls.full_name), cls.ThisClassNs3PtrParameter)
        except ValueError:
            pass

        class ThisClassNs3PtrReturn(CppClassNs3PtrReturnValue):
            """Register this C++ class as pointer return"""
            CTYPES = []
            cpp_class = cls
        cls.ThisClassNs3PtrReturn = ThisClassNs3PtrReturn
        try:
            return_type_matcher.register(self.get_pointer_name(cls.full_name), cls.ThisClassNs3PtrReturn)
        except ValueError:
            pass

    def register_ptr_alias_parameter_and_return(self, cls, alias):
        alias_ptr = '::ns3::Ptr< %s >' % alias
        cls.ThisClassNs3PtrParameter.CTYPES.append(alias_ptr)
        try:
            param_type_matcher.register(alias_ptr, cls.ThisClassNs3PtrParameter)
        except ValueError: pass

        cls.ThisClassNs3PtrReturn.CTYPES.append(alias_ptr)
        try:
            return_type_matcher.register(alias_ptr, cls.ThisClassNs3PtrReturn)
        except ValueError: pass

def ns3_ptr_instance_creation_function(cpp_class, code_block, lvalue,
                                       parameters, construct_type_name):
    """
    ns3::Ptr "instance creation function"; it is called whenever a new
    C++ class instance needs to be created

    :param cpp_class: the CppClass object whose instance is to be created
    :param code_block: CodeBlock object on which the instance creation code should be generated
    :param lvalue: lvalue expression that should hold the result in the end
    :param parameters: stringified list of parameters
    :param construct_type_name: actual name of type to be constructed (it is
                          not always the class name, sometimes it's
                          the python helper class)
    """
    assert lvalue
    assert not lvalue.startswith('None')
    if cpp_class.incomplete_type:
        raise CodeGenerationError("%s cannot be constructed (incomplete type)"
                                  % cpp_class.full_name)
    code_block.write_code(
        "%s = ::ns3::Create<%s>(%s);" % (lvalue, construct_type_name, parameters))

class CppClassNs3PtrParameter(CppClassParameterBase):
    "Class* handlers"
    CTYPES = []
    cpp_class = None #cppclass.CppClass('dummy') # CppClass instance
    DIRECTIONS = [Parameter.DIRECTION_IN,
                  Parameter.DIRECTION_OUT,
                  Parameter.DIRECTION_INOUT]
    SUPPORTS_TRANSFORMATIONS = False

    def __init__(self, ctype, name, direction=Parameter.DIRECTION_IN, is_const=False,
                 null_ok=False, default_value=None):
        super(CppClassNs3PtrParameter, self).__init__(
            ctype, name, direction, is_const, default_value)
        self.null_ok = null_ok


    def convert_python_to_c(self, wrapper):
        "parses python args to get C++ value"
        assert isinstance(wrapper, ForwardWrapperBase)
        assert isinstance(self.cpp_class, CppClass)

        self.py_name = wrapper.declarations.declare_variable(
            self.cpp_class.pystruct+'*', self.name,
            initializer=(self.default_value and 'NULL' or None))

        value_ptr = wrapper.declarations.declare_variable(
            self.cpp_class.memory_policy.get_pointer_name(self.cpp_class.full_name), "%s_ptr" % self.name)

        if self.null_ok:
            num = wrapper.parse_params.add_parameter('O', ['&'+self.py_name], self.name, optional=bool(self.default_value))

            wrapper.before_call.write_error_check(

                "%s && ((PyObject *) %s != Py_None) && !PyObject_IsInstance((PyObject *) %s, (PyObject *) &%s)"
                % (self.py_name, self.py_name, self.py_name, self.cpp_class.pytypestruct),

                'PyErr_SetString(PyExc_TypeError, "Parameter %i must be of type %s");' % (num, self.cpp_class.name))

            wrapper.before_call.write_code("if (%(PYNAME)s) {\n"
                                           "    if ((PyObject *) %(PYNAME)s == Py_None)\n"
                                           "        %(VALUE)s = NULL;\n"
                                           "    else\n"
                                           "        %(VALUE)s = %(PYNAME)s->obj;\n"
                                           "} else {\n"
                                           "    %(VALUE)s = NULL;\n"
                                           "}" % dict(PYNAME=self.py_name, VALUE=value_ptr))

        else:

            wrapper.parse_params.add_parameter(
                'O!', ['&'+self.cpp_class.pytypestruct, '&'+self.py_name], self.name, optional=bool(self.default_value))
            wrapper.before_call.write_code("if (%s) { %s = %s->obj; }" % (self.py_name, value_ptr, self.py_name))

        wrapper.call_params.append(value_ptr)



    def convert_c_to_python(self, wrapper):
        """foo"""

        ## Value transformations
        value = self.transformation.untransform(
            self, wrapper.declarations, wrapper.after_call, self.value)

        ## declare wrapper variable
        py_name = wrapper.declarations.declare_variable(
            self.cpp_class.pystruct+'*', 'py_'+self.cpp_class.name)
        self.py_name = py_name

        def write_create_new_wrapper():
            """Code path that creates a new wrapper for the parameter"""

            ## Find out what Python wrapper to use, in case
            ## automatic_type_narrowing is active and we are not forced to
            ## make a copy of the object
            if self.cpp_class.automatic_type_narrowing:

                typeid_map_name = self.cpp_class.get_type_narrowing_root().typeid_map_name
                wrapper_type = wrapper.declarations.declare_variable(
                    'PyTypeObject*', 'wrapper_type', '0')
                wrapper.before_call.write_code(
                    '%s = %s.lookup_wrapper(typeid(*%s), &%s);'
                    % (wrapper_type, typeid_map_name, value, self.cpp_class.memory_policy.get_pointer_to_void_name(self.cpp_class.pytypestruct)))
            else:
                wrapper_type = '&'+self.cpp_class.pytypestruct

            ## Create the Python wrapper object
            self.cpp_class.write_allocate_pystruct(wrapper.before_call, py_name, wrapper_type)
            self.py_name = py_name

            wrapper.before_call.write_code("%s->flags = PYBINDGEN_WRAPPER_FLAG_NONE;" % py_name)

            ## Assign the C++ value to the Python wrapper
            wrapper.before_call.write_code("%s->obj = %s;" % (py_name, value))

        if self.cpp_class.helper_class is None:
            try:
                self.cpp_class.wrapper_registry.write_lookup_wrapper(
                    wrapper.before_call, self.cpp_class.pystruct, py_name, value)
            except NotSupportedError:
                write_create_new_wrapper()
                self.cpp_class.wrapper_registry.write_register_new_wrapper(wrapper.before_call, py_name,
                                                                           "%s->obj" % py_name)
            else:
                wrapper.before_call.write_code("if (%s == NULL)\n{" % py_name)
                wrapper.before_call.indent()
                write_create_new_wrapper()
                self.cpp_class.wrapper_registry.write_register_new_wrapper(wrapper.before_call, py_name,
                                                                           "%s->obj" % py_name)
                wrapper.before_call.unindent()
                wrapper.before_call.write_code('}')
            wrapper.build_params.add_parameter("N", [py_name])
        else:
            wrapper.before_call.write_code("if (typeid(*(%s)).name() == typeid(%s).name())\n{"
                                          % (value, self.cpp_class.helper_class.name))
            wrapper.before_call.indent()

            if self.type_traits.target_is_const:
                wrapper.before_call.write_code(
                    "%s = (%s*) (((%s*) ((%s*) %s))->m_pyself);"
                    % (py_name, self.cpp_class.pystruct,
                       self.cpp_class.helper_class.name, self.cpp_class.full_name, value))
                wrapper.before_call.write_code("%s->obj =  (%s*) (%s);" %
                                               (py_name, self.cpp_class.full_name, value))
            else:
                wrapper.before_call.write_code(
                    "%s = (%s*) (((%s*) %s)->m_pyself);"
                    % (py_name, self.cpp_class.pystruct,
                       self.cpp_class.helper_class.name, value))
                wrapper.before_call.write_code("%s->obj = %s;" % (py_name, value))
            wrapper.before_call.write_code("Py_INCREF(%s);" % py_name)
            wrapper.before_call.unindent()
            wrapper.before_call.write_code("} else {")
            wrapper.before_call.indent()

            try:
                self.cpp_class.wrapper_registry.write_lookup_wrapper(
                    wrapper.before_call, self.cpp_class.pystruct, py_name, value)
            except NotSupportedError:
                write_create_new_wrapper()
                self.cpp_class.wrapper_registry.write_register_new_wrapper(
                    wrapper.before_call, py_name, "%s->obj" % py_name)
            else:
                wrapper.before_call.write_code("if (%s == NULL)\n{" % py_name)
                wrapper.before_call.indent()
                write_create_new_wrapper()
                self.cpp_class.wrapper_registry.write_register_new_wrapper(wrapper.before_call, py_name,
                                                                           "%s->obj" % py_name)
                wrapper.before_call.unindent()
                wrapper.before_call.write_code('}') # closes if (%s == NULL)

            wrapper.before_call.unindent()
            wrapper.before_call.write_code("}") # closes if (typeid(*(%s)) == typeid(%s))\n{
            wrapper.build_params.add_parameter("N", [py_name])




class CppClassNs3PtrReturnValue(CppClassReturnValueBase):
    "Class* return handler"
    CTYPES = []
    SUPPORTS_TRANSFORMATIONS = True
    cpp_class = None #cppclass.CppClass('dummy') # CppClass instance

    def __init__(self, ctype, is_const=False):
        super(CppClassNs3PtrReturnValue, self).__init__(ctype, is_const=is_const)

    def get_c_error_return(self): # only used in reverse wrappers
        """See ReturnValue.get_c_error_return"""
        return "return NULL;"

    def convert_c_to_python(self, wrapper):
        """See ReturnValue.convert_c_to_python"""

        ## Value transformations
        value = self.transformation.untransform(
            self, wrapper.declarations, wrapper.after_call, self.value)

        # if value is NULL, return None
        wrapper.after_call.write_code("if (!(%s)) {\n"
                                      "    Py_INCREF(Py_None);\n"
                                      "    return Py_None;\n"
                                      "}" % value)

        ## declare wrapper variable
        py_name = wrapper.declarations.declare_variable(
            self.cpp_class.pystruct+'*', 'py_'+self.cpp_class.name)
        self.py_name = py_name

        common_shared_object_return(value, py_name, self.cpp_class, wrapper.after_call,
                                    self.type_traits, caller_owns_return=True,
                                    reference_existing_object=False,
                                    type_is_pointer=True)

        # return the value
        wrapper.build_params.add_parameter("N", [py_name], prepend=True)


    def convert_python_to_c(self, wrapper):
        """See ReturnValue.convert_python_to_c"""
        name = wrapper.declarations.declare_variable(
            self.cpp_class.pystruct+'*', "tmp_%s" % self.cpp_class.name)
        wrapper.parse_params.add_parameter(
            'O!', ['&'+self.cpp_class.pytypestruct, '&'+name])

        value = self.transformation.transform(
            self, wrapper.declarations, wrapper.after_call, "%s->obj" % name)

        # caller gets a shared pointer
        wrapper.after_call.write_code("%s = %s;" % (self.value, value))

import gameconfig
from interface.menus import menu
from libtcod import libtcodpy as libtcod
import json
from sound.SoundPlayer import SoundPlayer
from random import randint


class Dialogue:

    def __init__(self, dialogue, npc):
        blip = SoundPlayer(gameconfig.SOUND_FX['dialogue'])
        blip.play()
        self.current_dialogue = json.loads(dialogue)
        self.npc = npc
        self.elements = self.current_dialogue['elements']
        self.element = None

    def start(self):
        self._set_current_element('init')
        self._next()

    def get_dialogue_element(self, el_id):
        self.elements = self.current_dialogue['elements']
        for el in self.elements:
            if el['id'] == el_id:
                return el

    def _set_current_element(self, id):
        self.element = self.get_dialogue_element(id)

    def _draw_dialogue_screen(self):
        img = libtcod.image_load(self.npc.fighter.portrait)
        portrait = libtcod.console_new(50, 20)
        libtcod.console_set_default_background(portrait, gameconfig.MENU_BKGND)
        libtcod.console_set_default_foreground(portrait, libtcod.white)
        libtcod.console_rect(portrait, 0, 0, 50, 20, False, libtcod.BKGND_SET)
        libtcod.console_print_ex(portrait, 10, 10, libtcod.BKGND_NONE,
                                 libtcod.LEFT, self.npc.name)
        libtcod.image_blit_2x(img, portrait, 1, 1, 0, 0, -1, -1)
        libtcod.console_blit(portrait, 0, 0, 50, 20, 0,
                             gameconfig.SCREEN_WIDTH/2-25,
                             gameconfig.SCREEN_HEIGHT/2-16, 1.0, 1.0)

    def _handle_player_choices(self):
        choices = []
        for i in self.element['choices']:
            choices.append(i['text'])
        if len(self.element['choices']) == 0:
            choices.append('End.')
        index = menu(self.element['text'][0], choices)
        if index is None or len(choices) == 0:
            return None
        for i in self.element['choices']:
            if i['text'] == choices[index]:
                el = self.get_dialogue_element(i['followup'])
                if el is not None:
                    blip2 = SoundPlayer(gameconfig.SOUND_FX['dialogue'])
                    blip2.play()
                    self._set_current_element(i['followup'])
                    self._next()
                else:
                    return

    def _next(self):
        self._draw_dialogue_screen()
        self._handle_player_choices()

# Configuring will run device.configure(request.getDeviceModel()), setting the
# device model to the one given in the request.

from utilities.listeners import MonitorHandler
from utilities.connections import create_connection, set_handlers, subscribe_all, send_all

conn_dict = {'device-response-topic': "/topic/org.eclipse.scanning.response.device.topic",
             'device-request-topic': "/topic/org.eclipse.scanning.request.device.topic",
             }

handlers = {'device-response-topic':MonitorHandler()}

conn = create_connection()

set_handlers(conn, handlers)

subscribe_all(conn, conn_dict, handlers)


device_request_message = {'@type':'DeviceRequest',
                          'deviceType':'RUNNABLE',
                          'configure':'true',
                          'deviceName':'dkExmpl',
                          'deviceAction':'CONFIGURE',

                          'deviceModel': {
                                          '@type': 'DarkImageModel',
                                          'columns': 100,
                                          'frequency': 100,
                                          'name': 'meep',
                                          'rows': 72
                                         }
                          }
messages = [
            ('device-request-topic', device_request_message, None),
            ]

send_all(conn, conn_dict, messages)
 
# Required to keep Python running indefinitely.
raw_input()
# This testfile tests SymPy <-> Sage compatibility
#
# Execute this test inside Sage, e.g. with:
# sage -python bin/test sympy/external/tests/test_sage.py
#
# This file can be tested by Sage itself by:
# sage -t sympy/external/tests/test_sage.py
# and if all tests pass, it should be copied (verbatim) to Sage, so that it is
# automatically doctested by Sage.  Note that this second method imports the
# version of SymPy in Sage, whereas the -python method imports the local version
# of SymPy (both use the local version of the tests, however).
#
# Don't test any SymPy features here. Just pure interaction with Sage.
# Always write regular SymPy tests for anything, that can be tested in pure
# Python (without Sage). Here we test everything, that a user may need when
# using SymPy with Sage.

import os
import re
import sys

from sympy.external import import_module

sage = import_module('sage.all', __import__kwargs={'fromlist': ['all']})
if not sage:
    #bin/test will not execute any tests now
    disabled = True

if sys.version_info[0] == 3:
    # Sage does not support Python 3 currently
    disabled = True

import sympy

from sympy.utilities.pytest import XFAIL


def check_expression(expr, var_symbols, only_from_sympy=False):
    """
    Does eval(expr) both in Sage and SymPy and does other checks.
    """

    # evaluate the expression in the context of Sage:
    if var_symbols:
        sage.var(var_symbols)
    a = globals().copy()
    # safety checks...
    a.update(sage.__dict__)
    assert "sin" in a
    is_different = False
    try:
        e_sage = eval(expr, a)
        assert not isinstance(e_sage, sympy.Basic)
    except (NameError, TypeError):
        is_different = True
        pass

    # evaluate the expression in the context of SymPy:
    if var_symbols:
        sympy_vars = sympy.var(var_symbols)
    b = globals().copy()
    b.update(sympy.__dict__)
    assert "sin" in b
    b.update(sympy.__dict__)
    e_sympy = eval(expr, b)
    assert isinstance(e_sympy, sympy.Basic)

    # Sympy func may have specific _sage_ method
    if is_different:
        _sage_method = getattr(e_sympy.func, "_sage_")
        e_sage = _sage_method(sympy.S(e_sympy))

    # Do the actual checks:
    if not only_from_sympy:
        assert sympy.S(e_sage) == e_sympy
    assert e_sage == sage.SR(e_sympy)


def test_basics():
    check_expression("x", "x")
    check_expression("x**2", "x")
    check_expression("x**2+y**3", "x y")
    check_expression("1/(x+y)**2-x**3/4", "x y")


def test_complex():
    check_expression("I", "")
    check_expression("23+I*4", "x")


@XFAIL
def test_complex_fail():
    # Sage doesn't properly implement _sympy_ on I
    check_expression("I*y", "y")
    check_expression("x+I*y", "x y")


def test_integer():
    check_expression("4*x", "x")
    check_expression("-4*x", "x")


def test_real():
    check_expression("1.123*x", "x")
    check_expression("-18.22*x", "x")


def test_E():
    assert sympy.sympify(sage.e) == sympy.E
    assert sage.e == sage.SR(sympy.E)


def test_pi():
    assert sympy.sympify(sage.pi) == sympy.pi
    assert sage.pi == sage.SR(sympy.pi)


def test_euler_gamma():
    assert sympy.sympify(sage.euler_gamma) == sympy.EulerGamma
    assert sage.euler_gamma == sage.SR(sympy.EulerGamma)


def test_oo():
    assert sympy.sympify(sage.oo) == sympy.oo
    assert sage.oo == sage.SR(sympy.oo)
    assert sympy.sympify(-sage.oo) == -sympy.oo
    assert -sage.oo == sage.SR(-sympy.oo)
    #assert sympy.sympify(sage.UnsignedInfinityRing.gen()) == sympy.zoo
    #assert sage.UnsignedInfinityRing.gen() == sage.SR(sympy.zoo)

def test_NaN():
    assert sympy.sympify(sage.NaN) == sympy.nan
    assert sage.NaN == sage.SR(sympy.nan)


def test_Catalan():
    assert sympy.sympify(sage.catalan) == sympy.Catalan
    assert sage.catalan == sage.SR(sympy.Catalan)


def test_GoldenRation():
    assert sympy.sympify(sage.golden_ratio) == sympy.GoldenRatio
    assert sage.golden_ratio == sage.SR(sympy.GoldenRatio)


def test_functions():
    # Test at least one Function without own _sage_ method
    assert not "_sage_" in sympy.factorial.__dict__
    check_expression("factorial(x)", "x")
    check_expression("sin(x)", "x")
    check_expression("cos(x)", "x")
    check_expression("tan(x)", "x")
    check_expression("cot(x)", "x")
    check_expression("asin(x)", "x")
    check_expression("acos(x)", "x")
    check_expression("atan(x)", "x")
    check_expression("atan2(y, x)", "x, y")
    check_expression("acot(x)", "x")
    check_expression("sinh(x)", "x")
    check_expression("cosh(x)", "x")
    check_expression("tanh(x)", "x")
    check_expression("coth(x)", "x")
    check_expression("asinh(x)", "x")
    check_expression("acosh(x)", "x")
    check_expression("atanh(x)", "x")
    check_expression("acoth(x)", "x")
    check_expression("exp(x)", "x")
    check_expression("log(x)", "x")
    check_expression("re(x)", "x")
    check_expression("im(x)", "x")
    check_expression("sign(x)", "x")
    check_expression("abs(x)", "x")
    check_expression("arg(x)", "x")
    check_expression("conjugate(x)", "x")

    # The following tests differently named functions
    check_expression("besselj(y, x)", "x, y")
    check_expression("bessely(y, x)", "x, y")
    check_expression("besseli(y, x)", "x, y")
    check_expression("besselk(y, x)", "x, y")
    check_expression("DiracDelta(x)", "x")
    check_expression("KroneckerDelta(x, y)", "x, y")
    check_expression("expint(y, x)", "x, y")
    check_expression("Si(x)", "x")
    check_expression("Ci(x)", "x")
    check_expression("Shi(x)", "x")
    check_expression("Chi(x)", "x")
    check_expression("loggamma(x)", "x")
    check_expression("Ynm(n,m,x,y)", "n, m, x, y")
    check_expression("hyper((n,m),(m,n),x)", "n, m, x")

def test_issue_4023():
    sage.var("a x")
    log = sage.log
    i = sympy.integrate(log(x)/a, (x, a, a + 1))
    i2 = sympy.simplify(i)
    s = sage.SR(i2)
    assert s == (a*log(1 + a) - a*log(a) + log(1 + a) - 1)/a

def test_integral():
    #test Sympy-->Sage
    check_expression("Integral(x, (x,))", "x", only_from_sympy=True)
    check_expression("Integral(x, (x, 0, 1))", "x", only_from_sympy=True)
    check_expression("Integral(x*y, (x,), (y, ))", "x,y", only_from_sympy=True)
    check_expression("Integral(x*y, (x,), (y, 0, 1))", "x,y", only_from_sympy=True)
    check_expression("Integral(x*y, (x, 0, 1), (y,))", "x,y", only_from_sympy=True)
    check_expression("Integral(x*y, (x, 0, 1), (y, 0, 1))", "x,y", only_from_sympy=True)
    check_expression("Integral(x*y*z, (x, 0, 1), (y, 0, 1), (z, 0, 1))", "x,y,z", only_from_sympy=True)

@XFAIL
def test_integral_failing():
    check_expression("Integral(x, (x, 0))", "x", only_from_sympy=True)
    check_expression("Integral(x*y, (x,), (y, 0))", "x,y", only_from_sympy=True)
    check_expression("Integral(x*y, (x, 0, 1), (y, 0))", "x,y", only_from_sympy=True)

def test_undefined_function():
    f = sympy.Function('f')
    sf = sage.function('f')
    x = sympy.symbols('x')
    sx = sage.var('x')
    assert bool(sf(sx) == f(x)._sage_())
    #assert bool(f == sympy.sympify(sf))

# This string contains Sage doctests, that execute all the functions above.
# When you add a new function, please add it here as well.
"""

TESTS::

    sage: test_basics()
    sage: test_basics()
    sage: test_complex()
    sage: test_integer()
    sage: test_real()
    sage: test_E()
    sage: test_pi()
    sage: test_euler_gamma()
    sage: test_oo()
    sage: test_NaN()
    sage: test_Catalan()
    sage: test_GoldenRation()
    sage: test_functions()
    sage: test_issue_4023()
    sage: test_integral()
    sage: test_undefined_function()

Sage has no symbolic Lucas function at the moment::

    sage: check_expression("lucas(x)", "x")
    Traceback (most recent call last):
    ...
    AttributeError: 'module' object has no attribute 'lucas'

"""

"""
Copyright (c) 2012-2013 RockStor, Inc. <http://rockstor.com>
This file is part of RockStor.

RockStor is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

RockStor is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
"""

from django.db import models


class Service(models.Model):

    name = models.CharField(max_length=24, unique=True)
    display_name = models.CharField(max_length=24, unique=True)
    config = models.CharField(max_length=8192, null=True)

    class Meta:
        app_label = 'smart_manager'


class ServiceStatus(models.Model):

    service = models.ForeignKey(Service)
    status = models.BooleanField(default=False)
    count = models.BigIntegerField(default=1)
    ts = models.DateTimeField(auto_now=True, db_index=True)

    @property
    def config(self, *args, **kwargs):
        return self.service.config

    @property
    def name(self, *args, **kwargs):
        return self.service.name

    @property
    def display_name(self, *args, **kwargs):
        return self.service.display_name

    class Meta:
        app_label = 'smart_manager'

import boto3
from utils import *
from dynamoTable import *
from boto3.dynamodb.conditions import Key, Attr

def setNextAvailMachineTimer(intent, session):
    """Dynamo resource and table"""
    userTable = DynamoTable('Users')
    return buildNextAvailMachineResponse(intent, session, userTable)
    
def buildNextAvailMachineResponse(intent, session, userTable):

    cardTitle = intent.get('name')
    sessionAttributes = {}
    shouldEndSession = False
    
    """Get buildingId from User table and machineType from session
       Get available machines using API
       If there are available machines, tell user how many
       If not, set a timer for the next machine to become available
    """
    if session.get('user'):
        userIdVal = session.get('user').get('userId')
        response = userTable.get(userId=userIdVal)
        
        if response.get('Item'):
            buildingId = APIBuildingId(response)
            machineType = APIMachineType(intent)
            numMachinesRequested = APINumMachinesRequested(intent)
            
            """API Call /buildings/buildingId/machineType=machineType"""
            totalMachines = APIInfo(buildingId, machineType, False, "")
            numTotalMachines = len(totalMachines)
            
            """API Call /buildings/buildingId/machines?=available&machineType=machineType"""
            machineInfo = APIInfo(buildingId, machineType, True, "")
            
            numAvailMachines = len(machineInfo)
            """More available machines than requested machines"""
            if type(machineInfo) == list and (numAvailMachines >= numMachinesRequested):
                speechOutput, repromptText = machinesAvail(numAvailMachines, machineType)
            elif numTotalMachines < numMachinesRequested:
                speechOutput, repromptText = tooManyMachines(numTotalMachines, machineType)
            else:
               speechOutput, repromptText = settingMulTimers(numMachinesRequested, machineType, totalMachines)
        else:
            speechOutput, repromptText = buildingNotFound()
    else:
        speechOutput, repromptText = userNotFound()

    return buildResponse(sessionAttributes, buildSpeechletResponse(
        cardTitle, speechOutput, repromptText, shouldEndSession))

# Copyright 2012 Nebula, Inc.
# Copyright 2013 IBM Corp.
#
#    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.

from oslo_config import cfg

from nova.tests.functional.api_sample_tests import api_sample_base

CONF = cfg.CONF
CONF.import_opt('osapi_compute_extension',
                'nova.api.openstack.compute.legacy_v2.extensions')


class FlavorExtraSpecsSampleJsonTests(api_sample_base.ApiSampleTestBaseV21):
    ADMIN_API = True
    extension_name = 'flavor-extra-specs'

    def _get_flags(self):
        f = super(FlavorExtraSpecsSampleJsonTests, self)._get_flags()
        f['osapi_compute_extension'] = CONF.osapi_compute_extension[:]
        f['osapi_compute_extension'].append(
            'nova.api.openstack.compute.contrib.flavorextraspecs.'
            'Flavorextraspecs')
        return f

    def _flavor_extra_specs_create(self):
        subs = {'value1': 'value1',
                'value2': 'value2'
        }
        response = self._do_post('flavors/1/os-extra_specs',
                                 'flavor-extra-specs-create-req', subs)
        self._verify_response('flavor-extra-specs-create-resp',
                              subs, response, 200)

    def test_flavor_extra_specs_get(self):
        subs = {'value1': 'value1'}
        self._flavor_extra_specs_create()
        response = self._do_get('flavors/1/os-extra_specs/key1')
        self._verify_response('flavor-extra-specs-get-resp',
                              subs, response, 200)

    def test_flavor_extra_specs_list(self):
        subs = {'value1': 'value1',
                'value2': 'value2'
        }
        self._flavor_extra_specs_create()
        response = self._do_get('flavors/1/os-extra_specs')
        self._verify_response('flavor-extra-specs-list-resp',
                              subs, response, 200)

    def test_flavor_extra_specs_create(self):
        self._flavor_extra_specs_create()

    def test_flavor_extra_specs_update(self):
        subs = {'value1': 'new_value1'}
        self._flavor_extra_specs_create()
        response = self._do_put('flavors/1/os-extra_specs/key1',
                                'flavor-extra-specs-update-req', subs)
        self._verify_response('flavor-extra-specs-update-resp',
                              subs, response, 200)

    def test_flavor_extra_specs_delete(self):
        self._flavor_extra_specs_create()
        response = self._do_delete('flavors/1/os-extra_specs/key1')
        self.assertEqual(200, response.status_code)
        self.assertEqual('', response.content)

import distutils.command.bdist_rpm as orig

class bdist_rpm(orig.bdist_rpm):
    """
    Override the default bdist_rpm behavior to do the following:

    1. Run egg_info to ensure the name and version are properly calculated.
    2. Always run 'install' using --single-version-externally-managed to
       disable eggs in RPM distributions.
    3. Replace dash with underscore in the version numbers for better RPM
       compatibility.
    """

    def run(self):
        # ensure distro name is up-to-date
        self.run_command('egg_info')

        orig.bdist_rpm.run(self)

    def _make_spec_file(self):
        version = self.distribution.get_version()
        rpmversion = version.replace('-','_')
        spec = orig.bdist_rpm._make_spec_file(self)
        line23 = '%define version ' + version
        line24 = '%define version ' + rpmversion
        spec = [
            line.replace(
                "Source0: %{name}-%{version}.tar",
                "Source0: %{name}-%{unmangled_version}.tar"
            ).replace(
                "setup.py install ",
                "setup.py install --single-version-externally-managed "
            ).replace(
                "%setup",
                "%setup -n %{name}-%{unmangled_version}"
            ).replace(line23, line24)
            for line in spec
        ]
        insert_loc = spec.index(line24) + 1
        unmangled_version = "%define unmangled_version " + version
        spec.insert(insert_loc, unmangled_version)
        return spec

# This file is part of Buildbot.  Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members

from __future__ import absolute_import
from __future__ import print_function

import sys

import twisted
from twisted.internet import utils
from twisted.trial import reporter
from twisted.trial import unittest

from buildbot.test.util.gpo import Expect
from buildbot.test.util.gpo import GetProcessOutputMixin


class TestGPOMixin(unittest.TestCase):

    # these tests use self.patch, but the SkipTest exception gets eaten, so
    # explicitly skip things here.
    if twisted.version.major <= 9 and sys.version_info[:2] == (2, 7):
        skip = "unittest.TestCase.patch is not available"

    def runTestMethod(self, method):
        class TestCase(GetProcessOutputMixin, unittest.TestCase):

            def setUp(self):
                self.setUpGetProcessOutput()

            def runTest(self):
                return method(self)
        self.testcase = TestCase()
        result = reporter.TestResult()
        self.testcase.run(result)  # This blocks
        return result

    def assertTestFailure(self, result, expectedFailure):
        self.assertEqual(result.errors, [])
        self.assertEqual(len(result.failures), 1)
        self.assertTrue(result.failures[0][1].check(unittest.FailTest))
        if expectedFailure:
            self.assertSubstring(
                expectedFailure, result.failures[0][1].getErrorMessage())

    def assertSuccessful(self, result):
        if not result.wasSuccessful():
            output = 'expected success'
            if result.failures:
                output += ('\ntest failed: %s' %
                           result.failures[0][1].getErrorMessage())
            if result.errors:
                output += ('\nerrors: %s' %
                           map(lambda x: x[1].value, result.errors))
            raise self.failureException(output)

        self.assertTrue(result.wasSuccessful())

    def test_patch(self):
        original_getProcessOutput = utils.getProcessOutput
        original_getProcessOutputAndValue = utils.getProcessOutputAndValue

        def method(testcase):
            testcase.expectCommands()
            self.assertEqual(utils.getProcessOutput,
                             testcase.patched_getProcessOutput)
            self.assertEqual(utils.getProcessOutputAndValue,
                             testcase.patched_getProcessOutputAndValue)
        result = self.runTestMethod(method)
        self.assertSuccessful(result)
        self.assertEqual(utils.getProcessOutput,
                         original_getProcessOutput)
        self.assertEqual(utils.getProcessOutputAndValue,
                         original_getProcessOutputAndValue)

    def test_methodChaining(self):
        expect = Expect('command')
        self.assertEqual(expect, expect.exit(0))
        self.assertEqual(expect, expect.stdout("output"))
        self.assertEqual(expect, expect.stderr("error"))

    def test_gpo_oneCommand(self):
        def method(testcase):
            testcase.expectCommands(Expect("command"))
            d = utils.getProcessOutput("command", ())
            d.addCallback(self.assertEqual, '')
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpo_expectTwo_runOne(self):
        def method(testcase):
            testcase.expectCommands(Expect("command"))
            testcase.expectCommands(Expect("command2"))
            d = utils.getProcessOutput("command", ())
            d.addCallback(self.assertEqual, '')
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "assert all expected commands were run")

    def test_gpo_wrongCommand(self):
        def method(testcase):
            testcase.expectCommands(Expect("command2"))
            d = utils.getProcessOutput("command", ())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")
        # assert we have a meaningful message
        self.assertTestFailure(result, "command2")

    def test_gpo_wrongArgs(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg"))
            d = utils.getProcessOutput("command", ("otherarg",))
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpo_missingPath(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg").path("/home"))
            d = utils.getProcessOutput("command", ("otherarg",))
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpo_wrongPath(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg").path("/home"))
            d = utils.getProcessOutput("command", ("otherarg",), path="/work")
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpo_notCurrentPath(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg"))
            d = utils.getProcessOutput("command", ("otherarg",), path="/work")
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpo_errorOutput(self):
        def method(testcase):
            testcase.expectCommands(Expect("command").stderr("some test"))
            d = testcase.assertFailure(
                utils.getProcessOutput("command", ()), [IOError])
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "got stderr: 'some test'")

    def test_gpo_errorOutput_errtoo(self):
        def method(testcase):
            testcase.expectCommands(Expect("command").stderr("some test"))
            d = utils.getProcessOutput("command", (), errortoo=True)
            d.addCallback(testcase.assertEqual, "some test")
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpo_exitIgnored(self):
        def method(testcase):
            testcase.expectCommands(Expect("command").exit(1))
            d = utils.getProcessOutput("command", ())
            d.addCallback(self.assertEqual, '')
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpo_output(self):
        def method(testcase):
            testcase.expectCommands(Expect("command").stdout("stdout"))
            d = utils.getProcessOutput("command", ())
            d.addCallback(testcase.assertEqual, "stdout")
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpo_outputAndError(self):
        def method(testcase):
            testcase.expectCommands(
                Expect("command").stdout("stdout").stderr("stderr"))
            d = utils.getProcessOutput("command", (), errortoo=True)

            @d.addCallback
            def cb(res):
                testcase.assertSubstring("stdout", res)
                testcase.assertSubstring("stderr", res)
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpo_environ_success(self):
        def method(testcase):
            testcase.expectCommands(Expect("command"))
            testcase.addGetProcessOutputExpectEnv({'key': 'value'})
            d = utils.getProcessOutput("command", (), env={'key': 'value'})
            d.addCallback(self.assertEqual, '')
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpo_environ_wrongValue(self):
        def method(testcase):
            testcase.expectCommands(Expect("command"))
            testcase.addGetProcessOutputExpectEnv({'key': 'value'})
            d = utils.getProcessOutput(
                "command", (), env={'key': 'wrongvalue'})
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(
            result, "Expected environment to have key = 'value'")

    def test_gpo_environ_missing(self):
        def method(testcase):
            testcase.expectCommands(Expect("command"))
            testcase.addGetProcessOutputExpectEnv({'key': 'value'})
            d = utils.getProcessOutput("command", ())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(
            result, "Expected environment to have key = 'value'")

    def test_gpoav_oneCommand(self):
        def method(testcase):
            testcase.expectCommands(Expect("command"))
            d = utils.getProcessOutputAndValue("command", ())
            d.addCallback(self.assertEqual, ('', '', 0))
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpoav_expectTwo_runOne(self):
        def method(testcase):
            testcase.expectCommands(Expect("command"))
            testcase.expectCommands(Expect("command2"))
            d = utils.getProcessOutputAndValue("command", ())
            d.addCallback(self.assertEqual, ('', '', 0))
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "assert all expected commands were run")

    def test_gpoav_wrongCommand(self):
        def method(testcase):
            testcase.expectCommands(Expect("command2"))
            d = utils.getProcessOutputAndValue("command", ())
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpoav_wrongArgs(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg"))
            d = utils.getProcessOutputAndValue("command", ("otherarg",))
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpoav_missingPath(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg").path("/home"))
            d = utils.getProcessOutputAndValue("command", ("otherarg",))
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpoav_wrongPath(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg").path("/home"))
            d = utils.getProcessOutputAndValue(
                "command", ("otherarg",), path="/work")
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpoav_notCurrentPath(self):
        def method(testcase):
            testcase.expectCommands(Expect("command", "arg"))
            d = utils.getProcessOutputAndValue(
                "command", ("otherarg",), path="/work")
            d.addCallback(lambda _: testcase.assertAllCommandsRan())
            return d
        result = self.runTestMethod(method)
        self.assertTestFailure(result, "unexpected command run")

    def test_gpoav_errorOutput(self):
        def method(testcase):
            testcase.expectCommands(Expect("command").stderr("some test"))
            d = utils.getProcessOutputAndValue("command", ())
            d.addCallback(self.assertEqual, ('', 'some test', 0))
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpoav_exit(self):
        def method(testcase):
            testcase.expectCommands(Expect("command").exit(1))
            d = utils.getProcessOutputAndValue("command", ())
            d.addCallback(self.assertEqual, ('', '', 1))
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpoav_output(self):
        def method(testcase):
            testcase.expectCommands(Expect("command").stdout("stdout"))
            d = utils.getProcessOutputAndValue("command", ())
            d.addCallback(testcase.assertEqual, ("stdout", '', 0))
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

    def test_gpoav_outputAndError(self):
        def method(testcase):
            testcase.expectCommands(
                Expect("command").stdout("stdout").stderr("stderr"))
            d = utils.getProcessOutputAndValue("command", ())
            d.addCallback(testcase.assertEqual, ("stdout", 'stderr', 0))
            return d
        result = self.runTestMethod(method)
        self.assertSuccessful(result)

'''
ModalView
=========

.. versionadded:: 1.4.0

The :class:`ModalView` widget is used to create modal views. By default, the
view will cover the whole "parent" window.

Remember that the default size of a Widget is size_hint=(1, 1). If you don't
want your view to be fullscreen, either use size hints with values lower than
1 (for instance size_hint=(.8, .8)) or deactivate the size_hint and use fixed
size attributes.

Examples
--------

Example of a simple 400x400 Hello world view::

    view = ModalView(size_hint=(None, None), size=(400, 400))
    view.add_widget(Label(text='Hello world'))

By default, any click outside the view will dismiss it. If you don't
want that, you can set :attr:`ModalView.auto_dismiss` to False::

    view = ModalView(auto_dismiss=False)
    view.add_widget(Label(text='Hello world'))
    view.open()

To manually dismiss/close the view, use the :meth:`ModalView.dismiss` method of
the ModalView instance::

    view.dismiss()

Both :meth:`ModalView.open` and :meth:`ModalView.dismiss` are bindable. That
means you can directly bind the function to an action, e.g. to a button's
on_press ::

    # create content and add it to the view
    content = Button(text='Close me!')
    view = ModalView(auto_dismiss=False)
    view.add_widget(content)

    # bind the on_press event of the button to the dismiss function
    content.bind(on_press=view.dismiss)

    # open the view
    view.open()


ModalView Events
----------------

There are two events available: `on_open` which is raised when the view is
opening, and `on_dismiss` which is raised when the view is closed.
For `on_dismiss`, you can prevent the view from closing by explictly returning
True from your callback. ::

    def my_callback(instance):
        print('ModalView', instance, 'is being dismissed, but is prevented!')
        return True
    view = ModalView()
    view.add_widget(Label(text='Hello world'))
    view.bind(on_dismiss=my_callback)
    view.open()


.. versionchanged:: 1.5.0
    The ModalView can be closed by hitting the escape key on the
    keyboard if the :attr:`ModalView.auto_dismiss` property is True (the
    default).

'''

__all__ = ('ModalView', )

from kivy.logger import Logger
from kivy.animation import Animation
from kivy.uix.anchorlayout import AnchorLayout
from kivy.properties import StringProperty, BooleanProperty, ObjectProperty, \
    NumericProperty, ListProperty


class ModalView(AnchorLayout):
    '''ModalView class. See module documentation for more information.

    :Events:
        `on_open`:
            Fired when the ModalView is opened.
        `on_dismiss`:
            Fired when the ModalView is closed. If the callback returns True,
            the dismiss will be canceled.
    '''

    auto_dismiss = BooleanProperty(True)
    '''This property determines if the view is automatically
    dismissed when the user clicks outside it.

    :attr:`auto_dismiss` is a :class:`~kivy.properties.BooleanProperty` and
    defaults to True.
    '''

    attach_to = ObjectProperty(None)
    '''If a widget is set on attach_to, the view will attach to the nearest
    parent window of the widget. If none is found, it will attach to the
    main/global Window.

    :attr:`attach_to` is an :class:`~kivy.properties.ObjectProperty` and
    defaults to None.
    '''

    background_color = ListProperty([0, 0, 0, .7])
    '''Background color in the format (r, g, b, a).

    :attr:`background_color` is a :class:`~kivy.properties.ListProperty` and
    defaults to [0, 0, 0, .7].
    '''

    background = StringProperty(
        'atlas://data/images/defaulttheme/modalview-background')
    '''Background image of the view used for the view background.

    :attr:`background` is a :class:`~kivy.properties.StringProperty` and
    defaults to 'atlas://data/images/defaulttheme/modalview-background'.
    '''

    border = ListProperty([16, 16, 16, 16])
    '''Border used for :class:`~kivy.graphics.vertex_instructions.BorderImage`
    graphics instruction. Used for the :attr:`background_normal` and the
    :attr:`background_down` properties. Can be used when using custom
    backgrounds.

    It must be a list of four values: (bottom, right, top, left). Read the
    BorderImage instructions for more information about how to use it.

    :attr:`border` is a :class:`~kivy.properties.ListProperty` and defaults to
    (16, 16, 16, 16).
    '''

    # Internals properties used for graphical representation.

    _anim_alpha = NumericProperty(0)

    _anim_duration = NumericProperty(.1)

    _window = ObjectProperty(None, allownone=True, rebind=True)

    __events__ = ('on_open', 'on_dismiss')

    def __init__(self, **kwargs):
        self._parent = None
        super(ModalView, self).__init__(**kwargs)

    def _search_window(self):
        # get window to attach to
        window = None
        if self.attach_to is not None:
            window = self.attach_to.get_parent_window()
            if not window:
                window = self.attach_to.get_root_window()
        if not window:
            from kivy.core.window import Window
            window = Window
        return window

    def open(self, *largs):
        '''Show the view window from the :attr:`attach_to` widget. If set, it
        will attach to the nearest window. If the widget is not attached to any
        window, the view will attach to the global
        :class:`~kivy.core.window.Window`.
        '''
        if self._window is not None:
            Logger.warning('ModalView: you can only open once.')
            return
        # search window
        self._window = self._search_window()
        if not self._window:
            Logger.warning('ModalView: cannot open view, no window found.')
            return
        self._window.add_widget(self)
        self._window.bind(
            on_resize=self._align_center,
            on_keyboard=self._handle_keyboard)
        self.center = self._window.center
        self.fbind('center', self._align_center)
        self.fbind('size', self._align_center)
        a = Animation(_anim_alpha=1., d=self._anim_duration)
        a.bind(on_complete=lambda *x: self.dispatch('on_open'))
        a.start(self)

    def dismiss(self, *largs, **kwargs):
        '''Close the view if it is open. If you really want to close the
        view, whatever the on_dismiss event returns, you can use the *force*
        argument:
        ::

            view = ModalView()
            view.dismiss(force=True)

        When the view is dismissed, it will be faded out before being
        removed from the parent. If you don't want animation, use::

            view.dismiss(animation=False)

        '''
        if self._window is None:
            return
        if self.dispatch('on_dismiss') is True:
            if kwargs.get('force', False) is not True:
                return
        if kwargs.get('animation', True):
            Animation(_anim_alpha=0., d=self._anim_duration).start(self)
        else:
            self._anim_alpha = 0
            self._real_remove_widget()

    def _align_center(self, *l):
        if self._window:
            self.center = self._window.center

    def on_touch_down(self, touch):
        if not self.collide_point(*touch.pos):
            if self.auto_dismiss:
                self.dismiss()
                return True
        super(ModalView, self).on_touch_down(touch)
        return True

    def on_touch_move(self, touch):
        super(ModalView, self).on_touch_move(touch)
        return True

    def on_touch_up(self, touch):
        super(ModalView, self).on_touch_up(touch)
        return True

    def on__anim_alpha(self, instance, value):
        if value == 0 and self._window is not None:
            self._real_remove_widget()

    def _real_remove_widget(self):
        if self._window is None:
            return
        self._window.remove_widget(self)
        self._window.unbind(
            on_resize=self._align_center,
            on_keyboard=self._handle_keyboard)
        self._window = None

    def on_open(self):
        pass

    def on_dismiss(self):
        pass

    def _handle_keyboard(self, window, key, *largs):
        if key == 27 and self.auto_dismiss:
            self.dismiss()
            return True


if __name__ == '__main__':
    from kivy.base import runTouchApp
    from kivy.uix.button import Button
    from kivy.uix.label import Label
    from kivy.uix.gridlayout import GridLayout
    from kivy.core.window import Window

    # add view
    content = GridLayout(cols=1)
    content.add_widget(Label(text='This is a hello world'))
    view = ModalView(size_hint=(None, None), size=(256, 256),
                     auto_dismiss=True)
    view.add_widget(content)

    def open_view(btn):
        view.open()

    layout = GridLayout(cols=3)
    for x in range(9):
        btn = Button(text='click me %s' % x)
        btn.bind(on_release=view.open)
        layout.add_widget(btn)
    Window.add_widget(layout)

    view.open()

    runTouchApp()

import h5py
from numpy import *
import sys
import scripts.skewtools as st
from matplotlib import pyplot
import scipy.special as sf	# Special functions

#

nmax=1000

bzs = -sf.jn_zeros(1,nmax) # Tabulate the first nmax zeroes of Bessel -J_1 for the sums.

def m2(t,Pe=10.**4):
     out = zeros(shape(t))
     for i in range(nmax):
          out += bzs[i]**-8 * exp(-bzs[i]**2*t)
     # end for
     
     out *= 128*Pe**2
     out += -1./360*Pe**2 + 2*(1. + 1./48*Pe**2)*t

     return out
# end def

def m3(t,Pe=10.**4):
     out = zeros(shape(t))
     for i in range(nmax):
          out += (t*bzs[i]**-8 + 18*bzs[i]**-10 - 240*bzs[i]**-12)*exp(-bzs[i]**2*t)
     # end for
     
     out *= 128*Pe**3
     out += 1./480*Pe**3*(t-17./112)

     return out
# end def

# --------------------------------------------- 
#
# Keep in mind these are for the flow u=2(1-r**2).
#

t,var,sk = st.importDatasets(sys.argv[1],'Time','Avgd_Variance','Avgd_Skewness')

fig,ax = pyplot.subplots(2,1)

tv = t[1:]
skv = sk[1:]

exact = m3(tv)/m2(tv)**1.5

ax[0].plot(tv,exact,label='Exact')
ax[0].scatter(tv,skv,facecolor=[0,0,0,0],edgecolor=[0,0,0,1],s=40,label='Monte Carlo')

ax[1].plot(tv,abs(exact-skv),color='red',label='Absolute error')
ax[1].plot(tv,abs(exact-skv)/abs(exact),color=[0.4,0,0.4],label='Relative error')

ax[0].set_xscale('log')
ax[1].set_xscale('log')
ax[1].set_yscale('log')

ax[0].set_xlim([tv[0],tv[-1]])
ax[1].set_xlim([tv[0],tv[-1]])

ax[0].set_ylim([-0.2,0.5])

ax[0].grid(True)
ax[1].grid(True)

ax[0].legend(loc='best')
ax[1].legend(loc='best')

pyplot.tight_layout()
pyplot.show(block=False)

"""A script to generate a cloudbuild yaml."""

import os
import yaml

import util

# Add directories for new tests here.
TEST_DIRS = [
    'packages_test', 'metadata_test',
    'python3_test', 'pipfile_test',
    'virtualenv_dir_test', 'no_descriptor_test',
    'empty_descriptor_test',
    'additional_directory',
    'commented_descriptor_test',
    'setup_cfg_test',
    'recursive_req_test',
    'venv_test'
    ]

_ST_IMAGE = ('gcr.io/gcp-runtimes/structure-test:'
             '6195641f5a5a14c63c7945262066270842150ddb')
_TEST_DIR = '/workspace/ftl/python/testdata'
_PYTHON_BASE = 'gcr.io/google-appengine/python:latest'


def main():

    cloudbuild_yaml = util.INITIAL_CLOUDBUILD_YAML
    cloudbuild_yaml['steps'].append(
        # Build the FTL image from source and load it into the daemon.
        {
            'name': 'gcr.io/cloud-builders/bazel@sha256:7360c36bded15db68a35cfb1740a994f0a09ad5ce378a97f96d698bc223e442a',
            'args': ['run', '//ftl:python_builder_image', '--', '--norun'],
            'id': 'build-builder',
        }, )

    # Generate a set of steps for each test and add them.
    test_map = {}
    for test in TEST_DIRS:
        test_map[test] = [
            '--base', _PYTHON_BASE, '--name',
            'gcr.io/ftl-node-test/%s-image:latest' % test, '--directory',
            os.path.join(_TEST_DIR, test), '--no-cache'
        ]
    test_map['metadata_test'].extend(['--entrypoint', '/bin/echo'])
    test_map['metadata_test'].extend(['--exposed-ports', '8090,8091'])
    test_map['python3_test'].extend(['--python-cmd', 'python3.6'])
    test_map['python3_test'].extend(['--pip-cmd', 'python3.6 -m pip'])
    test_map['virtualenv_dir_test'].extend(['--virtualenv-dir',
                                            '/alternate-env'])
    test_map['additional_directory'].extend([
        '--additional-directory',
        '/workspace/ftl/python/testdata/additional_directory'
    ])
    test_map['setup_cfg_test'].extend(['--python-cmd', 'python3.6'])
    test_map['setup_cfg_test'].extend(['--pip-cmd', 'python3.6 -m pip'])
    test_map['venv_test'].extend(['--venv-cmd', 'python3.6 -m venv /env'])

    for test, args in test_map.iteritems():
        cloudbuild_yaml['steps'] += util.run_test_steps(
            'python_builder_image',
            'gcr.io/ftl-node-test/%s-image:latest' % test,
            os.path.join(_TEST_DIR, test), args)

    print yaml.dump(cloudbuild_yaml)


if __name__ == "__main__":
    main()

# Copyright 2013 The Servo Project Developers. See the COPYRIGHT
# file at the top-level directory of this distribution.
#
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
# option. This file may not be copied, modified, or distributed
# except according to those terms.

import os
from os import path
import contextlib
import subprocess
from subprocess import PIPE
import sys
import toml

from mach.registrar import Registrar


@contextlib.contextmanager
def cd(new_path):
    """Context manager for changing the current working directory"""
    previous_path = os.getcwd()
    try:
        os.chdir(new_path)
        yield
    finally:
        os.chdir(previous_path)


def host_triple():
    os_type = subprocess.check_output(["uname", "-s"]).strip().lower()
    if os_type == "linux":
        os_type = "unknown-linux-gnu"
    elif os_type == "darwin":
        os_type = "apple-darwin"
    elif os_type == "android":
        os_type = "linux-androideabi"
    else:
        os_type = "unknown"

    cpu_type = subprocess.check_output(["uname", "-m"]).strip().lower()
    if cpu_type in ["i386", "i486", "i686", "i768", "x86"]:
        cpu_type = "i686"
    elif cpu_type in ["x86_64", "x86-64", "x64", "amd64"]:
        cpu_type = "x86_64"
    elif cpu_type == "arm":
        cpu_type = "arm"
    else:
        cpu_type = "unknown"

    return "%s-%s" % (cpu_type, os_type)


class CommandBase(object):
    """Base class for mach command providers.

    This mostly handles configuration management, such as .servobuild."""

    def __init__(self, context):
        self.context = context

        def resolverelative(category, key):
            # Allow ~
            self.config[category][key] = path.expanduser(self.config[category][key])
            # Resolve relative paths
            self.config[category][key] = path.join(context.topdir,
                                                   self.config[category][key])

        if not hasattr(self.context, "bootstrapped"):
            self.context.bootstrapped = False

        config_path = path.join(context.topdir, ".servobuild")
        if path.exists(config_path):
            with open(config_path) as f:
                self.config = toml.loads(f.read())
        else:
            self.config = {}

        # Handle missing/default items
        self.config.setdefault("tools", {})
        default_cache_dir = os.environ.get("SERVO_CACHE_DIR",
                                           path.join(context.topdir, ".servo"))
        self.config["tools"].setdefault("cache-dir", default_cache_dir)
        resolverelative("tools", "cache-dir")

        self.config["tools"].setdefault("cargo-home-dir",
                                        path.join(context.topdir, ".cargo"))
        resolverelative("tools", "cargo-home-dir")

        context.sharedir = self.config["tools"]["cache-dir"]

        self.config["tools"].setdefault("system-rust", False)
        self.config["tools"].setdefault("system-cargo", False)
        self.config["tools"].setdefault("rust-root", "")
        self.config["tools"].setdefault("cargo-root", "")
        if not self.config["tools"]["system-rust"]:
            self.config["tools"]["rust-root"] = path.join(
                context.sharedir, "rust", *self.rust_snapshot_path().split("/"))
        if not self.config["tools"]["system-cargo"]:
            self.config["tools"]["cargo-root"] = path.join(
                context.sharedir, "cargo", self.cargo_build_id())
        self.config["tools"].setdefault("rustc-with-gold", True)

        self.config.setdefault("build", {})
        self.config["build"].setdefault("android", False)
        self.config["build"].setdefault("mode", "")
        self.config["build"].setdefault("debug-mozjs", False)

        self.config.setdefault("android", {})
        self.config["android"].setdefault("sdk", "")
        self.config["android"].setdefault("ndk", "")
        self.config["android"].setdefault("toolchain", "")

        self.config.setdefault("gonk", {})
        self.config["gonk"].setdefault("b2g", "")
        self.config["gonk"].setdefault("product", "flame")

    _rust_snapshot_path = None
    _cargo_build_id = None

    def rust_snapshot_path(self):
        if self._rust_snapshot_path is None:
            filename = path.join(self.context.topdir, "rust-snapshot-hash")
            with open(filename) as f:
                snapshot_hash = f.read().strip()
            self._rust_snapshot_path = "%s-%s" % (snapshot_hash, host_triple())
        return self._rust_snapshot_path

    def cargo_build_id(self):
        if self._cargo_build_id is None:
            filename = path.join(self.context.topdir, "cargo-nightly-build")
            with open(filename) as f:
                self._cargo_build_id = f.read().strip()
        return self._cargo_build_id

    def get_target_dir(self):
        if "CARGO_TARGET_DIR" in os.environ:
            return os.environ["CARGO_TARGET_DIR"]
        else:
            return path.join(self.context.topdir, "target")

    def get_binary_path(self, release, dev):
        base_path = self.get_target_dir()
        release_path = path.join(base_path, "release", "servo")
        dev_path = path.join(base_path, "debug", "servo")

        # Prefer release if both given
        if release and dev:
            dev = False

        release_exists = path.exists(release_path)
        dev_exists = path.exists(dev_path)

        if not release_exists and not dev_exists:
            print("No Servo binary found. Please run './mach build' and try again.")
            sys.exit()

        if release and release_exists:
            return release_path

        if dev and dev_exists:
            return dev_path

        if not dev and not release and release_exists and dev_exists:
            print("You have multiple profiles built. Please specify which "
                  "one to run with '--release' or '--dev'.")
            sys.exit()

        if not dev and not release:
            if release_exists:
                return release_path
            else:
                return dev_path

        print("The %s profile is not built. Please run './mach build%s' "
              "and try again." % ("release" if release else "dev",
                                  " --release" if release else ""))
        sys.exit()

    def build_env(self, gonk=False, hosts_file_path=None):
        """Return an extended environment dictionary."""
        env = os.environ.copy()
        extra_path = []
        extra_lib = []
        if not self.config["tools"]["system-rust"] \
                or self.config["tools"]["rust-root"]:
            env["RUST_ROOT"] = self.config["tools"]["rust-root"]
            # These paths are for when rust-root points to an unpacked installer
            extra_path += [path.join(self.config["tools"]["rust-root"], "rustc", "bin")]
            extra_lib += [path.join(self.config["tools"]["rust-root"], "rustc", "lib")]
            # These paths are for when rust-root points to a rustc sysroot
            extra_path += [path.join(self.config["tools"]["rust-root"], "bin")]
            extra_lib += [path.join(self.config["tools"]["rust-root"], "lib")]

        if not self.config["tools"]["system-cargo"] \
                or self.config["tools"]["cargo-root"]:
            # This path is for when rust-root points to an unpacked installer
            extra_path += [
                path.join(self.config["tools"]["cargo-root"], "cargo", "bin")]
            # This path is for when rust-root points to a rustc sysroot
            extra_path += [
                path.join(self.config["tools"]["cargo-root"], "bin")]

        if extra_path:
            env["PATH"] = "%s%s%s" % (
                os.pathsep.join(extra_path), os.pathsep, env["PATH"])

        if "CARGO_HOME" not in env:
            env["CARGO_HOME"] = self.config["tools"]["cargo-home-dir"]

        if "CARGO_TARGET_DIR" not in env:
            env["CARGO_TARGET_DIR"] = path.join(self.context.topdir, "target")

        if extra_lib:
            if sys.platform == "darwin":
                env["DYLD_LIBRARY_PATH"] = "%s%s%s" % \
                                           (os.pathsep.join(extra_lib),
                                            os.pathsep,
                                            env.get("DYLD_LIBRARY_PATH", ""))
            else:
                env["LD_LIBRARY_PATH"] = "%s%s%s" % \
                                         (os.pathsep.join(extra_lib),
                                          os.pathsep,
                                          env.get("LD_LIBRARY_PATH", ""))

        # Paths to Android build tools:
        if self.config["android"]["sdk"]:
            env["ANDROID_SDK"] = self.config["android"]["sdk"]
        if self.config["android"]["ndk"]:
            env["ANDROID_NDK"] = self.config["android"]["ndk"]
        if self.config["android"]["toolchain"]:
            env["ANDROID_TOOLCHAIN"] = self.config["android"]["toolchain"]

        if gonk:
            if self.config["gonk"]["b2g"]:
                env["GONKDIR"] = self.config["gonk"]["b2g"]
            if "GONKDIR" not in env:
                # Things can get pretty opaque if this hasn't been set
                print("Please set $GONKDIR in your environment or .servobuild file")
                sys.exit(1)
            if self.config["gonk"]["product"]:
                env["GONK_PRODUCT"] = self.config["gonk"]["product"]

            env["ARCH_DIR"] = "arch-arm"
            env["CPPFLAGS"] = (
                "-DANDROID -DTARGET_OS_GONK "
                "-DANDROID_VERSION=19 "
                "-DGR_GL_USE_NEW_SHADER_SOURCE_SIGNATURE=1 "
                "-isystem %(gonkdir)s/bionic/libc/%(archdir)s/include "
                "-isystem %(gonkdir)s/bionic/libc/include/ "
                "-isystem %(gonkdir)s/bionic/libc/kernel/common "
                "-isystem %(gonkdir)s/bionic/libc/kernel/%(archdir)s "
                "-isystem %(gonkdir)s/bionic/libm/include "
                "-I%(gonkdir)s/system "
                "-I%(gonkdir)s/system/core/include "
                "-I%(gonkdir)s/frameworks/native/opengl/include "
                "-I%(gonkdir)s/external/zlib "
            ) % {"gonkdir": env["GONKDIR"], "archdir": env["ARCH_DIR"]}
            env["CXXFLAGS"] = (
                "-O2 -mandroid -fPIC "
                "-isystem %(gonkdir)s/api/cpp/include "
                "-isystem %(gonkdir)s/external/stlport/stlport "
                "-isystem %(gonkdir)s/bionic "
                "-isystem %(gonkdir)s/bionic/libstdc++/include "
                "%(cppflags)s"
            ) % {"gonkdir": env["GONKDIR"], "cppflags": env["CPPFLAGS"]}
            env["CFLAGS"] = (
                "%(cxxflags)s"
            ) % {"cxxflags": env["CXXFLAGS"]}

            another_extra_path = path.join(
                env["GONKDIR"], "prebuilts", "gcc", "linux-x86", "arm", "arm-linux-androideabi-4.7", "bin")

            env["gonkdir"] = env["GONKDIR"]
            env["gonk_toolchain_prefix"] = (
                "%(toolchain)s/arm-linux-androideabi-"
            ) % {"toolchain": another_extra_path}

            env["PATH"] = "%s%s%s" % (another_extra_path, os.pathsep, env["PATH"])
            env["LDFLAGS"] = (
                "-mandroid -L%(gonkdir)s/out/target/product/%(gonkproduct)s/obj/lib "
                "-Wl,-rpath-link=%(gonkdir)s/out/target/product/%(gonkproduct)s/obj/lib "
                "--sysroot=%(gonkdir)s/out/target/product/%(gonkproduct)s/obj/"
            ) % {"gonkdir": env["GONKDIR"], "gonkproduct": env["GONK_PRODUCT"]}

            # Not strictly necessary for a vanilla build, but might be when tweaking the openssl build
            openssl_dir = (
                "%(gonkdir)s/out/target/product/%(gonkproduct)s/obj/lib"
            ) % {"gonkdir": env["GONKDIR"], "gonkproduct": env["GONK_PRODUCT"]}
            env["OPENSSL_LIB_DIR"] = openssl_dir
            env['OPENSSL_INCLUDE_DIR'] = path.join(env["GONKDIR"], "external/openssl/include")

        # FIXME: These are set because they are the variable names that
        # android-rs-glue expects. However, other submodules have makefiles that
        # reference the env var names above. Once glutin is enabled and set as
        # the default, we could modify the subproject makefiles to use the names
        # below and remove the vars above, to avoid duplication.
        if "ANDROID_SDK" in env:
            env["ANDROID_HOME"] = env["ANDROID_SDK"]
        if "ANDROID_NDK" in env:
            env["NDK_HOME"] = env["ANDROID_NDK"]
        if "ANDROID_TOOLCHAIN" in env:
            env["NDK_STANDALONE"] = env["ANDROID_TOOLCHAIN"]

        if hosts_file_path:
            env['HOST_FILE'] = hosts_file_path

        env['RUSTDOC'] = path.join(self.context.topdir, 'etc', 'rustdoc-with-private')

        if self.config["tools"]["rustc-with-gold"]:
            if subprocess.call(['which', 'ld.gold'], stdout=PIPE, stderr=PIPE) == 0:
                env['RUSTC'] = path.join(self.context.topdir, 'etc', 'rustc-with-gold')

        return env

    def servo_crate(self):
        return path.join(self.context.topdir, "components", "servo")

    def android_support_dir(self):
        return path.join(self.context.topdir, "support", "android")

    def ensure_bootstrapped(self):
        if self.context.bootstrapped:
            return

        Registrar.dispatch("update-submodules", context=self.context)

        if not self.config["tools"]["system-rust"] and \
           not path.exists(path.join(
                self.config["tools"]["rust-root"], "rustc", "bin", "rustc")):
            Registrar.dispatch("bootstrap-rust", context=self.context)
        if not self.config["tools"]["system-cargo"] and \
           not path.exists(path.join(
                self.config["tools"]["cargo-root"], "cargo", "bin", "cargo")):
            Registrar.dispatch("bootstrap-cargo", context=self.context)

        self.context.bootstrapped = True

import numpy as np
import matplotlib.pyplot as plt
import xray

import atmos.utils as utils
import atmos.plots as ap
import atmos.data as dat
from atmos.constants import const as constants
from atmos.data import get_coord, int_pres

# ----------------------------------------------------------------------
# Read monthly mean climatologies and do some test calcs
# ----------------------------------------------------------------------

filename = 'data/more/ncep2_climatology_monthly.nc'
ds = dat.ncload(filename)
u = ds['u']
v = ds['v']
T = ds['T']
ps = ds['ps']
lat = get_coord(u, 'lat')
lon = get_coord(u, 'lon')
plev = get_coord(u, 'plev')
mon = ds['mon'].values

topo = dat.get_ps_clim(lat, lon) / 100
topo.units = 'hPa'

# ----------------------------------------------------------------------
# Correct for topography

u_orig = u
u = dat.correct_for_topography(u_orig, topo)

# ----------------------------------------------------------------------
# Integrated vertically dp/g

# DataArray
u_int = int_pres(u, pdim=-3)

# ndarray
u_int2 = int_pres(u.values, plev*100, pdim=-3)

p0=1e5
g = constants.g.values
scale = g/p0

m = 7
k = 5
cint=2

plt.figure(figsize=(7,10))
plt.subplot(311)
ap.contourf_latlon(u[m,k], clev=cint)
plt.subplot(312)
ap.contourf_latlon(scale*u_int[m], clev=cint)
plt.subplot(313)
ap.contourf_latlon(scale*u_int2[m], lat, lon, clev=cint)

# ----------------------------------------------------------------------
# Integrate over subset
# pmin = 400e2
# pmax = 600e2
# m, k = 3, 5
pmin, pmax = 600e2, 1000e2
m, k = 3, 2
scale = g/(pmax-pmin)
cint=1

u_int = int_pres(u, pdim=-3, pmin=pmin, pmax=pmax)
u_int2 = int_pres(u.values, plev*100, pdim=-3, pmin=pmin, pmax=pmax)

plt.figure(figsize=(7,10))
plt.subplot(311)
ap.contourf_latlon(u[m,k], clev=cint)
plt.subplot(312)
ap.contourf_latlon(scale*u_int[m], clev=cint)
plt.subplot(313)
ap.contourf_latlon(scale*u_int2[m], lat, lon, clev=cint)

#! /usr/bin/env python

import rospy
import random
import numpy as np
from visualization_msgs.msg import Marker, MarkerArray
from nav_msgs.msg import Odometry
from std_msgs.msg import String

"""
type of marker:
ARROW = 0   --> triangle
CUBE=1      --> cruciform
SPHERE=2    --> circle
CYLINDER=3  --> totem
LINE_STRIP=4--> rectangle
id: color:
RED=0
GREEN=1
BLUE=2
BLACK=3
WHITE=4
YELLOW=5
ORANGE=6
"""

class PingerPublisher():
    x0, y0 = 0, 0
    map_dim = [[0, 40], [0, 40]]
    def __init__(self):
        rospy.init_node('pinger_pub', anonymous=False)
        r = rospy.Rate(1)
        gate_pub = rospy.Publisher("gate_totem", MarkerArray, queue_size=10)
        pinger_pub = rospy.Publisher("pinger", String, queue_size=10)
        self.odom_received = False
        rospy.Subscriber("odometry/filtered/global", Odometry, self.odom_callback, queue_size=None)
        while not self.odom_received:
            r.sleep()

        count = 1
        MARKERS_MAX = 12
        self.red = [8, 30]
        self.green = [8+7.07*3, 30-7.07*3]
        self.white1 = [8+7.07, 30-7.07]
        self.white2 = [8+7.07*2, 30-7.07*2]
        self.black = [35, 35]
        self.pinger = [8+7.07/2, 30-7.07/2]
        markerArray = MarkerArray()
        pinger = String()
        threshold = 30

        while not rospy.is_shutdown():
            if self.distance(self.red) < threshold:
                if self.likely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("red"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white1"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white2"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("green"))
            if self.distance(self.green) < threshold:
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("red"))
                if self.likely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("green"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white1"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white2"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("black"))
            if self.distance(self.white1) < threshold:
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("red"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("green"))
                if self.likely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white1"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white2"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("black"))
            if self.distance(self.white2) < threshold:
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("red"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("green"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white1"))
                if self.likely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white2"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("black"))
            if self.distance(self.black) < threshold:
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("red"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("green"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white1"))
                if self.unlikely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("white2"))
                if self.likely_spawn():
                    count += 1
                    if(count > MARKERS_MAX):
                        markerArray.markers.pop(0)
                    markerArray.markers.append(self.create_marker("black"))

            if self.distance(self.pinger) < threshold * 0.75:
                pinger.data = "matched"
            else:
                pinger.data = "unknown"

            # Publish the MarkerArray
            gate_pub.publish(markerArray)
            pinger_pub.publish(pinger)

            r.sleep()

    def create_marker(self, color):
        marker = Marker()
        marker.header.frame_id = "/map"
        marker.scale.x = 0.2
        marker.scale.y = 0.2
        marker.scale.z = 0.2
        marker.color.a = 1.0
        marker.color.r = 1.0
        marker.color.g = 1.0
        marker.color.b = 0.0
        # create start red totem
        marker.header.stamp = rospy.Time.now()
        marker.type = marker.CYLINDER  # totem
        marker.action = marker.ADD
        marker.pose.orientation.w = 1.0
        marker.pose.position.z = 0
        if color == "red":
            marker.id = 0  # red
            marker.pose.position.x = self.red[0] + self.random_noise()
            marker.pose.position.y = self.red[1] + self.random_noise()
        elif color == "green":
            marker.id = 1  # green
            marker.pose.position.x = self.green[0] + self.random_noise()
            marker.pose.position.y = self.green[1] + self.random_noise()
        elif color == "white1":
            marker.id = 4  # white 1
            marker.pose.position.x = self.white1[0] + self.random_noise()
            marker.pose.position.y = self.white1[1] + self.random_noise()
        elif color == "white2":
            marker.id = 4  # white 2
            marker.pose.position.x = self.white2[0] + self.random_noise()
            marker.pose.position.y = self.white2[1] + self.random_noise()
        elif color == "black":
            marker.id = 3  # black
            marker.pose.position.x = self.black[0] + self.random_noise()
            marker.pose.position.y = self.black[1] + self.random_noise()

        return marker

    def distance(self, target):
        return np.sqrt((self.x0 - target[0]) ** 2 + (self.y0 - target[1]) ** 2)

    def random_noise(self):
        return random.random() * 4.0 - 2.0

    def likely_spawn(self):
        return random.choice([True, True])

    def unlikely_spawn(self):
        return random.choice([True] * 4 + [True])

    def odom_callback(self, msg):
        """ call back to subscribe, get odometry data:
        pose and orientation of the current boat,
        suffix 0 is for origin """
        self.x0 = msg.pose.pose.position.x
        self.y0 = msg.pose.pose.position.y
        self.odom_received = True




if __name__ == "__main__":
    try:
         PingerPublisher()
    except rospy.ROSInterruptException:
        pass


# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

from __future__ import division, absolute_import

import re
import os

from twisted.trial import unittest
from twisted.internet.address import (
        IPv4Address, UNIXAddress, IPv6Address, HostnameAddress)

try:
    os.symlink
except AttributeError:
    symlinkSkip = "Platform does not support symlinks"
else:
    symlinkSkip = None


class AddressTestCaseMixin(object):
    def test_addressComparison(self):
        """
        Two different address instances, sharing the same properties are
        considered equal by C{==} and not considered not equal by C{!=}.

        Note: When applied via UNIXAddress class, this uses the same
        filename for both objects being compared.
        """
        self.assertTrue(self.buildAddress() == self.buildAddress())
        self.assertFalse(self.buildAddress() != self.buildAddress())


    def _stringRepresentation(self, stringFunction):
        """
        Verify that the string representation of an address object conforms to a
        simple pattern (the usual one for Python object reprs) and contains
        values which accurately reflect the attributes of the address.
        """
        addr = self.buildAddress()
        pattern = "".join([
           "^",
           "([^\(]+Address)", # class name,
           "\(",       # opening bracket,
           "([^)]+)",  # arguments,
           "\)",       # closing bracket,
           "$"
        ])
        stringValue = stringFunction(addr)
        m = re.match(pattern, stringValue)
        self.assertNotEqual(
            None, m,
            "%s does not match the standard __str__ pattern "
            "ClassName(arg1, arg2, etc)" % (stringValue,))
        self.assertEqual(addr.__class__.__name__, m.group(1))

        args = [x.strip() for x in m.group(2).split(",")]
        self.assertEqual(
            args,
            [argSpec[1] % (getattr(addr, argSpec[0]),)
             for argSpec in self.addressArgSpec])


    def test_str(self):
        """
        C{str} can be used to get a string representation of an address instance
        containing information about that address.
        """
        self._stringRepresentation(str)


    def test_repr(self):
        """
        C{repr} can be used to get a string representation of an address
        instance containing information about that address.
        """
        self._stringRepresentation(repr)


    def test_hash(self):
        """
        C{__hash__} can be used to get a hash of an address, allowing
        addresses to be used as keys in dictionaries, for instance.
        """
        addr = self.buildAddress()
        d = {addr: True}
        self.assertTrue(d[self.buildAddress()])


    def test_differentNamesComparison(self):
        """
        Check that comparison operators work correctly on address objects
        when a different name is passed in
        """
        self.assertFalse(self.buildAddress() == self.buildDifferentAddress())
        self.assertFalse(self.buildDifferentAddress() == self.buildAddress())

        self.assertTrue(self.buildAddress() != self.buildDifferentAddress())
        self.assertTrue(self.buildDifferentAddress() != self.buildAddress())


    def assertDeprecations(self, testMethod, message):
        """
        Assert that the a DeprecationWarning with the given message was
        emitted against the given method.
        """
        warnings = self.flushWarnings([testMethod])
        self.assertEqual(warnings[0]['category'], DeprecationWarning)
        self.assertEqual(warnings[0]['message'], message)
        self.assertEqual(len(warnings), 1)



class IPv4AddressTestCaseMixin(AddressTestCaseMixin):
    addressArgSpec = (("type", "%s"), ("host", "%r"), ("port", "%d"))



class HostnameAddressTests(unittest.TestCase, AddressTestCaseMixin):
    """
    Test case for L{HostnameAddress}.
    """
    addressArgSpec = (("hostname", "%s"), ("port", "%d"))

    def buildAddress(self):
        """
        Create an arbitrary new L{HostnameAddress} instance.

        @return: A L{HostnameAddress} instance.
        """
        return HostnameAddress(b"example.com", 0)


    def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different hostname.

        @return: A L{HostnameAddress} instance.
        """
        return HostnameAddress(b"example.net", 0)



class IPv4AddressTCPTestCase(unittest.SynchronousTestCase,
                             IPv4AddressTestCaseMixin):
    def buildAddress(self):
        """
        Create an arbitrary new L{IPv4Address} instance with a C{"TCP"}
        type.  A new instance is created for each call, but always for the
        same address.
        """
        return IPv4Address("TCP", "127.0.0.1", 0)


    def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return IPv4Address("TCP", "127.0.0.2", 0)


    def test_bwHackDeprecation(self):
        """
        If a value is passed for the C{_bwHack} parameter to L{IPv4Address},
        a deprecation warning is emitted.
        """
        # Construct this for warning side-effects, disregard the actual object.
        IPv4Address("TCP", "127.0.0.3", 0, _bwHack="TCP")

        message = (
            "twisted.internet.address.IPv4Address._bwHack is deprecated "
            "since Twisted 11.0")
        return self.assertDeprecations(self.test_bwHackDeprecation, message)



class IPv4AddressUDPTestCase(unittest.SynchronousTestCase,
                             IPv4AddressTestCaseMixin):
    def buildAddress(self):
        """
        Create an arbitrary new L{IPv4Address} instance with a C{"UDP"}
        type.  A new instance is created for each call, but always for the
        same address.
        """
        return IPv4Address("UDP", "127.0.0.1", 0)


    def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return IPv4Address("UDP", "127.0.0.2", 0)


    def test_bwHackDeprecation(self):
        """
        If a value is passed for the C{_bwHack} parameter to L{IPv4Address},
        a deprecation warning is emitted.
        """
        # Construct this for warning side-effects, disregard the actual object.
        IPv4Address("UDP", "127.0.0.3", 0, _bwHack="UDP")

        message = (
            "twisted.internet.address.IPv4Address._bwHack is deprecated "
            "since Twisted 11.0")
        return self.assertDeprecations(self.test_bwHackDeprecation, message)



class IPv6AddressTestCase(unittest.SynchronousTestCase, AddressTestCaseMixin):
    addressArgSpec = (("type", "%s"), ("host", "%r"), ("port", "%d"))

    def buildAddress(self):
        """
        Create an arbitrary new L{IPv6Address} instance with a C{"TCP"}
        type.  A new instance is created for each call, but always for the
        same address.
        """
        return IPv6Address("TCP", "::1", 0)


    def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return IPv6Address("TCP", "::2", 0)



class UNIXAddressTestCase(unittest.SynchronousTestCase, AddressTestCaseMixin):
    addressArgSpec = (("name", "%r"),)

    def setUp(self):
        self._socketAddress = self.mktemp()
        self._otherAddress = self.mktemp()


    def buildAddress(self):
        """
        Create an arbitrary new L{UNIXAddress} instance.  A new instance is
        created for each call, but always for the same address.
        """
        return UNIXAddress(self._socketAddress)


    def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a different fixed address.
        """
        return UNIXAddress(self._otherAddress)


    def test_comparisonOfLinkedFiles(self):
        """
        UNIXAddress objects compare as equal if they link to the same file.
        """
        linkName = self.mktemp()
        self.fd = open(self._socketAddress, 'w')
        os.symlink(os.path.abspath(self._socketAddress), linkName)
        self.assertTrue(
            UNIXAddress(self._socketAddress) == UNIXAddress(linkName))
        self.assertTrue(
            UNIXAddress(linkName) == UNIXAddress(self._socketAddress))
    test_comparisonOfLinkedFiles.skip = symlinkSkip


    def test_hashOfLinkedFiles(self):
        """
        UNIXAddress Objects that compare as equal have the same hash value.
        """
        linkName = self.mktemp()
        self.fd = open(self._socketAddress, 'w')
        os.symlink(os.path.abspath(self._socketAddress), linkName)
        self.assertEqual(
            hash(UNIXAddress(self._socketAddress)), hash(UNIXAddress(linkName)))
    test_hashOfLinkedFiles.skip = symlinkSkip


    def test_bwHackDeprecation(self):
        """
        If a value is passed for the C{_bwHack} parameter to L{UNIXAddress},
        a deprecation warning is emitted.
        """
        # Construct this for warning side-effects, disregard the actual object.
        UNIXAddress(self.mktemp(), _bwHack='UNIX')

        message = (
            "twisted.internet.address.UNIXAddress._bwHack is deprecated "
            "since Twisted 11.0")
        return self.assertDeprecations(self.test_bwHackDeprecation, message)



class EmptyUNIXAddressTestCase(unittest.SynchronousTestCase,
                               AddressTestCaseMixin):
    """
    Tests for L{UNIXAddress} operations involving a C{None} address.
    """
    addressArgSpec = (("name", "%r"),)

    def setUp(self):
        self._socketAddress = self.mktemp()


    def buildAddress(self):
        """
        Create an arbitrary new L{UNIXAddress} instance.  A new instance is
        created for each call, but always for the same address.
        """
        return UNIXAddress(self._socketAddress)


    def buildDifferentAddress(self):
        """
        Like L{buildAddress}, but with a fixed address of C{None}.
        """
        return UNIXAddress(None)


    def test_comparisonOfLinkedFiles(self):
        """
        A UNIXAddress referring to a C{None} address does not compare equal to a
        UNIXAddress referring to a symlink.
        """
        linkName = self.mktemp()
        self.fd = open(self._socketAddress, 'w')
        os.symlink(os.path.abspath(self._socketAddress), linkName)
        self.assertTrue(
            UNIXAddress(self._socketAddress) != UNIXAddress(None))
        self.assertTrue(
            UNIXAddress(None) != UNIXAddress(self._socketAddress))
    test_comparisonOfLinkedFiles.skip = symlinkSkip


    def test_emptyHash(self):
        """
        C{__hash__} can be used to get a hash of an address, even one referring
        to C{None} rather than a real path.
        """
        addr = self.buildDifferentAddress()
        d = {addr: True}
        self.assertTrue(d[self.buildDifferentAddress()])



#
# Copyright: (c) 2016, Red Hat Inc.

# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import sys
import copy

from ansible import constants as C
from ansible.module_utils._text import to_text
from ansible.module_utils.connection import Connection
from ansible.plugins.action.network import ActionModule as ActionNetworkModule
from ansible.module_utils.network.cloudengine.ce import ce_provider_spec
from ansible.module_utils.network.common.utils import load_provider
from ansible.utils.display import Display

display = Display()

CLI_SUPPORTED_MODULES = ['ce_config', 'ce_command', 'ce_facts']


class ActionModule(ActionNetworkModule):

    def run(self, tmp=None, task_vars=None):
        del tmp  # tmp no longer has any effect

        self._config_module = True if self._task.action == 'ce_config' else False
        socket_path = None

        if self._play_context.connection == 'local':
            provider = load_provider(ce_provider_spec, self._task.args)
            transport = provider['transport'] or 'cli'

            display.vvvv('connection transport is %s' % transport, self._play_context.remote_addr)

            if transport == 'cli':
                pc = copy.deepcopy(self._play_context)
                pc.connection = 'network_cli'
                pc.network_os = 'ce'
                pc.remote_addr = provider['host'] or self._play_context.remote_addr
                pc.port = int(provider['port'] or self._play_context.port or 22)
                pc.remote_user = provider['username'] or self._play_context.connection_user
                pc.password = provider['password'] or self._play_context.password
                command_timeout = int(provider['timeout'] or C.PERSISTENT_COMMAND_TIMEOUT)
                self._task.args['provider'] = provider.update(
                    host=pc.remote_addr,
                    port=pc.port,
                    username=pc.remote_user,
                    password=pc.password
                )
                if self._task.action in ['ce_netconf'] or self._task.action not in CLI_SUPPORTED_MODULES:
                    pc.connection = 'netconf'
                display.vvv('using connection plugin %s (was local)' % pc.connection, pc.remote_addr)
                connection = self._shared_loader_obj.connection_loader.get('persistent', pc, sys.stdin)
                connection.set_options(direct={'persistent_command_timeout': command_timeout})

                socket_path = connection.run()
                display.vvvv('socket_path: %s' % socket_path, pc.remote_addr)
                if not socket_path:
                    return {'failed': True,
                            'msg': 'unable to open shell. Please see: ' +
                                   'https://docs.ansible.com/ansible/network_debug_troubleshooting.html#unable-to-open-shell'}

                task_vars['ansible_socket'] = socket_path
                # make sure a transport value is set in args
                self._task.args['transport'] = transport
                self._task.args['provider'] = provider
        elif self._play_context.connection in ('netconf', 'network_cli'):
            provider = self._task.args.get('provider', {})
            if any(provider.values()):
                display.warning('provider is unnecessary when using %s and will be ignored' % self._play_context.connection)
                del self._task.args['provider']

            if (self._play_context.connection == 'network_cli' and self._task.action not in CLI_SUPPORTED_MODULES) or \
                    (self._play_context.connection == 'netconf' and self._task.action in CLI_SUPPORTED_MODULES):
                return {'failed': True, 'msg': "Connection type '%s' is not valid for '%s' module."
                        % (self._play_context.connection, self._task.action)}

        if (self._play_context.connection == 'local' and transport == 'cli' and self._task.action in CLI_SUPPORTED_MODULES) \
                or self._play_context.connection == 'network_cli':
            # make sure we are in the right cli context which should be
            # enable mode and not config module
            if socket_path is None:
                socket_path = self._connection.socket_path
            conn = Connection(socket_path)
            out = conn.get_prompt()
            while to_text(out, errors='surrogate_then_replace').strip().endswith(']'):
                display.vvvv('wrong context, sending exit to device', self._play_context.remote_addr)
                conn.exec_command('return')
                out = conn.get_prompt()

        result = super(ActionModule, self).run(task_vars=task_vars)
        return result

##########################################################################
#
#  Copyright (c) 2008, Image Engine Design Inc. All rights reserved.
#
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions are
#  met:
#
#     * Redistributions of source code must retain the above copyright
#       notice, this list of conditions and the following disclaimer.
#
#     * Redistributions in binary form must reproduce the above copyright
#       notice, this list of conditions and the following disclaimer in the
#       documentation and/or other materials provided with the distribution.
#
#     * Neither the name of Image Engine Design nor the names of any
#       other contributors to this software may be used to endorse or
#       promote products derived from this software without specific prior
#       written permission.
#
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
#  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
#  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
#  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
#  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
#  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
#  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
#  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
#  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
#  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
##########################################################################

import math
import nuke
import imath
import IECore
from KnobAccessors import getKnobValue

## This function set can be used to manipulate any nodes which have
# an axis knob. This includes the Axis, TransformGeo and Camera nodes.
## \todo Methods for dealing with TransformationMatrices, absolute transforms
# and for setting transforms.
class FnAxis :

	def __init__( self, node ) :

		if isinstance( node, str ) :

			axis = nuke.toNode( node )

		self.__node = node

	## Returns the transformation matrix for the local axis knob.
	# This ignores any parent transforms.
	def getLocalMatrix( self, resultType=imath.M44f ) :

		vectorType = imath.V3f
		eulerType = imath.Eulerf
		if resultType==imath.M44d :
			vectorType = imath.V3d
			eulerType = imath.Eulerd

		translate = getKnobValue( self.__node.knob( "translate" ), resultType=vectorType )
		translate = resultType().translate( translate )

		pivot = getKnobValue( self.__node.knob( "pivot" ), resultType=vectorType )

		rotate = getKnobValue( self.__node.knob( "rotate" ), resultType=vectorType )
		rotate *= math.pi / 180.0

		rotOrderKnob = self.__node.knob( "rot_order" )
		rotateOrder = rotOrderKnob.enumName( int(rotOrderKnob.getValue()) )
		rotate = eulerType( rotate, getattr( eulerType.Order, rotateOrder ) )
		rotate = rotate.toMatrix44()
		rotate = resultType().translate( -pivot ) * rotate * resultType().translate( pivot )

		scale = getKnobValue( self.__node.knob(  "scaling" ), resultType=vectorType )
		scale *= self.__node.knob( "uniform_scale" ).getValue()
		scale = resultType().scale( scale )
		scale = resultType().translate( -pivot ) * scale * resultType().translate( pivot )

		orderKnob = self.__node.knob( "xform_order" )
		order = orderKnob.enumName( int(orderKnob.getValue()) )
		matrices = {
			"T" : translate,
			"R" : rotate,
			"S" : scale
		}

		result = resultType()
		for m in order :
			result = result * matrices[m]

		return result

# -*- coding: utf-8 -*-
#

from trac.core import *
from trac.db import *
from trac.env import IEnvironmentSetupParticipant
from trac.db import Table, Column, DatabaseManager
from trac.util.text import printout


# Database schema variables
db_version_key = 'tracbuildbot_version'
db_version = 1

table = Table('buildbot_builds', key = 'id') [
            Column('id', type = 'integer', auto_increment = True),
            Column('builder'),
            Column('status'),
            Column('start', type='int64'),
            Column('num', type='int64'),
            Column('finish', type='int64'),
            Column('rev'),
            Column('error'),
            Column('error_log'),
        ]

"""
Extension point interface for components that need to participate in the
creation and upgrading of Trac environments, for example to create
additional database tables."""
class BuildbotParticipant(Component):
    implements(IEnvironmentSetupParticipant)

    """
    Called when a new Trac environment is created."""
    def environment_created(self):
        pass

    """
    Called when Trac checks whether the environment needs to be upgraded.
    Should return `True` if this participant needs an upgrade to be
    performed, `False` otherwise."""
    def environment_needs_upgrade(self, db):
        # Initialise database schema version tracking.
        cursor = db.cursor()
        # Get currently installed database schema version
        db_installed_version = 0
        try:
            sqlGetInstalledVersion = """SELECT value FROM system WHERE name = %s"""
            cursor.execute(sqlGetInstalledVersion, [db_version_key])
            db_installed_version = int(cursor.fetchone()[0])
        except:
            # No version currently, inserting new one.
            db_installed_version = 0

        self.log.debug("tracbuildbot database schema version: %s (should be %s)",
                       db_installed_version, db_version)
        # return boolean for if we need to update or not
        needsUpgrade = (db_installed_version < db_version)
        if needsUpgrade:
            self.log.info("tracbuildbot database schema version is %s, should be %s",
                          db_installed_version, db_version)
        return needsUpgrade


    """
    Actually perform an environment upgrade.
    Implementations of this method should not commit any database
    transactions. This is done implicitly after all participants have
    performed the upgrades they need without an error being raised."""
    def upgrade_environment(self, db):
        printout("Upgrading tracbuildbot database schema")
        cursor = db.cursor()

        db_installed_version = 0
        sqlGetInstalledVersion = """SELECT value FROM system WHERE name = %s"""
        cursor.execute(sqlGetInstalledVersion, [db_version_key])
        for row in cursor:
            db_installed_version = int(row[0])
        printout("tracbuildbot database schema version is %s, should be %s" %
                 (db_installed_version, db_version))

        db_connector, _ = DatabaseManager(self.env)._get_connector()

        if db_installed_version < 1:
            # Create tables
            for statement in db_connector.to_sql(table):
                cursor.execute(statement)
                    
            sqlInsertVersion = """INSERT INTO system (name, value) VALUES (%s,%s)"""
            cursor.execute(sqlInsertVersion, [db_version_key, db_version])
            db_installed_version = 1
            

"""Base email backend class."""


class BaseEmailBackend(object):
    """
    Base class for email backend implementations.

    Subclasses must at least overwrite send_messages().
    """
    def __init__(self, fail_silently=False, **kwargs):
        self.fail_silently = fail_silently

    def open(self):
        """Open a network connection.

        This method can be overwritten by backend implementations to
        open a network connection.

        It's up to the backend implementation to track the status of
        a network connection if it's needed by the backend.

        This method can be called by applications to force a single
        network connection to be used when sending mails. See the
        send_messages() method of the SMTP backend for a reference
        implementation.

        The default implementation does nothing.
        """
        pass

    def close(self):
        """Close a network connection."""
        pass

    def send_messages(self, email_messages):
        """
        Sends one or more EmailMessage objects and returns the number of email
        messages sent.
        """
        raise NotImplementedError('subclasses of BaseEmailBackend must override send_messages() method')

# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

########################################################
import datetime
import os
import platform
import random
import shutil
import socket
import sys
import time

from ansible.cli import CLI
from ansible.errors import AnsibleOptionsError
from ansible.module_utils._text import to_native
from ansible.plugins.loader import module_loader
from ansible.utils.cmd_functions import run_cmd

try:
    from __main__ import display
except ImportError:
    from ansible.utils.display import Display
    display = Display()


########################################################

class PullCLI(CLI):
    ''' is used to up a remote copy of ansible on each managed node,
        each set to run via cron and update playbook source via a source repository.
        This inverts the default *push* architecture of ansible into a *pull* architecture,
        which has near-limitless scaling potential.

        The setup playbook can be tuned to change the cron frequency, logging locations, and parameters to ansible-pull.
        This is useful both for extreme scale-out as well as periodic remediation.
        Usage of the 'fetch' module to retrieve logs from ansible-pull runs would be an
        excellent way to gather and analyze remote logs from ansible-pull.
    '''

    DEFAULT_REPO_TYPE = 'git'
    DEFAULT_PLAYBOOK = 'local.yml'
    PLAYBOOK_ERRORS = {
        1: 'File does not exist',
        2: 'File is not readable',
    }
    SUPPORTED_REPO_MODULES = ['git']
    ARGUMENTS = {'playbook.yml': 'The name of one the YAML format files to run as an Ansible playbook.'
                                 'This can be a relative path within the checkout. By default, Ansible will'
                                 "look for a playbook based on the host's fully-qualified domain name,"
                                 'on the host hostname and finally a playbook named *local.yml*.', }

    def _get_inv_cli(self):

        inv_opts = ''
        if getattr(self.options, 'inventory'):
            for inv in self.options.inventory:
                if isinstance(inv, list):
                    inv_opts += " -i '%s' " % ','.join(inv)
                elif ',' in inv or os.path.exists(inv):
                    inv_opts += ' -i %s ' % inv

        if not inv_opts:
            inv_opts = " -i localhost, "

        return inv_opts

    def parse(self):
        ''' create an options parser for bin/ansible '''

        self.parser = CLI.base_parser(
            usage='%prog -U <repository> [options] [<playbook.yml>]',
            connect_opts=True,
            vault_opts=True,
            runtask_opts=True,
            subset_opts=True,
            inventory_opts=True,
            module_opts=True,
            runas_prompt_opts=True,
            desc="pulls playbooks from a VCS repo and executes them for the local host",
        )

        # options unique to pull
        self.parser.add_option('--purge', default=False, action='store_true', help='purge checkout after playbook run')
        self.parser.add_option('-o', '--only-if-changed', dest='ifchanged', default=False, action='store_true',
                               help='only run the playbook if the repository has been updated')
        self.parser.add_option('-s', '--sleep', dest='sleep', default=None,
                               help='sleep for random interval (between 0 and n number of seconds) before starting. '
                                    'This is a useful way to disperse git requests')
        self.parser.add_option('-f', '--force', dest='force', default=False, action='store_true',
                               help='run the playbook even if the repository could not be updated')
        self.parser.add_option('-d', '--directory', dest='dest', default=None, help='directory to checkout repository to')
        self.parser.add_option('-U', '--url', dest='url', default=None, help='URL of the playbook repository')
        self.parser.add_option('--full', dest='fullclone', action='store_true', help='Do a full clone, instead of a shallow one.')
        self.parser.add_option('-C', '--checkout', dest='checkout',
                               help='branch/tag/commit to checkout. Defaults to behavior of repository module.')
        self.parser.add_option('--accept-host-key', default=False, dest='accept_host_key', action='store_true',
                               help='adds the hostkey for the repo url if not already added')
        self.parser.add_option('-m', '--module-name', dest='module_name', default=self.DEFAULT_REPO_TYPE,
                               help='Repository module name, which ansible will use to check out the repo. Default is %s.' % self.DEFAULT_REPO_TYPE)
        self.parser.add_option('--verify-commit', dest='verify', default=False, action='store_true',
                               help='verify GPG signature of checked out commit, if it fails abort running the playbook. '
                                    'This needs the corresponding VCS module to support such an operation')
        self.parser.add_option('--clean', dest='clean', default=False, action='store_true',
                               help='modified files in the working repository will be discarded')
        self.parser.add_option('--track-subs', dest='tracksubs', default=False, action='store_true',
                               help='submodules will track the latest changes. This is equivalent to specifying the --remote flag to git submodule update')
        self.parser.add_option("--check", default=False, dest='check', action='store_true',
                               help="don't make any changes; instead, try to predict some of the changes that may occur")

        # for pull we don't want a default
        self.parser.set_defaults(inventory=None)

        super(PullCLI, self).parse()

        if not self.options.dest:
            hostname = socket.getfqdn()
            # use a hostname dependent directory, in case of $HOME on nfs
            self.options.dest = os.path.join('~/.ansible/pull', hostname)
        self.options.dest = os.path.expandvars(os.path.expanduser(self.options.dest))

        if os.path.exists(self.options.dest) and not os.path.isdir(self.options.dest):
            raise AnsibleOptionsError("%s is not a valid or accessible directory." % self.options.dest)

        if self.options.sleep:
            try:
                secs = random.randint(0, int(self.options.sleep))
                self.options.sleep = secs
            except ValueError:
                raise AnsibleOptionsError("%s is not a number." % self.options.sleep)

        if not self.options.url:
            raise AnsibleOptionsError("URL for repository not specified, use -h for help")

        if self.options.module_name not in self.SUPPORTED_REPO_MODULES:
            raise AnsibleOptionsError("Unsupported repo module %s, choices are %s" % (self.options.module_name, ','.join(self.SUPPORTED_REPO_MODULES)))

        display.verbosity = self.options.verbosity
        self.validate_conflicts(vault_opts=True)

    def run(self):
        ''' use Runner lib to do SSH things '''

        super(PullCLI, self).run()

        # log command line
        now = datetime.datetime.now()
        display.display(now.strftime("Starting Ansible Pull at %F %T"))
        display.display(' '.join(sys.argv))

        # Build Checkout command
        # Now construct the ansible command
        node = platform.node()
        host = socket.getfqdn()
        limit_opts = 'localhost,%s,127.0.0.1' % ','.join(set([host, node, host.split('.')[0], node.split('.')[0]]))
        base_opts = '-c local '
        if self.options.verbosity > 0:
            base_opts += ' -%s' % ''.join(["v" for x in range(0, self.options.verbosity)])

        # Attempt to use the inventory passed in as an argument
        # It might not yet have been downloaded so use localhost as default
        inv_opts = self._get_inv_cli()

        # FIXME: enable more repo modules hg/svn?
        if self.options.module_name == 'git':
            repo_opts = "name=%s dest=%s" % (self.options.url, self.options.dest)
            if self.options.checkout:
                repo_opts += ' version=%s' % self.options.checkout

            if self.options.accept_host_key:
                repo_opts += ' accept_hostkey=yes'

            if self.options.private_key_file:
                repo_opts += ' key_file=%s' % self.options.private_key_file

            if self.options.verify:
                repo_opts += ' verify_commit=yes'

            if self.options.clean:
                repo_opts += ' force=yes'

            if self.options.tracksubs:
                repo_opts += ' track_submodules=yes'

            if not self.options.fullclone:
                repo_opts += ' depth=1'

        path = module_loader.find_plugin(self.options.module_name)
        if path is None:
            raise AnsibleOptionsError(("module '%s' not found.\n" % self.options.module_name))

        bin_path = os.path.dirname(os.path.abspath(sys.argv[0]))
        # hardcode local and inventory/host as this is just meant to fetch the repo
        cmd = '%s/ansible %s %s -m %s -a "%s" all -l "%s"' % (bin_path, inv_opts, base_opts, self.options.module_name, repo_opts, limit_opts)

        for ev in self.options.extra_vars:
            cmd += ' -e "%s"' % ev

        # Nap?
        if self.options.sleep:
            display.display("Sleeping for %d seconds..." % self.options.sleep)
            time.sleep(self.options.sleep)

        # RUN the Checkout command
        display.debug("running ansible with VCS module to checkout repo")
        display.vvvv('EXEC: %s' % cmd)
        rc, out, err = run_cmd(cmd, live=True)

        if rc != 0:
            if self.options.force:
                display.warning("Unable to update repository. Continuing with (forced) run of playbook.")
            else:
                return rc
        elif self.options.ifchanged and '"changed": true' not in out:
            display.display("Repository has not changed, quitting.")
            return 0

        playbook = self.select_playbook(self.options.dest)
        if playbook is None:
            raise AnsibleOptionsError("Could not find a playbook to run.")

        # Build playbook command
        cmd = '%s/ansible-playbook %s %s' % (bin_path, base_opts, playbook)
        if self.options.vault_password_files:
            for vault_password_file in self.options.vault_password_files:
                cmd += " --vault-password-file=%s" % vault_password_file

        for ev in self.options.extra_vars:
            cmd += ' -e "%s"' % ev
        if self.options.ask_sudo_pass or self.options.ask_su_pass or self.options.become_ask_pass:
            cmd += ' --ask-become-pass'
        if self.options.skip_tags:
            cmd += ' --skip-tags "%s"' % to_native(u','.join(self.options.skip_tags))
        if self.options.tags:
            cmd += ' -t "%s"' % to_native(u','.join(self.options.tags))
        if self.options.subset:
            cmd += ' -l "%s"' % self.options.subset
        else:
            cmd += ' -l "%s"' % limit_opts
        if self.options.check:
            cmd += ' -C'

        os.chdir(self.options.dest)

        # redo inventory options as new files might exist now
        inv_opts = self._get_inv_cli()
        if inv_opts:
            cmd += inv_opts

        # RUN THE PLAYBOOK COMMAND
        display.debug("running ansible-playbook to do actual work")
        display.debug('EXEC: %s' % cmd)
        rc, out, err = run_cmd(cmd, live=True)

        if self.options.purge:
            os.chdir('/')
            try:
                shutil.rmtree(self.options.dest)
            except Exception as e:
                display.error("Failed to remove %s: %s" % (self.options.dest, str(e)))

        return rc

    def try_playbook(self, path):
        if not os.path.exists(path):
            return 1
        if not os.access(path, os.R_OK):
            return 2
        return 0

    def select_playbook(self, path):
        playbook = None
        if len(self.args) > 0 and self.args[0] is not None:
            playbook = os.path.join(path, self.args[0])
            rc = self.try_playbook(playbook)
            if rc != 0:
                display.warning("%s: %s" % (playbook, self.PLAYBOOK_ERRORS[rc]))
                return None
            return playbook
        else:
            fqdn = socket.getfqdn()
            hostpb = os.path.join(path, fqdn + '.yml')
            shorthostpb = os.path.join(path, fqdn.split('.')[0] + '.yml')
            localpb = os.path.join(path, self.DEFAULT_PLAYBOOK)
            errors = []
            for pb in [hostpb, shorthostpb, localpb]:
                rc = self.try_playbook(pb)
                if rc == 0:
                    playbook = pb
                    break
                else:
                    errors.append("%s: %s" % (pb, self.PLAYBOOK_ERRORS[rc]))
            if playbook is None:
                display.warning("\n".join(errors))
            return playbook

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
Format management.


Creating new formats
--------------------

A new format named 'foo-bar' corresponds to Python module
'tracetool/format/foo_bar.py'.

A format module should provide a docstring, whose first non-empty line will be
considered its short description.

All formats must generate their contents through the 'tracetool.out' routine.


Format functions
----------------

All the following functions are optional, and no output will be generated if
they do not exist.

======== =======================================================================
Function Description
======== =======================================================================
begin    Called to generate the format-specific file header.
end      Called to generate the format-specific file footer.
nop      Called to generate the per-event contents when the event is disabled or
         the selected backend is 'nop'.
======== =======================================================================
"""

__author__     = "Lluís Vilanova <vilanova@ac.upc.edu>"
__copyright__  = "Copyright 2012, Lluís Vilanova <vilanova@ac.upc.edu>"
__license__    = "GPL version 2 or (at your option) any later version"

__maintainer__ = "Stefan Hajnoczi"
__email__      = "stefanha@linux.vnet.ibm.com"


import os

import tracetool


def get_list():
    """Get a list of (name, description) pairs."""
    res = []
    modnames = []
    for filename in os.listdir(tracetool.format.__path__[0]):
        if filename.endswith('.py') and filename != '__init__.py':
            modnames.append(filename.rsplit('.', 1)[0])
    for modname in modnames:
        module = tracetool.try_import("tracetool.format." + modname)

        # just in case; should never fail unless non-module files are put there
        if not module[0]:
            continue
        module = module[1]

        doc = module.__doc__
        if doc is None:
            doc = ""
        doc = doc.strip().split("\n")[0]

        name = modname.replace("_", "-")
        res.append((name, doc))
    return res


def exists(name):
    """Return whether the given format exists."""
    if len(name) == 0:
        return False
    name = name.replace("-", "_")
    return tracetool.try_import("tracetool.format." + name)[1]


def _empty(events):
    pass

def generate_begin(name, events):
    """Generate the header of the format-specific file."""
    if not exists(name):
        raise ValueError("unknown format: %s" % name)

    name = name.replace("-", "_")
    func = tracetool.try_import("tracetool.format." + name,
                                "begin", _empty)[1]
    func(events)

def generate_end(name, events):
    """Generate the footer of the format-specific file."""
    if not exists(name):
        raise ValueError("unknown format: %s" % name)

    name = name.replace("-", "_")
    func = tracetool.try_import("tracetool.format." + name,
                                "end", _empty)[1]
    func(events)

# Copyright 2016 Google Inc. All Rights Reserved.
#
# 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.

"""Tests for the DjangoORM storage class."""

# Mock a Django environment
import datetime
import unittest

from django.db import models
import mock

from oauth2client import GOOGLE_TOKEN_URI
from oauth2client.client import OAuth2Credentials
from oauth2client.contrib.django_util.models import CredentialsField
from oauth2client.contrib.django_util.storage import (
    DjangoORMStorage as Storage)


class TestStorage(unittest.TestCase):
    def setUp(self):
        access_token = 'foo'
        client_id = 'some_client_id'
        client_secret = 'cOuDdkfjxxnv+'
        refresh_token = '1/0/a.df219fjls0'
        token_expiry = datetime.datetime.utcnow()
        user_agent = 'refresh_checker/1.0'

        self.credentials = OAuth2Credentials(
            access_token, client_id, client_secret,
            refresh_token, token_expiry, GOOGLE_TOKEN_URI,
            user_agent)

        self.key_name = 'id'
        self.key_value = '1'
        self.property_name = 'credentials'

    def test_constructor(self):
        storage = Storage(FakeCredentialsModel, self.key_name,
                          self.key_value, self.property_name)

        self.assertEqual(storage.model_class, FakeCredentialsModel)
        self.assertEqual(storage.key_name, self.key_name)
        self.assertEqual(storage.key_value, self.key_value)
        self.assertEqual(storage.property_name, self.property_name)

    @mock.patch('django.db.models')
    def test_locked_get(self, djangoModel):
        fake_model_with_credentials = FakeCredentialsModelMock()
        entities = [
            fake_model_with_credentials
        ]
        filter_mock = mock.Mock(return_value=entities)
        object_mock = mock.Mock()
        object_mock.filter = filter_mock
        FakeCredentialsModelMock.objects = object_mock

        storage = Storage(FakeCredentialsModelMock, self.key_name,
                          self.key_value, self.property_name)
        credential = storage.locked_get()
        self.assertEqual(
            credential, fake_model_with_credentials.credentials)

    @mock.patch('django.db.models')
    def test_locked_get_no_entities(self, djangoModel):
        entities = []
        filter_mock = mock.Mock(return_value=entities)
        object_mock = mock.Mock()
        object_mock.filter = filter_mock
        FakeCredentialsModelMock.objects = object_mock

        storage = Storage(FakeCredentialsModelMock, self.key_name,
                          self.key_value, self.property_name)
        credential = storage.locked_get()
        self.assertIsNone(credential)

    @mock.patch('django.db.models')
    def test_locked_get_no_set_store(self, djangoModel):
        fake_model_with_credentials = FakeCredentialsModelMockNoSet()
        entities = [
            fake_model_with_credentials
        ]
        filter_mock = mock.Mock(return_value=entities)
        object_mock = mock.Mock()
        object_mock.filter = filter_mock
        FakeCredentialsModelMockNoSet.objects = object_mock

        storage = Storage(FakeCredentialsModelMockNoSet, self.key_name,
                          self.key_value, self.property_name)
        credential = storage.locked_get()
        self.assertEqual(
            credential, fake_model_with_credentials.credentials)

    @mock.patch('django.db.models')
    def test_locked_put(self, djangoModel):
        entity_mock = mock.Mock(credentials=None)
        objects = mock.Mock(
            get_or_create=mock.Mock(return_value=(entity_mock, None)))
        FakeCredentialsModelMock.objects = objects
        storage = Storage(FakeCredentialsModelMock, self.key_name,
                          self.key_value, self.property_name)
        storage.locked_put(self.credentials)

    @mock.patch('django.db.models')
    def test_locked_delete(self, djangoModel):
        class FakeEntities(object):
            def __init__(self):
                self.deleted = False

            def delete(self):
                self.deleted = True

        fake_entities = FakeEntities()
        entities = fake_entities

        filter_mock = mock.Mock(return_value=entities)
        object_mock = mock.Mock()
        object_mock.filter = filter_mock
        FakeCredentialsModelMock.objects = object_mock
        storage = Storage(FakeCredentialsModelMock, self.key_name,
                          self.key_value, self.property_name)
        storage.locked_delete()
        self.assertTrue(fake_entities.deleted)


class CredentialWithSetStore(CredentialsField):
    def __init__(self):
        self.model = CredentialWithSetStore

    def set_store(self, storage):
        pass


class FakeCredentialsModel(models.Model):
    credentials = CredentialsField()


class FakeCredentialsModelMock(object):
    def __init__(self, *args, **kwargs):
        self.model = FakeCredentialsModelMock
        self.saved = False
        self.deleted = False

    credentials = CredentialWithSetStore()


class FakeCredentialsModelMockNoSet(object):
    def __init__(self, set_store=False, *args, **kwargs):
        self.model = FakeCredentialsModelMock
        self.saved = False
        self.deleted = False

    credentials = CredentialsField()

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for summary ops."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from tensorflow.core.framework import summary_pb2
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import ops
from tensorflow.python.ops import logging_ops
from tensorflow.python.platform import test
from tensorflow.python.summary import summary


class SummaryOpsTest(test.TestCase):

  def _AsSummary(self, s):
    summ = summary_pb2.Summary()
    summ.ParseFromString(s)
    return summ

  def testScalarSummary(self):
    with self.test_session() as sess:
      const = constant_op.constant([10.0, 20.0])
      summ = logging_ops.scalar_summary(["c1", "c2"], const, name="mysumm")
      value = sess.run(summ)
    self.assertEqual([], summ.get_shape())
    self.assertProtoEquals("""
      value { tag: "c1" simple_value: 10.0 }
      value { tag: "c2" simple_value: 20.0 }
      """, self._AsSummary(value))

  def testScalarSummaryDefaultName(self):
    with self.test_session() as sess:
      const = constant_op.constant([10.0, 20.0])
      summ = logging_ops.scalar_summary(["c1", "c2"], const)
      value = sess.run(summ)
    self.assertEqual([], summ.get_shape())
    self.assertProtoEquals("""
      value { tag: "c1" simple_value: 10.0 }
      value { tag: "c2" simple_value: 20.0 }
      """, self._AsSummary(value))

  def testMergeSummary(self):
    with self.test_session() as sess:
      const = constant_op.constant(10.0)
      summ1 = summary.histogram("h", const)
      summ2 = logging_ops.scalar_summary("c", const)
      merge = summary.merge([summ1, summ2])
      value = sess.run(merge)
    self.assertEqual([], merge.get_shape())
    self.assertProtoEquals("""
      value {
        tag: "h"
        histo {
          min: 10.0
          max: 10.0
          num: 1.0
          sum: 10.0
          sum_squares: 100.0
          bucket_limit: 9.93809490288
          bucket_limit: 10.9319043932
          bucket_limit: 1.7976931348623157e+308
          bucket: 0.0
          bucket: 1.0
          bucket: 0.0
        }
      }
      value { tag: "c" simple_value: 10.0 }
    """, self._AsSummary(value))

  def testMergeAllSummaries(self):
    with ops.Graph().as_default():
      const = constant_op.constant(10.0)
      summ1 = summary.histogram("h", const)
      summ2 = summary.scalar("o", const, collections=["foo_key"])
      summ3 = summary.scalar("c", const)
      merge = summary.merge_all()
      self.assertEqual("MergeSummary", merge.op.type)
      self.assertEqual(2, len(merge.op.inputs))
      self.assertEqual(summ1, merge.op.inputs[0])
      self.assertEqual(summ3, merge.op.inputs[1])
      merge = summary.merge_all("foo_key")
      self.assertEqual("MergeSummary", merge.op.type)
      self.assertEqual(1, len(merge.op.inputs))
      self.assertEqual(summ2, merge.op.inputs[0])
      self.assertTrue(summary.merge_all("bar_key") is None)

  def testHistogramSummaryTypes(self):
    with ops.Graph().as_default():
      for dtype in (dtypes.int8, dtypes.uint8, dtypes.int16, dtypes.int32,
                    dtypes.float32, dtypes.float64):
        const = constant_op.constant(10, dtype=dtype)
        summary.histogram("h", const)


if __name__ == "__main__":
  test.main()

# python
# This file is generated by a program (mib2py). Any edits will be lost.

from pycopia.aid import Enum
import pycopia.SMI.Basetypes
Range = pycopia.SMI.Basetypes.Range
Ranges = pycopia.SMI.Basetypes.Ranges

from pycopia.SMI.Objects import ColumnObject, MacroObject, NotificationObject, RowObject, ScalarObject, NodeObject, ModuleObject, GroupObject

# imports 
from SNMPv2_SMI import MODULE_IDENTITY, OBJECT_TYPE, Unsigned32, Counter32
from SNMPv2_CONF import MODULE_COMPLIANCE, OBJECT_GROUP
from TUBS_SMI import ibr
from SNMPv2_TC import TEXTUAL_CONVENTION
from SNMP_FRAMEWORK_MIB import SnmpAdminString

class TUBS_IBR_XEN_MIB(ModuleObject):
	path = '/usr/share/snmp/mibs/tubs/TUBS-IBR-XEN-MIB'
	name = 'TUBS-IBR-XEN-MIB'
	language = 2
	description = 'Experimental MIB module for Xen Virtual Hosting.'

# nodes
class xenMIB(NodeObject):
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14])
	name = 'xenMIB'

class xenObjects(NodeObject):
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1])
	name = 'xenObjects'

class xenHost(NodeObject):
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 1])
	name = 'xenHost'

class xenTraps(NodeObject):
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 2])
	name = 'xenTraps'

class xenConformance(NodeObject):
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 3])
	name = 'xenConformance'

class xenCompliances(NodeObject):
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 3, 1])
	name = 'xenCompliances'

class xenGroups(NodeObject):
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 3, 2])
	name = 'xenGroups'


# macros
# types 

class XenDomainState(pycopia.SMI.Basetypes.Enumeration):
	status = 1
	enumerations = [Enum(1, 'unknown'), Enum(2, 'running'), Enum(3, 'blocked'), Enum(4, 'paused'), Enum(5, 'crashed'), Enum(6, 'dying'), Enum(7, 'shutdown')]

# scalars 
class xenHostXenVersion(ScalarObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 1, 1])
	syntaxobject = SnmpAdminString


class xenHostTotalMemKBytes(ScalarObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 1, 2])
	syntaxobject = pycopia.SMI.Basetypes.Unsigned32


class xenHostCPUs(ScalarObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 1, 3])
	syntaxobject = pycopia.SMI.Basetypes.Unsigned32


class xenHostCPUMHz(ScalarObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 1, 4])
	syntaxobject = pycopia.SMI.Basetypes.Unsigned32


# columns
class xenDomainName(ColumnObject):
	access = 2
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 2, 1, 1])
	syntaxobject = SnmpAdminString


class xenDomainState(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 2, 1, 2])
	syntaxobject = XenDomainState


class xenDomainMemKBytes(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 2, 1, 3])
	syntaxobject = pycopia.SMI.Basetypes.Unsigned32


class xenDomainMaxMemKBytes(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 2, 1, 4])
	syntaxobject = pycopia.SMI.Basetypes.Unsigned32


class xenVCPUIndex(ColumnObject):
	access = 2
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 3, 1, 1])
	syntaxobject = pycopia.SMI.Basetypes.Unsigned32


class xenVCPUMilliseconds(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 3, 1, 2])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkIndex(ColumnObject):
	access = 2
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 1])
	syntaxobject = pycopia.SMI.Basetypes.Unsigned32


class xenNetworkInKBytes(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 2])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkInPkts(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 3])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkInErrors(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 4])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkInDiscards(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 5])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkOutKBytes(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 6])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkOutPkts(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 7])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkOutErrors(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 8])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


class xenNetworkOutDiscards(ColumnObject):
	access = 4
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1, 9])
	syntaxobject = pycopia.SMI.Basetypes.Counter32


# rows 
class xenDomainEntry(RowObject):
	status = 1
	index = pycopia.SMI.Objects.IndexObjects([xenDomainName], False)
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 2, 1])
	access = 2
	columns = {'xenDomainName': xenDomainName, 'xenDomainState': xenDomainState, 'xenDomainMemKBytes': xenDomainMemKBytes, 'xenDomainMaxMemKBytes': xenDomainMaxMemKBytes}


class xenVCPUEntry(RowObject):
	status = 1
	index = pycopia.SMI.Objects.IndexObjects([xenDomainName, xenVCPUIndex], False)
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 3, 1])
	access = 2
	columns = {'xenVCPUIndex': xenVCPUIndex, 'xenVCPUMilliseconds': xenVCPUMilliseconds}


class xenNetworkEntry(RowObject):
	status = 1
	index = pycopia.SMI.Objects.IndexObjects([xenDomainName, xenNetworkIndex], False)
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 1, 4, 1])
	access = 2
	columns = {'xenNetworkIndex': xenNetworkIndex, 'xenNetworkInKBytes': xenNetworkInKBytes, 'xenNetworkInPkts': xenNetworkInPkts, 'xenNetworkInErrors': xenNetworkInErrors, 'xenNetworkInDiscards': xenNetworkInDiscards, 'xenNetworkOutKBytes': xenNetworkOutKBytes, 'xenNetworkOutPkts': xenNetworkOutPkts, 'xenNetworkOutErrors': xenNetworkOutErrors, 'xenNetworkOutDiscards': xenNetworkOutDiscards}


# notifications (traps) 
# groups 
class xenGeneralGroup(GroupObject):
	access = 2
	status = 1
	OID = pycopia.SMI.Basetypes.ObjectIdentifier([1, 3, 6, 1, 4, 1, 1575, 1, 14, 3, 2, 1])
	group = [xenHostXenVersion, xenHostTotalMemKBytes, xenHostCPUs, xenHostCPUMHz, xenDomainState, xenDomainMemKBytes, xenDomainMaxMemKBytes, xenVCPUMilliseconds, xenNetworkInKBytes, xenNetworkInPkts, xenNetworkInErrors, xenNetworkInDiscards, xenNetworkOutKBytes, xenNetworkOutPkts, xenNetworkOutErrors, xenNetworkOutDiscards]

# capabilities 

# special additions

# Add to master OIDMAP.
from pycopia import SMI
SMI.update_oidmap(__name__)

"""
Tests for filter terms.
"""
from operator import and_

from numpy import (
    arange,
    argsort,
    array,
    eye,
    float64,
    full_like,
    nan,
    nanpercentile,
    ones,
    putmask,
)

from zipline.errors import BadPercentileBounds
from zipline.modelling.factor import TestingFactor
from zipline.utils.test_utils import check_arrays

from .base import BaseFFCTestCase


def rowwise_rank(array):
    """
    Take a 2D array and return the 0-indexed sorted position of each element in
    the array for each row.

    Example
    -------
    In [5]: data
    Out[5]:
    array([[-0.141, -1.103, -1.0171,  0.7812,  0.07  ],
           [ 0.926,  0.235, -0.7698,  1.4552,  0.2061],
           [ 1.579,  0.929, -0.557 ,  0.7896, -1.6279],
           [-1.362, -2.411, -1.4604,  1.4468, -0.1885],
           [ 1.272,  1.199, -3.2312, -0.5511, -1.9794]])

    In [7]: argsort(argsort(data))
    Out[7]:
    array([[2, 0, 1, 4, 3],
           [3, 2, 0, 4, 1],
           [4, 3, 1, 2, 0],
           [2, 0, 1, 4, 3],
           [4, 3, 0, 2, 1]])
    """
    # note that unlike scipy.stats.rankdata, the output here is 0-indexed, not
    # 1-indexed.
    return argsort(argsort(array))


class SomeFactor(TestingFactor):
    inputs = ()
    window_length = 0


class SomeOtherFactor(TestingFactor):
    inputs = ()
    window_length = 0


class FilterTestCase(BaseFFCTestCase):

    def setUp(self):
        super(FilterTestCase, self).setUp()
        self.f = SomeFactor()
        self.g = SomeOtherFactor()

    def test_bad_percentiles(self):
        f = self.f

        bad_percentiles = [
            (-.1, 10),
            (10, 100.1),
            (20, 10),
            (50, 50),
        ]
        for min_, max_ in bad_percentiles:
            with self.assertRaises(BadPercentileBounds):
                f.percentile_between(min_, max_)

    def test_top(self):
        counts = 2, 3, 10
        data = self.randn_data(seed=5)  # Arbitrary seed choice.
        results = self.run_terms(
            terms={'top_' + str(c): self.f.top(c) for c in counts},
            initial_workspace={self.f: data},
        )
        for c in counts:
            result = results['top_' + str(c)]

            # Check that `min(c, num_assets)` assets passed each day.
            passed_per_day = result.sum(axis=1)
            check_arrays(
                passed_per_day,
                full_like(passed_per_day, min(c, data.shape[1])),
            )

            # Check that the top `c` assets passed.
            expected = rowwise_rank(-data) < c
            check_arrays(result, expected)

    def test_bottom(self):
        counts = 2, 3, 10
        data = self.randn_data(seed=5)  # Arbitrary seed choice.
        results = self.run_terms(
            terms={'bottom_' + str(c): self.f.bottom(c) for c in counts},
            initial_workspace={self.f: data},
        )
        for c in counts:
            result = results['bottom_' + str(c)]

            # Check that `min(c, num_assets)` assets passed each day.
            passed_per_day = result.sum(axis=1)
            check_arrays(
                passed_per_day,
                full_like(passed_per_day, min(c, data.shape[1])),
            )

            # Check that the bottom `c` assets passed.
            expected = rowwise_rank(data) < c
            check_arrays(result, expected)

    def test_percentile_between(self):

        quintiles = range(5)
        filter_names = ['pct_' + str(q) for q in quintiles]
        iter_quintiles = zip(filter_names, quintiles)

        terms = {
            name: self.f.percentile_between(q * 20.0, (q + 1) * 20.0)
            for name, q in zip(filter_names, quintiles)
        }

        # Test with 5 columns and no NaNs.
        eye5 = eye(5, dtype=float64)
        results = self.run_terms(
            terms,
            initial_workspace={self.f: eye5},
            mask=self.build_mask(ones((5, 5))),
        )
        for name, quintile in iter_quintiles:
            result = results[name]
            if quintile < 4:
                # There are four 0s and one 1 in each row, so the first 4
                # quintiles should be all the locations with zeros in the input
                # array.
                check_arrays(result, ~eye5.astype(bool))
            else:
                # The top quintile should match the sole 1 in each row.
                check_arrays(result, eye5.astype(bool))

        # Test with 6 columns, no NaNs, and one masked entry per day.
        eye6 = eye(6, dtype=float64)
        mask = array([[1, 1, 1, 1, 1, 0],
                      [0, 1, 1, 1, 1, 1],
                      [1, 0, 1, 1, 1, 1],
                      [1, 1, 0, 1, 1, 1],
                      [1, 1, 1, 0, 1, 1],
                      [1, 1, 1, 1, 0, 1]], dtype=bool)

        results = self.run_terms(
            terms,
            initial_workspace={self.f: eye6},
            mask=self.build_mask(mask)
        )
        for name, quintile in iter_quintiles:
            result = results[name]
            if quintile < 4:
                # Should keep all values that were 0 in the base data and were
                # 1 in the mask.
                check_arrays(result, mask & (~eye6.astype(bool))),
            else:
                # Should keep all the 1s in the base data.
                check_arrays(result, eye6.astype(bool))

        # Test with 6 columns, no mask, and one NaN per day.  Should have the
        # same outcome as if we had masked the NaNs.
        # In particular, the NaNs should never pass any filters.
        eye6_withnans = eye6.copy()
        putmask(eye6_withnans, ~mask, nan)
        results = self.run_terms(
            terms,
            initial_workspace={self.f: eye6},
            mask=self.build_mask(mask)
        )
        for name, quintile in iter_quintiles:
            result = results[name]
            if quintile < 4:
                # Should keep all values that were 0 in the base data and were
                # 1 in the mask.
                check_arrays(result, mask & (~eye6.astype(bool))),
            else:
                # Should keep all the 1s in the base data.
                check_arrays(result, eye6.astype(bool))

    def test_percentile_nasty_partitions(self):
        # Test percentile with nasty partitions: divide up 5 assets into
        # quartiles.
        # There isn't a nice mathematical definition of correct behavior here,
        # so for now we guarantee the behavior of numpy.nanpercentile.  This is
        # mostly for regression testing in case we write our own specialized
        # percentile calculation at some point in the future.

        data = arange(25, dtype=float).reshape(5, 5) % 4
        quartiles = range(4)
        filter_names = ['pct_' + str(q) for q in quartiles]

        terms = {
            name: self.f.percentile_between(q * 25.0, (q + 1) * 25.0)
            for name, q in zip(filter_names, quartiles)
        }
        results = self.run_terms(
            terms,
            initial_workspace={self.f: data},
            mask=self.build_mask(ones((5, 5))),
        )

        for name, quartile in zip(filter_names, quartiles):
            result = results[name]
            lower = quartile * 25.0
            upper = (quartile + 1) * 25.0
            expected = and_(
                nanpercentile(data, lower, axis=1, keepdims=True) <= data,
                data <= nanpercentile(data, upper, axis=1, keepdims=True),
            )
            check_arrays(result, expected)

    def test_sequenced_filter_order_independent(self):
        data = self.arange_data() % 5
        results = self.run_terms(
            {
                # Sequencing is equivalent to &ing for commutative filters.
                'sequenced': (1.5 < self.f).then(self.f < 3.5),
                'anded': (1.5 < self.f) & (self.f < 3.5),
            },
            initial_workspace={self.f: data},
        )
        expected = (1.5 < data) & (data < 3.5)

        check_arrays(results['sequenced'], expected)
        check_arrays(results['anded'], expected)

    def test_sequenced_filter_order_dependent(self):

        first = self.f < 1
        f_input = eye(5)

        second = self.g.percentile_between(80, 100)
        g_input = arange(25, dtype=float).reshape(5, 5)

        initial_mask = self.build_mask(ones((5, 5)))

        terms = {
            'first': first,
            'second': second,
            'sequenced': first.then(second),
        }

        results = self.run_terms(
            terms,
            initial_workspace={self.f: f_input, self.g: g_input},
            mask=initial_mask,
        )

        # First should pass everything but the diagonal.
        check_arrays(results['first'], ~eye(5, dtype=bool))

        # Second should pass the largest value each day.  Each row is strictly
        # increasing, so we always select the last value.
        expected_second = array(
            [[0, 0, 0, 0, 1],
             [0, 0, 0, 0, 1],
             [0, 0, 0, 0, 1],
             [0, 0, 0, 0, 1],
             [0, 0, 0, 0, 1]],
            dtype=bool,
        )
        check_arrays(results['second'], expected_second)

        # When sequencing, we should remove the diagonal as an option before
        # computing percentiles.  On the last day, we should get the
        # second-largest value, rather than the largest.
        expected_sequenced = array(
            [[0, 0, 0, 0, 1],
             [0, 0, 0, 0, 1],
             [0, 0, 0, 0, 1],
             [0, 0, 0, 0, 1],
             [0, 0, 0, 1, 0]],  # Different from previous!
            dtype=bool,
        )
        check_arrays(results['sequenced'], expected_sequenced)

#! /usr/bin/env python

# $Id: test_compound.py 7072 2011-07-06 15:52:30Z milde $
# Author: David Goodger <goodger@python.org>
# Copyright: This module has been placed in the public domain.

"""
Tests for the 'compound' directive from body.py.
"""

from __init__ import DocutilsTestSupport

def suite():
    s = DocutilsTestSupport.ParserTestSuite()
    s.generateTests(totest)
    return s

totest = {}

totest['compound'] = [
["""\
.. compound::

   Compound paragraphs are single logical paragraphs
   which contain embedded

   * lists
   * tables
   * literal blocks
   * and other body elements

   and are split into multiple physical paragraphs.
""",
"""\
<document source="test data">
    <compound>
        <paragraph>
            Compound paragraphs are single logical paragraphs
            which contain embedded
        <bullet_list bullet="*">
            <list_item>
                <paragraph>
                    lists
            <list_item>
                <paragraph>
                    tables
            <list_item>
                <paragraph>
                    literal blocks
            <list_item>
                <paragraph>
                    and other body elements
        <paragraph>
            and are split into multiple physical paragraphs.
"""],
["""\
.. compound::
   :name: interesting
   :class: log

   This is an extremely interesting compound paragraph containing a
   simple paragraph, a literal block with some useless log messages::

       Connecting... OK
       Transmitting data... OK
       Disconnecting... OK

   and another simple paragraph which is actually just a continuation
   of the first simple paragraph, with the literal block in between.
""",
"""\
<document source="test data">
    <compound classes="log" ids="interesting" names="interesting">
        <paragraph>
            This is an extremely interesting compound paragraph containing a
            simple paragraph, a literal block with some useless log messages:
        <literal_block xml:space="preserve">
            Connecting... OK
            Transmitting data... OK
            Disconnecting... OK
        <paragraph>
            and another simple paragraph which is actually just a continuation
            of the first simple paragraph, with the literal block in between.
"""],
["""\
.. compound:: content may start on same line

   second paragraph
""",
"""\
<document source="test data">
    <compound>
        <paragraph>
            content may start on same line
        <paragraph>
            second paragraph
"""],
]


if __name__ == '__main__':
    import unittest
    unittest.main(defaultTest='suite')

from openerp.tests.common import TransactionCase
import time

class TestReconciliation(TransactionCase):
    """Tests for reconciliation (account.tax)

    Test used to check that when doing a sale or purchase invoice in a different currency,
    the result will be balanced.
    """

    def setUp(self):
        super(TestReconciliation, self).setUp()
        self.account_invoice_model = self.registry('account.invoice')
        self.account_invoice_line_model = self.registry('account.invoice.line')
        self.acc_bank_stmt_model = self.registry('account.bank.statement')
        self.acc_bank_stmt_line_model = self.registry('account.bank.statement.line')
        self.res_currency_model = self.registry('res.currency')
        self.res_currency_rate_model = self.registry('res.currency.rate')
        
        self.partner_agrolait_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "base", "res_partner_2")[1]
        self.currency_swiss_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "base", "CHF")[1]
        self.currency_usd_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "base", "USD")[1]
        self.account_rcv_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "account", "a_recv")[1]
        self.account_fx_income_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "account", "income_fx_income")[1]
        self.account_fx_expense_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "account", "income_fx_expense")[1]

        self.product_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "product", "product_product_4")[1]
        
        self.bank_journal_usd_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "account", "bank_journal_usd")[1]
        self.account_usd_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "account", "usd_bnk")[1]
        
        self.company_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "base", "main_company")[1]

        #set expense_currency_exchange_account_id and income_currency_exchange_account_id to the according accounts
        self.registry("res.company").write(self.cr, self.uid, [self.company_id], {'expense_currency_exchange_account_id': self.account_fx_expense_id, 'income_currency_exchange_account_id':self.account_fx_income_id})

    def test_balanced_customer_invoice(self):
        cr, uid = self.cr, self.uid
        #we create an invoice in CHF
        invoice_id = self.account_invoice_model.create(cr, uid, {'partner_id': self.partner_agrolait_id,
            'reference_type': 'none',
            'currency_id': self.currency_swiss_id,
            'name': 'invoice to client',
            'account_id': self.account_rcv_id,
            'type': 'out_invoice',
            'date_invoice': time.strftime('%Y')+'-07-01', # to use USD rate rateUSDbis
            })
        self.account_invoice_line_model.create(cr, uid, {'product_id': self.product_id,
            'quantity': 1,
            'price_unit': 100,
            'invoice_id': invoice_id,
            'name': 'product that cost 100',})

        #validate purchase
        self.registry('account.invoice').signal_workflow(cr, uid, [invoice_id], 'invoice_open')        
        invoice_record = self.account_invoice_model.browse(cr, uid, [invoice_id])

        #we pay half of it on a journal with currency in dollar (bank statement)
        bank_stmt_id = self.acc_bank_stmt_model.create(cr, uid, {
            'journal_id': self.bank_journal_usd_id,
            'date': time.strftime('%Y')+'-07-15',
        })

        bank_stmt_line_id = self.acc_bank_stmt_line_model.create(cr, uid, {'name': 'half payment',
            'statement_id': bank_stmt_id,
            'partner_id': self.partner_agrolait_id,
            'amount': 42,
            'amount_currency': 50,
            'currency_id': self.currency_swiss_id,
            'date': time.strftime('%Y')+'-07-15',})

        #reconcile the payment with the invoice
        for l in invoice_record.move_id.line_id:
            if l.account_id.id == self.account_rcv_id:
                line_id = l
                break
        self.acc_bank_stmt_line_model.process_reconciliation(cr, uid, bank_stmt_line_id, [
            {'counterpart_move_line_id': line_id.id, 'credit':50, 'debit':0, 'name': line_id.name,}])

        #we check that the line is balanced (bank statement line)
        move_line_ids = self.acc_bank_stmt_model.browse(cr,uid,bank_stmt_id).move_line_ids

        self.assertEquals(len(move_line_ids), 3)
        checked_line = 0
        for move_line in move_line_ids:
            if move_line.account_id.id == self.account_usd_id:
                self.assertEquals(move_line.debit, 27.47)
                self.assertEquals(move_line.credit, 0.0)
                self.assertEquals(move_line.amount_currency, 42)
                self.assertEquals(move_line.currency_id.id, self.currency_usd_id)
                checked_line += 1
                continue
            if move_line.account_id.id == self.account_rcv_id:
                self.assertEquals(move_line.debit, 0.0)
                self.assertEquals(move_line.credit, 38.21)
                self.assertEquals(move_line.amount_currency, -50)
                self.assertEquals(move_line.currency_id.id, self.currency_swiss_id)
                checked_line += 1
                continue
            if move_line.account_id.id == self.account_fx_expense_id:
                self.assertEquals(move_line.debit, 10.74)
                self.assertEquals(move_line.credit, 0.0)
                checked_line += 1
                continue
        self.assertEquals(checked_line, 3)

        

    def test_balanced_supplier_invoice(self):
        cr, uid = self.cr, self.uid
        #we create a supplier invoice in CHF
        invoice_id = self.account_invoice_model.create(cr, uid, {'partner_id': self.partner_agrolait_id,
            'reference_type': 'none',
            'currency_id': self.currency_swiss_id,
            'name': 'invoice to client',
            'account_id': self.account_rcv_id,
            'type': 'in_invoice',
            'date_invoice': time.strftime('%Y')+'-07-01',
            })
        self.account_invoice_line_model.create(cr, uid, {'product_id': self.product_id,
            'quantity': 1,
            'price_unit': 100,
            'invoice_id': invoice_id,
            'name': 'product that cost 100',})

        #validate purchase
        self.registry('account.invoice').signal_workflow(cr, uid, [invoice_id], 'invoice_open')        
        invoice_record = self.account_invoice_model.browse(cr, uid, [invoice_id])

        #we pay half of it on a journal with currency in dollar (bank statement)
        bank_stmt_id = self.acc_bank_stmt_model.create(cr, uid, {
            'journal_id': self.bank_journal_usd_id,
            'date': time.strftime('%Y')+'-07-15',
        })

        bank_stmt_line_id = self.acc_bank_stmt_line_model.create(cr, uid, {'name': 'half payment',
            'statement_id': bank_stmt_id,
            'partner_id': self.partner_agrolait_id,
            'amount': -42,
            'amount_currency': -50,
            'currency_id': self.currency_swiss_id,
            'date': time.strftime('%Y')+'-07-15',})

        #reconcile the payment with the invoice
        for l in invoice_record.move_id.line_id:
            if l.account_id.id == self.account_rcv_id:
                line_id = l
                break
        self.acc_bank_stmt_line_model.process_reconciliation(cr, uid, bank_stmt_line_id, [
            {'counterpart_move_line_id': line_id.id, 'credit':0, 'debit':50, 'name': line_id.name,}])

        #we check that the line is balanced (bank statement line)
        move_line_ids = self.acc_bank_stmt_model.browse(cr,uid,bank_stmt_id).move_line_ids

        self.assertEquals(len(move_line_ids), 3)
        checked_line = 0
        for move_line in move_line_ids:
            if move_line.account_id.id == self.account_usd_id:
                self.assertEquals(move_line.debit, 0.0)
                self.assertEquals(move_line.credit, 27.47)
                self.assertEquals(move_line.amount_currency, -42)
                self.assertEquals(move_line.currency_id.id, self.currency_usd_id)
                checked_line += 1
                continue
            if move_line.account_id.id == self.account_rcv_id:
                self.assertEquals(move_line.debit, 38.21)
                self.assertEquals(move_line.credit, 0.0)
                self.assertEquals(move_line.amount_currency, 50)
                self.assertEquals(move_line.currency_id.id, self.currency_swiss_id)
                checked_line += 1
                continue
            if move_line.account_id.id == self.account_fx_income_id:
                self.assertEquals(move_line.debit, 0.0)
                self.assertEquals(move_line.credit, 10.74)
                checked_line += 1
                continue
        self.assertEquals(checked_line, 3)

    def test_balanced_exchanges_gain_loss(self):
        # The point of this test is to show that we handle correctly the gain/loss exchanges during reconciliations in foreign currencies.
        # For instance, with a company set in EUR, and a USD rate set to 0.033,
        # the reconciliation of an invoice of 2.00 USD (60.61 EUR) and a bank statement of two lines of 1.00 USD (30.30 EUR)
        # will lead to an exchange loss, that should be handled correctly within the journal items.
        cr, uid = self.cr, self.uid
        # We update the currency rate of the currency USD in order to force the gain/loss exchanges in next steps
        rateUSDbis_id = self.registry("ir.model.data").get_object_reference(self.cr, self.uid, "base", "rateUSDbis")[1]
        self.res_currency_rate_model.write(cr, uid, rateUSDbis_id, {
            'name': time.strftime('%Y-%m-%d') + ' 00:00:00',
            'rate': 0.033,
        })
        # We create a customer invoice of 2.00 USD
        invoice_id = self.account_invoice_model.create(cr, uid, {
            'partner_id': self.partner_agrolait_id,
            'currency_id': self.currency_usd_id,
            'name': 'Foreign invoice with exchange gain',
            'account_id': self.account_rcv_id,
            'type': 'out_invoice',
            'date_invoice': time.strftime('%Y-%m-%d'),
            'journal_id': self.bank_journal_usd_id,
            'invoice_line': [
                (0, 0, {
                    'name': 'line that will lead to an exchange gain',
                    'quantity': 1,
                    'price_unit': 2,
                })
            ]
        })
        self.registry('account.invoice').signal_workflow(cr, uid, [invoice_id], 'invoice_open')
        invoice = self.account_invoice_model.browse(cr, uid, invoice_id)
        # We create a bank statement with two lines of 1.00 USD each.
        bank_stmt_id = self.acc_bank_stmt_model.create(cr, uid, {
            'journal_id': self.bank_journal_usd_id,
            'date': time.strftime('%Y-%m-%d'),
            'line_ids': [
                (0, 0, {
                    'name': 'half payment',
                    'partner_id': self.partner_agrolait_id,
                    'amount': 1.0,
                    'date': time.strftime('%Y-%m-%d')
                }),
                (0, 0, {
                    'name': 'second half payment',
                    'partner_id': self.partner_agrolait_id,
                    'amount': 1.0,
                    'date': time.strftime('%Y-%m-%d')
                })
            ]
        })

        statement = self.acc_bank_stmt_model.browse(cr, uid, bank_stmt_id)

        # We process the reconciliation of the invoice line with the two bank statement lines
        line_id = None
        for l in invoice.move_id.line_id:
            if l.account_id.id == self.account_rcv_id:
                line_id = l
                break
        for statement_line in statement.line_ids:
            self.acc_bank_stmt_line_model.process_reconciliation(cr, uid, statement_line.id, [
                {'counterpart_move_line_id': line_id.id, 'credit': 1.0, 'debit': 0.0, 'name': line_id.name}
            ])

        # The invoice should be paid, as the payments totally cover its total
        self.assertEquals(invoice.state, 'paid', 'The invoice should be paid by now')
        reconcile = None
        for payment in invoice.payment_ids:
            reconcile = payment.reconcile_id
            break
        # The invoice should be reconciled (entirely, not a partial reconciliation)
        self.assertTrue(reconcile, 'The invoice should be totally reconciled')
        result = {}
        exchange_loss_line = None
        for line in reconcile.line_id:
            res_account = result.setdefault(line.account_id, {'debit': 0.0, 'credit': 0.0, 'count': 0})
            res_account['debit'] = res_account['debit'] + line.debit
            res_account['credit'] = res_account['credit'] + line.credit
            res_account['count'] += 1
            if line.credit == 0.01:
                exchange_loss_line = line
        # We should be able to find a move line of 0.01 EUR on the Debtors account, being the cent we lost during the currency exchange
        self.assertTrue(exchange_loss_line, 'There should be one move line of 0.01 EUR in credit')
        # The journal items of the reconciliation should have their debit and credit total equal
        # Besides, the total debit and total credit should be 60.61 EUR (2.00 USD)
        self.assertEquals(sum([res['debit'] for res in result.values()]), 60.61)
        self.assertEquals(sum([res['credit'] for res in result.values()]), 60.61)
        counterpart_exchange_loss_line = None
        for line in exchange_loss_line.move_id.line_id:
            if line.account_id.id == self.account_fx_expense_id:
                counterpart_exchange_loss_line = line
        #  We should be able to find a move line of 0.01 EUR on the Foreign Exchange Loss account
        self.assertTrue(counterpart_exchange_loss_line, 'There should be one move line of 0.01 EUR on account "Foreign Exchange Loss"')

# Orca
#
# Copyright (C) 2013 The Orca Team.
#
# Author: Joanmarie Diggs <jdiggs@igalia.com>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., Franklin Street, Fifth Floor,
# Boston MA  02110-1301 USA.

__id__ = "$Id$"
__version__   = "$Revision$"
__date__      = "$Date$"
__copyright__ = "Copyright (c) 2013 The Orca Team."
__license__   = "LGPL"

import pyatspi

import orca.script_utilities as script_utilities
import orca.scripts.toolkits.gtk as gtk

class Utilities(gtk.Utilities):

    def __init__(self, script):
        gtk.Utilities.__init__(self, script)

    def isReadOnlyTextArea(self, obj):
        if obj.getRole() == pyatspi.ROLE_DOCUMENT_FRAME:
            return False

        return gtk.Utilities.isReadOnlyTextArea(self, obj)

    def isTextArea(self, obj):
        if obj.getRole() == pyatspi.ROLE_DOCUMENT_FRAME:
            return True

        return gtk.Utilities.isTextArea(self, obj)

# This code is part of Ansible, but is an independent component.
# This particular file snippet, and this file snippet only, is BSD licensed.
# Modules you write using this snippet, which is embedded dynamically by Ansible
# still belong to the author of the module, and may assign their own license
# to the complete work.
#
# Copyright (c) 2015 Peter Sprygada, <psprygada@ansible.com>
# Copyright (c) 2017 Red Hat Inc.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
#    * Redistributions of source code must retain the above copyright
#      notice, this list of conditions and the following disclaimer.
#    * Redistributions in binary form must reproduce the above copyright notice,
#      this list of conditions and the following disclaimer in the documentation
#      and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
from ansible.module_utils.basic import env_fallback
from ansible.module_utils.network_common import to_list, ComplexList
from ansible.module_utils.connection import exec_command

_DEVICE_CONFIGS = {}

iosxr_argument_spec = {
    'host': dict(),
    'port': dict(type='int'),
    'username': dict(fallback=(env_fallback, ['ANSIBLE_NET_USERNAME'])),
    'password': dict(fallback=(env_fallback, ['ANSIBLE_NET_PASSWORD']), no_log=True),
    'ssh_keyfile': dict(fallback=(env_fallback, ['ANSIBLE_NET_SSH_KEYFILE']), type='path'),
    'timeout': dict(type='int'),
    'provider': dict(type='dict', no_log=True)
}

def check_args(module, warnings):
    provider = module.params['provider'] or {}
    for key in iosxr_argument_spec:
        if key != 'provider' and module.params[key]:
            warnings.append('argument %s has been deprecated and will be '
                    'removed in a future version' % key)

def get_config(module, flags=[]):
    cmd = 'show running-config '
    cmd += ' '.join(flags)
    cmd = cmd.strip()

    try:
        return _DEVICE_CONFIGS[cmd]
    except KeyError:
        rc, out, err = exec_command(module, cmd)
        if rc != 0:
            module.fail_json(msg='unable to retrieve current config', stderr=err)
        cfg = str(out).strip()
        _DEVICE_CONFIGS[cmd] = cfg
        return cfg


def to_commands(module, commands):
    spec = {
        'command': dict(key=True),
        'prompt': dict(),
        'answer': dict()
    }
    transform = ComplexList(spec, module)
    return transform(commands)


def run_commands(module, commands, check_rc=True):
    responses = list()
    commands = to_commands(module, to_list(commands))
    for cmd in to_list(commands):
        rc, out, err = exec_command(module, cmd)
        if check_rc and rc != 0:
            module.fail_json(msg=err, rc=rc)
        responses.append(out)
    return responses

def load_config(module, commands, commit=False, replace=False, comment=None):

    rc, out, err = exec_command(module, 'configure terminal')
    if rc != 0:
        module.fail_json(msg='unable to enter configuration mode', err=err)

    failed = False
    for command in to_list(commands):
        if command == 'end':
            continue

        rc, out, err = exec_command(module, command)
        if rc != 0:
            failed = True
            break

    if failed:
        exec_command(module, 'abort')
        module.fail_json(msg=err, commands=commands, rc=rc)

    rc, diff, err = exec_command(module, 'show commit changes diff')
    if commit:
        cmd = 'commit'
        if comment:
            cmd += ' comment {0}'.format(comment)
    else:
        cmd = 'abort'
        diff = None
    exec_command(module, cmd)

    return diff

# -*- coding: utf-8 -*-
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.


"""
DAG designed to test what happens when a DAG with pooled tasks is run
by a BackfillJob.
Addresses issue #1225.
"""
from datetime import datetime

from airflow.models import DAG
from airflow.operators.dummy_operator import DummyOperator

dag = DAG(dag_id='test_backfill_pooled_task_dag')
task = DummyOperator(
    task_id='test_backfill_pooled_task',
    dag=dag,
    pool='test_backfill_pooled_task_pool',
    owner='airflow',
    start_date=datetime(2016, 2, 1))

# -*- coding: utf-8 -*-
##
## This file is part of Invenio.
## Copyright (C) 2012 CERN.
##
## Invenio is free software; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## License, or (at your option) any later version.
##
## Invenio is distributed in the hope that it will be useful, but
## WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
## General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with Invenio; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

"""BibCatalog db layer."""

from invenio.dbquery import run_sql


def get_all_new_records(since, last_id):
    """
    Get all the newly inserted records since last run.
    """
    # Fetch all records inserted since last run
    sql = "SELECT `id`, `creation_date` FROM `bibrec` " \
        "WHERE `creation_date` >= %s " \
        "AND `id` > %s " \
        "ORDER BY `creation_date`"
    return run_sql(sql, (since.isoformat(), last_id))


def get_all_modified_records(since, last_id):
    """
    Get all the newly modified records since last run.
    """
    sql = "SELECT `id`, `modification_date` FROM `bibrec` " \
        "WHERE `modification_date` >= %s " \
        "AND `id` > %s " \
        "ORDER BY `modification_date`"
    return run_sql(sql, (since.isoformat(), last_id))


def can_launch_bibupload(taskid):
    """
    Checks if task can be launched.
    """
    if taskid == 0:
        return True

    sql = 'SELECT status FROM schTASK WHERE id = %s'
    if run_sql(sql, [str(taskid)])[0][0] != 'DONE':
        return False
    return True

# -------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
# --------------------------------------------------------------------------

"""
Hummingbird main (converters) API.
"""
from copy import deepcopy
import numpy as np

from .operator_converters import constants
from ._parse import parse_sklearn_api_model, parse_onnx_api_model
from ._topology import convert as topology_converter
from ._utils import torch_installed, lightgbm_installed, xgboost_installed
from .exceptions import MissingConverter, MissingBackend
from .supported import backends

# Invoke the registration of all our converters.
from . import operator_converters  # noqa

# Set up the converter dispatcher.
from .supported import xgb_operator_list  # noqa
from .supported import lgbm_operator_list  # noqa


def _is_onnx_model(model):
    """
    Function returning whether the input model is an ONNX model or not.
    """
    return type(model).__name__ == "ModelProto"


def _supported_backend_check(backend):
    """
    Function used to check whether the specified backend is supported or not.
    """
    if backend is None:
        raise MissingBackend("Backend: {}".format(backend))


def _supported_backend_check_config(model, backend, extra_config):
    """
    Function used to check whether the specified backend and configuration pair is supported or not.
    """
    assert torch_installed(), "To use Hummingbird you need to install torch."
    import onnx
    import torch

    if backend is torch.jit.__name__ and constants.TEST_INPUT not in extra_config:
        raise RuntimeError("Backend {} requires test inputs. Please pass some test input to the convert.".format(backend))

    if backend is onnx.__name__:
        if constants.ONNX_INITIAL_TYPES not in extra_config and constants.TEST_INPUT not in extra_config:
            raise RuntimeError("Cannot generate test input data for ONNX. Either pass some input data or the initial_types")

    if _is_onnx_model(model) and constants.ONNX_INITIAL_TYPES not in extra_config and constants.TEST_INPUT not in extra_config:
        raise RuntimeError(
            "Cannot extract number of input features from the ONNX. Either pass some input data or the initial_types"
        )


def _convert_sklearn(model, backend, test_input, device, extra_config={}):
    """
    This function converts the specified *scikit-learn* (API) model into its *backend* counterpart.
    The supported operators and backends can be found at `hummingbird.ml.supported`.
    """
    assert model is not None
    assert torch_installed(), "To use Hummingbird you need to install torch."

    import torch

    # Parse scikit-learn model as our internal data structure (i.e., Topology)
    # We modify the scikit learn model during translation.
    model = deepcopy(model)
    topology = parse_sklearn_api_model(model, extra_config)

    # Convert the Topology object into a PyTorch model.
    hb_model = topology_converter(topology, backend, device, extra_config=extra_config)
    return hb_model


def _convert_lightgbm(model, backend, test_input, device, extra_config={}):
    """
    This function is used to generate a *backend* model from a given input [LightGBM] model.
    [LightGBM]: https://lightgbm.readthedocs.io/
    """
    assert (
        lightgbm_installed()
    ), "To convert LightGBM models you need to install LightGBM (or `pip install hummingbird-ml[extra]`)."

    return _convert_sklearn(model, backend, test_input, device, extra_config)


def _convert_xgboost(model, backend, test_input, device, extra_config={}):
    """
    This function is used to generate a *backend* model from a given input [XGBoost] model.
    [XGBoost]: https://xgboost.readthedocs.io/
    """
    assert (
        xgboost_installed()
    ), "To convert XGboost models you need to instal XGBoost (or `pip install hummingbird-ml[extra]`)."

    # XGBoostRegressor and Classifier have different APIs for extracting the number of features.
    # In the former case we need to infer them from the test_input.
    if constants.N_FEATURES not in extra_config:
        if "_features_count" in dir(model):
            extra_config[constants.N_FEATURES] = model._features_count
        elif test_input is not None:
            if type(test_input) is np.ndarray and len(test_input.shape) == 2:
                extra_config[constants.N_FEATURES] = test_input.shape[1]
            else:
                raise RuntimeError(
                    "XGBoost converter is not able to infer the number of input features.\
                        Apparently test_input is not an ndarray. \
                        Please fill an issue at https://github.com/microsoft/hummingbird/."
                )
        else:
            raise RuntimeError(
                "XGBoost converter is not able to infer the number of input features.\
                    Please pass some test_input to the converter."
            )
    return _convert_sklearn(model, backend, test_input, device, extra_config)


def _convert_onnxml(model, backend, test_input, device, extra_config={}):
    """
    This function converts the specified [ONNX-ML] model into its *backend* counterpart.
    The supported operators can be found at `hummingbird.ml.supported`.
    """
    assert model is not None
    assert torch_installed(), "To use Hummingbird you need to install torch."

    import onnx

    # The conversion requires some test input for tracing.
    # Test inputs can be either provided or generate from the inital types.
    # Get the initial types if any.
    initial_types = None
    if constants.ONNX_INITIAL_TYPES in extra_config:
        initial_types = extra_config[constants.ONNX_INITIAL_TYPES]

    # Generate some test input if necessary.
    if test_input is None:
        if backend == onnx.__name__:
            assert (
                initial_types is not None and not initial_types[0][1].shape is None
            ), "Cannot generate test input data. Initial_types do not contain shape information."
            assert len(initial_types[0][1].shape) == 2, "Hummingbird currently support only inputs with len(shape) == 2."

            from onnxconverter_common.data_types import FloatTensorType, Int32TensorType

            test_input = np.random.rand(initial_types[0][1].shape[0], initial_types[0][1].shape[1])
            extra_config[constants.N_FEATURES] = initial_types[0][1].shape[1]
            if type(initial_types[0][1]) is FloatTensorType:
                test_input = np.array(test_input, dtype=np.float32)
            elif type(initial_types[0][1]) is Int32TensorType:
                test_input = np.array(test_input, dtype=np.int32)
            else:
                raise RuntimeError(
                    "Type {} not supported. Please fill an issue on https://github.com/microsoft/hummingbird/.".format(
                        type(initial_types[0][1])
                    )
                )
            extra_config[constants.TEST_INPUT] = test_input
    elif constants.N_FEATURES not in extra_config:
        extra_config[constants.N_FEATURES] = test_input.shape[1]

    # Set the initializers. Some converter requires the access to initializers.
    initializers = {} if model.graph.initializer is None else {in_.name: in_ for in_ in model.graph.initializer}
    extra_config[constants.ONNX_INITIALIZERS] = initializers

    # Parse ONNX model as our internal data structure (i.e., Topology).
    topology = parse_onnx_api_model(model)

    # Convert the Topology object into a PyTorch model.
    hb_model = topology_converter(topology, backend, device, extra_config=extra_config)
    return hb_model


def convert(model, backend, test_input=None, device="cpu", extra_config={}):
    """
    This function converts the specified input *model* into an implementation targeting *backend*.
    *Convert* supports [Sklearn], [LightGBM], [XGBoost] and [ONNX] models.
    For *LightGBM* and *XGBoost* currently only the Sklearn API is supported.
    The detailed list of models and backends can be found at `hummingbird.ml.supported`.
    The *onnx* backend requires either a test_input of a the initial types set through the exta_config parameter.
    The *torch.jit* backend requires a test_input.
    [Sklearn]: https://scikit-learn.org/
    [LightGBM]: https://lightgbm.readthedocs.io/
    [XGBoost]: https://xgboost.readthedocs.io/
    [ONNX]: https://onnx.ai/
    [ONNX-ML]: https://github.com/onnx/onnx/blob/master/docs/Operators-ml.md
    [ONNX operators]: https://github.com/onnx/onnx/blob/master/docs/Operators.md

    Args:
        model: An input model
        backend: The target for the conversion
        test_input: Some input data used to trace the model execution.
                    For the ONNX backend the test_input size is supposed to be as large as the expected batch size.
                    Multiple inputs can be passed as `tuple` objects.
                    For the moment only (`numpy`)`arrays` are supported.
        device: The target device the model should be run. This parameter is only used by the *torch** backends, and
                the devices supported are the one supported by PyTorch, i.e., 'cpu' or 'cuda'.
        extra_config: Extra configurations to be used by the individual operator converters.
                      The set of supported extra configurations can be found at `hummingbird.ml.supported`

    Examples:
        >>> pytorch_model = convert(sklearn_model,`torch`)

    Returns:
        A model implemented in *backend*, which is equivalent to the input model
    """
    assert model is not None

    # We destroy extra_config during conversion, we create a copy here.
    extra_config = deepcopy(extra_config)

    # Add test input as extra configuration for conversion.
    if test_input is not None and constants.TEST_INPUT not in extra_config and len(test_input) > 0:
        extra_config[constants.TEST_INPUT] = test_input

    # Fix the test_input type
    if constants.TEST_INPUT in extra_config:
        if type(extra_config[constants.TEST_INPUT]) == list:
            extra_config[constants.TEST_INPUT] = np.array(extra_config[constants.TEST_INPUT])
        elif type(extra_config[constants.TEST_INPUT]) == tuple:
            # We are passing multiple datasets.
            assert all([len(input.shape) == 2 for input in extra_config[constants.TEST_INPUT]])
            extra_config[constants.N_FEATURES] = sum([input.shape[1] for input in extra_config[constants.TEST_INPUT]])
            extra_config[constants.N_INPUTS] = len(extra_config[constants.TEST_INPUT])
        test_input = extra_config[constants.TEST_INPUT]

    # We do some normalization on backends.
    backend = backend.lower()
    backend = backends[backend]

    # Check whether we actually support the backend.
    _supported_backend_check(backend)
    _supported_backend_check_config(model, backend, extra_config)

    if type(model) in xgb_operator_list:
        return _convert_xgboost(model, backend, test_input, device, extra_config)

    if type(model) in lgbm_operator_list:
        return _convert_lightgbm(model, backend, test_input, device, extra_config)

    if _is_onnx_model(model):
        return _convert_onnxml(model, backend, test_input, device, extra_config)

    return _convert_sklearn(model, backend, test_input, device, extra_config)

######################## BEGIN LICENSE BLOCK ########################
# The Original Code is Mozilla Universal charset detector code.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 2001
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
#   Mark Pilgrim - port to Python
#   Shy Shalom - original C code
#   Proofpoint, Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301  USA
######################### END LICENSE BLOCK #########################

from .charsetprober import CharSetProber
from .enums import ProbingState, MachineState


class MultiByteCharSetProber(CharSetProber):
    """
    MultiByteCharSetProber
    """

    def __init__(self, lang_filter=None):
        super(MultiByteCharSetProber, self).__init__(lang_filter=lang_filter)
        self.distribution_analyzer = None
        self.coding_sm = None
        self._last_char = [0, 0]

    def reset(self):
        super(MultiByteCharSetProber, self).reset()
        if self.coding_sm:
            self.coding_sm.reset()
        if self.distribution_analyzer:
            self.distribution_analyzer.reset()
        self._last_char = [0, 0]

    @property
    def charset_name(self):
        raise NotImplementedError

    @property
    def language(self):
        raise NotImplementedError

    def feed(self, byte_str):
        for i in range(len(byte_str)):
            coding_state = self.coding_sm.next_state(byte_str[i])
            if coding_state == MachineState.ERROR:
                self.logger.debug('%s %s prober hit error at byte %s',
                                  self.charset_name, self.language, i)
                self._state = ProbingState.NOT_ME
                break
            elif coding_state == MachineState.ITS_ME:
                self._state = ProbingState.FOUND_IT
                break
            elif coding_state == MachineState.START:
                char_len = self.coding_sm.get_current_charlen()
                if i == 0:
                    self._last_char[1] = byte_str[0]
                    self.distribution_analyzer.feed(self._last_char, char_len)
                else:
                    self.distribution_analyzer.feed(byte_str[i - 1:i + 1],
                                                    char_len)

        self._last_char[0] = byte_str[-1]

        if self.state == ProbingState.DETECTING:
            if (self.distribution_analyzer.got_enough_data() and
                    (self.get_confidence() > self.SHORTCUT_THRESHOLD)):
                self._state = ProbingState.FOUND_IT

        return self.state

    def get_confidence(self):
        return self.distribution_analyzer.get_confidence()

# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt

from __future__ import unicode_literals
import frappe


@frappe.whitelist()
def get_children():
	ctype = frappe.local.form_dict.get('ctype')
	frappe.local.form_dict['parent_field'] = 'parent_' + ctype.lower().replace(' ', '_')
	if not frappe.form_dict.get('parent'):
		frappe.local.form_dict['parent'] = ''

	return frappe.db.sql("""select name as value,
		if(is_group='Yes', 1, 0) as expandable
		from `tab%(ctype)s`
		where docstatus < 2
		and ifnull(%(parent_field)s,'') = "%(parent)s"
		order by name""" % frappe.local.form_dict, as_dict=1)

@frappe.whitelist()
def add_node():
	ctype = frappe.form_dict.get('ctype')
	parent_field = 'parent_' + ctype.lower().replace(' ', '_')
	name_field = ctype.lower().replace(' ', '_') + '_name'

	doc = frappe.new_doc(ctype)
	doc.update({
		name_field: frappe.form_dict['name_field'],
		parent_field: frappe.form_dict['parent'],
		"is_group": frappe.form_dict['is_group']
	})
	if ctype == "Sales Person":
		doc.employee = frappe.form_dict.get('employee')

	doc.save()

import pytest
import threading

from share.search.daemon import SearchIndexerDaemon
from share.search.messages import MessageType


TIMEOUT = 10  # seconds


def wait_for(event):
    if not event.wait(timeout=TIMEOUT):
        raise Exception('timed out waiting for event (see stack trace)')


class FakeElasticManager:
    def __init__(self, expected_index_name, block_each_action=True):
        self.expected_index_name = expected_index_name
        self.block_each_action = block_each_action

        self.next_action_ready = threading.Event()
        self.next_action_released = threading.Event()
        self.action_stream_done = threading.Event()

        # only what's necessary
        self.settings = {
            'CHUNK_SIZE': 17,
        }

    def get_index_setup(self, index_name):
        assert index_name == self.expected_index_name
        return FakeIndexSetup()

    def stream_actions(self, actions):
        self.action_stream_done.clear()
        for action in actions:
            if self.block_each_action:
                # set so the waiting test thread will continue
                self.next_action_ready.set()
                # immediately clear so the test thread can wait on it again
                self.next_action_ready.clear()

                self.next_action_released.clear()
                wait_for(self.next_action_released)

            yield (True, 'fake_op_type', action)
        self.action_stream_done.set()

    # ElasticManager methods that aren't (shouldn't be) used in these tests:
    #
    # def delete_index(self, index_name):
    #
    # def create_index(self, index_name):


class FakeIndexSetup:
    @property
    def supported_message_types(self):
        return {MessageType.INDEX_SUID}

    def build_action_generator(self, index_name, message_type):
        def _fake_action_generator(target_id_iter):
            for target_id in target_id_iter:
                yield (target_id, {'_id': target_id, '_type': message_type.value})
        return _fake_action_generator

    # IndexSetup methods that aren't (shouldn't be) used in these tests
    #
    # @property
    # def index_settings(self):
    #
    # @property
    # def index_mappings(self):
    #
    # def build_and_cache_source_doc(self, message_type, target_id):


class FakeCeleryMessage:

    def __init__(self, message_type, target_id):
        self.payload = {
            'version': 2,
            'message_type': message_type.value,
            'target_id': target_id,
        }
        self.acked = False

    def ack(self):
        self.acked = True
        return True


class TestIndexerDaemon:

    @pytest.fixture
    def _action_sent_event(self):
        return threading.Event()

    @pytest.fixture(scope='class')
    def _manager(self):
        return FakeElasticManager(expected_index_name='fake_index')

    @pytest.fixture(scope='class')
    def _daemon(self, _manager):
        stop_event = threading.Event()
        daemon = SearchIndexerDaemon(
            index_name='fake_index',
            elastic_manager=_manager,
            stop_event=stop_event,
        )
        daemon.start_loops_and_queues()
        yield daemon
        stop_event.set()

    def test_message_ack_after_action_success(self, _manager, _daemon):
        message_1 = FakeCeleryMessage(MessageType.INDEX_SUID, 1)
        message_2 = FakeCeleryMessage(MessageType.INDEX_SUID, 2)
        _daemon.on_message(message_1.payload, message_1)
        _daemon.on_message(message_2.payload, message_2)

        wait_for(_manager.next_action_ready)

        assert not message_1.acked
        assert not message_2.acked
        _manager.next_action_released.set()

        wait_for(_manager.next_action_ready)

        assert message_1.acked
        assert not message_2.acked
        _manager.next_action_released.set()

        wait_for(_manager.action_stream_done)

        assert message_1.acked
        assert message_2.acked

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from openerp.osv import fields, osv
from openerp.tools.translate import _
from openerp import SUPERUSER_ID, api
import logging
_logger = logging.getLogger(__name__)


class stock_inventory(osv.osv):
    _inherit = "stock.inventory"
    _columns = {
        'period_id': fields.many2one('account.period', 'Force Valuation Period', help="Choose the accounting period where you want to value the stock moves created by the inventory instead of the default one (chosen by the inventory end date)"),
    }

    def post_inventory(self, cr, uid, inv, context=None):
        if context is None:
            context = {}
        ctx = context.copy()
        if inv.period_id:
            ctx['force_period'] = inv.period_id.id
        return super(stock_inventory, self).post_inventory(cr, uid, inv, context=ctx)


#----------------------------------------------------------
# Stock Location
#----------------------------------------------------------

class stock_location(osv.osv):
    _inherit = "stock.location"

    _columns = {
        'valuation_in_account_id': fields.many2one('account.account', 'Stock Valuation Account (Incoming)', domain=[('type', '=', 'other')],
                                                   help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "
                                                        "this account will be used to hold the value of products being moved from an internal location "
                                                        "into this location, instead of the generic Stock Output Account set on the product. "
                                                        "This has no effect for internal locations."),
        'valuation_out_account_id': fields.many2one('account.account', 'Stock Valuation Account (Outgoing)', domain=[('type', '=', 'other')],
                                                   help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "
                                                        "this account will be used to hold the value of products being moved out of this location "
                                                        "and into an internal location, instead of the generic Stock Output Account set on the product. "
                                                        "This has no effect for internal locations."),
    }

#----------------------------------------------------------
# Quants
#----------------------------------------------------------

class stock_quant(osv.osv):
    _inherit = "stock.quant"

    def _get_inventory_value(self, cr, uid, quant, context=None):
        if quant.product_id.cost_method in ('real'):
            return quant.cost * quant.qty
        return super(stock_quant, self)._get_inventory_value(cr, uid, quant, context=context)

    @api.cr_uid_ids_context
    def _price_update(self, cr, uid, quant_ids, newprice, context=None):
        ''' This function is called at the end of negative quant reconciliation and does the accounting entries adjustemnts and the update of the product cost price if needed
        '''
        if context is None:
            context = {}
        account_period = self.pool['account.period']
        super(stock_quant, self)._price_update(cr, uid, quant_ids, newprice, context=context)
        for quant in self.browse(cr, uid, quant_ids, context=context):
            move = self._get_latest_move(cr, uid, quant, context=context)
            valuation_update = newprice - quant.cost
            # this is where we post accounting entries for adjustment, if needed
            if not quant.company_id.currency_id.is_zero(valuation_update):
                # adjustment journal entry needed, cost has been updated
                period_id = (context.get('force_period') or
                                 account_period.find(cr, uid, move.date, context=context)[0])
                period = account_period.browse(cr, uid, period_id, context=context)
                # If neg quant period already closed (likely with manual valuation), skip update
                if period.state != 'done':
                    ctx = dict(context, force_valuation_amount=valuation_update)
                    self._account_entry_move(cr, uid, [quant], move, context=ctx)

            #update the standard price of the product, only if we would have done it if we'd have had enough stock at first, which means
            #1) the product cost's method is 'real'
            #2) we just fixed a negative quant caused by an outgoing shipment
            if quant.product_id.cost_method == 'real' and quant.location_id.usage != 'internal':
                self.pool.get('stock.move')._store_average_cost_price(cr, uid, move, context=context)

    def _account_entry_move(self, cr, uid, quants, move, context=None):
        """
        Accounting Valuation Entries

        quants: browse record list of Quants to create accounting valuation entries for. Unempty and all quants are supposed to have the same location id (thay already moved in)
        move: Move to use. browse record
        """
        if context is None:
            context = {}
        location_obj = self.pool.get('stock.location')
        location_from = move.location_id
        location_to = quants[0].location_id
        company_from = location_obj._location_owner(cr, uid, location_from, context=context)
        company_to = location_obj._location_owner(cr, uid, location_to, context=context)

        if move.product_id.valuation != 'real_time':
            return False
        for q in quants:
            if q.owner_id:
                #if the quant isn't owned by the company, we don't make any valuation entry
                return False
            if q.qty <= 0:
                #we don't make any stock valuation for negative quants because the valuation is already made for the counterpart.
                #At that time the valuation will be made at the product cost price and afterward there will be new accounting entries
                #to make the adjustments when we know the real cost price.
                return False

        #in case of routes making the link between several warehouse of the same company, the transit location belongs to this company, so we don't need to create accounting entries
        # Create Journal Entry for products arriving in the company
        if company_to and (move.location_id.usage not in ('internal', 'transit') and move.location_dest_id.usage == 'internal' or company_from != company_to):
            ctx = context.copy()
            ctx['force_company'] = company_to.id
            journal_id, acc_src, acc_dest, acc_valuation = self._get_accounting_data_for_valuation(cr, uid, move, context=ctx)
            if location_from and location_from.usage == 'customer':
                #goods returned from customer
                self._create_account_move_line(cr, uid, quants, move, acc_dest, acc_valuation, journal_id, context=ctx)
            else:
                self._create_account_move_line(cr, uid, quants, move, acc_src, acc_valuation, journal_id, context=ctx)

        # Create Journal Entry for products leaving the company
        if company_from and (move.location_id.usage == 'internal' and move.location_dest_id.usage not in ('internal', 'transit') or company_from != company_to):
            ctx = context.copy()
            ctx['force_company'] = company_from.id
            journal_id, acc_src, acc_dest, acc_valuation = self._get_accounting_data_for_valuation(cr, uid, move, context=ctx)
            if location_to and location_to.usage == 'supplier':
                #goods returned to supplier
                self._create_account_move_line(cr, uid, quants, move, acc_valuation, acc_src, journal_id, context=ctx)
            else:
                self._create_account_move_line(cr, uid, quants, move, acc_valuation, acc_dest, journal_id, context=ctx)

    def _quant_create(self, cr, uid, qty, move, lot_id=False, owner_id=False, src_package_id=False, dest_package_id=False, force_location_from=False, force_location_to=False, context=None):
        quant = super(stock_quant, self)._quant_create(cr, uid, qty, move, lot_id=lot_id, owner_id=owner_id, src_package_id=src_package_id, dest_package_id=dest_package_id, force_location_from=force_location_from, force_location_to=force_location_to, context=context)
        if move.product_id.valuation == 'real_time':
            self._account_entry_move(cr, uid, [quant], move, context)
        return quant

    def move_quants_write(self, cr, uid, quants, move, location_dest_id, dest_package_id, context=None):
        res = super(stock_quant, self).move_quants_write(cr, uid, quants, move, location_dest_id,  dest_package_id, context=context)
        if move.product_id.valuation == 'real_time':
            self._account_entry_move(cr, uid, quants, move, context=context)
        return res


    def _get_accounting_data_for_valuation(self, cr, uid, move, context=None):
        """
        Return the accounts and journal to use to post Journal Entries for the real-time
        valuation of the quant.

        :param context: context dictionary that can explicitly mention the company to consider via the 'force_company' key
        :returns: journal_id, source account, destination account, valuation account
        :raise: osv.except_osv() is any mandatory account or journal is not defined.
        """
        product_obj = self.pool.get('product.template')
        accounts = product_obj.get_product_accounts(cr, uid, move.product_id.product_tmpl_id.id, context)
        if move.location_id.valuation_out_account_id:
            acc_src = move.location_id.valuation_out_account_id.id
        else:
            acc_src = accounts['stock_account_input']

        if move.location_dest_id.valuation_in_account_id:
            acc_dest = move.location_dest_id.valuation_in_account_id.id
        else:
            acc_dest = accounts['stock_account_output']

        acc_valuation = accounts.get('property_stock_valuation_account_id', False)
        journal_id = accounts['stock_journal']
        return journal_id, acc_src, acc_dest, acc_valuation

    def _prepare_account_move_line(self, cr, uid, move, qty, cost, credit_account_id, debit_account_id, context=None):
        """
        Generate the account.move.line values to post to track the stock valuation difference due to the
        processing of the given quant.
        """
        if context is None:
            context = {}
        currency_obj = self.pool.get('res.currency')
        if context.get('force_valuation_amount'):
            valuation_amount = context.get('force_valuation_amount')
        else:
            if move.product_id.cost_method == 'average':
                valuation_amount = cost if move.location_id.usage != 'internal' and move.location_dest_id.usage == 'internal' else move.product_id.standard_price
            else:
                valuation_amount = cost if move.product_id.cost_method == 'real' else move.product_id.standard_price
        #the standard_price of the product may be in another decimal precision, or not compatible with the coinage of
        #the company currency... so we need to use round() before creating the accounting entries.
        valuation_amount = currency_obj.round(cr, uid, move.company_id.currency_id, valuation_amount * qty)
        partner_id = (move.picking_id.partner_id and self.pool.get('res.partner')._find_accounting_partner(move.picking_id.partner_id).id) or False
        debit_line_vals = {
                    'name': move.name,
                    'product_id': move.product_id.id,
                    'quantity': qty,
                    'product_uom_id': move.product_id.uom_id.id,
                    'ref': move.picking_id and move.picking_id.name or False,
                    'date': move.date,
                    'partner_id': partner_id,
                    'debit': valuation_amount > 0 and valuation_amount or 0,
                    'credit': valuation_amount < 0 and -valuation_amount or 0,
                    'account_id': debit_account_id,
        }
        credit_line_vals = {
                    'name': move.name,
                    'product_id': move.product_id.id,
                    'quantity': qty,
                    'product_uom_id': move.product_id.uom_id.id,
                    'ref': move.picking_id and move.picking_id.name or False,
                    'date': move.date,
                    'partner_id': partner_id,
                    'credit': valuation_amount > 0 and valuation_amount or 0,
                    'debit': valuation_amount < 0 and -valuation_amount or 0,
                    'account_id': credit_account_id,
        }
        return [(0, 0, debit_line_vals), (0, 0, credit_line_vals)]

    def _create_account_move_line(self, cr, uid, quants, move, credit_account_id, debit_account_id, journal_id, context=None):
        #group quants by cost
        quant_cost_qty = {}
        for quant in quants:
            if quant_cost_qty.get(quant.cost):
                quant_cost_qty[quant.cost] += quant.qty
            else:
                quant_cost_qty[quant.cost] = quant.qty
        move_obj = self.pool.get('account.move')
        for cost, qty in quant_cost_qty.items():
            move_lines = self._prepare_account_move_line(cr, uid, move, qty, cost, credit_account_id, debit_account_id, context=context)
            period_id = context.get('force_period', self.pool.get('account.period').find(cr, uid, context=context)[0])
            move_obj.create(cr, uid, {'journal_id': journal_id,
                                      'line_id': move_lines,
                                      'period_id': period_id,
                                      'date': fields.date.context_today(self, cr, uid, context=context),
                                      'ref': move.picking_id.name}, context=context)

    #def _reconcile_single_negative_quant(self, cr, uid, to_solve_quant, quant, quant_neg, qty, context=None):
    #    move = self._get_latest_move(cr, uid, to_solve_quant, context=context)
    #    quant_neg_position = quant_neg.negative_dest_location_id.usage
    #    remaining_solving_quant, remaining_to_solve_quant = super(stock_quant, self)._reconcile_single_negative_quant(cr, uid, to_solve_quant, quant, quant_neg, qty, context=context)
    #    #update the standard price of the product, only if we would have done it if we'd have had enough stock at first, which means
    #    #1) there isn't any negative quant anymore
    #    #2) the product cost's method is 'real'
    #    #3) we just fixed a negative quant caused by an outgoing shipment
    #    if not remaining_to_solve_quant and move.product_id.cost_method == 'real' and quant_neg_position != 'internal':
    #        self.pool.get('stock.move')._store_average_cost_price(cr, uid, move, context=context)
    #    return remaining_solving_quant, remaining_to_solve_quant

class stock_move(osv.osv):
    _inherit = "stock.move"

    def action_done(self, cr, uid, ids, context=None):
        self.product_price_update_before_done(cr, uid, ids, context=context)
        res = super(stock_move, self).action_done(cr, uid, ids, context=context)
        self.product_price_update_after_done(cr, uid, ids, context=context)
        return res

    def _store_average_cost_price(self, cr, uid, move, context=None):
        ''' move is a browe record '''
        product_obj = self.pool.get('product.product')
        if any([q.qty <= 0 for q in move.quant_ids]):
            #if there is a negative quant, the standard price shouldn't be updated
            return
        #Note: here we can't store a quant.cost directly as we may have moved out 2 units (1 unit to 5€ and 1 unit to 7€) and in case of a product return of 1 unit, we can't know which of the 2 costs has to be used (5€ or 7€?). So at that time, thanks to the average valuation price we are storing we will svaluate it at 6€
        average_valuation_price = 0.0
        for q in move.quant_ids:
            average_valuation_price += q.qty * q.cost
        average_valuation_price = average_valuation_price / move.product_qty
        # Write the standard price, as SUPERUSER_ID because a warehouse manager may not have the right to write on products
        ctx = dict(context, force_company=move.company_id.id)
        product_obj.write(cr, SUPERUSER_ID, [move.product_id.id], {'standard_price': average_valuation_price}, context=ctx)
        self.write(cr, uid, [move.id], {'price_unit': average_valuation_price}, context=context)

    def product_price_update_before_done(self, cr, uid, ids, context=None):
        product_obj = self.pool.get('product.product')
        tmpl_dict = {}
        for move in self.browse(cr, uid, ids, context=context):
            #adapt standard price on incomming moves if the product cost_method is 'average'
            if (move.location_id.usage == 'supplier') and (move.product_id.cost_method == 'average'):
                product = move.product_id
                prod_tmpl_id = move.product_id.product_tmpl_id.id
                qty_available = move.product_id.product_tmpl_id.qty_available
                if tmpl_dict.get(prod_tmpl_id):
                    product_avail = qty_available + tmpl_dict[prod_tmpl_id]
                else:
                    tmpl_dict[prod_tmpl_id] = 0
                    product_avail = qty_available
                if product_avail <= 0:
                    new_std_price = move.price_unit
                else:
                    # Get the standard price
                    amount_unit = product.standard_price
                    new_std_price = ((amount_unit * product_avail) + (move.price_unit * move.product_qty)) / (product_avail + move.product_qty)
                tmpl_dict[prod_tmpl_id] += move.product_qty
                # Write the standard price, as SUPERUSER_ID because a warehouse manager may not have the right to write on products
                ctx = dict(context or {}, force_company=move.company_id.id)
                product_obj.write(cr, SUPERUSER_ID, [product.id], {'standard_price': new_std_price}, context=ctx)

    def product_price_update_after_done(self, cr, uid, ids, context=None):
        '''
        This method adapts the price on the product when necessary
        '''
        for move in self.browse(cr, uid, ids, context=context):
            #adapt standard price on outgoing moves if the product cost_method is 'real', so that a return
            #or an inventory loss is made using the last value used for an outgoing valuation.
            if move.product_id.cost_method == 'real' and move.location_dest_id.usage != 'internal':
                #store the average price of the move on the move and product form
                self._store_average_cost_price(cr, uid, move, context=context)

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import migrations, models, connection

def table_description():
    """Handle Mysql/Pg vs Sqlite"""
    # django's mysql/pg introspection.get_table_description tries to select *
    # from table and fails during initial migrations from scratch.
    # sqlite does not have this failure, so we can use the API.
    # For not-sqlite, query information-schema directly with code lifted
    # from the internals of django.db.backends.mysql.introspection.py

    if connection.vendor == 'sqlite':
        fields = connection.introspection.get_table_description(connection.cursor(), 'course_overviews_courseoverview')
        return [f.name for f in fields]
    else:
        cursor = connection.cursor()
        cursor.execute("""
            SELECT column_name
            FROM information_schema.columns
            WHERE table_name = 'course_overviews_courseoverview' AND table_schema = DATABASE()""")
        rows = cursor.fetchall()
        return [r[0] for r in rows]


class Migration(migrations.Migration):

    dependencies = [
        ('course_overviews', '0008_remove_courseoverview_facebook_url'),
    ]

    # An original version of 0008 removed the facebook_url field We need to
    # handle the case where our noop 0008 ran AND the case where the original
    # 0008 ran.  We do that by using the standard information_schema to find out
    # what columns exist. _meta is unavailable as the column has already been
    # removed from the model
    operations = []
    fields = table_description()

    # during a migration from scratch, fields will be empty, but we do not want to add
    # an additional facebook_url
    if fields and not any(f == 'facebook_url' for f in fields):
        operations += migrations.AddField(
            model_name='courseoverview',
            name='facebook_url',
            field=models.TextField(null=True),
        ),

#!/usr/bin/env python
# -------------------------------------------------------------
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.
#
# -------------------------------------------------------------

import sys
import os
from os.path import join, exists
from os import environ
import shutil


def get_env_systemml_home():
    """
    Env variable error check and path location

    return: String
    Location of SYSTEMML_HOME
    """
    systemml_home = os.environ.get('SYSTEMML_HOME')
    if systemml_home is None:
        print('SYSTEMML_HOME not found')
        sys.exit()

    return systemml_home


def get_env_spark_home():
    """
    Env variable error check and path location

    return: String
    Location of SPARK_HOME
    """
    spark_home = environ.get('SPARK_HOME')
    if spark_home is None:
        print('SPARK_HOME not found')
        sys.exit()

    return spark_home


def find_file(name, path):
    """
    Responsible for finding a specific file recursively given a location
    """
    for root, dirs, files in os.walk(path):
        if name in files:
            return join(root, name)


def find_dml_file(systemml_home, script_file):
    """
    Find the location of DML script being executed

    return: String
    Location of the dml script
    """
    scripts_dir = join(systemml_home, 'scripts')
    if not exists(script_file):
        script_file_path = find_file(script_file, scripts_dir)
        if script_file_path is not None:
            return script_file_path
        else:
            print('Could not find DML script: ' + script_file)
            sys.exit()

    return script_file

def log4j_path(systemml_home):
    """
    Create log4j.properties from the template if not exist

    return: String
    Location of log4j.properties path
    """
    log4j_properties_path = join(systemml_home, 'conf', 'log4j.properties')
    log4j_template_properties_path = join(systemml_home, 'conf', 'log4j.properties.template')
    if not (exists(log4j_properties_path)):
        shutil.copyfile(log4j_template_properties_path, log4j_properties_path)
        print('... created ' + log4j_properties_path)
    return log4j_properties_path


def config_path(systemml_home):
    """
    Create SystemML-config from the template if not exist

    return: String
    Location of SystemML-config.xml
    """
    systemml_config_path = join(systemml_home, 'conf', 'SystemML-config.xml')
    systemml_template_config_path = join(systemml_home, 'conf', 'SystemML-config.xml.template')
    if not (exists(systemml_config_path)):
        shutil.copyfile(systemml_template_config_path, systemml_config_path)
        print('... created ' + systemml_config_path)
    return systemml_config_path

#!/usr/bin/python
from __future__ import (absolute_import, division, print_function)
# Copyright 2019 Fortinet, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <https://www.gnu.org/licenses/>.
#
# the lib use python logging can get it if the following is set in your
# Ansible config.

__metaclass__ = type

ANSIBLE_METADATA = {'status': ['preview'],
                    'supported_by': 'community',
                    'metadata_version': '1.1'}

DOCUMENTATION = '''
---
module: fortios_log_custom_field
short_description: Configure custom log fields in Fortinet's FortiOS and FortiGate.
description:
    - This module is able to configure a FortiGate or FortiOS by allowing the
      user to set and modify log feature and custom_field category.
      Examples include all parameters and values need to be adjusted to datasources before usage.
      Tested with FOS v6.0.2
version_added: "2.8"
author:
    - Miguel Angel Munoz (@mamunozgonzalez)
    - Nicolas Thomas (@thomnico)
notes:
    - Requires fortiosapi library developed by Fortinet
    - Run as a local_action in your playbook
requirements:
    - fortiosapi>=0.9.8
options:
    host:
       description:
            - FortiOS or FortiGate ip address.
       required: true
    username:
        description:
            - FortiOS or FortiGate username.
        required: true
    password:
        description:
            - FortiOS or FortiGate password.
        default: ""
    vdom:
        description:
            - Virtual domain, among those defined previously. A vdom is a
              virtual instance of the FortiGate that can be configured and
              used as a different unit.
        default: root
    https:
        description:
            - Indicates if the requests towards FortiGate must use HTTPS
              protocol
        type: bool
        default: true
    log_custom_field:
        description:
            - Configure custom log fields.
        default: null
        suboptions:
            state:
                description:
                    - Indicates whether to create or remove the object
                choices:
                    - present
                    - absent
            id:
                description:
                    - field ID <string>.
                required: true
            name:
                description:
                    - "Field name (max: 15 characters)."
            value:
                description:
                    - "Field value (max: 15 characters)."
'''

EXAMPLES = '''
- hosts: localhost
  vars:
   host: "192.168.122.40"
   username: "admin"
   password: ""
   vdom: "root"
  tasks:
  - name: Configure custom log fields.
    fortios_log_custom_field:
      host:  "{{ host }}"
      username: "{{ username }}"
      password: "{{ password }}"
      vdom:  "{{ vdom }}"
      https: "False"
      log_custom_field:
        state: "present"
        id:  "3"
        name: "default_name_4"
        value: "<your_own_value>"
'''

RETURN = '''
build:
  description: Build number of the fortigate image
  returned: always
  type: str
  sample: '1547'
http_method:
  description: Last method used to provision the content into FortiGate
  returned: always
  type: str
  sample: 'PUT'
http_status:
  description: Last result given by FortiGate on last operation applied
  returned: always
  type: str
  sample: "200"
mkey:
  description: Master key (id) used in the last call to FortiGate
  returned: success
  type: str
  sample: "id"
name:
  description: Name of the table used to fulfill the request
  returned: always
  type: str
  sample: "urlfilter"
path:
  description: Path of the table used to fulfill the request
  returned: always
  type: str
  sample: "webfilter"
revision:
  description: Internal revision number
  returned: always
  type: str
  sample: "17.0.2.10658"
serial:
  description: Serial number of the unit
  returned: always
  type: str
  sample: "FGVMEVYYQT3AB5352"
status:
  description: Indication of the operation's result
  returned: always
  type: str
  sample: "success"
vdom:
  description: Virtual domain used
  returned: always
  type: str
  sample: "root"
version:
  description: Version of the FortiGate
  returned: always
  type: str
  sample: "v5.6.3"

'''

from ansible.module_utils.basic import AnsibleModule

fos = None


def login(data):
    host = data['host']
    username = data['username']
    password = data['password']

    fos.debug('on')
    if 'https' in data and not data['https']:
        fos.https('off')
    else:
        fos.https('on')

    fos.login(host, username, password)


def filter_log_custom_field_data(json):
    option_list = ['id', 'name', 'value']
    dictionary = {}

    for attribute in option_list:
        if attribute in json and json[attribute] is not None:
            dictionary[attribute] = json[attribute]

    return dictionary


def log_custom_field(data, fos):
    vdom = data['vdom']
    log_custom_field_data = data['log_custom_field']
    filtered_data = filter_log_custom_field_data(log_custom_field_data)
    if log_custom_field_data['state'] == "present":
        return fos.set('log',
                       'custom-field',
                       data=filtered_data,
                       vdom=vdom)

    elif log_custom_field_data['state'] == "absent":
        return fos.delete('log',
                          'custom-field',
                          mkey=filtered_data['id'],
                          vdom=vdom)


def fortios_log(data, fos):
    login(data)

    methodlist = ['log_custom_field']
    for method in methodlist:
        if data[method]:
            resp = eval(method)(data, fos)
            break

    fos.logout()
    return not resp['status'] == "success", resp['status'] == "success", resp


def main():
    fields = {
        "host": {"required": True, "type": "str"},
        "username": {"required": True, "type": "str"},
        "password": {"required": False, "type": "str", "no_log": True},
        "vdom": {"required": False, "type": "str", "default": "root"},
        "https": {"required": False, "type": "bool", "default": True},
        "log_custom_field": {
            "required": False, "type": "dict",
            "options": {
                "state": {"required": True, "type": "str",
                          "choices": ["present", "absent"]},
                "id": {"required": True, "type": "str"},
                "name": {"required": False, "type": "str"},
                "value": {"required": False, "type": "str"}

            }
        }
    }

    module = AnsibleModule(argument_spec=fields,
                           supports_check_mode=False)
    try:
        from fortiosapi import FortiOSAPI
    except ImportError:
        module.fail_json(msg="fortiosapi module is required")

    global fos
    fos = FortiOSAPI()

    is_error, has_changed, result = fortios_log(module.params, fos)

    if not is_error:
        module.exit_json(changed=has_changed, meta=result)
    else:
        module.fail_json(msg="Error in repo", meta=result)


if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-
#
#
#    Author: Nicolas Bessi, Yannick Vaucher, Leonardo Pistone
#    Copyright 2014 Camptocamp SA
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
#
{'name': 'Sale stock exception',
 'version': '8.0.1.2.0',
 'author': "Camptocamp,Odoo Community Association (OCA)",
 'maintainer': 'Camptocamp',
 'category': 'sale',
 'complexity': "normal",
 'depends': ['sale_exceptions', 'sale_stock'],
 'description': """
Sale stock exception
--------------------

This addon adds two new sales exceptions to be used by the `sale_exception`
addon:

* The first one ensures that an order line can be delivered on the delivery
  date if it is in MTS. Validation is done by using the order line location via
  related shop and using the line delay.

* The second one will create a sales exception if the current SO will break a
  sales order already placed in the future.

The second test will only look for stock moves that pass by the line location,
so if your stock have children or if you have configured automated stock
actions they must pass by the location related to the SO line, else they will
be ignored.

If the module sale_owner_stock_sourcing is installed, each sale order line can
specify a stock owner. In that case, the owner will be used when computing the
virtual stock availability. For this to work correctly,
https://github.com/odoo/odoo/issues/5814 needs to be fixed (fixes are proposed
both for odoo and OCB).

**Warning:**

The second test is a workaround to compensate the lack of
stock reservation process in OpenERP. This can be a performance killer
and should not be be used if you have hundreds of simultaneous open SO.
""",
 'website': 'http://www.camptocamp.com',
 'data': ["data/data.xml"],
 'demo': [],
 'test': ['test/no_stock_test.yml'],
 'installable': True,
 'auto_install': False,
 'license': 'AGPL-3',
 'application': False,
 }

from __future__ import division, print_function, absolute_import
import numpy as np


def pad(data, padwidth, value=0.0):
    """
    Pad an array with a specific value.

    Parameters
    ----------
    data : ndarray
        Numpy array of any dimension and type.
    padwidth : int or tuple
        If int, it will pad using this amount at the beginning and end of all
        dimensions. If it is a tuple (of same length as `ndim`), then the
        padding amount will be specified per axis.
    value : data.dtype
        The value with which to pad. Default is ``0.0``.

    See also
    --------
    pad_to_size, pad_repeat_border, pad_repeat_border_corner

    Examples
    --------
    >>> import deepdish as dd
    >>> import numpy as np

    Pad an array with zeros.

    >>> x = np.ones((3, 3))
    >>> dd.util.pad(x, (1, 2), value=0.0)
    array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.],
           [ 0.,  0.,  1.,  1.,  1.,  0.,  0.],
           [ 0.,  0.,  1.,  1.,  1.,  0.,  0.],
           [ 0.,  0.,  1.,  1.,  1.,  0.,  0.],
           [ 0.,  0.,  0.,  0.,  0.,  0.,  0.]])

    """
    data = np.asarray(data)
    shape = data.shape
    if isinstance(padwidth, int):
        padwidth = (padwidth,)*len(shape)

    padded_shape = tuple(map(lambda ix: ix[1]+padwidth[ix[0]]*2,
                             enumerate(shape)))
    new_data = np.empty(padded_shape, dtype=data.dtype)
    new_data[..., :] = value
    new_data[[slice(w, -w) if w > 0 else slice(None) for w in padwidth]] = data
    return new_data


def pad_to_size(data, shape, value=0.0):
    """
    This is similar to `pad`, except you specify the final shape of the array.

    Parameters
    ----------
    data : ndarray
        Numpy array of any dimension and type.
    shape : tuple
        Final shape of padded array. Should be tuple of length ``data.ndim``.
        If it has to pad unevenly, it will pad one more at the end of the axis
        than at the beginning. If a dimension is specified as ``-1``, then it
        will remain its current size along that dimension.
    value : data.dtype
        The value with which to pad. Default is ``0.0``. This can even be an
        array, as long as ``pdata[:] = value`` is valid, where ``pdata`` is the
        size of the padded array.

    Examples
    --------
    >>> import deepdish as dd
    >>> import numpy as np

    Pad an array with zeros.

    >>> x = np.ones((4, 2))
    >>> dd.util.pad_to_size(x, (5, 5))
    array([[ 0.,  1.,  1.,  0.,  0.],
           [ 0.,  1.,  1.,  0.,  0.],
           [ 0.,  1.,  1.,  0.,  0.],
           [ 0.,  1.,  1.,  0.,  0.],
           [ 0.,  0.,  0.,  0.,  0.]])


    """
    shape = [data.shape[i] if shape[i] == -1 else shape[i]
             for i in range(len(shape))]
    new_data = np.empty(shape)
    new_data[:] = value
    II = [slice((shape[i] - data.shape[i])//2,
                (shape[i] - data.shape[i])//2 + data.shape[i])
          for i in range(len(shape))]
    new_data[II] = data
    return new_data


def pad_repeat_border(data, padwidth):
    """
    Similar to `pad`, except the border value from ``data`` is used to pad.

    Parameters
    ----------
    data : ndarray
        Numpy array of any dimension and type.
    padwidth : int or tuple
        If int, it will pad using this amount at the beginning and end of all
        dimensions. If it is a tuple (of same length as `ndim`), then the
        padding amount will be specified per axis.

    Examples
    --------
    >>> import deepdish as dd
    >>> import numpy as np

    Pad an array by repeating its borders:

    >>> shape = (3, 4)
    >>> x = np.arange(np.prod(shape)).reshape(shape)
    >>> dd.util.pad_repeat_border(x, 2)
    array([[ 0,  0,  0,  1,  2,  3,  3,  3],
           [ 0,  0,  0,  1,  2,  3,  3,  3],
           [ 0,  0,  0,  1,  2,  3,  3,  3],
           [ 4,  4,  4,  5,  6,  7,  7,  7],
           [ 8,  8,  8,  9, 10, 11, 11, 11],
           [ 8,  8,  8,  9, 10, 11, 11, 11],
           [ 8,  8,  8,  9, 10, 11, 11, 11]])

    """

    data = np.asarray(data)
    shape = data.shape
    if isinstance(padwidth, int):
        padwidth = (padwidth,)*len(shape)

    padded_shape = tuple(map(lambda ix: ix[1]+padwidth[ix[0]]*2,
                             enumerate(shape)))
    new_data = np.empty(padded_shape, dtype=data.dtype)
    new_data[[slice(w, -w) if w > 0 else slice(None) for w in padwidth]] = data

    for i, pw in enumerate(padwidth):
        if pw > 0:
            selection = [slice(None)] * data.ndim
            selection2 = [slice(None)] * data.ndim

            # Lower boundary
            selection[i] = slice(0, pw)
            selection2[i] = slice(pw, pw+1)
            new_data[tuple(selection)] = new_data[tuple(selection2)]

            # Upper boundary
            selection[i] = slice(-pw, None)
            selection2[i] = slice(-pw-1, -pw)
            new_data[tuple(selection)] = new_data[tuple(selection2)]

    return new_data


def pad_repeat_border_corner(data, shape):
    """
    Similar to `pad_repeat_border`, except the padding is always done on the
    upper end of each axis and the target size is specified.

    Parameters
    ----------
    data : ndarray
        Numpy array of any dimension and type.
    shape : tuple
        Final shape of padded array. Should be tuple of length ``data.ndim``.
        If it has to pad unevenly, it will pad one more at the end of the axis
        than at the beginning.

    Examples
    --------
    >>> import deepdish as dd
    >>> import numpy as np

    Pad an array by repeating its upper borders.

    >>> shape = (3, 4)
    >>> x = np.arange(np.prod(shape)).reshape(shape)
    >>> dd.util.pad_repeat_border_corner(x, (5, 5))
    array([[  0.,   1.,   2.,   3.,   3.],
           [  4.,   5.,   6.,   7.,   7.],
           [  8.,   9.,  10.,  11.,  11.],
           [  8.,   9.,  10.,  11.,  11.],
           [  8.,   9.,  10.,  11.,  11.]])

    """
    new_data = np.empty(shape)
    new_data[[slice(upper) for upper in data.shape]] = data
    for i in range(len(shape)):
        selection = [slice(None)]*i + [slice(data.shape[i], None)]
        selection2 = [slice(None)]*i + [slice(data.shape[i]-1, data.shape[i])]
        new_data[selection] = new_data[selection2]
    return new_data

# coding=utf-8
import re

from datetime import datetime
from scrapy.contrib.spiders import CrawlSpider, Rule
from scrapy.contrib.linkextractors.sgml import SgmlLinkExtractor
from scrapy.http import Request
from scrapy.selector import HtmlXPathSelector
from scrapy.utils.response import get_base_url
from scrapy.utils.url import urljoin_rfc

from psp_cz.database import db_session
from psp_cz.items import ParlMembVote, Voting, Sitting
from psp_cz.psp_cz_models import Sitting as TSitting

def get_parl_memb_id(url):
    match = re.search('id=([0-9]+)', url)
    if match:
        return int(match.group(1))


class PspCzSpider(CrawlSpider):
    """
    Spider gets information about parliament sittings, votings, parliament
    members (not complete information - poslanci.psp.cz spider gets it) and
    about voting of each parliament member.

    Spider accepts following parameters:
        mode - values 'incremental' or 'full'. Incremental is the default.
            Completely parses the information from psp.cz. For incremental mode
            there are 2 possible run options - either parameters from_term and
            from_sitting are specified and then parsing starts at the sitting
             specified and continues until the latest sitting. If from_term or
             from_sitting is not specified then spider gets the latest parsed
             sitting from the database and starts with this sitting (the latest
             sitting from the database is crawled again to make sure that the
             previously fetched information is complete).
        from_term - term of parliament. Applicable only if mode=incremental and
            from_sitting parameter is also specified
        from_sitting - sitting number we should start at with parsing. It is
            applicable only for incremental mode and from_term parameter
            specified.

    """
    name = "psp.cz"
    allowed_domains = ["www.psp.cz"]
    start_urls = [
        "http://www.psp.cz/sqw/hp.sqw?k=27",
        "http://www.psp.cz/sqw/hlasovani.sqw?zvo=1"
    ]
    # restriction not to parse all data over and over again
    SITTING_URL_SORT_REGEXP = r'o=([:0-9:]+)\&s=([:0-9:]+)'

    rules = (
        # extract sittings
        Rule(SgmlLinkExtractor(allow=('hlasovani\.sqw$')), callback='parse_sittings', follow=False),
    )

    def __init__(self, *a, **kw):
        super(PspCzSpider, self).__init__(*a, **kw)

        if kw.get('mode', None) in ['full', 'incremental']:
            self.mode = kw['mode']
        else:
            self.mode = 'incremental'

        if self.mode == 'incremental':
            from_sitting = kw.get('from_sitting', None)
            from_term = kw.get('from_term', None)
            if not from_sitting or not from_term:
                # get the latest Sitting urls from the database
                db_sitting_urls = db_session.query(TSitting.url).all()

                if db_sitting_urls:
                    # sort the list
                    db_sitting_urls.sort(key=lambda x: map(int, re.findall(self.SITTING_URL_SORT_REGEXP, x[0])[0]))
                    latest_db_sitting_url = db_sitting_urls[-1][0]
                    self.log('Latest URL in DB is ' + latest_db_sitting_url)
                    self.start_from = map(int, re.findall(self.SITTING_URL_SORT_REGEXP, latest_db_sitting_url)[0])
                else:
                    # no starting point specified and no sitting record in DB - switch to 'full' mode
                    self.mode = 'full'
            else:
                self.start_from = [int(from_term), int(from_sitting)]

    def parse_sittings(self, response):
        """ Parses parliament sittings at the current season """

        hxs = HtmlXPathSelector(response)
        base_url = get_base_url(response)

        sitting_links = hxs.select('//*[@id="main-content"]/div[1]/table/tbody/tr/td[1]/b')

        for sitting_link in sitting_links:
            sitting = Sitting()
            relative_url = sitting_link.select('a/@href').extract()[0]
            sitting['url'] = urljoin_rfc(base_url, relative_url)
            sitting['id'] = sitting['url']
            sitting['name'] = sitting_link.select('a/text()').extract()[0]

            # to optimize speed start downloading only from latest sitting stored in DB
            if self.mode == 'full' or \
                    map(int, re.findall(self.SITTING_URL_SORT_REGEXP, sitting['url'])[0]) >= self.start_from:
                self.log('PARSE ' + sitting['url'])
                yield sitting

                request = Request(sitting['url'], self.proceed_to_votings, meta={'sitting':sitting})
                yield request

            else:
                self.log('SKIP ' + sitting['url'])


    # this callback just adds sitting info to requests and follows links
    def proceed_to_votings(self, response):
        """ Navigates from more descriptive page about votings to voting table """

        hxs = HtmlXPathSelector(response)
        base_url = get_base_url(response)

        if 'sitting' in response.meta:
            sitting = response.meta['sitting']
        else:
            self.log('Error: SITTING parameter not found! %s' % response.url)
            return

        voting_links = hxs.select('//@href').re(r'phlasa\.sqw.*')

        for voting_link in voting_links:
            request = Request(urljoin_rfc(base_url, voting_link),
                              self.parse_votings,
                              meta={'sitting':sitting})
            yield request


    def parse_votings(self, response):
        """ Parses votings from given parliament sitting """

        hxs = HtmlXPathSelector(response)

        base_url = get_base_url(response)
        if 'sitting' in response.meta:
            sitting = response.meta['sitting']
        else:
            self.log('Error: SITTING parameter not found! %s' % response.url)
            return

        voting_links = hxs.select('//*[@id="main-content"]/div[1]/center/table/tr[position()>1]')

        for voting_link in voting_links:
            voting = Voting()
            relative_url = voting_link.select('td[2]/a/@href').extract()[0]
            voting['url'] = urljoin_rfc(base_url, relative_url)
            voting['id'] = voting['url']
            voting['voting_nr'] = int(voting_link.select('td[2]/a/text()').extract()[0])
            voting['name'] = voting_link.select('td[4]/node()').extract()[0]
            if voting_link.select('td[5]/a/text()'):
                date_text = voting_link.select('td[5]/a/text()').extract()[0].replace(u'\xa0', '')
                voting['voting_date'] = datetime.strptime(date_text, '%d.%m.%Y')
                voting['minutes_url'] = voting_link.select('td[5]/a/@href').extract()[0]
            else:
                date_text = voting_link.select('td[5]/text()').extract()[0].replace(u'\xa0', '')
                voting['voting_date'] = datetime.strptime(date_text, '%d.%m.%Y')
                voting['minutes_url'] = None
            voting['result'] = voting_link.select('td[6]/text()').extract()[0]
            voting['sitting'] = sitting
            yield voting

            request = Request(voting['url'], self.parse_parl_memb_votes, meta={'voting':voting})
            yield request


    def parse_parl_memb_votes(self, response):
        """ Parses votes of individual members of parliament """

        hxs = HtmlXPathSelector(response)
        base_url = get_base_url(response)
        if 'voting' in response.meta:
            voting = response.meta['voting']
        else:
            self.log('Error: VOTING parameter not found! %s' % response.url)
            return

        votings = hxs.select('//ul[@class="results"]//li')

        for v in votings:
            parl_memb_vote = ParlMembVote()
            parl_memb_vote['vote'] = v.select('span/text()').extract()[0]
            parl_memb_vote['parl_memb_name'] = v.select('a/text()').extract()[0]
            relative_url = v.select('a/@href').extract()[0]
            # remove &o=<number> parameter - it refers to tenure
            relative_url = re.sub(r'\&o=[:0-9:]+', '', relative_url)
            parl_memb_vote['parl_memb_url'] = urljoin_rfc(base_url, relative_url)
            parl_memb_vote['id'] = response.url + '|' + parl_memb_vote['parl_memb_url']
            parl_memb_vote['voting'] = voting
            parl_memb_vote['parl_memb_id'] = get_parl_memb_id(parl_memb_vote['parl_memb_url'])
            yield parl_memb_vote

# Natural Language Toolkit: Chunkers
#
# Copyright (C) 2001-2015 NLTK Project
# Author: Steven Bird <stevenbird1@gmail.com>
#         Edward Loper <edloper@gmail.com>
# URL: <http://nltk.org/>
# For license information, see LICENSE.TXT
#

"""
Classes and interfaces for identifying non-overlapping linguistic
groups (such as base noun phrases) in unrestricted text.  This task is
called "chunk parsing" or "chunking", and the identified groups are
called "chunks".  The chunked text is represented using a shallow
tree called a "chunk structure."  A chunk structure is a tree
containing tokens and chunks, where each chunk is a subtree containing
only tokens.  For example, the chunk structure for base noun phrase
chunks in the sentence "I saw the big dog on the hill" is::

  (SENTENCE:
    (NP: <I>)
    <saw>
    (NP: <the> <big> <dog>)
    <on>
    (NP: <the> <hill>))

To convert a chunk structure back to a list of tokens, simply use the
chunk structure's ``leaves()`` method.

This module defines ``ChunkParserI``, a standard interface for
chunking texts; and ``RegexpChunkParser``, a regular-expression based
implementation of that interface. It also defines ``ChunkScore``, a
utility class for scoring chunk parsers.

RegexpChunkParser
=================

``RegexpChunkParser`` is an implementation of the chunk parser interface
that uses regular-expressions over tags to chunk a text.  Its
``parse()`` method first constructs a ``ChunkString``, which encodes a
particular chunking of the input text.  Initially, nothing is
chunked.  ``parse.RegexpChunkParser`` then applies a sequence of
``RegexpChunkRule`` rules to the ``ChunkString``, each of which modifies
the chunking that it encodes.  Finally, the ``ChunkString`` is
transformed back into a chunk structure, which is returned.

``RegexpChunkParser`` can only be used to chunk a single kind of phrase.
For example, you can use an ``RegexpChunkParser`` to chunk the noun
phrases in a text, or the verb phrases in a text; but you can not
use it to simultaneously chunk both noun phrases and verb phrases in
the same text.  (This is a limitation of ``RegexpChunkParser``, not of
chunk parsers in general.)

RegexpChunkRules
----------------

A ``RegexpChunkRule`` is a transformational rule that updates the
chunking of a text by modifying its ``ChunkString``.  Each
``RegexpChunkRule`` defines the ``apply()`` method, which modifies
the chunking encoded by a ``ChunkString``.  The
``RegexpChunkRule`` class itself can be used to implement any
transformational rule based on regular expressions.  There are
also a number of subclasses, which can be used to implement
simpler types of rules:

    - ``ChunkRule`` chunks anything that matches a given regular
      expression.
    - ``ChinkRule`` chinks anything that matches a given regular
      expression.
    - ``UnChunkRule`` will un-chunk any chunk that matches a given
      regular expression.
    - ``MergeRule`` can be used to merge two contiguous chunks.
    - ``SplitRule`` can be used to split a single chunk into two
      smaller chunks.
    - ``ExpandLeftRule`` will expand a chunk to incorporate new
      unchunked material on the left.
    - ``ExpandRightRule`` will expand a chunk to incorporate new
      unchunked material on the right.

Tag Patterns
~~~~~~~~~~~~

A ``RegexpChunkRule`` uses a modified version of regular
expression patterns, called "tag patterns".  Tag patterns are
used to match sequences of tags.  Examples of tag patterns are::

     r'(<DT>|<JJ>|<NN>)+'
     r'<NN>+'
     r'<NN.*>'

The differences between regular expression patterns and tag
patterns are:

    - In tag patterns, ``'<'`` and ``'>'`` act as parentheses; so
      ``'<NN>+'`` matches one or more repetitions of ``'<NN>'``, not
      ``'<NN'`` followed by one or more repetitions of ``'>'``.
    - Whitespace in tag patterns is ignored.  So
      ``'<DT> | <NN>'`` is equivalant to ``'<DT>|<NN>'``
    - In tag patterns, ``'.'`` is equivalant to ``'[^{}<>]'``; so
      ``'<NN.*>'`` matches any single tag starting with ``'NN'``.

The function ``tag_pattern2re_pattern`` can be used to transform
a tag pattern to an equivalent regular expression pattern.

Efficiency
----------

Preliminary tests indicate that ``RegexpChunkParser`` can chunk at a
rate of about 300 tokens/second, with a moderately complex rule set.

There may be problems if ``RegexpChunkParser`` is used with more than
5,000 tokens at a time.  In particular, evaluation of some regular
expressions may cause the Python regular expression engine to
exceed its maximum recursion depth.  We have attempted to minimize
these problems, but it is impossible to avoid them completely.  We
therefore recommend that you apply the chunk parser to a single
sentence at a time.

Emacs Tip
---------

If you evaluate the following elisp expression in emacs, it will
colorize a ``ChunkString`` when you use an interactive python shell
with emacs or xemacs ("C-c !")::

    (let ()
      (defconst comint-mode-font-lock-keywords
        '(("<[^>]+>" 0 'font-lock-reference-face)
          ("[{}]" 0 'font-lock-function-name-face)))
      (add-hook 'comint-mode-hook (lambda () (turn-on-font-lock))))

You can evaluate this code by copying it to a temporary buffer,
placing the cursor after the last close parenthesis, and typing
"``C-x C-e``".  You should evaluate it before running the interactive
session.  The change will last until you close emacs.

Unresolved Issues
-----------------

If we use the ``re`` module for regular expressions, Python's
regular expression engine generates "maximum recursion depth
exceeded" errors when processing very large texts, even for
regular expressions that should not require any recursion.  We
therefore use the ``pre`` module instead.  But note that ``pre``
does not include Unicode support, so this module will not work
with unicode strings.  Note also that ``pre`` regular expressions
are not quite as advanced as ``re`` ones (e.g., no leftward
zero-length assertions).

:type CHUNK_TAG_PATTERN: regexp
:var CHUNK_TAG_PATTERN: A regular expression to test whether a tag
     pattern is valid.
"""

from nltk.data import load

from nltk.chunk.api import ChunkParserI
from nltk.chunk.util import (ChunkScore, accuracy, tagstr2tree, conllstr2tree,
                             conlltags2tree, tree2conlltags, tree2conllstr, tree2conlltags,
                             ieerstr2tree)
from nltk.chunk.regexp import RegexpChunkParser, RegexpParser

# Standard treebank POS tagger
_BINARY_NE_CHUNKER = 'chunkers/maxent_ne_chunker/english_ace_binary.pickle'
_MULTICLASS_NE_CHUNKER = 'chunkers/maxent_ne_chunker/english_ace_multiclass.pickle'

def ne_chunk(tagged_tokens, binary=False):
    """
    Use NLTK's currently recommended named entity chunker to
    chunk the given list of tagged tokens.
    """
    if binary:
        chunker_pickle = _BINARY_NE_CHUNKER
    else:
        chunker_pickle = _MULTICLASS_NE_CHUNKER
    chunker = load(chunker_pickle)
    return chunker.parse(tagged_tokens)

def ne_chunk_sents(tagged_sentences, binary=False):
    """
    Use NLTK's currently recommended named entity chunker to chunk the
    given list of tagged sentences, each consisting of a list of tagged tokens.
    """
    if binary:
        chunker_pickle = _BINARY_NE_CHUNKER
    else:
        chunker_pickle = _MULTICLASS_NE_CHUNKER
    chunker = load(chunker_pickle)
    return chunker.parse_sents(tagged_sentences)


import waLBerla
import subprocess
import re
from collections import defaultdict
import sys
from datetime import timedelta

base = (32, 16, 2, 64)
BlOCK_SIZES_SQ = [(i, i, i) for i in base]
BLOCK_SIZES_RECT = [(i, i, i // 2) for i in base] + [(i, i // 2, i // 2) for i in base]

time_for_benchmark = 0.25
outer_iterations = 2
db_file = 'FieldCommunication.sqlite'


def supermuc_network_spread():
    try:
        node_list = subprocess.check_output("scontrol show hostname $SLURM_JOB_NODELIST", shell=True, encoding='utf8')
    except subprocess.CalledProcessError:
        return defaultdict(lambda: 0)

    spread = defaultdict(set)
    for s in node_list.split("\n"):
        m = re.search("i(\d\d)r(\d\d)c(\d\d)s(\d\d)", s)
        if m:
            for name, idx in zip(['i', 'r', 'c', 's'], range(1, 5)):
                spread[name].add(m.group(idx))
    return {k: len(v) for k, v in spread.items()}


sng_network = supermuc_network_spread()


class AlreadySimulated:

    def __init__(self, db_file, properties=('processes0*processes1*processes2', 'layout', 'ghostLayers',
                                            'cartesianCommunicator', 'stencil',
                                            'cellsPerBlock0', 'cellsPerBlock1', 'cellsPerBlock2',
                                            'blocksPerProcess', 'localCommunicationMode', 'singleMessage',
                                            'fieldsPdf', 'fieldsPdfOpt', 'fieldsVector', 'fieldsScalar',
                                            'buffered')):
        self.properties = properties
        import sqlite3
        conn = sqlite3.connect(db_file)
        self.data = set()

        try:
            for row in conn.execute("SELECT {} FROM runs;".format(",".join(self.properties))):
                self.data.add(row)
        except sqlite3.OperationalError:
            pass
        waLBerla.log_info_on_root("Loaded {} scenarios".format(len(self.data)))

    def in_db(self, args):
        return args in self.data


@waLBerla.callback("config")
def config(processes=None):
    simulated_db = AlreadySimulated(db_file)
    isWalberlaRun = processes is None
    skipped = 0
    simulated = 0
    if isWalberlaRun:
        processes = waLBerla.mpi.numProcesses()
    for layout in ('fzyx', 'zyxf'):
        for ghost_layers in (1, 2):
            for cartesian_comm in (False, True):
                for stencil in ('D3Q19', 'D3Q27', 'D3Q7'):
                    for cells in BlOCK_SIZES_SQ + BLOCK_SIZES_RECT:
                        for blocksPerProcess in (1, 2, 4, 8, 16):
                            for local_comm in ('start', 'noOptimization', 'buffer'):
                                for single_message in (True, False):
                                    for pdf, pdf_opt, vector, scalar in ([1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1],
                                                                         [0, 0, 0, 3], [0, 0, 0, 19], [2, 0, 0, 0], [0, 2, 0, 0]):
                                        for buffered in (0, 1):
                                            if blocksPerProcess >= 8 and cells[0] >= 64 and cells[1] >= 64 and cells[2] >= 64:
                                                continue

                                            data = (processes, layout, ghost_layers, int(cartesian_comm), stencil, *cells, blocksPerProcess, local_comm,
                                                    int(single_message), pdf, pdf_opt, vector, scalar, buffered)

                                            if simulated_db.in_db(data):
                                                skipped += 1
                                                if skipped % 100 == 0 and isWalberlaRun:
                                                    waLBerla.log_info_on_root("Skipped {} scenarios".format(skipped))
                                                continue
                                            else:
                                                simulated += 1
                                                if not isWalberlaRun:
                                                    continue

                                            cfg = {
                                                'Domain': {
                                                    'cellsPerBlock': cells,
                                                    'domainWeights': (1, 1, 1),
                                                    'blocksPerProcess': blocksPerProcess,
                                                },
                                                'Communication': {
                                                    'buffered': buffered,
                                                    'stencil': stencil,
                                                    'ghostLayers': ghost_layers,
                                                    'cartesianCommunicator': cartesian_comm,
                                                    'singleMessage': single_message,
                                                    'Fields': {
                                                        'pdf': pdf,
                                                        'pdfOpt': pdf_opt,
                                                        'vector': vector,
                                                        'scalar': scalar,
                                                    },
                                                    'layout': layout,
                                                    'localCommunicationMode': local_comm,
                                                },
                                                'Run': {
                                                    'warmupIterations': 3,
                                                    'iterations': 100,
                                                    'outerIterations': outer_iterations,
                                                    'databaseFile': db_file,
                                                    'timeForBenchmark': time_for_benchmark,
                                                    'minIterations': 2,
                                                    'maxIterations': 10000,
                                                },
                                                'Database': {
                                                    'sngNetworkIslands': sng_network['i'],
                                                    'sngNetworkRows': sng_network['r'],
                                                    'sngNetworkCabinets': sng_network['c'],
                                                    'sngNetworkSlots': sng_network['s'],
                                                }
                                            }
                                            yield cfg
    if not isWalberlaRun:
        print("Skipped", skipped, "to simulate", simulated)
        estimated_seconds = simulated * time_for_benchmark * outer_iterations
        print("Estimated time ", timedelta(seconds=estimated_seconds))


if __name__ == '__main__':
    for _ in config(int(sys.argv[1])):
        pass

#!/usr/bin/python
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['stableinterface'],
                    'supported_by': 'community'}


DOCUMENTATION = '''
---
module: rds_param_group
version_added: "1.5"
short_description: manage RDS parameter groups
description:
     - Creates, modifies, and deletes RDS parameter groups. This module has a dependency on python-boto >= 2.5.
requirements: [ boto3 ]
options:
  state:
    description:
      - Specifies whether the group should be present or absent.
    required: true
    default: present
    choices: [ 'present' , 'absent' ]
  name:
    description:
      - Database parameter group identifier.
    required: true
  description:
    description:
      - Database parameter group description. Only set when a new group is added.
  engine:
    description:
      - The type of database for this group. Required for state=present.
    choices:
        - 'aurora5.6'
        - 'mariadb10.0'
        - 'mariadb10.1'
        - 'mysql5.1'
        - 'mysql5.5'
        - 'mysql5.6'
        - 'mysql5.7'
        - 'oracle-ee-11.2'
        - 'oracle-ee-12.1'
        - 'oracle-se-11.2'
        - 'oracle-se-12.1'
        - 'oracle-se1-11.2'
        - 'oracle-se1-12.1'
        - 'postgres9.3'
        - 'postgres9.4'
        - 'postgres9.5'
        - 'postgres9.6'
        - 'sqlserver-ee-10.5'
        - 'sqlserver-ee-11.0'
        - 'sqlserver-ex-10.5'
        - 'sqlserver-ex-11.0'
        - 'sqlserver-ex-12.0'
        - 'sqlserver-se-10.5'
        - 'sqlserver-se-11.0'
        - 'sqlserver-se-12.0'
        - 'sqlserver-web-10.5'
        - 'sqlserver-web-11.0'
        - 'sqlserver-web-12.0'
  immediate:
    description:
      - Whether to apply the changes immediately, or after the next reboot of any associated instances.
    aliases:
      - apply_immediately
  params:
    description:
      - Map of parameter names and values. Numeric values may be represented as K for kilo (1024), M for mega (1024^2), G for giga (1024^3),
        or T for tera (1024^4), and these values will be expanded into the appropriate number before being set in the parameter group.
    aliases: [parameters]
  tags:
    description:
      - Dictionary of tags to attach to the parameter group
    version_added: "2.4"
  purge_tags:
    description:
      - Whether or not to remove tags that do not appear in the I(tags) list. Defaults to false.
    version_added: "2.4"
author:
    - "Scott Anderson (@tastychutney)"
    - "Will Thames (@willthames)"
extends_documentation_fragment:
    - aws
    - ec2
'''

EXAMPLES = '''
# Add or change a parameter group, in this case setting auto_increment_increment to 42 * 1024
- rds_param_group:
      state: present
      name: norwegian_blue
      description: 'My Fancy Ex Parrot Group'
      engine: 'mysql5.6'
      params:
          auto_increment_increment: "42K"
      tags:
          Environment: production
          Application: parrot

# Remove a parameter group
- rds_param_group:
      state: absent
      name: norwegian_blue
'''

RETURN = '''
db_parameter_group_name:
    description: Name of DB parameter group
    type: string
    returned: when state is present
db_parameter_group_family:
    description: DB parameter group family that this DB parameter group is compatible with.
    type: string
    returned: when state is present
db_parameter_group_arn:
    description: ARN of the DB parameter group
    type: string
    returned: when state is present
description:
    description: description of the DB parameter group
    type: string
    returned: when state is present
errors:
    description: list of errors from attempting to modify parameters that are not modifiable
    type: list
    returned: when state is present
tags:
    description: dictionary of tags
    type: dict
    returned: when state is present
'''

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.ec2 import ec2_argument_spec, get_aws_connection_info, boto3_conn
from ansible.module_utils.ec2 import camel_dict_to_snake_dict, HAS_BOTO3, compare_aws_tags
from ansible.module_utils.ec2 import ansible_dict_to_boto3_tag_list, boto3_tag_list_to_ansible_dict
from ansible.module_utils.parsing.convert_bool import BOOLEANS_TRUE
from ansible.module_utils.six import string_types
from ansible.module_utils._text import to_native

import traceback

try:
    import botocore
except ImportError:
    pass  # caught by imported HAS_BOTO3


VALID_ENGINES = [
    'aurora5.6',
    'mariadb10.0',
    'mariadb10.1',
    'mysql5.1',
    'mysql5.5',
    'mysql5.6',
    'mysql5.7',
    'oracle-ee-11.2',
    'oracle-ee-12.1',
    'oracle-se-11.2',
    'oracle-se-12.1',
    'oracle-se1-11.2',
    'oracle-se1-12.1',
    'postgres9.3',
    'postgres9.4',
    'postgres9.5',
    'postgres9.6',
    'sqlserver-ee-10.5',
    'sqlserver-ee-11.0',
    'sqlserver-ex-10.5',
    'sqlserver-ex-11.0',
    'sqlserver-ex-12.0',
    'sqlserver-se-10.5',
    'sqlserver-se-11.0',
    'sqlserver-se-12.0',
    'sqlserver-web-10.5',
    'sqlserver-web-11.0',
    'sqlserver-web-12.0',
]

INT_MODIFIERS = {
    'K': 1024,
    'M': pow(1024, 2),
    'G': pow(1024, 3),
    'T': pow(1024, 4),
}


def convert_parameter(param, value):
    """
    Allows setting parameters with 10M = 10* 1024 * 1024 and so on.
    """
    converted_value = value

    if param['DataType'] == 'integer':
        if isinstance(value, string_types):
            try:
                for modifier in INT_MODIFIERS.keys():
                    if value.endswith(modifier):
                        converted_value = int(value[:-1]) * INT_MODIFIERS[modifier]
            except ValueError:
                # may be based on a variable (ie. {foo*3/4}) so
                # just pass it on through to boto
                pass
        elif isinstance(value, bool):
            converted_value = 1 if value else 0

    elif param['DataType'] == 'boolean':
        if isinstance(value, string_types):
            converted_value = to_native(value) in BOOLEANS_TRUE
        # convert True/False to 1/0
        converted_value = 1 if converted_value else 0
    return str(converted_value)


def update_parameters(module, connection):
    groupname = module.params['name']
    desired = module.params['params']
    apply_method = 'immediate' if module.params['immediate'] else 'pending-reboot'
    errors = []
    modify_list = []
    parameters_paginator = connection.get_paginator('describe_db_parameters')
    existing = parameters_paginator.paginate(DBParameterGroupName=groupname).build_full_result()['Parameters']
    lookup = dict((param['ParameterName'], param) for param in existing)
    for param_key, param_value in desired.items():
        if param_key not in lookup:
            errors.append("Parameter %s is not an available parameter for the %s engine" %
                          (param_key, module.params.get('engine')))
        else:
            converted_value = convert_parameter(lookup[param_key], param_value)
            # engine-default parameters do not have a ParameterValue, so we'll always override those.
            if converted_value != lookup[param_key].get('ParameterValue'):
                if lookup[param_key]['IsModifiable']:
                    modify_list.append(dict(ParameterValue=converted_value, ParameterName=param_key, ApplyMethod=apply_method))
                else:
                    errors.append("Parameter %s is not modifiable" % param_key)

    # modify_db_parameters takes at most 20 parameters
    if modify_list:
        try:
            from itertools import izip_longest as zip_longest  # python 2
        except ImportError:
            from itertools import zip_longest  # python 3
        for modify_slice in zip_longest(*[iter(modify_list)] * 20, fillvalue=None):
            non_empty_slice = [item for item in modify_slice if item]
            try:
                connection.modify_db_parameter_group(DBParameterGroupName=groupname, Parameters=non_empty_slice)
            except botocore.exceptions.ClientError as e:
                module.fail_json(msg="Couldn't update parameters: %s" % str(e),
                                 exception=traceback.format_exc(),
                                 **camel_dict_to_snake_dict(e.response))
        return True, errors
    return False, errors


def update_tags(module, connection, group, tags):
    changed = False
    existing_tags = connection.list_tags_for_resource(ResourceName=group['DBParameterGroupArn'])['TagList']
    to_update, to_delete = compare_aws_tags(boto3_tag_list_to_ansible_dict(existing_tags),
                                            tags, module.params['purge_tags'])
    if to_update:
        try:
            connection.add_tags_to_resource(ResourceName=group['DBParameterGroupArn'],
                                            Tags=ansible_dict_to_boto3_tag_list(to_update))
            changed = True
        except botocore.exceptions.ClientError as e:
            module.fail_json(msg="Couldn't add tags to parameter group: %s" % str(e),
                             exception=traceback.format_exc(),
                             **camel_dict_to_snake_dict(e.response))
        except botocore.exceptions.ParamValidationError as e:
            # Usually a tag value has been passed as an int or bool, needs to be a string
            # The AWS exception message is reasonably ok for this purpose
            module.fail_json(msg="Couldn't add tags to parameter group: %s." % str(e),
                             exception=traceback.format_exc())
    if to_delete:
        try:
            connection.remove_tags_from_resource(ResourceName=group['DBParameterGroupArn'],
                                                 TagKeys=to_delete)
            changed = True
        except botocore.exceptions.ClientError as e:
            module.fail_json(msg="Couldn't remove tags from parameter group: %s" % str(e),
                             exception=traceback.format_exc(),
                             **camel_dict_to_snake_dict(e.response))
    return changed


def ensure_present(module, connection):
    groupname = module.params['name']
    tags = module.params.get('tags')
    changed = False
    errors = []
    try:
        response = connection.describe_db_parameter_groups(DBParameterGroupName=groupname)
    except botocore.exceptions.ClientError as e:
        if e.response['Error']['Code'] == 'DBParameterGroupNotFound':
            response = None
        else:
            module.fail_json(msg="Couldn't access parameter group information: %s" % str(e),
                             exception=traceback.format_exc(),
                             **camel_dict_to_snake_dict(e.response))
    if not response:
        params = dict(DBParameterGroupName=groupname,
                      DBParameterGroupFamily=module.params['engine'],
                      Description=module.params['description'])
        if tags:
            params['Tags'] = ansible_dict_to_boto3_tag_list(tags)
        try:
            response = connection.create_db_parameter_group(**params)
            changed = True
        except botocore.exceptions.ClientError as e:
            module.fail_json(msg="Couldn't create parameter group: %s" % str(e),
                             exception=traceback.format_exc(),
                             **camel_dict_to_snake_dict(e.response))
    else:
        group = response['DBParameterGroups'][0]
        if tags:
            changed = update_tags(module, connection, group, tags)

    if module.params.get('params'):
        params_changed, errors = update_parameters(module, connection)
        changed = changed or params_changed

    try:
        response = connection.describe_db_parameter_groups(DBParameterGroupName=groupname)
        group = camel_dict_to_snake_dict(response['DBParameterGroups'][0])
    except botocore.exceptions.ClientError as e:
        module.fail_json(msg="Couldn't obtain parameter group information: %s" % str(e),
                         exception=traceback.format_exc(),
                         **camel_dict_to_snake_dict(e.response))
    try:
        tags = connection.list_tags_for_resource(ResourceName=group['db_parameter_group_arn'])['TagList']
    except botocore.exceptions.ClientError as e:
        module.fail_json(msg="Couldn't obtain parameter group tags: %s" % str(e),
                         exception=traceback.format_exc(),
                         **camel_dict_to_snake_dict(e.response))
    group['tags'] = boto3_tag_list_to_ansible_dict(tags)

    module.exit_json(changed=changed, errors=errors, **group)


def ensure_absent(module, connection):
    group = module.params['name']
    try:
        response = connection.describe_db_parameter_groups(DBParameterGroupName=group)
    except botocore.exceptions.ClientError as e:
        if e.response['Error']['Code'] == 'DBParameterGroupNotFound':
            module.exit_json(changed=False)
        else:
            module.fail_json(msg="Couldn't access parameter group information: %s" % str(e),
                             exception=traceback.format_exc(),
                             **camel_dict_to_snake_dict(e.response))
    try:
        response = connection.delete_db_parameter_group(DBParameterGroupName=group)
        module.exit_json(changed=True)
    except botocore.exceptions.ClientError as e:
        module.fail_json(msg="Couldn't delete parameter group: %s" % str(e),
                         exception=traceback.format_exc(),
                         **camel_dict_to_snake_dict(e.response))


def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(
            state=dict(required=True, choices=['present', 'absent']),
            name=dict(required=True),
            engine=dict(),
            description=dict(),
            params=dict(aliases=['parameters'], type='dict'),
            immediate=dict(type='bool', aliases=['apply_immediately']),
            tags=dict(type='dict', default={}),
            purge_tags=dict(type='bool', default=False)
        )
    )
    module = AnsibleModule(argument_spec=argument_spec,
                           required_if=[['state', 'present', ['description', 'engine']]])

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 and botocore are required for this module')

    # Retrieve any AWS settings from the environment.
    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)

    if not region:
        module.fail_json(msg="Region must be present")

    try:
        conn = boto3_conn(module, conn_type='client', resource='rds', region=region, endpoint=ec2_url, **aws_connect_kwargs)
    except botocore.exceptions.NoCredentialsError as e:
        module.fail_json(msg="Couldn't connect to AWS: %s" % str(e))

    state = module.params.get('state')
    if state == 'present':
        ensure_present(module, conn)
    if state == 'absent':
        ensure_absent(module, conn)


if __name__ == '__main__':
    main()

#!/usr/bin/env python
#
# Copyright 2008 The Closure Linter Authors. All Rights Reserved.
#
# 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.

"""Parser for JavaScript files."""



from closure_linter import javascripttokens
from closure_linter import statetracker
from closure_linter import tokenutil

# Shorthand
Type = javascripttokens.JavaScriptTokenType


class JsDocFlag(statetracker.DocFlag):
  """Javascript doc flag object.

  Attribute:
    flag_type: param, return, define, type, etc.
    flag_token: The flag token.
    type_start_token: The first token specifying the flag JS type,
      including braces.
    type_end_token: The last token specifying the flag JS type,
      including braces.
    type: The JavaScript type spec.
    name_token: The token specifying the flag name.
    name: The flag name
    description_start_token: The first token in the description.
    description_end_token: The end token in the description.
    description: The description.
  """

  # Please keep these lists alphabetized.

  # Some projects use the following extensions to JsDoc.
  # TODO(robbyw): determine which of these, if any, should be illegal.
  EXTENDED_DOC = frozenset([
      'class', 'code', 'desc', 'final', 'hidden', 'inheritDoc', 'link',
      'meaning', 'protected', 'notypecheck', 'throws'])

  LEGAL_DOC = EXTENDED_DOC | statetracker.DocFlag.LEGAL_DOC

  def __init__(self, flag_token):
    """Creates the JsDocFlag object and attaches it to the given start token.

    Args:
      flag_token: The starting token of the flag.
    """
    statetracker.DocFlag.__init__(self, flag_token)


class JavaScriptStateTracker(statetracker.StateTracker):
  """JavaScript state tracker.

  Inherits from the core EcmaScript StateTracker adding extra state tracking
  functionality needed for JavaScript.
  """

  def __init__(self):
    """Initializes a JavaScript token stream state tracker."""
    statetracker.StateTracker.__init__(self, JsDocFlag)

  def InTopLevel(self):
    """Compute whether we are at the top level in the class.

    This function call is language specific.  In some languages like
    JavaScript, a function is top level if it is not inside any parenthesis.
    In languages such as ActionScript, a function is top level if it is directly
    within a class.

    Returns:
      Whether we are at the top level in the class.
    """
    return not self.InParentheses()

  def GetBlockType(self, token):
    """Determine the block type given a START_BLOCK token.

    Code blocks come after parameters, keywords  like else, and closing parens.

    Args:
      token: The current token. Can be assumed to be type START_BLOCK
    Returns:
      Code block type for current token.
    """
    last_code = tokenutil.SearchExcept(token, Type.NON_CODE_TYPES, None,
                                       True)
    if last_code.type in (Type.END_PARAMETERS, Type.END_PAREN,
                          Type.KEYWORD) and not last_code.IsKeyword('return'):
      return self.CODE
    else:
      return self.OBJECT_LITERAL

  def HandleToken(self, token, last_non_space_token):
    """Handles the given token and updates state.

    Args:
      token: The token to handle.
      last_non_space_token:
    """
    super(JavaScriptStateTracker, self).HandleToken(token,
                                                    last_non_space_token)

"""
Copyright (c) 2004-Present Pivotal Software, Inc.

This program and the accompanying materials are made available under
the terms of the 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.
"""

from mpp.models import MPPTestCase

from gppylib.commands.base import Command
from mpp.gpdb.tests.storage.walrepl.run import StandbyRunMixin

class gpstart(StandbyRunMixin, MPPTestCase):
    def test_start(self):
        """
        Verify if gpstart stops the standby and gpstart starts it
        correctly.
        """

        # set up standby
        res = self.standby.create()
        self.assertEqual(res, 0)
        res = self.standby.start()
        self.assertTrue(res.wasSuccessful())

        # stop the whole cluster including standby
        cmd = Command("gpstop", "gpstop -a")
        cmd.run()
        self.assertEqual(cmd.get_results().rc, 0, str(cmd))

        # check if standby is shut down
        cmd = Command("pg_ctl status",
                      "pg_ctl status -D {0}".format(self.standby.datadir))
        cmd.run()
        # pg_ctl status returns 1 if it's not running
        self.assertEqual(cmd.get_results().rc, 1, str(cmd))

        # bring up the cluster.  gpstart should bring up the standby, too.
        cmd = Command("gpstart", "gpstart -a")
        cmd.run()
        self.assertTrue(cmd.get_results().rc in (0, 1), str(cmd))

        # wait for the standby to connect to the primary
        num_walsender = self.wait_for_walsender()
        self.assertEqual(num_walsender, 1)

        # make sure pg_ctl also agrees it's running
        cmd = Command("pg_ctl status",
                      "pg_ctl status -D {0}".format(self.standby.datadir))
        cmd.run()
        self.assertEqual(cmd.get_results().rc, 0, str(cmd))


# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for checkpoints tools."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os

from tensorflow.contrib.framework.python.framework import checkpoint_utils
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors_impl
from tensorflow.python.framework import ops
from tensorflow.python.ops import init_ops
from tensorflow.python.ops import partitioned_variables
from tensorflow.python.ops import variable_scope
from tensorflow.python.ops import variables
from tensorflow.python.platform import test
from tensorflow.python.training import saver as saver_lib


def _create_checkpoints(sess, checkpoint_dir):
  checkpoint_prefix = os.path.join(checkpoint_dir, "model")
  checkpoint_state_name = "checkpoint"
  v1 = variable_scope.get_variable("var1", [1, 10])
  v2 = variable_scope.get_variable("var2", [10, 10])
  v3 = variable_scope.get_variable("var3", [100, 100])
  with variable_scope.variable_scope("useful_scope"):
    v4 = variable_scope.get_variable("var4", [9, 9])
  sess.run(variables.global_variables_initializer())
  v1_value, v2_value, v3_value, v4_value = sess.run([v1, v2, v3, v4])
  saver = saver_lib.Saver()
  saver.save(
      sess,
      checkpoint_prefix,
      global_step=0,
      latest_filename=checkpoint_state_name)
  return v1_value, v2_value, v3_value, v4_value


def _create_partition_checkpoints(sess, checkpoint_dir):
  checkpoint_prefix = os.path.join(checkpoint_dir, "model")
  checkpoint_state_name = "checkpoint"
  with variable_scope.variable_scope("scope"):
    v1 = variable_scope.get_variable(
        name="var1",
        shape=[100, 100],
        initializer=init_ops.truncated_normal_initializer(0.5),
        partitioner=partitioned_variables.min_max_variable_partitioner(
            max_partitions=5, axis=0, min_slice_size=8 << 10))
  sess.run(variables.global_variables_initializer())
  v1_value = sess.run(v1._get_variable_list())
  saver = saver_lib.Saver()
  saver.save(
      sess,
      checkpoint_prefix,
      global_step=0,
      latest_filename=checkpoint_state_name)
  return v1_value


class CheckpointsTest(test.TestCase):

  def testNoCheckpoints(self):
    checkpoint_dir = self.get_temp_dir() + "/no_checkpoints"
    with self.assertRaises(errors_impl.OpError):
      self.assertAllEqual(
          checkpoint_utils.load_variable(checkpoint_dir, "var1"), [])

  def testNoTensor(self):
    checkpoint_dir = self.get_temp_dir()
    with self.test_session() as session:
      _, _, _, _ = _create_checkpoints(session, checkpoint_dir)
    with self.assertRaises(errors_impl.OpError):
      self.assertAllEqual(
          checkpoint_utils.load_variable(checkpoint_dir, "var5"), [])

  def testGetTensor(self):
    checkpoint_dir = self.get_temp_dir()
    with self.test_session() as session:
      v1, v2, v3, v4 = _create_checkpoints(session, checkpoint_dir)
    self.assertAllEqual(
        checkpoint_utils.load_variable(checkpoint_dir, "var1"), v1)
    self.assertAllEqual(
        checkpoint_utils.load_variable(checkpoint_dir, "var2"), v2)
    self.assertAllEqual(
        checkpoint_utils.load_variable(checkpoint_dir, "var3"), v3)
    self.assertAllEqual(
        checkpoint_utils.load_variable(checkpoint_dir, "useful_scope/var4"), v4)

  def testGetAllVariables(self):
    checkpoint_dir = self.get_temp_dir()
    with self.test_session() as session:
      _create_checkpoints(session, checkpoint_dir)
    self.assertEqual(
        checkpoint_utils.list_variables(checkpoint_dir),
        [("useful_scope/var4", [9, 9]), ("var1", [1, 10]), ("var2", [10, 10]),
         ("var3", [100, 100])])

  def testInitFromCheckpoint(self):
    checkpoint_dir = self.get_temp_dir()
    with self.test_session() as session:
      v1, v2, v3, v4 = _create_checkpoints(session, checkpoint_dir)

    # New graph and session.
    with ops.Graph().as_default() as g:
      with self.test_session(graph=g) as session:
        with variable_scope.variable_scope("some_scope"):
          my1 = variable_scope.get_variable("my1", [1, 10])
          with variable_scope.variable_scope("some_other_scope"):
            my2 = variable_scope.get_variable("my2", [10, 10])
            with variable_scope.variable_scope("other_useful_scope"):
              my4 = variable_scope.get_variable("var4", [9, 9])
        my3 = variable_scope.get_variable("my3", [100, 100])

        checkpoint_utils.init_from_checkpoint(checkpoint_dir, {
            "var1": "some_scope/my1",
            "useful_scope/": "some_scope/some_other_scope/other_useful_scope/",
        })
        checkpoint_utils.init_from_checkpoint(checkpoint_dir, {
            "var2": "some_scope/some_other_scope/my2",
            "var3": my3,
        })

        session.run(variables.global_variables_initializer())
        self.assertAllEqual(my1.eval(session), v1)
        self.assertAllEqual(my2.eval(session), v2)
        self.assertAllEqual(my3.eval(session), v3)
        self.assertAllEqual(my4.eval(session), v4)

        # Check that tensors are not explicitly in the graph.
        self.assertLess(len(str(session.graph.as_graph_def())), 27000)

  def testInitFromRootCheckpoint(self):
    checkpoint_dir = self.get_temp_dir()
    with self.test_session() as session:
      v1, v2, v3, v4 = _create_checkpoints(session, checkpoint_dir)

    # New graph and session.
    with ops.Graph().as_default() as g:
      with self.test_session(graph=g) as session:
        with variable_scope.variable_scope("some_scope"):
          my1 = variable_scope.get_variable("var1", [1, 10])
          my2 = variable_scope.get_variable("var2", [10, 10])
          my3 = variable_scope.get_variable("var3", [100, 100])
          with variable_scope.variable_scope("useful_scope"):
            my4 = variable_scope.get_variable("var4", [9, 9])

        checkpoint_utils.init_from_checkpoint(checkpoint_dir,
                                              {"/": "some_scope/",})

        session.run(variables.global_variables_initializer())
        self.assertAllEqual(my1.eval(session), v1)
        self.assertAllEqual(my2.eval(session), v2)
        self.assertAllEqual(my3.eval(session), v3)
        self.assertAllEqual(my4.eval(session), v4)

  def testInitFromPartitionVar(self):
    checkpoint_dir = self.get_temp_dir()
    with self.test_session() as session:
      v1 = _create_partition_checkpoints(session, checkpoint_dir)

    # New graph and session.
    with ops.Graph().as_default() as g:
      with self.test_session(graph=g) as session:
        with variable_scope.variable_scope("some_scope"):
          my1 = variable_scope.get_variable(
              name="my1",
              shape=[100, 100],
              initializer=init_ops.truncated_normal_initializer(0.5),
              partitioner=partitioned_variables.min_max_variable_partitioner(
                  max_partitions=5, axis=0, min_slice_size=8 << 10))
          my1_var_list = my1._get_variable_list()
        with variable_scope.variable_scope("some_other_scope"):
          my2 = variable_scope.get_variable(
              name="var1",
              shape=[100, 100],
              initializer=init_ops.truncated_normal_initializer(0.5),
              partitioner=partitioned_variables.min_max_variable_partitioner(
                  max_partitions=5, axis=0, min_slice_size=8 << 10))
          my2_var_list = my2._get_variable_list()

        checkpoint_utils.init_from_checkpoint(checkpoint_dir, {
            "scope/var1": "some_scope/my1",
            "scope/": "some_other_scope/"})

        session.run(variables.global_variables_initializer())
        my1_values = session.run(my1_var_list)
        self.assertAllEqual(my1_values, v1)
        my2_values = session.run(my2_var_list)
        self.assertAllEqual(my2_values, v1)

    # New graph and session.
    with ops.Graph().as_default() as g:
      with self.test_session(graph=g) as session:
        with variable_scope.variable_scope("some_scope"):
          my1 = variable_scope.get_variable(
              name="my1",
              shape=[100, 100],
              initializer=init_ops.truncated_normal_initializer(0.5),
              partitioner=partitioned_variables.min_max_variable_partitioner(
                  max_partitions=5, axis=0, min_slice_size=8 << 10))
          my1_var_list = my1._get_variable_list()

        checkpoint_utils.init_from_checkpoint(checkpoint_dir,
                                              {"scope/var1": my1_var_list,})

        session.run(variables.global_variables_initializer())
        my1_values = session.run(my1_var_list)
        self.assertAllEqual(my1_values, v1)

  def testInitFromCheckpointMissing(self):
    checkpoint_dir = self.get_temp_dir()
    with self.test_session() as session:
      _, _, _, _ = _create_checkpoints(session, checkpoint_dir)

    # New graph and session.
    with ops.Graph().as_default() as g:
      with self.test_session(graph=g) as session:
        with variable_scope.variable_scope("some_scope"):
          _ = variable_scope.get_variable("my1", [10, 10])
          _ = variable_scope.get_variable(
              "my2", [1, 10],
              dtype=dtypes.int64,
              initializer=init_ops.zeros_initializer())

        # No directory.
        with self.assertRaises(errors_impl.OpError):
          checkpoint_utils.init_from_checkpoint("no_dir",
                                                {"var1": "some_scope/my1"})

        # No variable in checkpoint.
        with self.assertRaises(ValueError):
          checkpoint_utils.init_from_checkpoint(checkpoint_dir,
                                                {"no_var": "some_scope/my1"})

        # No variable in the graph.
        with self.assertRaises(ValueError):
          checkpoint_utils.init_from_checkpoint(checkpoint_dir,
                                                {"var3": "some_scope/no_var"})

        # Shape mismatch.
        with self.assertRaises(ValueError):
          checkpoint_utils.init_from_checkpoint(checkpoint_dir,
                                                {"var1": "some_scope/my1"})

        # Variable 'my1' and 'my2' are missing in given checkpoint scope.
        with self.assertRaises(ValueError):
          checkpoint_utils.init_from_checkpoint(
              checkpoint_dir, {"useful_scope/": "some_scope/"})

        # Mapping is not to scope name.
        with self.assertRaises(ValueError):
          checkpoint_utils.init_from_checkpoint(checkpoint_dir,
                                                {"useful_scope": "some_scope/"})


if __name__ == "__main__":
  test.main()

# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt

from __future__ import unicode_literals
import frappe, os, json
from frappe.utils import cstr
from unidecode import unidecode

def create_charts(chart_name, company):
	chart = get_chart(chart_name)

	if chart:
		accounts = []

		def _import_accounts(children, parent, root_type, root_account=False):
			for account_name, child in children.items():
				if root_account:
					root_type = child.get("root_type")

				if account_name not in ["account_type", "root_type", "is_group"]:

					account_name_in_db = unidecode(account_name.strip().lower())
					if account_name_in_db in accounts:
						count = accounts.count(account_name_in_db)
						account_name = account_name + " " + cstr(count)

					is_group = identify_is_group(child)
					report_type = "Balance Sheet" if root_type in ["Asset", "Liability", "Equity"] \
						else "Profit and Loss"

					account = frappe.get_doc({
						"doctype": "Account",
						"account_name": account_name,
						"company": company,
						"parent_account": parent,
						"is_group": is_group,
						"root_type": root_type,
						"report_type": report_type,
						"account_type": child.get("account_type")
					})

					if root_account:
						account.flags.ignore_mandatory = True

					account.insert()

					accounts.append(account_name_in_db)

					_import_accounts(child, account.name, root_type)

		_import_accounts(chart, None, None, root_account=True)

def identify_is_group(child):
	if child.get("is_group"):
		is_group = child.get("is_group")
	elif len(set(child.keys()) - set(["account_type", "root_type", "is_group"])):
		is_group = 1
	else:
		is_group = 0

	return is_group

def get_chart(chart_name):
	chart = {}
	if chart_name == "Standard":
		from erpnext.accounts.doctype.account.chart_of_accounts.verified import standard_chart_of_accounts
		return standard_chart_of_accounts.get()
	else:
		path = os.path.join(os.path.dirname(__file__), "verified")
		for fname in os.listdir(path):
			if fname.endswith(".json"):
				with open(os.path.join(path, fname), "r") as f:
					chart = f.read()
					if chart and json.loads(chart).get("name") == chart_name:
						return json.loads(chart).get("tree")

@frappe.whitelist()
def get_charts_for_country(country):
	charts = []

	def _get_chart_name(content):
		if content:
			content = json.loads(content)
			if content and content.get("is_active", "No") == "Yes" and content.get("disabled", "No") == "No":
				charts.append(content["name"])

	country_code = frappe.db.get_value("Country", country, "code")
	if country_code:
		path = os.path.join(os.path.dirname(__file__), "verified")
		for fname in os.listdir(path):
			if fname.startswith(country_code) and fname.endswith(".json"):
				with open(os.path.join(path, fname), "r") as f:
					_get_chart_name(f.read())

	countries_use_OHADA_system = ["Benin", "Burkina Faso", "Cameroon", "Central African Republic", "Comoros",
		"Congo", "Ivory Coast", "Gabon", "Guinea", "Guinea Bissau", "Equatorial Guinea", "Mali", "Niger",
		"Replica of Democratic Congo", "Senegal", "Chad", "Togo"]

	if country in countries_use_OHADA_system:
		with open(os.path.join(os.path.dirname(__file__), "syscohada_syscohada_chart_template.json"), "r") as f:
			_get_chart_name(f.read())

	if len(charts) != 1:
		charts.append("Standard")

	return charts

# -*- coding: utf-8 -*-
"""
Created on Sat May 10 17:51:01 2014

@author: davestanley
"""



#Imports
import json
import nltk
import collections
from supporting_funcs import *
from json_clean import *


def extract_features(filename):
    
    #Variables
    train_fract = 0.5
    
    
    #Load JSON data
    json_data=open(filename)
    data = json.load(json_data)
    json_data.close()
    Nemails = len(data)
    Nemails = 2
    
    #Clean data
    for ind in range(Nemails):
        body_html_merge(data[ind])
    
    
    
    Nemails_test = int(floor(Nemails * train_fract))
    
    
    #Get a list of words for each email
    data_words = list()
    for ind in range(Nemails):
        email_tokens = tokenize_email(data[ind]['bodyText'])
        email_english = convert2english(email_tokens)
        email_nouns = extract_onlynouns(email_english)
        email_stems = convert2stems(email_nouns)
        email_lcase = convert2lcase(email_stems)
        data_words.append(email_lcase)
    
    
    cnt = collections.Counter()
    for ind in range(Nemails_test):
        for word in data_words[ind]:
            cnt[word.lower()] += 1
    
    feature_words = list()
    for words in cnt.most_common(100):
        feature_words.append(words[0])
    
    
    
    #Get a feature vector for each email
    data_features = list()
    for ind in range(Nemails):
        email_lcase = data_words[ind]
        curr_featurevector = list()
        for feature in feature_words:
            curr_featurevector.append(email_lcase.count(feature.lower()))
        data_features.append(curr_featurevector)
        
        
    return data_features



# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.
import sys
import unittest
from libcloud.utils.py3 import httplib

from libcloud.common.types import InvalidCredsError
from libcloud.compute.drivers.dimensiondata import DimensionDataNodeDriver as DimensionData
from libcloud.compute.drivers.dimensiondata import DimensionDataAPIException
from libcloud.compute.base import Node, NodeAuthPassword, NodeLocation

from libcloud.test import MockHttp
from libcloud.test.compute import TestCaseMixin
from libcloud.test.file_fixtures import ComputeFileFixtures

from libcloud.test.secrets import DIMENSIONDATA_PARAMS


class DimensionDataTests(unittest.TestCase, TestCaseMixin):

    def setUp(self):
        DimensionData.connectionCls.conn_classes = (None, DimensionDataMockHttp)
        DimensionDataMockHttp.type = None
        self.driver = DimensionData(*DIMENSIONDATA_PARAMS)

    def test_invalid_creds(self):
        DimensionDataMockHttp.type = 'UNAUTHORIZED'
        try:
            self.driver.list_nodes()
            self.assertTrue(
                False)  # Above command should have thrown an InvalidCredsException
        except InvalidCredsError:
            pass

    def test_list_sizes_response(self):
        DimensionDataMockHttp.type = None
        ret = self.driver.list_sizes()
        self.assertEqual(len(ret), 1)
        size = ret[0]
        self.assertEqual(size.name, 'default')

    def test_reboot_node_response(self):
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        ret = node.reboot()
        self.assertTrue(ret is True)

    def test_reboot_node_response_INPROGRESS(self):
        DimensionDataMockHttp.type = 'INPROGRESS'
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        try:
            node.reboot()
            self.assertTrue(
                False)  # above command should have thrown DimensionDataAPIException
        except DimensionDataAPIException:
            pass

    def test_destroy_node_response(self):
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        ret = node.destroy()
        self.assertTrue(ret is True)

    def test_destroy_node_response_INPROGRESS(self):
        DimensionDataMockHttp.type = 'INPROGRESS'
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        try:
            node.destroy()
            self.assertTrue(
                False)  # above command should have thrown DimensionDataAPIException
        except DimensionDataAPIException:
            pass

    def test_create_node_response(self):
        rootPw = NodeAuthPassword('pass123')
        image = self.driver.list_images()[0]
        network = self.driver.ex_list_networks()[0]
        node = self.driver.create_node(name='test2', image=image, auth=rootPw,
                                       ex_description='test2 node', ex_network=network,
                                       ex_isStarted=False)
        self.assertEqual(node.id, 'e75ead52-692f-4314-8725-c8a4f4d13a87')
        self.assertEqual(node.extra['status'].action, 'DEPLOY_SERVER')

    def test_ex_shutdown_graceful(self):
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        ret = self.driver.ex_shutdown_graceful(node)
        self.assertTrue(ret is True)

    def test_ex_shutdown_graceful_INPROGRESS(self):
        DimensionDataMockHttp.type = 'INPROGRESS'
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        try:
            self.driver.ex_shutdown_graceful(node)
            self.assertTrue(
                False)  # above command should have thrown DimensionDataAPIException
        except DimensionDataAPIException:
            pass

    def test_ex_start_node(self):
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        ret = self.driver.ex_start_node(node)
        self.assertTrue(ret is True)

    def test_ex_start_node_INPROGRESS(self):
        DimensionDataMockHttp.type = 'INPROGRESS'
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        try:
            self.driver.ex_start_node(node)
            self.assertTrue(
                False)  # above command should have thrown DimensionDataAPIException
        except DimensionDataAPIException:
            pass

    def test_ex_power_off(self):
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        ret = self.driver.ex_power_off(node)
        self.assertTrue(ret is True)

    def test_ex_power_off_INPROGRESS(self):
        DimensionDataMockHttp.type = 'INPROGRESS'
        node = Node(id='11', name=None, state=None,
                    public_ips=None, private_ips=None, driver=self.driver)
        try:
            self.driver.ex_power_off(node)
            self.assertTrue(
                False)  # above command should have thrown DimensionDataAPIException
        except DimensionDataAPIException:
            pass

    def test_ex_list_networks(self):
        nets = self.driver.ex_list_networks()
        self.assertEqual(nets[0].name, 'test-net1')
        self.assertTrue(isinstance(nets[0].location, NodeLocation))

    def test_node_public_ip(self):
        nodes = self.driver.list_nodes()
        node = [n for n in nodes if n.id ==
                'abadbc7e-9e10-46ca-9d4a-194bcc6b6c16'][0]
        self.assertEqual(node.public_ips[0], '200.16.132.7')


class DimensionDataMockHttp(MockHttp):

    fixtures = ComputeFileFixtures('dimensiondata')

    def _oec_0_9_myaccount_UNAUTHORIZED(self, method, url, body, headers):
        return (httplib.UNAUTHORIZED, "", {}, httplib.responses[httplib.UNAUTHORIZED])

    def _oec_0_9_myaccount(self, method, url, body, headers):
        body = self.fixtures.load('oec_0_9_myaccount.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_myaccount_INPROGRESS(self, method, url, body, headers):
        body = self.fixtures.load('oec_0_9_myaccount.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_base_image(self, method, url, body, headers):
        body = self.fixtures.load('oec_0_9_base_image.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_deployed(self, method, url, body, headers):
        body = self.fixtures.load(
            'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_deployed.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_pendingDeploy(self, method, url, body, headers):
        body = self.fixtures.load(
            'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_pendingDeploy.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_datacenter(self, method, url, body, headers):
        body = self.fixtures.load(
            'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_datacenter.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11(self, method, url, body, headers):
        body = None
        action = url.split('?')[-1]

        if action == 'restart':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_restart.xml')
        elif action == 'shutdown':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_shutdown.xml')
        elif action == 'delete':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_delete.xml')
        elif action == 'start':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_start.xml')
        elif action == 'poweroff':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_poweroff.xml')

        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_INPROGRESS(self, method, url, body, headers):
        body = None
        action = url.split('?')[-1]

        if action == 'restart':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_restart_INPROGRESS.xml')
        elif action == 'shutdown':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_shutdown_INPROGRESS.xml')
        elif action == 'delete':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_delete_INPROGRESS.xml')
        elif action == 'start':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_start_INPROGRESS.xml')
        elif action == 'poweroff':
            body = self.fixtures.load(
                'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server_11_poweroff_INPROGRESS.xml')

        return (httplib.BAD_REQUEST, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server(self, method, url, body, headers):
        body = self.fixtures.load(
            '_oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_server.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])

    def _oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_networkWithLocation(self, method, url, body, headers):
        body = self.fixtures.load(
            'oec_0_9_8a8f6abc_2745_4d8a_9cbc_8dabe5a7d0e4_networkWithLocation.xml')
        return (httplib.OK, body, {}, httplib.responses[httplib.OK])


if __name__ == '__main__':
    sys.exit(unittest.main())

# Copyright 2013 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2

from portage.tests import TestCase
from portage.tests.resolver.ResolverPlayground import (ResolverPlayground,
	ResolverPlaygroundTestCase)

class SlotChangeWithoutRevBumpTestCase(TestCase):

	def testSlotChangeWithoutRevBump(self):

		ebuilds = {
			"app-arch/libarchive-3.1.1" : {
				"EAPI": "5",
				"SLOT": "0/13"
			},
			"app-arch/libarchive-3.0.4-r1" : {
				"EAPI": "5",
				"SLOT": "0"
			},
			"kde-base/ark-4.10.0" : {
				"EAPI": "5",
				"DEPEND": "app-arch/libarchive:=",
				"RDEPEND": "app-arch/libarchive:="
			},
		}

		binpkgs = {
			"app-arch/libarchive-3.1.1" : {
				"EAPI": "5",
				"SLOT": "0"
			},
		}

		installed = {
			"app-arch/libarchive-3.1.1" : {
				"EAPI": "5",
				"SLOT": "0"
			},

			"kde-base/ark-4.10.0" : {
				"EAPI": "5",
				"DEPEND": "app-arch/libarchive:0/0=",
				"RDEPEND": "app-arch/libarchive:0/0="
			},
		}

		world = ["kde-base/ark"]

		test_cases = (

			# Demonstrate bug #456208, where a sub-slot change
			# without revbump needs to trigger a rebuild.
			ResolverPlaygroundTestCase(
				["kde-base/ark"],
				options = {"--oneshot": True, "--usepkg": True},
				success = True,
				mergelist = ['app-arch/libarchive-3.1.1', "kde-base/ark-4.10.0"]),

		)

		playground = ResolverPlayground(ebuilds=ebuilds, binpkgs=binpkgs,
			installed=installed, world=world, debug=False)
		try:
			for test_case in test_cases:
				playground.run_TestCase(test_case)
				self.assertEqual(test_case.test_success, True, test_case.fail_msg)
		finally:
			playground.cleanup()

# Copyright 2016-2018 The NATS Authors
# 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.
#

import asyncio
from nats.aio.client import Client as NATS
from stan.aio.client import Client as STAN

async def run(loop):
    # Use borrowed connection for NATS then mount NATS Streaming
    # client on top.
    nc = NATS()
    await nc.connect(io_loop=loop)

    # Start session with NATS Streaming cluster.
    sc = STAN()
    await sc.connect("test-cluster", "client-123", nats=nc)

    # Synchronous Publisher, does not return until an ack
    # has been received from NATS Streaming.
    await sc.publish("hi", b'hello')
    await sc.publish("hi", b'world')

    total_messages = 0
    future = asyncio.Future(loop=loop)
    async def cb(msg):
        nonlocal future
        nonlocal total_messages
        print("Received a message (seq={}): {}".format(msg.seq, msg.data))
        total_messages += 1
        if total_messages >= 2:
            future.set_result(None)

    # Subscribe to get all messages since beginning.
    sub = await sc.subscribe("hi", start_at='first', cb=cb)
    await asyncio.wait_for(future, 1, loop=loop)

    # Stop receiving messages
    await sub.unsubscribe()

    # Close NATS Streaming session
    await sc.close()

    # We are using a NATS borrowed connection so we need to close manually.
    await nc.close()

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    loop.run_until_complete(run(loop))
    loop.close()

"""
Tests i18n in courseware
"""
import re
from nose.plugins.attrib import attr

from django.conf import settings
from django.contrib.auth.models import User
from django.core.urlresolvers import reverse, NoReverseMatch
from django.test import TestCase
from django.test.client import Client

from dark_lang.models import DarkLangConfig
from lang_pref import LANGUAGE_KEY
from openedx.core.djangoapps.user_api.preferences.api import set_user_preference
from student.tests.factories import UserFactory, RegistrationFactory, UserProfileFactory


class BaseI18nTestCase(TestCase):
    """
    Base utilities for i18n test classes to derive from
    """
    def assert_tag_has_attr(self, content, tag, attname, value):
        """Assert that a tag in `content` has a certain value in a certain attribute."""
        regex = r"""<{tag} [^>]*\b{attname}=['"]([\w\d\- ]+)['"][^>]*>""".format(tag=tag, attname=attname)
        match = re.search(regex, content)
        self.assertTrue(match, "Couldn't find desired tag '%s' with attr '%s' in %r" % (tag, attname, content))
        attvalues = match.group(1).split()
        self.assertIn(value, attvalues)

    def release_languages(self, languages):
        """
        Release a set of languages using the dark lang interface.
        languages is a list of comma-separated lang codes, eg, 'ar, es-419'
        """
        user = User()
        user.save()
        DarkLangConfig(
            released_languages=languages,
            changed_by=user,
            enabled=True
        ).save()


@attr('shard_1')
class I18nTestCase(BaseI18nTestCase):
    """
    Tests for i18n
    """
    def test_default_is_en(self):
        self.release_languages('fr')
        response = self.client.get('/')
        self.assert_tag_has_attr(response.content, "html", "lang", "en")
        self.assertEqual(response['Content-Language'], 'en')
        self.assert_tag_has_attr(response.content, "body", "class", "lang_en")

    def test_esperanto(self):
        self.release_languages('fr, eo')
        response = self.client.get('/', HTTP_ACCEPT_LANGUAGE='eo')
        self.assert_tag_has_attr(response.content, "html", "lang", "eo")
        self.assertEqual(response['Content-Language'], 'eo')
        self.assert_tag_has_attr(response.content, "body", "class", "lang_eo")

    def test_switching_languages_bidi(self):
        self.release_languages('ar, eo')
        response = self.client.get('/')
        self.assert_tag_has_attr(response.content, "html", "lang", "en")
        self.assertEqual(response['Content-Language'], 'en')
        self.assert_tag_has_attr(response.content, "body", "class", "lang_en")
        self.assert_tag_has_attr(response.content, "body", "class", "ltr")

        response = self.client.get('/', HTTP_ACCEPT_LANGUAGE='ar')
        self.assert_tag_has_attr(response.content, "html", "lang", "ar")
        self.assertEqual(response['Content-Language'], 'ar')
        self.assert_tag_has_attr(response.content, "body", "class", "lang_ar")
        self.assert_tag_has_attr(response.content, "body", "class", "rtl")


@attr('shard_1')
class I18nRegressionTests(BaseI18nTestCase):
    """
    Tests for i18n
    """
    def test_es419_acceptance(self):
        # Regression test; LOC-72, and an issue with Django
        self.release_languages('es-419')
        response = self.client.get('/', HTTP_ACCEPT_LANGUAGE='es-419')
        self.assert_tag_has_attr(response.content, "html", "lang", "es-419")

    def test_unreleased_lang_resolution(self):
        # Regression test; LOC-85
        self.release_languages('fa')

        # We've released 'fa', AND we have language files for 'fa-ir' but
        # we want to keep 'fa-ir' as a dark language. Requesting 'fa-ir'
        # in the http request (NOT with the ?preview-lang query param) should
        # receive files for 'fa'
        response = self.client.get('/', HTTP_ACCEPT_LANGUAGE='fa-ir')
        self.assert_tag_has_attr(response.content, "html", "lang", "fa")

        # Now try to access with dark lang
        response = self.client.get('/?preview-lang=fa-ir')
        self.assert_tag_has_attr(response.content, "html", "lang", "fa-ir")

    def test_preview_lang(self):
        # Regression test; LOC-87
        self.release_languages('es-419')
        site_lang = settings.LANGUAGE_CODE
        # Visit the front page; verify we see site default lang
        response = self.client.get('/')
        self.assert_tag_has_attr(response.content, "html", "lang", site_lang)

        # Verify we can switch language using the preview-lang query param
        response = self.client.get('/?preview-lang=eo')
        self.assert_tag_has_attr(response.content, "html", "lang", "eo")
        # We should be able to see released languages using preview-lang, too
        response = self.client.get('/?preview-lang=es-419')
        self.assert_tag_has_attr(response.content, "html", "lang", "es-419")

        # Clearing the language should go back to site default
        response = self.client.get('/?clear-lang')
        self.assert_tag_has_attr(response.content, "html", "lang", site_lang)


@attr('shard_1')
class I18nLangPrefTests(BaseI18nTestCase):
    """
    Regression tests of language presented to the user, when they
    choose a language preference, and when they have a preference
    and use the dark lang preview functionality.
    """
    def setUp(self):
        super(I18nLangPrefTests, self).setUp()
        # Create one user and save it to the database
        email = 'test@edx.org'
        pwd = 'test_password'
        self.user = UserFactory.build(username='test', email=email)
        self.user.set_password(pwd)
        self.user.save()

        # Create a registration for the user
        RegistrationFactory(user=self.user)

        # Create a profile for the user
        UserProfileFactory(user=self.user)

        # Create the test client
        self.client = Client()

        # Get the login url & log in our user
        try:
            login_url = reverse('login_post')
        except NoReverseMatch:
            login_url = reverse('login')
        self.client.post(login_url, {'email': email, 'password': pwd})

        # Url and site lang vars for tests to use
        self.url = reverse('dashboard')
        self.site_lang = settings.LANGUAGE_CODE

    def test_lang_preference(self):
        # Regression test; LOC-87
        self.release_languages('ar, es-419')

        # Visit the front page; verify we see site default lang
        response = self.client.get(self.url)
        self.assert_tag_has_attr(response.content, "html", "lang", self.site_lang)

        # Set user language preference
        set_user_preference(self.user, LANGUAGE_KEY, 'ar')
        # and verify we now get an ar response
        response = self.client.get(self.url)
        self.assert_tag_has_attr(response.content, "html", "lang", 'ar')

        # Verify that switching language preference gives the right language
        set_user_preference(self.user, LANGUAGE_KEY, 'es-419')
        response = self.client.get(self.url)
        self.assert_tag_has_attr(response.content, "html", "lang", 'es-419')

    def test_preview_precedence(self):
        # Regression test; LOC-87
        self.release_languages('ar, es-419')

        # Set user language preference
        set_user_preference(self.user, LANGUAGE_KEY, 'ar')
        # Verify preview-lang takes precedence
        response = self.client.get('{}?preview-lang=eo'.format(self.url))
        self.assert_tag_has_attr(response.content, "html", "lang", 'eo')
        # Hitting another page should keep the dark language set.
        response = self.client.get(reverse('courses'))
        self.assert_tag_has_attr(response.content, "html", "lang", "eo")

        # Clearing language must set language back to preference language
        response = self.client.get('{}?clear-lang'.format(self.url))
        self.assert_tag_has_attr(response.content, "html", "lang", 'ar')

#!/usr/bin/env python3
# Copyright (c) 2014-2016 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
"""Test mempool re-org scenarios.

Test re-org scenarios with a mempool that contains transactions
that spend (directly or indirectly) coinbase transactions.
"""

from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import *

# Create one-input, one-output, no-fee transaction:
class MempoolCoinbaseTest(BitcoinTestFramework):
    def __init__(self):
        super().__init__()
        self.num_nodes = 2
        self.setup_clean_chain = False
        self.extra_args = [["-checkmempool"]] * 2

    alert_filename = None  # Set by setup_network

    def run_test(self):
        # Start with a 200 block chain
        assert_equal(self.nodes[0].getblockcount(), 200)

        # Mine four blocks. After this, nodes[0] blocks
        # 101, 102, and 103 are spend-able.
        new_blocks = self.nodes[1].generate(4)
        self.sync_all()

        node0_address = self.nodes[0].getnewaddress()
        node1_address = self.nodes[1].getnewaddress()

        # Three scenarios for re-orging coinbase spends in the memory pool:
        # 1. Direct coinbase spend  :  spend_101
        # 2. Indirect (coinbase spend in chain, child in mempool) : spend_102 and spend_102_1
        # 3. Indirect (coinbase and child both in chain) : spend_103 and spend_103_1
        # Use invalidatblock to make all of the above coinbase spends invalid (immature coinbase),
        # and make sure the mempool code behaves correctly.
        b = [ self.nodes[0].getblockhash(n) for n in range(101, 105) ]
        coinbase_txids = [ self.nodes[0].getblock(h)['tx'][0] for h in b ]
        spend_101_raw = create_tx(self.nodes[0], coinbase_txids[1], node1_address, 49.99)
        spend_102_raw = create_tx(self.nodes[0], coinbase_txids[2], node0_address, 49.99)
        spend_103_raw = create_tx(self.nodes[0], coinbase_txids[3], node0_address, 49.99)

        # Create a transaction which is time-locked to two blocks in the future
        timelock_tx = self.nodes[0].createrawtransaction([{"txid": coinbase_txids[0], "vout": 0}], {node0_address: 49.99})
        # Set the time lock
        timelock_tx = timelock_tx.replace("ffffffff", "11111191", 1)
        timelock_tx = timelock_tx[:-8] + hex(self.nodes[0].getblockcount() + 2)[2:] + "000000"
        timelock_tx = self.nodes[0].signrawtransaction(timelock_tx)["hex"]
        # This will raise an exception because the timelock transaction is too immature to spend
        assert_raises_jsonrpc(-26, "non-final", self.nodes[0].sendrawtransaction, timelock_tx)

        # Broadcast and mine spend_102 and 103:
        spend_102_id = self.nodes[0].sendrawtransaction(spend_102_raw)
        spend_103_id = self.nodes[0].sendrawtransaction(spend_103_raw)
        self.nodes[0].generate(1)
        # Time-locked transaction is still too immature to spend
        assert_raises_jsonrpc(-26,'non-final', self.nodes[0].sendrawtransaction, timelock_tx)

        # Create 102_1 and 103_1:
        spend_102_1_raw = create_tx(self.nodes[0], spend_102_id, node1_address, 49.98)
        spend_103_1_raw = create_tx(self.nodes[0], spend_103_id, node1_address, 49.98)

        # Broadcast and mine 103_1:
        spend_103_1_id = self.nodes[0].sendrawtransaction(spend_103_1_raw)
        last_block = self.nodes[0].generate(1)
        # Time-locked transaction can now be spent
        timelock_tx_id = self.nodes[0].sendrawtransaction(timelock_tx)

        # ... now put spend_101 and spend_102_1 in memory pools:
        spend_101_id = self.nodes[0].sendrawtransaction(spend_101_raw)
        spend_102_1_id = self.nodes[0].sendrawtransaction(spend_102_1_raw)

        self.sync_all()

        assert_equal(set(self.nodes[0].getrawmempool()), {spend_101_id, spend_102_1_id, timelock_tx_id})

        for node in self.nodes:
            node.invalidateblock(last_block[0])
        # Time-locked transaction is now too immature and has been removed from the mempool
        # spend_103_1 has been re-orged out of the chain and is back in the mempool
        assert_equal(set(self.nodes[0].getrawmempool()), {spend_101_id, spend_102_1_id, spend_103_1_id})

        # Use invalidateblock to re-org back and make all those coinbase spends
        # immature/invalid:
        for node in self.nodes:
            node.invalidateblock(new_blocks[0])

        self.sync_all()

        # mempool should be empty.
        assert_equal(set(self.nodes[0].getrawmempool()), set())

if __name__ == '__main__':
    MempoolCoinbaseTest().main()

# -*- coding: utf-8 -*-
# Copyright 2019, Andrew Klychkov @Andersson007 <aaklychkov@mail.ru>
# Simplified BSD License (see licenses/simplified_bsd.txt or https://opensource.org/licenses/BSD-2-Clause)

from __future__ import absolute_import, division, print_function
__metaclass__ = type

import pytest

from ansible.module_utils.common.text.converters import container_to_text


DEFAULT_ENCODING = 'utf-8'
DEFAULT_ERR_HANDLER = 'surrogate_or_strict'


@pytest.mark.parametrize(
    'test_input,expected',
    [
        ({1: 1}, {1: 1}),
        ([1, 2], [1, 2]),
        ((1, 2), (1, 2)),
        (1, 1),
        (1.1, 1.1),
        (b'str', u'str'),
        (u'str', u'str'),
        ([b'str'], [u'str']),
        ((b'str'), (u'str')),
        ({b'str': b'str'}, {u'str': u'str'}),
    ]
)
@pytest.mark.parametrize('encoding', ['utf-8', 'latin1', 'shift-jis', 'big5', 'koi8_r', ])
@pytest.mark.parametrize('errors', ['strict', 'surrogate_or_strict', 'surrogate_then_replace', ])
def test_container_to_text_different_types(test_input, expected, encoding, errors):
    """Test for passing objects to container_to_text()."""
    assert container_to_text(test_input, encoding=encoding, errors=errors) == expected


@pytest.mark.parametrize(
    'test_input,expected',
    [
        ({1: 1}, {1: 1}),
        ([1, 2], [1, 2]),
        ((1, 2), (1, 2)),
        (1, 1),
        (1.1, 1.1),
        (True, True),
        (None, None),
        (u'str', u'str'),
        (u'くらとみ'.encode(DEFAULT_ENCODING), u'くらとみ'),
        (u'café'.encode(DEFAULT_ENCODING), u'café'),
        (u'str'.encode(DEFAULT_ENCODING), u'str'),
        ([u'str'.encode(DEFAULT_ENCODING)], [u'str']),
        ((u'str'.encode(DEFAULT_ENCODING)), (u'str')),
        ({b'str': b'str'}, {u'str': u'str'}),
    ]
)
def test_container_to_text_default_encoding_and_err(test_input, expected):
    """
    Test for passing objects to container_to_text(). Default encoding and errors
    """
    assert container_to_text(test_input, encoding=DEFAULT_ENCODING,
                             errors=DEFAULT_ERR_HANDLER) == expected


@pytest.mark.parametrize(
    'test_input,encoding,expected',
    [
        (u'й'.encode('utf-8'), 'latin1', u'й'),
        (u'café'.encode('utf-8'), 'shift_jis', u'cafﾃｩ'),
    ]
)
@pytest.mark.parametrize('errors', ['strict', 'surrogate_or_strict', 'surrogate_then_replace', ])
def test_container_to_text_incomp_encod_chars(test_input, encoding, errors, expected):
    """
    Test for passing incompatible characters and encodings container_to_text().
    """
    assert container_to_text(test_input, encoding=encoding, errors=errors) == expected

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################


{
    'name': 'OpenOffice Report Designer',
    'version': '0.1',
    'category': 'Reporting',
    'description': """
This module is used along with OpenERP OpenOffice Plugin.
=========================================================

This module adds wizards to Import/Export .sxw report that you can modify in OpenOffice. 
Once you have modified it you can upload the report using the same wizard.
""",
    'author': 'OpenERP SA',
    'website': 'https://www.odoo.com',
    'depends': ['base'],
    'data': ['wizard/base_report_design_view.xml' , 'base_report_designer_installer.xml'],
    'demo': [],
    'installable': True,
    'auto_install': False,
}
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#
# Based on AboutHashes in the Ruby Koans
#

from runner.koan import *


class AboutDictionaries(Koan):
    def test_creating_dictionaries(self):
        empty_dict = dict()
        self.assertEqual(dict, type(empty_dict))
        self.assertEqual(dict(), empty_dict)
        self.assertEqual(0, len(empty_dict))

    def test_dictionary_literals(self):
        empty_dict = {}
        self.assertEqual(dict, type(empty_dict))
        babel_fish = {'one': 'uno', 'two': 'dos'}
        self.assertEqual(2, len(babel_fish))

    def test_accessing_dictionaries(self):
        babel_fish = {'one': 'uno', 'two': 'dos'}
        self.assertEqual("uno", babel_fish['one'])
        self.assertEqual("dos", babel_fish['two'])

    def test_changing_dictionaries(self):
        babel_fish = {'one': 'uno', 'two': 'dos'}
        babel_fish['one'] = 'eins'

        expected = {'two': 'dos', 'one': "eins"}
        self.assertEqual(expected, babel_fish)

    def test_dictionary_is_unordered(self):
        dict1 = {'one': 'uno', 'two': 'dos'}
        dict2 = {'two': 'dos', 'one': 'uno'}

        self.assertEqual(True, dict1 == dict2)

    def test_dictionary_keys_and_values(self):
        babel_fish = {'one': 'uno', 'two': 'dos'}
        self.assertEqual(2, len(babel_fish.keys()))
        self.assertEqual(2, len(babel_fish.values()))
        self.assertEqual(True, 'one' in babel_fish.keys())
        self.assertEqual(False, 'two' in babel_fish.values())
        self.assertEqual(False, 'uno' in babel_fish.keys())
        self.assertEqual(True, 'dos' in babel_fish.values()) 

# IMPORTANT!
    def test_making_a_dictionary_from_a_sequence_of_keys(self):
        cards = {}.fromkeys(
            ('red warrior', 'green elf', 'blue valkyrie', 'yellow dwarf',
             'confused looking zebra'),
            42) 
        self.assertEqual(5, len(cards))
        self.assertEqual(42, cards['green elf'])
        self.assertEqual(42, cards['yellow dwarf'])

# Copyright (c) 2012, the Mozilla Foundation. All rights reserved.
# Use of this source code is governed by the Simplified BSD License which can
# be found in the LICENSE file.

# Python module to create, delete and get the target of junctions on
# Windows.

__all__ = ["create", "readlink", "unlink", "isjunction"]

import os
import fs
from fs import CreateFile, GetFileAttributes, DeviceIoControl, CloseHandle

import ctypes
from ctypes import WinError, sizeof, byref
from ctypes.wintypes import DWORD

IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003

FSCTL_SET_REPARSE_POINT    = 0x000900A4
FSCTL_GET_REPARSE_POINT    = 0x000900A8
FSCTL_DELETE_REPARSE_POINT = 0x000900AC

def new_junction_reparse_buffer(path=None):    
    """
    Given a path, return a pair containing a new REPARSE_DATA_BUFFER and the
    length of the buffer (not necessarily the same as sizeof due to packing
    issues).
    If no path is provided, the maximum length is assumed.
    """

    if path is None:
        # The maximum reparse point data buffer length is 16384 bytes. We are a
        # bit conservative here and set a length of 16000 bytes (8000
        # characters) + a few more for the header.
        substnamebufferchars = 8000
    else:
        # 1 more character for the null terminator. Python 2.x calculates
        # len(surrogate pair) = 2, so multiplying this by 2 is the right thing
        # to do.
        substnamebufferchars = len(path) + 1

    # It is amazing how ugly MSDN's version of REPARSE_DATA_BUFFER is:
    # <http://msdn.microsoft.com/en-us/library/windows/hardware/ff552012>. It
    # is a variable-length struct with two strings in the wchar[] buffer at
    # the end. Both are supposed to be null-terminated, and the individual
    # lengths do not include that of the null character, but the total
    # ReparseDataLength does.
    #
    # In our case, only the SubstituteName part of the mount point/junction-
    # specific part is relevant. So we set PrintNameLength to 0, but we still
    # need to allow for one null character, so PrintNameBuffer has length 1.
    class REPARSE_DATA_BUFFER(ctypes.Structure):
        _fields_ = [("ReparseTag", ctypes.c_ulong),
                    ("ReparseDataLength", ctypes.c_ushort),
                    ("Reserved", ctypes.c_ushort),
                    ("SubstituteNameOffset", ctypes.c_ushort),
                    ("SubstituteNameLength", ctypes.c_ushort),
                    ("PrintNameOffset", ctypes.c_ushort),
                    ("PrintNameLength", ctypes.c_ushort),
                    ("SubstituteNameBuffer", ctypes.c_wchar * substnamebufferchars),
                    ("PrintNameBuffer", ctypes.c_wchar * 1)]

    numpathbytes = (substnamebufferchars - 1) * sizeof(ctypes.c_wchar)
    # We can't really use sizeof on the struct because of packing issues.
    # Instead, calculate the size manually
    buffersize = (numpathbytes + (sizeof(ctypes.c_wchar) * 2) + 
        (sizeof(ctypes.c_ushort) * 4))
    if path is None:
        buffer = REPARSE_DATA_BUFFER()
        buffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT
    else:
        buffer = REPARSE_DATA_BUFFER(
            IO_REPARSE_TAG_MOUNT_POINT,
            buffersize,
            0,
            # print name offset, length
            0, numpathbytes,
            # substitute name offset, length
            numpathbytes + 2, 0,
            # print name
            path,
            # substitute name
            "")

    return (buffer, buffersize + REPARSE_DATA_BUFFER.SubstituteNameOffset.offset)

def unparsed_convert(path):
    path = os.path.abspath(path)
    # Remove the trailing slash for root drives
    if path[-2:] == ":\\":
        path = path[:-1]
    # This magic prefix disables parsing. Note that we do not want to use
    # \\?\, since that doesn't tolerate a different case.
    return "\\??\\" + path

def unparsed_unconvert(path):
    if path[0:4] == "\\??\\":
        path = path[4:]
    return path

def isjunction(path):
    if not os.path.exists(path) or not fs.junctions_supported(path):
        return False

    attrs = GetFileAttributes(path)
    return bool((attrs & fs.FILE_ATTRIBUTE_DIRECTORY) and
                (attrs & fs.FILE_ATTRIBUTE_REPARSE_POINT))

def create(source, link_name):
    """
    Create a junction at link_name pointing to source.
    """
    success = False
    if not os.path.isdir(source):
        raise Exception("%s is not a directory" % source)
    if os.path.exists(link_name):
        raise Exception("%s: junction link name already exists" % link_name)

    link_name = os.path.abspath(link_name)
    os.mkdir(link_name)

    # Get a handle to the directory
    hlink = CreateFile(link_name, fs.GENERIC_WRITE,
        fs.FILE_SHARE_READ | fs.FILE_SHARE_WRITE, None, fs.OPEN_EXISTING,
        fs.FILE_FLAG_OPEN_REPARSE_POINT | fs.FILE_FLAG_BACKUP_SEMANTICS,
        None)
    try:
        if hlink == fs.INVALID_HANDLE_VALUE:
            raise WinError(descr="Couldn't open directory to create junction")

        srcvolpath = unparsed_convert(source)
        (junctioninfo, infolen) = new_junction_reparse_buffer(srcvolpath)

        dummy = DWORD(0)
        res = DeviceIoControl(
            hlink,
            FSCTL_SET_REPARSE_POINT,
            byref(junctioninfo),
            infolen,
            None,
            0,
            byref(dummy),
            None)

        if res == 0:
            raise WinError(descr="Setting directory as junction failed")
        success = True
    finally:
        if hlink != fs.INVALID_HANDLE_VALUE:
            CloseHandle(hlink)
        if not success:
            os.rmdir(link_name)

def readlink(path):
    # Make sure the path exists and is actually a junction
    if not isjunction(path):
        raise Exception("%s does not exist or is not a junction" % path)

    hlink = CreateFile(path, fs.GENERIC_READ, fs.FILE_SHARE_READ, None,
        fs.OPEN_EXISTING,
        fs.FILE_FLAG_OPEN_REPARSE_POINT | fs.FILE_FLAG_BACKUP_SEMANTICS,
        None)
    if hlink == fs.INVALID_HANDLE_VALUE:
        raise WinError(descr=("%s: couldn't open directory to read junction" % path))
    
    try:
        (junctioninfo, infolen) = new_junction_reparse_buffer()
        dummy = DWORD(0)
        res = DeviceIoControl(
            hlink,
            FSCTL_GET_REPARSE_POINT,
            None,
            0,
            byref(junctioninfo),
            infolen,
            byref(dummy),
            None)
        
        if res == 0:
            raise WinError(descr="Getting junction info failed")

        return unparsed_unconvert(junctioninfo.SubstituteNameBuffer)
    finally:
        CloseHandle(hlink)

def unlink(path):
    # Make sure the path exists and is actually a junction
    if not isjunction(path):
        raise Exception("%s does not exist or is not a junction" % path)
    # Just get rid of the directory
    os.rmdir(path)

# coding: utf-8
from __future__ import unicode_literals

import re

from .common import InfoExtractor
from ..utils import float_or_none


class VRTIE(InfoExtractor):
    _VALID_URL = r'https?://(?:deredactie|sporza|cobra)\.be/cm/(?:[^/]+/)+(?P<id>[^/]+)/*'
    _TESTS = [
        # deredactie.be
        {
            'url': 'http://deredactie.be/cm/vrtnieuws/videozone/programmas/journaal/EP_141025_JOL',
            'md5': '4cebde1eb60a53782d4f3992cbd46ec8',
            'info_dict': {
                'id': '2129880',
                'ext': 'flv',
                'title': 'Het journaal L - 25/10/14',
                'description': None,
                'timestamp': 1414271750.949,
                'upload_date': '20141025',
                'duration': 929,
            }
        },
        # sporza.be
        {
            'url': 'http://sporza.be/cm/sporza/videozone/programmas/extratime/EP_141020_Extra_time',
            'md5': '11f53088da9bf8e7cfc42456697953ff',
            'info_dict': {
                'id': '2124639',
                'ext': 'flv',
                'title': 'Bekijk Extra Time van 20 oktober',
                'description': 'md5:83ac5415a4f1816c6a93f8138aef2426',
                'timestamp': 1413835980.560,
                'upload_date': '20141020',
                'duration': 3238,
            }
        },
        # cobra.be
        {
            'url': 'http://cobra.be/cm/cobra/videozone/rubriek/film-videozone/141022-mv-ellis-cafecorsari',
            'md5': '78a2b060a5083c4f055449a72477409d',
            'info_dict': {
                'id': '2126050',
                'ext': 'flv',
                'title': 'Bret Easton Ellis in Café Corsari',
                'description': 'md5:f699986e823f32fd6036c1855a724ee9',
                'timestamp': 1413967500.494,
                'upload_date': '20141022',
                'duration': 661,
            }
        },
    ]

    def _real_extract(self, url):
        video_id = self._match_id(url)

        webpage = self._download_webpage(url, video_id)

        video_id = self._search_regex(
            r'data-video-id="([^"]+)_[^"]+"', webpage, 'video id', fatal=False)

        formats = []
        mobj = re.search(
            r'data-video-iphone-server="(?P<server>[^"]+)"\s+data-video-iphone-path="(?P<path>[^"]+)"',
            webpage)
        if mobj:
            formats.extend(self._extract_m3u8_formats(
                '%s/%s' % (mobj.group('server'), mobj.group('path')),
                video_id, 'mp4'))
        mobj = re.search(r'data-video-src="(?P<src>[^"]+)"', webpage)
        if mobj:
            formats.extend(self._extract_f4m_formats(
                '%s/manifest.f4m' % mobj.group('src'), video_id))
        self._sort_formats(formats)

        title = self._og_search_title(webpage)
        description = self._og_search_description(webpage, default=None)
        thumbnail = self._og_search_thumbnail(webpage)
        timestamp = float_or_none(self._search_regex(
            r'data-video-sitestat-pubdate="(\d+)"', webpage, 'timestamp', fatal=False), 1000)
        duration = float_or_none(self._search_regex(
            r'data-video-duration="(\d+)"', webpage, 'duration', fatal=False), 1000)

        return {
            'id': video_id,
            'title': title,
            'description': description,
            'thumbnail': thumbnail,
            'timestamp': timestamp,
            'duration': duration,
            'formats': formats,
        }

# -*- coding: utf-8 -*-
"""
    werkzeug.contrib.lint
    ~~~~~~~~~~~~~~~~~~~~~

    .. versionadded:: 0.5

    This module provides a middleware that performs sanity checks of the WSGI
    application.  It checks that :pep:`333` is properly implemented and warns
    on some common HTTP errors such as non-empty responses for 304 status
    codes.

    This module provides a middleware, the :class:`LintMiddleware`.  Wrap your
    application with it and it will warn about common problems with WSGI and
    HTTP while your application is running.

    It's strongly recommended to use it during development.

    :copyright: (c) 2013 by the Werkzeug Team, see AUTHORS for more details.
    :license: BSD, see LICENSE for more details.
"""
from urlparse import urlparse
from warnings import warn

from werkzeug.datastructures import Headers
from werkzeug.http import is_entity_header
from werkzeug.wsgi import FileWrapper
from werkzeug._compat import string_types


class WSGIWarning(Warning):
    """Warning class for WSGI warnings."""


class HTTPWarning(Warning):
    """Warning class for HTTP warnings."""


def check_string(context, obj, stacklevel=3):
    if type(obj) is not str:
        warn(WSGIWarning('%s requires bytestrings, got %s' %
            (context, obj.__class__.__name__)))


class InputStream(object):

    def __init__(self, stream):
        self._stream = stream

    def read(self, *args):
        if len(args) == 0:
            warn(WSGIWarning('wsgi does not guarantee an EOF marker on the '
                             'input stream, thus making calls to '
                             'wsgi.input.read() unsafe.  Conforming servers '
                             'may never return from this call.'),
                 stacklevel=2)
        elif len(args) != 1:
            warn(WSGIWarning('too many parameters passed to wsgi.input.read()'),
                 stacklevel=2)
        return self._stream.read(*args)

    def readline(self, *args):
        if len(args) == 0:
            warn(WSGIWarning('Calls to wsgi.input.readline() without arguments'
                             ' are unsafe.  Use wsgi.input.read() instead.'),
                 stacklevel=2)
        elif len(args) == 1:
            warn(WSGIWarning('wsgi.input.readline() was called with a size hint. '
                             'WSGI does not support this, although it\'s available '
                             'on all major servers.'),
                 stacklevel=2)
        else:
            raise TypeError('too many arguments passed to wsgi.input.readline()')
        return self._stream.readline(*args)

    def __iter__(self):
        try:
            return iter(self._stream)
        except TypeError:
            warn(WSGIWarning('wsgi.input is not iterable.'), stacklevel=2)
            return iter(())

    def close(self):
        warn(WSGIWarning('application closed the input stream!'),
             stacklevel=2)
        self._stream.close()


class ErrorStream(object):

    def __init__(self, stream):
        self._stream = stream

    def write(self, s):
        check_string('wsgi.error.write()', s)
        self._stream.write(s)

    def flush(self):
        self._stream.flush()

    def writelines(self, seq):
        for line in seq:
            self.write(seq)

    def close(self):
        warn(WSGIWarning('application closed the error stream!'),
             stacklevel=2)
        self._stream.close()


class GuardedWrite(object):

    def __init__(self, write, chunks):
        self._write = write
        self._chunks = chunks

    def __call__(self, s):
        check_string('write()', s)
        self._write.write(s)
        self._chunks.append(len(s))


class GuardedIterator(object):

    def __init__(self, iterator, headers_set, chunks):
        self._iterator = iterator
        self._next = iter(iterator).next
        self.closed = False
        self.headers_set = headers_set
        self.chunks = chunks

    def __iter__(self):
        return self

    def next(self):
        if self.closed:
            warn(WSGIWarning('iterated over closed app_iter'),
                 stacklevel=2)
        rv = self._next()
        if not self.headers_set:
            warn(WSGIWarning('Application returned before it '
                             'started the response'), stacklevel=2)
        check_string('application iterator items', rv)
        self.chunks.append(len(rv))
        return rv

    def close(self):
        self.closed = True
        if hasattr(self._iterator, 'close'):
            self._iterator.close()

        if self.headers_set:
            status_code, headers = self.headers_set
            bytes_sent = sum(self.chunks)
            content_length = headers.get('content-length', type=int)

            if status_code == 304:
                for key, value in headers:
                    key = key.lower()
                    if key not in ('expires', 'content-location') and \
                       is_entity_header(key):
                        warn(HTTPWarning('entity header %r found in 304 '
                            'response' % key))
                if bytes_sent:
                    warn(HTTPWarning('304 responses must not have a body'))
            elif 100 <= status_code < 200 or status_code == 204:
                if content_length != 0:
                    warn(HTTPWarning('%r responses must have an empty '
                                     'content length') % status_code)
                if bytes_sent:
                    warn(HTTPWarning('%r responses must not have a body' %
                                     status_code))
            elif content_length is not None and content_length != bytes_sent:
                warn(WSGIWarning('Content-Length and the number of bytes '
                                 'sent to the client do not match.'))

    def __del__(self):
        if not self.closed:
            try:
                warn(WSGIWarning('Iterator was garbage collected before '
                                 'it was closed.'))
            except Exception:
                pass


class LintMiddleware(object):
    """This middleware wraps an application and warns on common errors.
    Among other thing it currently checks for the following problems:

    -   invalid status codes
    -   non-bytestrings sent to the WSGI server
    -   strings returned from the WSGI application
    -   non-empty conditional responses
    -   unquoted etags
    -   relative URLs in the Location header
    -   unsafe calls to wsgi.input
    -   unclosed iterators

    Detected errors are emitted using the standard Python :mod:`warnings`
    system and usually end up on :data:`stderr`.

    ::

        from werkzeug.contrib.lint import LintMiddleware
        app = LintMiddleware(app)

    :param app: the application to wrap
    """

    def __init__(self, app):
        self.app = app

    def check_environ(self, environ):
        if type(environ) is not dict:
            warn(WSGIWarning('WSGI environment is not a standard python dict.'),
                 stacklevel=4)
        for key in ('REQUEST_METHOD', 'SERVER_NAME', 'SERVER_PORT',
                    'wsgi.version', 'wsgi.input', 'wsgi.errors',
                    'wsgi.multithread', 'wsgi.multiprocess',
                    'wsgi.run_once'):
            if key not in environ:
                warn(WSGIWarning('required environment key %r not found'
                     % key), stacklevel=3)
        if environ['wsgi.version'] != (1, 0):
            warn(WSGIWarning('environ is not a WSGI 1.0 environ'),
                 stacklevel=3)

        script_name = environ.get('SCRIPT_NAME', '')
        if script_name and script_name[:1] != '/':
            warn(WSGIWarning('SCRIPT_NAME does not start with a slash: %r'
                             % script_name), stacklevel=3)
        path_info = environ.get('PATH_INFO', '')
        if path_info[:1] != '/':
            warn(WSGIWarning('PATH_INFO does not start with a slash: %r'
                             % path_info), stacklevel=3)


    def check_start_response(self, status, headers, exc_info):
        check_string('status', status)
        status_code = status.split(None, 1)[0]
        if len(status_code) != 3 or not status_code.isdigit():
            warn(WSGIWarning('Status code must be three digits'), stacklevel=3)
        if len(status) < 4 or status[3] != ' ':
            warn(WSGIWarning('Invalid value for status %r.  Valid '
                             'status strings are three digits, a space '
                             'and a status explanation'), stacklevel=3)
        status_code = int(status_code)
        if status_code < 100:
            warn(WSGIWarning('status code < 100 detected'), stacklevel=3)

        if type(headers) is not list:
            warn(WSGIWarning('header list is not a list'), stacklevel=3)
        for item in headers:
            if type(item) is not tuple or len(item) != 2:
                warn(WSGIWarning('Headers must tuple 2-item tuples'),
                     stacklevel=3)
            name, value = item
            if type(name) is not str or type(value) is not str:
                warn(WSGIWarning('header items must be strings'),
                     stacklevel=3)
            if name.lower() == 'status':
                warn(WSGIWarning('The status header is not supported due to '
                                 'conflicts with the CGI spec.'),
                                 stacklevel=3)

        if exc_info is not None and not isinstance(exc_info, tuple):
            warn(WSGIWarning('invalid value for exc_info'), stacklevel=3)

        headers = Headers(headers)
        self.check_headers(headers)

        return status_code, headers

    def check_headers(self, headers):
        etag = headers.get('etag')
        if etag is not None:
            if etag.startswith('w/'):
                etag = etag[2:]
            if not (etag[:1] == etag[-1:] == '"'):
                warn(HTTPWarning('unquoted etag emitted.'), stacklevel=4)

        location = headers.get('location')
        if location is not None:
            if not urlparse(location).netloc:
                warn(HTTPWarning('absolute URLs required for location header'),
                     stacklevel=4)

    def check_iterator(self, app_iter):
        if isinstance(app_iter, string_types):
            warn(WSGIWarning('application returned string.  Response will '
                             'send character for character to the client '
                             'which will kill the performance.  Return a '
                             'list or iterable instead.'), stacklevel=3)

    def __call__(self, *args, **kwargs):
        if len(args) != 2:
            warn(WSGIWarning('Two arguments to WSGI app required'), stacklevel=2)
        if kwargs:
            warn(WSGIWarning('No keyword arguments to WSGI app allowed'),
                 stacklevel=2)
        environ, start_response = args

        self.check_environ(environ)
        environ['wsgi.input'] = InputStream(environ['wsgi.input'])
        environ['wsgi.errors'] = ErrorStream(environ['wsgi.errors'])

        # hook our own file wrapper in so that applications will always
        # iterate to the end and we can check the content length
        environ['wsgi.file_wrapper'] = FileWrapper

        headers_set = []
        chunks = []

        def checking_start_response(*args, **kwargs):
            if len(args) not in (2, 3):
                warn(WSGIWarning('Invalid number of arguments: %s, expected '
                     '2 or 3' % len(args), stacklevel=2))
            if kwargs:
                warn(WSGIWarning('no keyword arguments allowed.'))

            status, headers = args[:2]
            if len(args) == 3:
                exc_info = args[2]
            else:
                exc_info = None

            headers_set[:] = self.check_start_response(status, headers,
                                                       exc_info)
            return GuardedWrite(start_response(status, headers, exc_info),
                                chunks)

        app_iter = self.app(environ, checking_start_response)
        self.check_iterator(app_iter)
        return GuardedIterator(app_iter, headers_set, chunks)

import datetime
import os
import random
import re
import signal
import sys
import time

from patroni.exceptions import PatroniException

ignore_sigterm = False
interrupted_sleep = False
reap_children = False

_DATE_TIME_RE = re.compile(r'''^
(?P<year>\d{4})\-(?P<month>\d{2})\-(?P<day>\d{2})  # date
T
(?P<hour>\d{2}):(?P<minute>\d{2}):(?P<second>\d{2})\.(?P<microsecond>\d{6})  # time
\d*Z$''', re.X)


def parse_datetime(time_str):
    """
    >>> parse_datetime('2015-06-10T12:56:30.552539016Z')
    datetime.datetime(2015, 6, 10, 12, 56, 30, 552539)
    >>> parse_datetime('2015-06-10 12:56:30.552539016Z')
    """
    m = _DATE_TIME_RE.match(time_str)
    if not m:
        return None
    p = dict((n, int(m.group(n))) for n in 'year month day hour minute second microsecond'.split(' '))
    return datetime.datetime(**p)


def calculate_ttl(expiration):
    """
    >>> calculate_ttl(None)
    >>> calculate_ttl('2015-06-10 12:56:30.552539016Z')
    >>> calculate_ttl('2015-06-10T12:56:30.552539016Z') < 0
    True
    """
    if not expiration:
        return None
    expiration = parse_datetime(expiration)
    if not expiration:
        return None
    now = datetime.datetime.utcnow()
    return int((expiration - now).total_seconds())


def sigterm_handler(signo, stack_frame):
    global ignore_sigterm
    if not ignore_sigterm:
        ignore_sigterm = True
        sys.exit()


def sigchld_handler(signo, stack_frame):
    global interrupted_sleep, reap_children
    reap_children = interrupted_sleep = True


def sleep(interval):
    global interrupted_sleep
    current_time = time.time()
    end_time = current_time + interval
    while current_time < end_time:
        interrupted_sleep = False
        time.sleep(end_time - current_time)
        if not interrupted_sleep:  # we will ignore only sigchld
            break
        current_time = time.time()
    interrupted_sleep = False


def setup_signal_handlers():
    signal.signal(signal.SIGTERM, sigterm_handler)
    signal.signal(signal.SIGCHLD, sigchld_handler)


def reap_children():
    global reap_children
    if reap_children:
        try:
            while True:
                ret = os.waitpid(-1, os.WNOHANG)
                if ret == (0, 0):
                    break
        except OSError:
            pass
        finally:
            reap_children = False


class RetryFailedError(PatroniException):

    """Raised when retrying an operation ultimately failed, after retrying the maximum number of attempts."""


class Retry:

    """Helper for retrying a method in the face of retry-able exceptions"""

    def __init__(self, max_tries=1, delay=0.1, backoff=2, max_jitter=0.8, max_delay=3600,
                 sleep_func=sleep, deadline=None, retry_exceptions=PatroniException):
        """Create a :class:`Retry` instance for retrying function calls

        :param max_tries: How many times to retry the command. -1 means infinite tries.
        :param delay: Initial delay between retry attempts.
        :param backoff: Backoff multiplier between retry attempts. Defaults to 2 for exponential backoff.
        :param max_jitter: Additional max jitter period to wait between retry attempts to avoid slamming the server.
        :param max_delay: Maximum delay in seconds, regardless of other backoff settings. Defaults to one hour.
        :param retry_exceptions: single exception or tuple"""

        self.max_tries = max_tries
        self.delay = delay
        self.backoff = backoff
        self.max_jitter = int(max_jitter * 100)
        self.max_delay = float(max_delay)
        self._attempts = 0
        self._cur_delay = delay
        self.deadline = deadline
        self._cur_stoptime = None
        self.sleep_func = sleep_func
        self.retry_exceptions = retry_exceptions

    def reset(self):
        """Reset the attempt counter"""
        self._attempts = 0
        self._cur_delay = self.delay
        self._cur_stoptime = None

    def copy(self):
        """Return a clone of this retry manager"""
        return Retry(max_tries=self.max_tries, delay=self.delay, backoff=self.backoff,
                     max_jitter=self.max_jitter / 100.0, max_delay=self.max_delay, sleep_func=self.sleep_func,
                     deadline=self.deadline, retry_exceptions=self.retry_exceptions)

    def __call__(self, func, *args, **kwargs):
        """Call a function with arguments until it completes without throwing a `retry_exceptions`

        :param func: Function to call
        :param args: Positional arguments to call the function with
        :params kwargs: Keyword arguments to call the function with

        The function will be called until it doesn't throw one of the retryable exceptions"""
        self.reset()

        while True:
            try:
                if self.deadline is not None and self._cur_stoptime is None:
                    self._cur_stoptime = time.time() + self.deadline
                return func(*args, **kwargs)
            except self.retry_exceptions:
                # Note: max_tries == -1 means infinite tries.
                if self._attempts == self.max_tries:
                    raise RetryFailedError("Too many retry attempts")
                self._attempts += 1
                sleeptime = self._cur_delay + (random.randint(0, self.max_jitter) / 100.0)

                if self._cur_stoptime is not None and time.time() + sleeptime >= self._cur_stoptime:
                    raise RetryFailedError("Exceeded retry deadline")
                else:
                    self.sleep_func(sleeptime)
                self._cur_delay = min(self._cur_delay * self.backoff, self.max_delay)

"""
Django settings for sest_settings project.

Generated by 'django-admin startproject' using Django 1.10.4.

For more information on this file, see
https://docs.djangoproject.com/en/1.10/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.10/ref/settings/
"""

import os
from .secret_settings import *

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/

# secret key moved out in separate hidden-from-git file.

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = ['testserver', '127.0.0.1', "sest.gq", "www.sest.gq", "*"]


EMAIL_BACKEND = 'postmarker.django.EmailBackend'
MAX_NUMBER_FIELDS = 3


# Application definition

INSTALLED_APPS = [
    'sest.apps.SestConfig',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'sest_settings.urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'sest_settings.wsgi.application'


# Database
# https://docs.djangoproject.com/en/1.10/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}


# Password validation
# https://docs.djangoproject.com/en/1.10/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/1.10/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'CET'

USE_I18N = True

USE_L10N = True

USE_TZ = True


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.10/howto/static-files/

STATIC_URL = '/static/'

# -*- coding: utf-8 -*-


class Apiario:
    def __init__(self):
        self.ID = 0
        self.Nome = ""
        self.Posizione = ""

    def Aggiungi(self, db):
        cur = db.cursor()
        cur.execute("SELECT COUNT(*) FROM APIARI;")
        LastID = cur.fetchone()
        self.ID = LastID[0]
        valori = (self.ID, self.Nome, self.Posizione)
        cur.execute("INSERT INTO APIARI VALUES(?, ?, ?);", valori)
        db.commit()

    def Modifica(self, db):
        cur = db.cursor()
        cur.execute("UPDATE APIARI SET Nome=?, Posizione=? WHERE ID=?;",
                    (self.Nome, self.Posizione, self.ID))
        db.commit()

    def Elimina(self, db):
        cur = db.cursor()
        cur.execute("DELETE FROM APIARI WHERE ID=?;",
                    (self.ID, ))
        db.commit()

    def Elenca(self, db):
        cur = db.cursor()
        cur.execute("SELECT * FROM APIARI;")
        valori = cur.fetchall()
        return valori

    def InterfacciaAggiungi(self, db):
        print("Aggiungi un Apiario")
        print("===================\n\n")
        self.Nome = input("Nome -> ")
        self.Posizione = input("Posizione -> ")
        self.Aggiungi(db)

    def InterfacciaElenca(self, db):
        print("Elenco degli apiari")
        print("===================\n\n")
        valori = self.Elenca(db)
        print("+====+==============+==================================+")
        print("| ID |     Nome     |            Posizione             |")
        print("+====+==============+==================================+")
        for val in valori:
            print("|{:>4}|{:>13}|{:>34}|".format(val[0], val[1], val[2]))
        print("+====+==============+==================================+")

    def InterfacciaModifica(self, db):
        print("Modifica Apiario")
        print("================\n\n")
        self.InterfacciaElenca(db)
        self.ID = eval(input("ID apiario da modificare -> "))
        self.Nome = input("Nome -> ")
        self.Posizione = input("Posizione -> ")
        self.Modifica(db)

    def InterfacciaCancella(self, db):
        print("Cancella Apiario")
        print("================")
        self.InterfacciaElenca(db)
        self.ID = eval(input("ID Apiario da cancellare"))
        self.Elimina(db)

# -*- coding: utf-8 -*-
##############################################################################
#
# Copyright (c) 2008 JAILLET Simon - CrysaLEAD - www.crysalead.fr
#
# WARNING: This program as such is intended to be used by professional
# programmers who take the whole responsability of assessing all potential
# consequences resulting from its eventual inadequacies and bugs
# End users who are looking for a ready-to-use solution with commercial
# garantees and support are strongly adviced to contract a Free Software
# Service Company
#
# This program is Free Software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
#
##############################################################################
{
    'name': 'France - Accounting',
    'version': '1.1',
    'author': 'OpenERP SA',
    'website': 'http://www.openerp.com',
    'category': 'Localization/Account Charts',
    'description': """
This is the module to manage the accounting chart for France in OpenERP.
========================================================================

This module applies to companies based in France mainland. It doesn't apply to
companies based in the DOM-TOMs (Guadeloupe, Martinique, Guyane, Réunion, Mayotte).

This localisation module creates the VAT taxes of type 'tax included' for purchases
(it is notably required when you use the module 'hr_expense'). Beware that these
'tax included' VAT taxes are not managed by the fiscal positions provided by this
module (because it is complex to manage both 'tax excluded' and 'tax included'
scenarios in fiscal positions).

This localisation module doesn't properly handle the scenario when a France-mainland
company sells services to a company based in the DOMs. We could manage it in the
fiscal positions, but it would require to differentiate between 'product' VAT taxes
and 'service' VAT taxes. We consider that it is too 'heavy' to have this by default
in l10n_fr; companies that sell services to DOM-based companies should update the
configuration of their taxes and fiscal positions manually.

**Credits:** Sistheo, Zeekom, CrysaLEAD, Akretion and Camptocamp.
""",
    'depends': ['base_iban', 'account', 'account_chart', 'base_vat'],
    'data': [
        'views/report_l10nfrbilan.xml',
        'views/report_l10nfrresultat.xml',
        'l10n_fr_reports.xml',
        'fr_report.xml',
        'plan_comptable_general.xml',
        'l10n_fr_view.xml',
        'l10n_fr_wizard.xml',
        'fr_pcg_taxes.xml',
        'fr_tax.xml',
        'fr_fiscal_templates.xml',
        'security/ir.model.access.csv',
        'wizard/fr_report_bilan_view.xml',
        'wizard/fr_report_compute_resultant_view.xml',
    ],
    'test': ['test/l10n_fr_report.yml'],
    'demo': [],
    'auto_install': False,
    'installable': True,
}

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

import sys
import logging

from antlr4 import *
from antlr4.error.ErrorListener import ErrorListener

# This class will 'override' the actual ErrorListener
# It'll collect all errors in a file and save the file at:
# -> output/errors.txt
# Base code from:
# -> http://stackoverflow.com/a/32228598/4808919
class ParserErrorListener( ErrorListener ):
    # '..\web\static\parserErrors.log'
    logging.basicConfig(level=logging.ERROR, filename='static/parserErrors.log')
    sys.tracebacklimit = 0

    def __init__(self):
        super(ParserErrorListener, self).__init__()

    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
        #print msg
        logging.error(" Syntax error at line %s:%s.\nError: %s.", line, column, msg)
        #raise Exception(msg)

    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
        #print msg
        logging.error(" Ambiguity from %s to %s, is known: %s.", startIndex, stopIndex, exact)
        #raise Exception(msg)

    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
        #print msg
        logging.error(" Attempting Full Context from %s to %s.", startIndex, stopIndex)
        #raise Exception(msg)

    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
        #print msg
        logging.error(" Context Sensitivity from %s to %s prediction at %s", startIndex, stopIndex, prediction)
        #raise Exception(msg)

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import migrations, models
import lms.djangoapps.verify_student.models
import model_utils.fields
import xmodule_django.models
import django.db.models.deletion
import django.utils.timezone
from django.conf import settings


class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name='HistoricalVerificationDeadline',
            fields=[
                ('id', models.IntegerField(verbose_name='ID', db_index=True, auto_created=True, blank=True)),
                ('created', model_utils.fields.AutoCreatedField(default=django.utils.timezone.now, verbose_name='created', editable=False)),
                ('modified', model_utils.fields.AutoLastModifiedField(default=django.utils.timezone.now, verbose_name='modified', editable=False)),
                ('course_key', xmodule_django.models.CourseKeyField(help_text='The course for which this deadline applies', max_length=255, db_index=True)),
                ('deadline', models.DateTimeField(help_text='The datetime after which users are no longer allowed to submit photos for verification.')),
                ('history_id', models.AutoField(serialize=False, primary_key=True)),
                ('history_date', models.DateTimeField()),
                ('history_type', models.CharField(max_length=1, choices=[('+', 'Created'), ('~', 'Changed'), ('-', 'Deleted')])),
                ('history_user', models.ForeignKey(related_name='+', on_delete=django.db.models.deletion.SET_NULL, to=settings.AUTH_USER_MODEL, null=True)),
            ],
            options={
                'ordering': ('-history_date', '-history_id'),
                'get_latest_by': 'history_date',
                'verbose_name': 'historical verification deadline',
            },
        ),
        migrations.CreateModel(
            name='IcrvStatusEmailsConfiguration',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('change_date', models.DateTimeField(auto_now_add=True, verbose_name='Change date')),
                ('enabled', models.BooleanField(default=False, verbose_name='Enabled')),
                ('changed_by', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, editable=False, to=settings.AUTH_USER_MODEL, null=True, verbose_name='Changed by')),
            ],
            options={
                'ordering': ('-change_date',),
                'abstract': False,
            },
        ),
        migrations.CreateModel(
            name='InCourseReverificationConfiguration',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('change_date', models.DateTimeField(auto_now_add=True, verbose_name='Change date')),
                ('enabled', models.BooleanField(default=False, verbose_name='Enabled')),
                ('changed_by', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, editable=False, to=settings.AUTH_USER_MODEL, null=True, verbose_name='Changed by')),
            ],
            options={
                'ordering': ('-change_date',),
                'abstract': False,
            },
        ),
        migrations.CreateModel(
            name='SkippedReverification',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('course_id', xmodule_django.models.CourseKeyField(max_length=255, db_index=True)),
                ('created_at', models.DateTimeField(auto_now_add=True)),
            ],
        ),
        migrations.CreateModel(
            name='SoftwareSecurePhotoVerification',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('status', model_utils.fields.StatusField(default=b'created', max_length=100, verbose_name='status', no_check_for_status=True, choices=[(b'created', b'created'), (b'ready', b'ready'), (b'submitted', b'submitted'), (b'must_retry', b'must_retry'), (b'approved', b'approved'), (b'denied', b'denied')])),
                ('status_changed', model_utils.fields.MonitorField(default=django.utils.timezone.now, verbose_name='status changed', monitor='status')),
                ('name', models.CharField(max_length=255, blank=True)),
                ('face_image_url', models.URLField(max_length=255, blank=True)),
                ('photo_id_image_url', models.URLField(max_length=255, blank=True)),
                ('receipt_id', models.CharField(default=lms.djangoapps.verify_student.models.generateUUID, max_length=255, db_index=True)),
                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
                ('updated_at', models.DateTimeField(auto_now=True, db_index=True)),
                ('display', models.BooleanField(default=True, db_index=True)),
                ('submitted_at', models.DateTimeField(null=True, db_index=True)),
                ('reviewing_service', models.CharField(max_length=255, blank=True)),
                ('error_msg', models.TextField(blank=True)),
                ('error_code', models.CharField(max_length=50, blank=True)),
                ('photo_id_key', models.TextField(max_length=1024)),
                ('copy_id_photo_from', models.ForeignKey(blank=True, to='verify_student.SoftwareSecurePhotoVerification', null=True)),
                ('reviewing_user', models.ForeignKey(related_name='photo_verifications_reviewed', default=None, to=settings.AUTH_USER_MODEL, null=True)),
                ('user', models.ForeignKey(to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'ordering': ['-created_at'],
                'abstract': False,
            },
        ),
        migrations.CreateModel(
            name='VerificationCheckpoint',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('course_id', xmodule_django.models.CourseKeyField(max_length=255, db_index=True)),
                ('checkpoint_location', models.CharField(max_length=255)),
                ('photo_verification', models.ManyToManyField(to='verify_student.SoftwareSecurePhotoVerification')),
            ],
        ),
        migrations.CreateModel(
            name='VerificationDeadline',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('created', model_utils.fields.AutoCreatedField(default=django.utils.timezone.now, verbose_name='created', editable=False)),
                ('modified', model_utils.fields.AutoLastModifiedField(default=django.utils.timezone.now, verbose_name='modified', editable=False)),
                ('course_key', xmodule_django.models.CourseKeyField(help_text='The course for which this deadline applies', unique=True, max_length=255, db_index=True)),
                ('deadline', models.DateTimeField(help_text='The datetime after which users are no longer allowed to submit photos for verification.')),
            ],
            options={
                'abstract': False,
            },
        ),
        migrations.CreateModel(
            name='VerificationStatus',
            fields=[
                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
                ('status', models.CharField(db_index=True, max_length=32, choices=[(b'submitted', b'submitted'), (b'approved', b'approved'), (b'denied', b'denied'), (b'error', b'error')])),
                ('timestamp', models.DateTimeField(auto_now_add=True)),
                ('response', models.TextField(null=True, blank=True)),
                ('error', models.TextField(null=True, blank=True)),
                ('checkpoint', models.ForeignKey(related_name='checkpoint_status', to='verify_student.VerificationCheckpoint')),
                ('user', models.ForeignKey(to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'get_latest_by': 'timestamp',
                'verbose_name': 'Verification Status',
                'verbose_name_plural': 'Verification Statuses',
            },
        ),
        migrations.AddField(
            model_name='skippedreverification',
            name='checkpoint',
            field=models.ForeignKey(related_name='skipped_checkpoint', to='verify_student.VerificationCheckpoint'),
        ),
        migrations.AddField(
            model_name='skippedreverification',
            name='user',
            field=models.ForeignKey(to=settings.AUTH_USER_MODEL),
        ),
        migrations.AlterUniqueTogether(
            name='verificationcheckpoint',
            unique_together=set([('course_id', 'checkpoint_location')]),
        ),
        migrations.AlterUniqueTogether(
            name='skippedreverification',
            unique_together=set([('user', 'course_id')]),
        ),
    ]

# GUI Application automation and testing library
# Copyright (C) 2006 Mark Mc Mahon
#
# This library is free software; you can redistribute it and/or 
# modify it under the terms of the GNU Lesser General Public License 
# as published by the Free Software Foundation; either version 2.1 
# of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful, 
# but WITHOUT ANY WARRANTY; without even the implied warranty of 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
# See the GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public 
# License along with this library; if not, write to the 
#    Free Software Foundation, Inc.,
#    59 Temple Place,
#    Suite 330, 
#    Boston, MA 02111-1307 USA 

#import set
from Test_RepeatedHotkey import GetHotkey

controls = (
	"&Hello",
	"&Exit",
	"&OK",
	"&Python",
	"&Ion Trail",
	"&Galaxy Quest",
	"&Xenon",
	"&Sierra",
	"&Zope",
	"&Sizzling",
	"Here &and Now",
	"&Later maybe",
	"&Scram",
	"Wo&w",
	"What is T&HAT",
	"&Mercury",
	"&Venus",
	"&Earth",
	"M&ercury",
	"Ven&us",
	"Ea&rth",
	"&Mercury",
	"&OK",
	"&Python",
	"&Ion Trail",
	"&Galaxy Quest",
	)


charIndex = {}
hotkeyCtrls = {}
allChars = set()
for ctrl in controls:
	# try to build up information on the dialog first
	# e.g. if it's possible to fix at all
	# any controls that have a unique character
	
	hotkeyCtrls.setdefault(GetHotkey(ctrl)[1].lower(), []).append(ctrl)
	allChars = allChars.union(set(ctrl.lower()))
	
	for c in ctrl:
		if c in ' _&': continue
		
		charIndex.setdefault(c.lower(), []).append(ctrl)


allChars.difference_update(" _&")

freeChars = allChars.difference(hotkeyCtrls.keys())
print freeChars


for c in hotkeyCtrls:
	print c
	for ctrl in hotkeyCtrls[c]:
		print "\t", ctrl

if len(allChars) < len(controls):
	print "impossible to fix completely because there are more hotkeys then individual characters in the dialog"
	print "the following characters are free:"
	
	#for c in freeChars:
	#	print "\t%s"% c
	#	for ctrl in charIndex[c]:
	#		print "\t\t%s" % ctrl
			
	usedChars = hotkeyCtrls.keys()
	
	changesMade = 1
	while changesMade:
		changesMade = 0
		
		for char, ctrls in charIndex.items():

			# if there is only one control that has this character
			if len (ctrls) == 1:
				# get the control
				ctrl = ctrls[0]
				
				# find the hotkey for that control
				ctrlHotkey = GetHotkey(ctrl)[1].lower()
				
				print ctrlHotkey, `ctrl`
				# remove the control from the list
				hotkeyCtrls[ctrlHotkey].remove(ctrl)
				
				# if there are now now controls for that hotkey
				# remove it
				if len(hotkeyCtrls[ctrlHotkey]) == 0:
					del(hotkeyCtrls[ctrlHotkey])
				
				# add the new changed one to the hotkeys
				hotkeyCtrls.setdefault(char, []).append(ctrl)
				changesMade = 1
else:
	

	for hotkey, ctrls in hotkeyCtrls.items():
		if len(ctrls) > 1:
			for ctrl in ctrls:
				ctrlChars = set(ctrl.lower()).difference(" &_")
				if freeChars.intersection(ctrlChars):
					
	


print "="*100

for c in hotkeyCtrls:
	print c
	for ctrl in hotkeyCtrls[c]:
		print "\t", ctrl

	
	

#for x in charIndex:
#	print x, charIndex[x]
	
for hotkey, ctrls in hotkeyCtrls.items():
	if len(ctrls) > 1:
		print "***** BUG *****"
		print "\t", hotkey, ctrls
		
		# find the chars free for each control
		ctrlFree = []
		for ctrl in ctrls:
			ctrlFree.append("".join(set(ctrl.lower()).intersection(freeChars)))
		
		# count the controls with no hotkey free
		countNotFree = len([c for c in ctrlFree if not c])
		if countNotFree > 1:
			print "Cannot be fixed without possibly changing other controls also"
		
		for i, free in enumerate(ctrlFree):
			if not free:
				print "Must leave '%s' alone" %ctrls[i]
		
		

	
	
	



import sys
sys.exit()

#================================================
#================================================
#================================================
#================================================
#================================================







	
# return the controls that have characters in common with
# the control
def GetCtrlsWithSameChars(ctrl, controls):
	ourChars = set(ctrl.lower())
	ourChars.difference_update("& _")
	
	toRet = []
	for control in controls:
		ctrlChars = set(control.lower())
	
		if ourChars.intersection(ctrlChars):
			toRet.append(control)
	
	return toRet


def GetFreeCharsForControls(allFree, controls):
	ctrlFree = []
	allCtrlsFree = []
	for ctrl in controls:
		curCtrlFree = set(ctrl.lower()).intersection(allFree)
		ctrlFree.append("".join(curCtrlFree))
		
		allCtrlsFree.extend(curCtrlFree)
	
	return ctrlFree, "".join(allCtrlsFree)
	
	
	
charIndex = {}
hotkeyCtrls = {}
for c in controls:
	hotkeyCtrls.setdefault(GetHotkey(c)[1].lower(), []).append(c)
	
	for char in c.lower():
		charIndex.setdefault(char, []).append(c)
	
	

hotkeys = set(hotkeyCtrls.keys())
allKeys = set("".join(controls).lower())
allKeys.difference_update("& _")

freeKeys = allKeys.difference(hotkeys)

print len(controls)
if len(controls) > len(allKeys):
	print "**** Oops - more hotkeys than available characters :-( "
	


	

	
for hotkey, ctrls in hotkeyCtrls.items():
	if len(ctrls) > 1:
		print "**bug**"
		
		# can it be fixed simply by changing one or more of the controls
		# to another character within these controls
		
		ctrlsFreeChars, allFree = GetFreeCharsForControls(freeKeys, ctrls)
		
		# find out if we can use this method (0 or 1 controls with no free characters)
		noFreeCount = 0
		for i, ctrl in enumerate(ctrls):
			if not ctrlsFreeChars[i]:
				noFreeCount += 1
		
		# ok - so more than one control has no free chars - can't use the 
		# simple method
		if noFreeCount > 1:
			print "cant use that method"
			continue
		
		if noFreeCount == 0:
			extraText = ' or leave the same'
		else:
			extraText = ''
		
		for i, ctrl in enumerate(ctrls):
			if len(ctrlsFreeChars[i]) > 1:
				print "Change '%s' to one of (%s)%s"% (ctrl, "".join(ctrlsFreeChars[i]), extraText)
			elif len(ctrlsFreeChars[i]) == 1:
				print "Change '%s' to %s%s"% (ctrl, "".join(ctrlsFreeChars[i]), extraText)
			else:
				print "do not change %s" % ctrl
		
		
#		
#		for curCtrl in ctrls:
#			# Get the letters that could be used
#			ctrlAvl = set(curCtrl.lower()).intersection(freeKeys)
#			
#			#changesNeeded = ''
#			
#			# if there are no free letters in that control
#			# try and find if any other control could have it's 
#			# hotkey changed to free up for ourself
#			if len(ctrlAvl) == 0:
#			
#				# get the controls that share some letters		
#				otherCtrls = GetCtrlsWithSameChars(c, controls)
#				
#				suggestedChanges = []
#				# check if any of the letters in those controls can be freed up
#				for otherCtrl in otherCtrls:
#					if GetHotkey(otherCtrl)[1].lower() == hotkey:
#					freeOther = set(otherCtrl.lower()).intersection(freeKeys)
#					
#					if freeOther:
#						print "To Fix %s Free %s in %s by changing to any of (%s)"%(curCtrl, GetHotkey(otherCtrl)[1], otherCtrl, "".join(freeOther))
#			
#			
#			
##				posChange = set(c.lower()).intersection(allKeys)
##				changesNeeded = "".join(posChange)
##				
##				for char in posChange:
##					# get the controls that have that character
##					otherCtrls = charIndex[char]
##					
#			else:
#				print "To fix %s change %s to any of (%s)"% (curCtrl, c, "".join(ctrlAvl))
#				
#				
			
		#print "bug", ctrls, "".join(freeKeys)


# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Dispatches tests, either sharding or replicating them.

Performs the following steps:
* Create a test collection factory, using the given tests
  - If sharding: test collection factory returns the same shared test collection
    to all test runners
  - If replciating: test collection factory returns a unique test collection to
    each test runner, with the same set of tests in each.
* Create a test runner for each device.
* Run each test runner in its own thread, grabbing tests from the test
  collection until there are no tests left.
"""

import logging
import threading

from pylib import android_commands
from pylib import constants
from pylib.base import base_test_result
from pylib.device import device_errors
from pylib.utils import reraiser_thread
from pylib.utils import watchdog_timer


DEFAULT_TIMEOUT = 7 * 60  # seven minutes


class _ThreadSafeCounter(object):
  """A threadsafe counter."""

  def __init__(self):
    self._lock = threading.Lock()
    self._value = 0

  def GetAndIncrement(self):
    """Get the current value and increment it atomically.

    Returns:
      The value before incrementing.
    """
    with self._lock:
      pre_increment = self._value
      self._value += 1
      return pre_increment


class _Test(object):
  """Holds a test with additional metadata."""

  def __init__(self, test, tries=0):
    """Initializes the _Test object.

    Args:
      test: The test.
      tries: Number of tries so far.
    """
    self.test = test
    self.tries = tries


class _TestCollection(object):
  """A threadsafe collection of tests.

  Args:
    tests: List of tests to put in the collection.
  """

  def __init__(self, tests=None):
    if not tests:
      tests = []
    self._lock = threading.Lock()
    self._tests = []
    self._tests_in_progress = 0
    # Used to signal that an item is available or all items have been handled.
    self._item_available_or_all_done = threading.Event()
    for t in tests:
      self.add(t)

  def _pop(self):
    """Pop a test from the collection.

    Waits until a test is available or all tests have been handled.

    Returns:
      A test or None if all tests have been handled.
    """
    while True:
      # Wait for a test to be available or all tests to have been handled.
      self._item_available_or_all_done.wait()
      with self._lock:
        # Check which of the two conditions triggered the signal.
        if self._tests_in_progress == 0:
          return None
        try:
          return self._tests.pop(0)
        except IndexError:
          # Another thread beat us to the available test, wait again.
          self._item_available_or_all_done.clear()

  def add(self, test):
    """Add an test to the collection.

    Args:
      test: A test to add.
    """
    with self._lock:
      self._tests.append(test)
      self._item_available_or_all_done.set()
      self._tests_in_progress += 1

  def test_completed(self):
    """Indicate that a test has been fully handled."""
    with self._lock:
      self._tests_in_progress -= 1
      if self._tests_in_progress == 0:
        # All tests have been handled, signal all waiting threads.
        self._item_available_or_all_done.set()

  def __iter__(self):
    """Iterate through tests in the collection until all have been handled."""
    while True:
      r = self._pop()
      if r is None:
        break
      yield r

  def __len__(self):
    """Return the number of tests currently in the collection."""
    return len(self._tests)

  def test_names(self):
    """Return a list of the names of the tests currently in the collection."""
    with self._lock:
      return list(t.test for t in self._tests)


def _RunTestsFromQueue(runner, test_collection, out_results, watcher,
                       num_retries, tag_results_with_device=False):
  """Runs tests from the test_collection until empty using the given runner.

  Adds TestRunResults objects to the out_results list and may add tests to the
  out_retry list.

  Args:
    runner: A TestRunner object used to run the tests.
    test_collection: A _TestCollection from which to get _Test objects to run.
    out_results: A list to add TestRunResults to.
    watcher: A watchdog_timer.WatchdogTimer object, used as a shared timeout.
    num_retries: Number of retries for a test.
    tag_results_with_device: If True, appends the name of the device on which
        the test was run to the test name. Used when replicating to identify
        which device ran each copy of the test, and to ensure each copy of the
        test is recorded separately.
  """

  def TagTestRunResults(test_run_results):
    """Tags all results with the last 4 digits of the device id.

    Used when replicating tests to distinguish the same tests run on different
    devices. We use a set to store test results, so the hash (generated from
    name and tag) must be unique to be considered different results.
    """
    new_test_run_results = base_test_result.TestRunResults()
    for test_result in test_run_results.GetAll():
      test_result.SetName('%s_%s' % (runner.device_serial[-4:],
                                     test_result.GetName()))
      new_test_run_results.AddResult(test_result)
    return new_test_run_results

  for test in test_collection:
    watcher.Reset()
    try:
      if runner.device_serial not in android_commands.GetAttachedDevices():
        # Device is unresponsive, stop handling tests on this device.
        msg = 'Device %s is unresponsive.' % runner.device_serial
        logging.warning(msg)
        raise device_errors.DeviceUnreachableError(msg)
      result, retry = runner.RunTest(test.test)
      if tag_results_with_device:
        result = TagTestRunResults(result)
      test.tries += 1
      if retry and test.tries <= num_retries:
        # Retry non-passing results, only record passing results.
        pass_results = base_test_result.TestRunResults()
        pass_results.AddResults(result.GetPass())
        out_results.append(pass_results)
        logging.warning('Will retry test, try #%s.' % test.tries)
        test_collection.add(_Test(test=retry, tries=test.tries))
      else:
        # All tests passed or retry limit reached. Either way, record results.
        out_results.append(result)
    except:
      # An unhandleable exception, ensure tests get run by another device and
      # reraise this exception on the main thread.
      test_collection.add(test)
      raise
    finally:
      # Retries count as separate tasks so always mark the popped test as done.
      test_collection.test_completed()


def _SetUp(runner_factory, device, out_runners, threadsafe_counter):
  """Creates a test runner for each device and calls SetUp() in parallel.

  Note: if a device is unresponsive the corresponding TestRunner will not be
    added to out_runners.

  Args:
    runner_factory: Callable that takes a device and index and returns a
      TestRunner object.
    device: The device serial number to set up.
    out_runners: List to add the successfully set up TestRunner object.
    threadsafe_counter: A _ThreadSafeCounter object used to get shard indices.
  """
  try:
    index = threadsafe_counter.GetAndIncrement()
    logging.warning('Creating shard %s for device %s.', index, device)
    runner = runner_factory(device, index)
    runner.SetUp()
    out_runners.append(runner)
  except (device_errors.DeviceUnreachableError,
          # TODO(jbudorick) Remove this once the underlying implementations
          #                 for the above are switched or wrapped.
          android_commands.errors.DeviceUnresponsiveError) as e:
    logging.warning('Failed to create shard for %s: [%s]', device, e)


def _RunAllTests(runners, test_collection_factory, num_retries, timeout=None,
                 tag_results_with_device=False):
  """Run all tests using the given TestRunners.

  Args:
    runners: A list of TestRunner objects.
    test_collection_factory: A callable to generate a _TestCollection object for
        each test runner.
    num_retries: Number of retries for a test.
    timeout: Watchdog timeout in seconds.
    tag_results_with_device: If True, appends the name of the device on which
        the test was run to the test name. Used when replicating to identify
        which device ran each copy of the test, and to ensure each copy of the
        test is recorded separately.

  Returns:
    A tuple of (TestRunResults object, exit code)
  """
  logging.warning('Running tests with %s test runners.' % (len(runners)))
  results = []
  exit_code = 0
  run_results = base_test_result.TestRunResults()
  watcher = watchdog_timer.WatchdogTimer(timeout)
  test_collections = [test_collection_factory() for _ in runners]

  threads = [
      reraiser_thread.ReraiserThread(
          _RunTestsFromQueue,
          [r, tc, results, watcher, num_retries, tag_results_with_device],
          name=r.device_serial[-4:])
      for r, tc in zip(runners, test_collections)]

  workers = reraiser_thread.ReraiserThreadGroup(threads)
  workers.StartAll()

  # Catch DeviceUnreachableErrors and set a warning exit code
  try:
    workers.JoinAll(watcher)
  except (device_errors.DeviceUnreachableError,
          # TODO(jbudorick) Remove this once the underlying implementations
          #                 for the above are switched or wrapped.
          android_commands.errors.DeviceUnresponsiveError) as e:
    logging.error(e)
    exit_code = constants.WARNING_EXIT_CODE

  if not all((len(tc) == 0 for tc in test_collections)):
    logging.error('Only ran %d tests (all devices are likely offline).' %
                  len(results))
    for tc in test_collections:
      run_results.AddResults(base_test_result.BaseTestResult(
          t, base_test_result.ResultType.UNKNOWN) for t in tc.test_names())

  for r in results:
    run_results.AddTestRunResults(r)
  if not run_results.DidRunPass():
    exit_code = constants.ERROR_EXIT_CODE
  return (run_results, exit_code)


def _CreateRunners(runner_factory, devices, timeout=None):
  """Creates a test runner for each device and calls SetUp() in parallel.

  Note: if a device is unresponsive the corresponding TestRunner will not be
    included in the returned list.

  Args:
    runner_factory: Callable that takes a device and index and returns a
      TestRunner object.
    devices: List of device serial numbers as strings.
    timeout: Watchdog timeout in seconds, defaults to the default timeout.

  Returns:
    A list of TestRunner objects.
  """
  logging.warning('Creating %s test runners.' % len(devices))
  runners = []
  counter = _ThreadSafeCounter()
  threads = reraiser_thread.ReraiserThreadGroup(
      [reraiser_thread.ReraiserThread(_SetUp,
                                      [runner_factory, d, runners, counter],
                                      name=d[-4:])
       for d in devices])
  threads.StartAll()
  threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))
  return runners


def _TearDownRunners(runners, timeout=None):
  """Calls TearDown() for each test runner in parallel.

  Args:
    runners: A list of TestRunner objects.
    timeout: Watchdog timeout in seconds, defaults to the default timeout.
  """
  threads = reraiser_thread.ReraiserThreadGroup(
      [reraiser_thread.ReraiserThread(r.TearDown, name=r.device_serial[-4:])
       for r in runners])
  threads.StartAll()
  threads.JoinAll(watchdog_timer.WatchdogTimer(timeout))


def RunTests(tests, runner_factory, devices, shard=True,
             test_timeout=DEFAULT_TIMEOUT, setup_timeout=DEFAULT_TIMEOUT,
             num_retries=2):
  """Run all tests on attached devices, retrying tests that don't pass.

  Args:
    tests: List of tests to run.
    runner_factory: Callable that takes a device and index and returns a
        TestRunner object.
    devices: List of attached devices.
    shard: True if we should shard, False if we should replicate tests.
      - Sharding tests will distribute tests across all test runners through a
        shared test collection.
      - Replicating tests will copy all tests to each test runner through a
        unique test collection for each test runner.
    test_timeout: Watchdog timeout in seconds for running tests.
    setup_timeout: Watchdog timeout in seconds for creating and cleaning up
        test runners.
    num_retries: Number of retries for a test.

  Returns:
    A tuple of (base_test_result.TestRunResults object, exit code).
  """
  if not tests:
    logging.critical('No tests to run.')
    return (base_test_result.TestRunResults(), constants.ERROR_EXIT_CODE)

  if shard:
    # Generate a shared _TestCollection object for all test runners, so they
    # draw from a common pool of tests.
    shared_test_collection = _TestCollection([_Test(t) for t in tests])
    test_collection_factory = lambda: shared_test_collection
    tag_results_with_device = False
    log_string = 'sharded across devices'
  else:
    # Generate a unique _TestCollection object for each test runner, but use
    # the same set of tests.
    test_collection_factory = lambda: _TestCollection([_Test(t) for t in tests])
    tag_results_with_device = True
    log_string = 'replicated on each device'

  logging.info('Will run %d tests (%s): %s', len(tests), log_string, str(tests))
  runners = _CreateRunners(runner_factory, devices, setup_timeout)
  try:
    return _RunAllTests(runners, test_collection_factory,
                        num_retries, test_timeout, tag_results_with_device)
  finally:
    try:
      _TearDownRunners(runners, setup_timeout)
    except (device_errors.DeviceUnreachableError,
            # TODO(jbudorick) Remove this once the underlying implementations
            #                 for the above are switched or wrapped.
            android_commands.errors.DeviceUnresponsiveError) as e:
      logging.warning('Device unresponsive during TearDown: [%s]', e)
    except Exception as e:
      logging.error('Unexpected exception caught during TearDown: %s' % str(e))

import math
import numpy as np
import matplotlib
matplotlib.use('SVG')

import matplotlib.pyplot as plt


fig, ax = plt.subplots()

N = 5
M = 6
h = 1. / M

grid = [(h * i, h * j) for i in range(0, M + 1) for j in range(0, N + 1)]

sx, sy = zip(*grid)
ax.scatter(sx, sy, marker='+')

boundary = [(0, h * j) for j in range(1, N + 1)] + [(1., h * j) for j in range(1, N + 1)]
ax.scatter(*zip(*boundary), marker='s')

outside= [(-h, h * j) for j in range(0, N + 1)] + [(1. + h, h * j) for j in range(0, N + 1)]
ax.scatter(*zip(*outside), marker='*', color='gray')

initial = [(h * i, 0) for i in range(0, M + 1)]
ax.scatter(*zip(*initial), marker='D')

xi, ti = h * 2, h * 2

stencil = [(xi, ti), (xi - h, ti - h), (xi, ti - h), (xi + h, ti - h)]
stx, sty = zip(*stencil)
ax.scatter(stx, sty, marker='o')

stencil_labels = ['$(x_k, t_{i+1})$', '$(x_{k -1}, t_{i})$', '$(x_{k}, t_{i})$', '$(x_{k + 1}, t_{i})$']
for i in range(len(stencil)):
    x, y = stencil[i]
    ax.annotate(stencil_labels[i], xy=stencil[i], xytext=(x + 0.01, y + (- 0.05 if (i > 0) else 0.03)))

for i in range(1, len(stencil)):
    x, y = stencil[i]
    xx, yy = stencil[0]
    dx = xx - x
    dy = yy - y
    ax.annotate("", xy=(xx - dx * 0.1, yy - dy * 0.1), xytext=(x + dx * 0.1, y + dy * 0.1),
                arrowprops=dict(arrowstyle="-|>", color='black'))

# boundary stencil
xi, ti = h * M, h * 2

stencil = [(xi, ti), (xi - h, ti - h), (xi, ti - h), (xi + h, ti - h)]
stx, sty = zip(*stencil)
ax.scatter(stx[1:2], sty[1:2], marker='o')

stencil_labels = ['$(x_{M+1}, t_{i+1})$', '$(x_{M}, t_{i})$', '$(x_{M+1}, t_{i})$', '$(x_{M+2}, t_{i})$']
for i in range(len(stencil)):
    x, y = stencil[i]
    ax.annotate(stencil_labels[i], xy=stencil[i], xytext=(x + 0.01, y + (- 0.05 if (i > 0) else 0.03)), color=('gray' if i == 3 else 'black'))

for i in range(1, len(stencil)):
    x, y = stencil[i]
    xx, yy = stencil[0]
    dx = xx - x
    dy = yy - y
    ax.annotate("", xy=(xx - dx * 0.1, yy - dy * 0.1), xytext=(x + dx * 0.1, y + dy * 0.1),
                arrowprops=dict(arrowstyle="-|>", linestyle=('dashed' if i == 3 else 'solid'), color=('gray' if i == 3 else 'black')))

ax.spines['right'].set_visible(False)
ax.spines['top'].set_visible(False)
ax.spines['left'].set_position('zero')
ax.spines['bottom'].set_position('zero')
ax.xaxis.set_ticks_position('none')
ax.yaxis.set_ticks_position('none')

ax.set_xticks([h * i for i in range(0, M + 1)])
ax.set_xticklabels(["$x_{}$".format(i + 1) for i in range(M+1)])
ax.set_yticks([h * i for i in range(0, N + 1)])
ax.set_yticklabels(["$t_{}$".format(i) for i in range(N+1)])

ax.spines['bottom'].set_bounds(-0.01, 1.01)
ax.spines['left'].set_bounds(-0.01, N * h + 0.01)
ax.set_xlim((0 - 0.05 - h, 1 + 0.05 + h))
ax.set_ylim((0 - 0.05, N * h + 0.05))
ax.set_xlabel('$x$', rotation=0)
ax.xaxis.set_label_coords(1.0, -0.025)
ax.set_ylabel('$t$', rotation=0)
ax.yaxis.set_label_coords(-0.025, 1.0)

plt.savefig('../img/fdm-neumann.svg')
# plt.show()

#!/usr/bin/env python

'''
 written by Rose A. Finn on 2/3/2013

 GOAL:
    - create a mastertable for each LCS cluster that uses the NASA-Sloan atlas as the parent sample 
 
 METHOD:
    - match NSA to 24-micron apex catalog
    - pull AGC data (NSA contains AGC number)
    - match with galaxy zoo info
    - append new columns using atpy
    - write out new table using atpy
 
 UPDATES:
 
 2015/07/13

 this program is only used to calculate local density and write out local density files
 
'''
 
 
 
 


from pylab import *
import os, atpy
from LCScommon import *

#import ReadAGCsav
from pyraf import iraf
import mystuff as my
import argparse

parser=argparse.ArgumentParser()
parser.add_argument('-v',"--velocitycut",help='velocity cut to use when calculating local density.  Galaxies within +/- vcut will be used.  Default value is 1500 km/s.',default=1500.,type=float)

args = parser.parse_args()


class cluster:
    def __init__(self,clustername):
        self.prefix=clustername
        self.image24=homedir+'research/LocalClusters/Images/'+self.prefix+'/24um/Full'+self.prefix+'ch1rf_mosaic_minus_median_extract.fits'
        self.noise24=homedir+'research/LocalClusters/Images/'+self.prefix+'/24um/Full'+self.prefix+'ch1rf_mosaic_unc.fits'
        if (clustername.find('A1367') > -1):
            self.image24='/home/rfinn/research/LocalClusters/Images/'+self.prefix+'/24um/'+self.prefix+'ch1r1_mosaic_minus_median_extract.fits'
            self.noise24='/home/rfinn/research/LocalClusters/Images/'+self.prefix+'/24um/'+self.prefix+'ch1r1_mosaic_unc.fits'
        elif (clustername.find('Herc')>-1):#for Abell 1367 and Hercules cluster
            self.image24='/home/rfinn/research/LocalClusters/Images/'+self.prefix+'/24um/'+self.prefix+'ch1r1_mosaic_minus_median_extract.fits'
            self.noise24='/home/rfinn/research/LocalClusters/Images/'+self.prefix+'/24um/'+self.prefix+'ch1r1_mosaic_unc.fits'

        # read NSA table for each cluster
        infile=homedir+'research/NSA/'+self.prefix+'_NSA.Fits'
        self.ndat=atpy.Table(infile,type='fits')
        self.nsadir=homedir+'research/NSA/'

        self.cra=clusterRA[self.prefix]
        self.cdec=clusterDec[self.prefix]
        self.cz=clusterz[self.prefix] 
        self.biweightvel=clusterbiweightcenter[self.prefix]
        self.biweightscale=clusterbiweightscale[self.prefix]
        self.r200=2.02*(self.biweightscale)/1000./sqrt(OmegaL+OmegaM*(1.+self.cz)**3)*H0/70. # in Mpc
        self.r200deg=self.r200*1000./my.DA(self.cz,h)/3600.

        self.cdMpc=self.biweightvel/H0
        self.cdcm=self.cdMpc*3.e24
        self.csigma=self.biweightscale
        self.mcl=my.clusterMass(self.csigma,self.cz,h)
        self.AngDistance=my.DA(self.cz,h)

    def geton24imageflag(self):
        iraf.imgets(image=self.image24,param='CD1_1')#get x plate scale on rotated image
        #print iraf.imgets.value
        xplate=abs(float(iraf.imgets.value))#deg/pixel
        dpix=deltaCutout/3600./xplate/2. # requires a 50 arcsec buffer b/w center of galaxy and edge of image
        iraf.imgets(image=self.image24,param='naxis1')#get x value corresponding to RA 
        xpixmax=(int(iraf.imgets.value))#deg/pixel
        iraf.imgets(image=self.image24,param='naxis2')#get x value corresponding to RA 
        ypixmax=(int(iraf.imgets.value))#deg/pixel

        # write RA and Dec to ascii file
        t = atpy.Table()
        t.add_column('RA',self.ndat.RA)
        t.add_column('DEC',self.ndat.DEC)
        outfile=self.nsadir+self.prefix+'_RADEC.txt'
        out1=open(outfile,'w')
        for i in range(len(self.ndat.RA)):
            s='%12.8f %12.8f \n'%(self.ndat.RA[i],self.ndat.DEC[i])
            out1.write(s)
        out1.close()
        
        # transform RA and Dec to pixels using wcsctran
        print 'transforming 24um coords'
        outcoords=self.nsadir+str(self.prefix)+'xy24.txt'
        if os.path.exists(outcoords):
            os.remove(outcoords)
        iraf.imcoords.wcsctran(image=self.image24,input=outfile,output=outcoords,inwcs='world',outwcs='logical',verbose='no')

        # read in pixel coordinates
        self.mipscoords=atpy.Table(outcoords,type='ascii')
        x=self.mipscoords['col1']
        y=self.mipscoords['col2']
        self.On24ImageFlag= (x > dpix) & (x < (xpixmax-dpix)) & (y > dpix) & (y < (ypixmax-dpix))  

        print self.prefix,': # on 24um image = ',sum(self.On24ImageFlag)
        # check to see if pixels are off image and set flag accordingly

    def localdensity5(self):
        # get local density by summing mass w/in 300 kpc
        # NOTE:
        #  - this measure will be unreliable for galaxies near the edge of the 3 deg area
        #  - this will be fine for galaxies on 24um image
        sdssflag=self.ndat.ISDSS > -1
        DA=self.AngDistance
        x=self.ndat.RA
        y=self.ndat.DEC
        xref=self.ndat.RA[sdssflag]
        yref=self.ndat.DEC[sdssflag]
        n1=6
        sigma5=zeros(len(x),'d')
        sigma10=zeros(len(x),'d')
        for i in range(len(x)):
            deltav=abs(self.ndat.ZDIST[sdssflag]-self.ndat.ZDIST[i])*3.e5
            d=sqrt((x[i]-xref)**2+(y[i]-yref)**2)*3600./1000.*DA#d in Mpc
            vflag = deltav < args.velocitycut
            #print i,sum(vflag)
            d=d[vflag]#apply a velocity cut of +/- 1500 km/s
            d.sort()#sort in ascending order, zeroth element is distance from galaxy to itself
            sig=0
            if len(d) < n1:
                print 'not enough points to calculate local density'
                print 'only have ',len(d),' galaxies w/in 1500 km/s'
                print 'skipping to next entry'
                continue
            else:
                sigma5[i]=1./(4.*pi)*(1.*5)/(d[5])**2
            try:
                sigma10[i]=1./(4.*pi)*(1.*10)/(d[10])**2
            except IndexError:
                continue
        self.sigma_5=sigma5
        self.sigma_10=sigma10
        

    def localdensity(self):
        # get local density by summing mass w/in 300 kpc
        # NOTE:
        #  - this measure will be unreliable for galaxies near the edge of the 3 deg area
        #  - this will be fine for galaxies on 24um image
        sdssflag=self.ndat.ISDSS > -1
        DA=self.AngDistance
        x=self.ndat.RA
        y=self.ndat.DEC
        xref=self.ndat.RA[sdssflag]
        yref=self.ndat.DEC[sdssflag]
        n1=3
        n2=6
        sigma=zeros(len(x),'d')
        for i in range(len(x)):
            deltav=abs(self.ndat.ZDIST[sdssflag]-self.ndat.ZDIST[i])*3.e5
            d=sqrt((x[i]-xref)**2+(y[i]-yref)**2)*3600./1000.*DA#d in Mpc
            d=d[deltav<args.velocitycut]#apply a velocity cut of +/- 1500 km/s
            d.sort()#sort in ascending order, zeroth element is distance from galaxy to itself
            sig=0
            '''
            if len(d) < n2:
                print 'not enough points to calculate local density'
                print 'only have ',len(d),' galaxies w/in ',args.velocitycut
                if len(d) < n1:
                    print 'ut oh!'
                for j in range(n1,len(d)):
                    sig += (1.*j)/(d[j])**2

            else:
                for j in range(n1,n2+1):
                    sig += (1.*j)/(d[j])**2
            '''
            
            sigma[i]=1./(4.*pi)*d[1]
        self.sigma_nn=sigma
        
        return
    def localdensitybymass(self):#find local density, using nearest neighbors n1 through n2
        DA=self.AngDistance #kpc/arcsec
        angDist_300kpc=300./DA/3600. # angular dist corresponding to 300 kpc, in degrees
        x=self.ndat.RA
        y=self.ndat.DEC
        # should probably use SDSS as the reference sample, but for now, using NSA
        sdssflag=self.ndat.ISDSS > -1
        xref=self.ndat.RA[sdssflag]
        yref=self.ndat.DEC[sdssflag]
        self.rhomass=zeros(len(x),'d')
        for i in range(len(x)):
            deltav=abs(self.ndat.ZDIST[sdssflag]-self.ndat.ZDIST[i])*3.e5
            d=sqrt((x[i]-xref)**2+(y[i]-yref)**2)*3600./1000.*DA#d in Mpc
            d=d[deltav<args.velocitycut]#apply a velocity cut of +/- 1500 km/s
            neighbor_flag=d < .3

            self.rhomass[i]=sum(self.ndat.MASS[neighbor_flag])
            #print i, self.rhomass[i],sum(neighbor_flag)
    def matchnsa2sdssphot(self):
        return
    def writeoutput(self):
        # append flag to NSA table 
        # create new table
        ldat=atpy.Table()
        #ldat.add_column('On24ImageFlag',self.On24ImageFlag)

        # will add more columns here as time permits
        ldat.add_column('NSAID',self.ndat.NSAID,unit='',description='NSA ID')
        ldat.add_column('RA',self.ndat.RA,unit='deg',description='RA')
        ldat.add_column('DEC',self.ndat.DEC,unit='deg',description='DEC')
        ldat.add_column('Z',self.ndat.Z,unit='',description='redshift')
        ldat.add_column('ZDIST',self.ndat.ZDIST,unit='',description='NSA ZDIST')
        ldat.add_column('RHOMASS',self.rhomass,unit='Msun',description='Mass of galaxies w/in 300 kpc')
        ldat.add_column('SIGMA_NN',self.sigma_nn,unit='Ngal/Mpc^2', description='3rd to 6th nearest neighbor')
        ldat.add_column('SIGMA_5',self.sigma_5,unit='Ngal/Mpc^2', description='to 5th nearest neighbor')
        ldat.add_column('SIGMA_10',self.sigma_10,unit='Ngal/Mpc^2', description='to 10th nearest neighbor')

        # write out table
        outfile=homedir+'research/LocalClusters/NSAmastertables/LocalDensityTables/'+self.prefix+'_localdensity.fits'
        if os.path.exists(outfile):
            os.remove(outfile)
        ldat.write(outfile)


if __name__ == '__main__':
    mkw11=cluster('MKW11')
    mkw8=cluster('MKW8')
    awm4=cluster('AWM4')
    a2052=cluster('A2052')
    a2063=cluster('A2063')
    ngc=cluster('NGC6107')
    coma=cluster ('Coma')
    herc=cluster('Hercules')
    a1367=cluster('A1367')

    mylocalclusters=[mkw11,mkw8,awm4,a2052,a2063,ngc,coma,herc,a1367]
    for cl in mylocalclusters:
        print  '\n ',cl.prefix,'\n'
        #cl.geton24imageflag()
        #cl.getsdssspeccat()
        #cl.getsdssphotcat()
        cl.localdensity()
        cl.localdensity5()
        cl.localdensitybymass()
        cl.writeoutput()


# -*- coding: utf-8 -*-
# © 2014 Elico Corp(https://www.elico-corp.com)
# © 2014 Yannick Gouin (yannick.gouin@elico-corp.com)
# Licence AGPL-3.0 or later(http://www.gnu.org/licenses/agpl.html)

from openerp import pooler
import time
from openerp.report import report_sxw

class lot_overview(report_sxw.rml_parse):
    def __init__(self, cr, uid, name, context):
        super(lot_overview, self).__init__(cr, uid, name, context=context)
        self.price_total = 0.0
        self.grand_total = 0.0
        self.localcontext.update({
            'time': time,
            'process':self.process,
            'price_total': self._price_total,
            'grand_total_price':self._grand_total,
        })

    def process(self, location_id):
        location_obj = pooler.get_pool(self.cr.dbname).get('stock.location')
        data = location_obj._product_get_report(self.cr, self.uid, [location_id])

        data['location_name'] = location_obj.read(self.cr, self.uid, [location_id], ['complete_name'])[0]['complete_name']
        self.price_total = 0.0
        self.price_total += data['total_price']
        self.grand_total += data['total_price']
        return [data]

    def _price_total(self):
        return self.price_total

    def _grand_total(self):
        return self.grand_total

report_sxw.report_sxw('report.lot.stock.overview2', 'stock.location', 'addons/stock_location_reports/report/lot_overview.rml', parser=lot_overview, header='internal')


# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

# Copyright (c) 2013 Hortonworks, Inc.
#
# 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.

import pkg_resources as pkg

from sahara.plugins.hdp import clusterspec as cs
from sahara import version


class TestServer(object):
    def __init__(self, hostname, role, img, flavor, public_ip, private_ip):
        self.inst_fqdn = hostname
        self.role = role
        self.instance_info = InstanceInfo(
            hostname, img, flavor, public_ip, private_ip)
        self.management_ip = public_ip
        self.public_ip = public_ip
        self.internal_ip = private_ip
        self.node_group = None

    def fqdn(self):
        return self.inst_fqdn

    def remote(self):
        return None


def get_instance_info(*args, **kwargs):
    return args[0].instance_info


def create_clusterspec(hdp_version='2.0.6'):
    version_suffix = hdp_version.replace('.', '_')
    cluster_config_file = pkg.resource_string(
        version.version_info.package,
        'plugins/hdp/versions/version_{0}/resources/'
        'default-cluster.template'.format(version_suffix))

    return cs.ClusterSpec(cluster_config_file, version=hdp_version)


class InstanceInfo(object):
    def __init__(self, hostname, image, flavor, management_ip, internal_ip):
        self.image = image
        self.flavor = flavor
        self.management_ip = management_ip
        self.internal_ip = internal_ip


class TestCluster(object):
    def __init__(self, node_groups, cluster_configs=None):
        self.plugin_name = 'hdp'
        self.hadoop_version = None
        if cluster_configs:
            self.cluster_configs = cluster_configs
        else:
            self.cluster_configs = {}
        self.node_groups = node_groups
        self.default_image_id = '11111'


class TestNodeGroup(object):
    def __init__(self, name, instances, node_processes, count=1):
        self.name = name
        self.instances = instances
        if instances:
            for i in instances:
                i.node_group = self
        self.node_processes = node_processes
        self.count = count
        self.id = name
        self.ng_storage_paths = []

    def storage_paths(self):
        return self.ng_storage_paths


class TestUserInputConfig(object):
    def __init__(self, tag, target, name):
        self.tag = tag
        self.applicable_target = target
        self.name = name


class TestRequest(object):
    def put(self, url, data=None, auth=None, headers=None):
        self.url = url
        self.data = data
        self.auth = auth
        self.headers = headers
        self.method = 'put'

        return TestResult(200)

    def post(self, url, data=None, auth=None, headers=None):
        self.url = url
        self.data = data
        self.auth = auth
        self.headers = headers
        self.method = 'post'

        return TestResult(201)

    def delete(self, url, auth=None, headers=None):
        self.url = url
        self.auth = auth
        self.data = None
        self.headers = headers
        self.method = 'delete'

        return TestResult(200)


class TestResult(object):
    def __init__(self, status):
        self.status_code = status
        self.text = ''


class TestUserInput(object):
    def __init__(self, config, value):
        self.config = config
        self.value = value

# -*- coding: utf-8 -*-
#
# Copyright (c) 2020 SUNET
# All rights reserved.
#
#   Redistribution and use in source and binary forms, with or
#   without modification, are permitted provided that the following
#   conditions are met:
#
#     1. Redistributions of source code must retain the above copyright
#        notice, this list of conditions and the following disclaimer.
#     2. Redistributions in binary form must reproduce the above
#        copyright notice, this list of conditions and the following
#        disclaimer in the documentation and/or other materials provided
#        with the distribution.
#     3. Neither the name of the NORDUnet nor the names of its
#        contributors may be used to endorse or promote products derived
#        from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
"""
Configuration (file) handling for the eduID group_management app.
"""

from typing import Any, Dict, Optional

from eduid_common.config.base import EduIDBaseAppConfig, MailConfigMixin


class GroupManagementConfig(EduIDBaseAppConfig, MailConfigMixin):
    """
    Configuration for the group_management app
    """

    app_name: str = 'group_management'

    eduid_site_name: str = 'eduID'
    eduid_site_url: str

    group_invite_template_html: str = 'group_invite_email.html.jinja2'
    group_invite_template_txt: str = 'group_invite_email.txt.jinja2'
    group_invite_url: str = 'https://dashboard.eduid.se'
    mail_default_from: str = 'no-reply@eduid.se'
    neo4j_config: Optional[Dict[str, Any]] = None
    neo4j_uri: str = ''
    scim_data_owner: str = 'eduid.se'
    scim_external_id_scope: str = 'eduid.se'

# -*- coding: utf-8 -*-
#
# Copyright (C) 2010-2016 Red Hat, Inc.
#
# Authors:
# Thomas Woerner <twoerner@redhat.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import dbus
import dbus.service

from firewall import config
from firewall.dbus_utils import dbus_to_python, \
    dbus_introspection_prepare_properties, \
    dbus_introspection_add_properties
from firewall.core.io.helper import Helper
from firewall.core.logger import log
from firewall.server.dbus import DbusServiceObject
from firewall.server.decorators import handle_exceptions, \
    dbus_handle_exceptions, dbus_service_method, \
    dbus_polkit_require_auth
from firewall import errors
from firewall.errors import FirewallError

############################################################################
#
# class FirewallDConfig
#
############################################################################

class FirewallDConfigHelper(DbusServiceObject):
    """FirewallD main class"""

    persistent = True
    """ Make FirewallD persistent. """
    default_polkit_auth_required = config.dbus.PK_ACTION_CONFIG
    """ Use PK_ACTION_INFO as a default """

    @handle_exceptions
    def __init__(self, parent, conf, helper, item_id, *args, **kwargs):
        super(FirewallDConfigHelper, self).__init__(*args, **kwargs)
        self.parent = parent
        self.config = conf
        self.obj = helper
        self.item_id = item_id
        self.busname = args[0]
        self.path = args[1]
        self._log_prefix = "config.helper.%d" % self.item_id
        dbus_introspection_prepare_properties(
            self, config.dbus.DBUS_INTERFACE_CONFIG_HELPER)

    @dbus_handle_exceptions
    def __del__(self):
        pass

    @dbus_handle_exceptions
    def unregister(self):
        self.remove_from_connection()

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    # P R O P E R T I E S

    @dbus_handle_exceptions
    def _get_property(self, property_name):
        if property_name == "name":
            return dbus.String(self.obj.name)
        elif property_name == "filename":
            return dbus.String(self.obj.filename)
        elif property_name == "path":
            return dbus.String(self.obj.path)
        elif property_name == "default":
            return dbus.Boolean(self.obj.default)
        elif property_name == "builtin":
            return dbus.Boolean(self.obj.builtin)
        else:
            raise dbus.exceptions.DBusException(
                "org.freedesktop.DBus.Error.InvalidArgs: "
                "Property '%s' does not exist" % property_name)

    @dbus_service_method(dbus.PROPERTIES_IFACE, in_signature='ss',
                         out_signature='v')
    @dbus_handle_exceptions
    def Get(self, interface_name, property_name, sender=None): # pylint: disable=W0613
        # get a property
        interface_name = dbus_to_python(interface_name, str)
        property_name = dbus_to_python(property_name, str)
        log.debug1("%s.Get('%s', '%s')", self._log_prefix,
                   interface_name, property_name)

        if interface_name != config.dbus.DBUS_INTERFACE_CONFIG_HELPER:
            raise dbus.exceptions.DBusException(
                "org.freedesktop.DBus.Error.UnknownInterface: "
                "Interface '%s' does not exist" % interface_name)

        return self._get_property(property_name)

    @dbus_service_method(dbus.PROPERTIES_IFACE, in_signature='s',
                         out_signature='a{sv}')
    @dbus_handle_exceptions
    def GetAll(self, interface_name, sender=None): # pylint: disable=W0613
        interface_name = dbus_to_python(interface_name, str)
        log.debug1("%s.GetAll('%s')", self._log_prefix, interface_name)

        if interface_name != config.dbus.DBUS_INTERFACE_CONFIG_HELPER:
            raise dbus.exceptions.DBusException(
                "org.freedesktop.DBus.Error.UnknownInterface: "
                "Interface '%s' does not exist" % interface_name)

        ret = { }
        for x in [ "name", "filename", "path", "default", "builtin" ]:
            ret[x] = self._get_property(x)
        return dbus.Dictionary(ret, signature="sv")

    @dbus_polkit_require_auth(config.dbus.PK_ACTION_CONFIG)
    @dbus_service_method(dbus.PROPERTIES_IFACE, in_signature='ssv')
    @dbus_handle_exceptions
    def Set(self, interface_name, property_name, new_value, sender=None):
        interface_name = dbus_to_python(interface_name, str)
        property_name = dbus_to_python(property_name, str)
        new_value = dbus_to_python(new_value)
        log.debug1("%s.Set('%s', '%s', '%s')", self._log_prefix,
                   interface_name, property_name, new_value)
        self.parent.accessCheck(sender)

        if interface_name != config.dbus.DBUS_INTERFACE_CONFIG_HELPER:
            raise dbus.exceptions.DBusException(
                "org.freedesktop.DBus.Error.UnknownInterface: "
                "Interface '%s' does not exist" % interface_name)

        raise dbus.exceptions.DBusException(
            "org.freedesktop.DBus.Error.PropertyReadOnly: "
            "Property '%s' is read-only" % property_name)

    @dbus.service.signal(dbus.PROPERTIES_IFACE, signature='sa{sv}as')
    def PropertiesChanged(self, interface_name, changed_properties,
                          invalidated_properties):
        interface_name = dbus_to_python(interface_name, str)
        changed_properties = dbus_to_python(changed_properties)
        invalidated_properties = dbus_to_python(invalidated_properties)
        log.debug1("%s.PropertiesChanged('%s', '%s', '%s')", self._log_prefix,
                   interface_name, changed_properties, invalidated_properties)

    @dbus_polkit_require_auth(config.dbus.PK_ACTION_INFO)
    @dbus_service_method(dbus.INTROSPECTABLE_IFACE, out_signature='s')
    @dbus_handle_exceptions
    def Introspect(self, sender=None): # pylint: disable=W0613
        log.debug2("%s.Introspect()", self._log_prefix)

        data = super(FirewallDConfigHelper, self).Introspect(
            self.path, self.busname.get_bus())

        return dbus_introspection_add_properties(
            self, data, config.dbus.DBUS_INTERFACE_CONFIG_HELPER)

    # S E T T I N G S

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         out_signature=Helper.DBUS_SIGNATURE)
    @dbus_handle_exceptions
    def getSettings(self, sender=None): # pylint: disable=W0613
        """get settings for helper
        """
        log.debug1("%s.getSettings()", self._log_prefix)
        return self.config.get_helper_config(self.obj)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature=Helper.DBUS_SIGNATURE)
    @dbus_handle_exceptions
    def update(self, settings, sender=None):
        """update settings for helper
        """
        settings = dbus_to_python(settings)
        log.debug1("%s.update('...')", self._log_prefix)
        self.parent.accessCheck(sender)
        self.obj = self.config.set_helper_config(self.obj, settings)
        self.Updated(self.obj.name)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER)
    @dbus_handle_exceptions
    def loadDefaults(self, sender=None):
        """load default settings for builtin helper
        """
        log.debug1("%s.loadDefaults()", self._log_prefix)
        self.parent.accessCheck(sender)
        self.obj = self.config.load_helper_defaults(self.obj)
        self.Updated(self.obj.name)

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         signature='s')
    @dbus_handle_exceptions
    def Updated(self, name):
        log.debug1("%s.Updated('%s')" % (self._log_prefix, name))

    # R E M O V E

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER)
    @dbus_handle_exceptions
    def remove(self, sender=None):
        """remove helper
        """
        log.debug1("%s.removeHelper()", self._log_prefix)
        self.parent.accessCheck(sender)
        self.config.remove_helper(self.obj)
        self.parent.removeHelper(self.obj)

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         signature='s')
    @dbus_handle_exceptions
    def Removed(self, name):
        log.debug1("%s.Removed('%s')" % (self._log_prefix, name))

    # R E N A M E

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s')
    @dbus_handle_exceptions
    def rename(self, name, sender=None):
        """rename helper
        """
        name = dbus_to_python(name, str)
        log.debug1("%s.rename('%s')", self._log_prefix, name)
        self.parent.accessCheck(sender)
        self.obj = self.config.rename_helper(self.obj, name)
        self.Renamed(name)

    @dbus.service.signal(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         signature='s')
    @dbus_handle_exceptions
    def Renamed(self, name):
        log.debug1("%s.Renamed('%s')" % (self._log_prefix, name))

    # version

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         out_signature='s')
    @dbus_handle_exceptions
    def getVersion(self, sender=None): # pylint: disable=W0613
        log.debug1("%s.getVersion()", self._log_prefix)
        return self.getSettings()[0]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s')
    @dbus_handle_exceptions
    def setVersion(self, version, sender=None):
        version = dbus_to_python(version, str)
        log.debug1("%s.setVersion('%s')", self._log_prefix, version)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        settings[0] = version
        self.update(settings)

    # short

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         out_signature='s')
    @dbus_handle_exceptions
    def getShort(self, sender=None): # pylint: disable=W0613
        log.debug1("%s.getShort()", self._log_prefix)
        return self.getSettings()[1]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s')
    @dbus_handle_exceptions
    def setShort(self, short, sender=None):
        short = dbus_to_python(short, str)
        log.debug1("%s.setShort('%s')", self._log_prefix, short)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        settings[1] = short
        self.update(settings)

    # description

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         out_signature='s')
    @dbus_handle_exceptions
    def getDescription(self, sender=None): # pylint: disable=W0613
        log.debug1("%s.getDescription()", self._log_prefix)
        return self.getSettings()[2]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s')
    @dbus_handle_exceptions
    def setDescription(self, description, sender=None):
        description = dbus_to_python(description, str)
        log.debug1("%s.setDescription('%s')", self._log_prefix,
                   description)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        settings[2] = description
        self.update(settings)

    # family

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         out_signature='s')
    @dbus_handle_exceptions
    def getFamily(self, sender=None):
        log.debug1("%s.getFamily()", self._log_prefix)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        return settings[3]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s')
    @dbus_handle_exceptions
    def setFamily(self, ipv, sender=None):
        ipv = dbus_to_python(ipv, str)
        log.debug1("%s.setFamily('%s')", self._log_prefix, ipv)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        if settings[3] == ipv:
            raise FirewallError(errors.ALREADY_ENABLED, "'%s'" % ipv)
        settings[3] = ipv
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s', out_signature='b')
    @dbus_handle_exceptions
    def queryFamily(self, ipv, sender=None): # pylint: disable=W0613
        ipv = dbus_to_python(ipv, str)
        log.debug1("%s.queryFamily('%s')", self._log_prefix, ipv)
        settings = self.getSettings()
        return (settings[3] == ipv)

    # module

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         out_signature='s')
    @dbus_handle_exceptions
    def getModule(self, sender=None):
        log.debug1("%s.getModule()", self._log_prefix)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        return settings[4]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s')
    @dbus_handle_exceptions
    def setModule(self, module, sender=None):
        module = dbus_to_python(module, str)
        log.debug1("%s.setModule('%s')", self._log_prefix, module)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        if settings[4] == module:
            raise FirewallError(errors.ALREADY_ENABLED, "'%s'" % module)
        settings[4] = module
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='s', out_signature='b')
    @dbus_handle_exceptions
    def queryModule(self, module, sender=None): # pylint: disable=W0613
        module = dbus_to_python(module, str)
        log.debug1("%s.queryModule('%s')", self._log_prefix, module)
        settings = self.getSettings()
        return (settings[4] == module)

    # port

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         out_signature='a(ss)')
    @dbus_handle_exceptions
    def getPorts(self, sender=None): # pylint: disable=W0613
        log.debug1("%s.getPorts()", self._log_prefix)
        return self.getSettings()[5]

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='a(ss)')
    @dbus_handle_exceptions
    def setPorts(self, ports, sender=None):
        _ports = [ ]
        # convert embedded lists to tuples
        for port in dbus_to_python(ports, list):
            if isinstance(port, list):
                _ports.append(tuple(port))
            else:
                _ports.append(port)
        ports = _ports
        log.debug1("%s.setPorts('[%s]')", self._log_prefix,
                   ",".join("('%s, '%s')" % (port[0], port[1]) for port in ports))
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        settings[5] = ports
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='ss')
    @dbus_handle_exceptions
    def addPort(self, port, protocol, sender=None):
        port = dbus_to_python(port, str)
        protocol = dbus_to_python(protocol, str)
        log.debug1("%s.addPort('%s', '%s')", self._log_prefix, port,
                   protocol)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        if (port,protocol) in settings[5]:
            raise FirewallError(errors.ALREADY_ENABLED,
                                "%s:%s" % (port, protocol))
        settings[5].append((port,protocol))
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='ss')
    @dbus_handle_exceptions
    def removePort(self, port, protocol, sender=None):
        port = dbus_to_python(port, str)
        protocol = dbus_to_python(protocol, str)
        log.debug1("%s.removePort('%s', '%s')", self._log_prefix, port,
                   protocol)
        self.parent.accessCheck(sender)
        settings = list(self.getSettings())
        if (port,protocol) not in settings[5]:
            raise FirewallError(errors.NOT_ENABLED, "%s:%s" % (port, protocol))
        settings[5].remove((port,protocol))
        self.update(settings)

    @dbus_service_method(config.dbus.DBUS_INTERFACE_CONFIG_HELPER,
                         in_signature='ss', out_signature='b')
    @dbus_handle_exceptions
    def queryPort(self, port, protocol, sender=None): # pylint: disable=W0613
        port = dbus_to_python(port, str)
        protocol = dbus_to_python(protocol, str)
        log.debug1("%s.queryPort('%s', '%s')", self._log_prefix, port,
                   protocol)
        return (port,protocol) in self.getSettings()[5]

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for tensorflow.ops.tf.variable_op."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import numpy as np

from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors
from tensorflow.python.framework import ops
from tensorflow.python.framework import tensor_shape
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gen_state_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import state_ops
from tensorflow.python.ops import variables
from tensorflow.python.platform import test

_NP_TO_TF = {
    np.float32: dtypes.float32,
    np.float64: dtypes.float64,
    np.int32: dtypes.int32,
    np.int64: dtypes.int64,
}


class VariableOpTest(test.TestCase):

  def _initFetch(self, x, tftype, use_gpu=None):
    with self.test_session(use_gpu=use_gpu):
      p = state_ops.variable_op(x.shape, tftype)
      op = state_ops.assign(p, x)
      op.op.run()
      return p.eval()

  def _testTypes(self, vals):
    for dtype in [np.float32, np.float64, np.int32, np.int64]:
      self.setUp()
      x = vals.astype(dtype)
      tftype = _NP_TO_TF[dtype]
      self.assertAllEqual(x, self._initFetch(x, tftype, use_gpu=False))
      # NOTE(touts): the GPU test should pass for all types, whether the
      # Variable op has an implementation for that type on GPU as we expect
      # that Variable and Assign have GPU implementations for matching tf.
      self.assertAllEqual(x, self._initFetch(x, tftype, use_gpu=True))

  def testBasic(self):
    self._testTypes(np.arange(0, 20).reshape([4, 5]))

  def testset_shape(self):
    p = state_ops.variable_op([1, 2], dtypes.float32)
    self.assertEqual([1, 2], p.get_shape())
    p = state_ops.variable_op([1, 2], dtypes.float32, set_shape=False)
    self.assertEqual(tensor_shape.unknown_shape(), p.get_shape())

  def testAssign(self):
    value = np.array([[42.0, 43.0]])
    var = state_ops.variable_op(value.shape, dtypes.float32)
    self.assertShapeEqual(value, var)
    assigned = state_ops.assign(var, value)
    self.assertShapeEqual(value, assigned)

  def testAssignNoValidateShape(self):
    value = np.array([[42.0, 43.0]])
    var = state_ops.variable_op(value.shape, dtypes.float32)
    self.assertShapeEqual(value, var)
    assigned = state_ops.assign(var, value, validate_shape=False)
    self.assertShapeEqual(value, assigned)

  def testAssignNoVarShape(self):
    value = np.array([[42.0, 43.0]])
    var = state_ops.variable_op(value.shape, dtypes.float32, set_shape=False)
    self.assertEqual(tensor_shape.unknown_shape(), var.get_shape())
    assigned = state_ops.assign(var, value)
    self.assertShapeEqual(value, assigned)

  def testAssignNoVarShapeNoValidateShape(self):
    value = np.array([[42.0, 43.0]])
    var = state_ops.variable_op(value.shape, dtypes.float32, set_shape=False)
    self.assertEqual(tensor_shape.unknown_shape(), var.get_shape())
    assigned = state_ops.assign(var, value, validate_shape=False)
    self.assertShapeEqual(value, assigned)

  def _NewShapelessTensor(self):
    tensor = array_ops.placeholder(dtypes.float32)
    self.assertEqual(tensor_shape.unknown_shape(), tensor.get_shape())
    return tensor

  def testAssignNoValueShape(self):
    value = self._NewShapelessTensor()
    shape = [1, 2]
    var = state_ops.variable_op(shape, dtypes.float32)
    assigned = state_ops.assign(var, value)
    self.assertEqual(shape, var.get_shape())
    self.assertEqual(shape, assigned.get_shape())

  def testAssignNoValueShapeNoValidateShape(self):
    value = self._NewShapelessTensor()
    shape = [1, 2]
    var = state_ops.variable_op(shape, dtypes.float32)
    self.assertEqual(shape, var.get_shape())
    assigned = state_ops.assign(var, value, validate_shape=False)
    self.assertEqual(tensor_shape.unknown_shape(), assigned.get_shape())

  def testAssignNoShape(self):
    with self.test_session():
      value = self._NewShapelessTensor()
      var = state_ops.variable_op([1, 2], dtypes.float32, set_shape=False)
      self.assertEqual(tensor_shape.unknown_shape(), var.get_shape())
      self.assertEqual(tensor_shape.unknown_shape(),
                       state_ops.assign(var, value).get_shape())

  def testAssignNoShapeNoValidateShape(self):
    with self.test_session():
      value = self._NewShapelessTensor()
      var = state_ops.variable_op([1, 2], dtypes.float32, set_shape=False)
      self.assertEqual(tensor_shape.unknown_shape(), var.get_shape())
      self.assertEqual(
          tensor_shape.unknown_shape(),
          state_ops.assign(
              var, value, validate_shape=False).get_shape())

  def testAssignUpdate(self):
    var = state_ops.variable_op([1, 2], dtypes.float32)
    added = state_ops.assign_add(var, [[2.0, 3.0]])
    self.assertEqual([1, 2], added.get_shape())
    subbed = state_ops.assign_sub(var, [[12.0, 13.0]])
    self.assertEqual([1, 2], subbed.get_shape())

  def testAssignUpdateNoVarShape(self):
    var = state_ops.variable_op([1, 2], dtypes.float32, set_shape=False)
    added = state_ops.assign_add(var, [[2.0, 3.0]])
    self.assertEqual([1, 2], added.get_shape())
    subbed = state_ops.assign_sub(var, [[12.0, 13.0]])
    self.assertEqual([1, 2], subbed.get_shape())

  def testAssignUpdateNoValueShape(self):
    var = state_ops.variable_op([1, 2], dtypes.float32)
    added = state_ops.assign_add(var, self._NewShapelessTensor())
    self.assertEqual([1, 2], added.get_shape())
    subbed = state_ops.assign_sub(var, self._NewShapelessTensor())
    self.assertEqual([1, 2], subbed.get_shape())

  def testAssignUpdateNoShape(self):
    var = state_ops.variable_op([1, 2], dtypes.float32, set_shape=False)
    added = state_ops.assign_add(var, self._NewShapelessTensor())
    self.assertEqual(tensor_shape.unknown_shape(), added.get_shape())
    subbed = state_ops.assign_sub(var, self._NewShapelessTensor())
    self.assertEqual(tensor_shape.unknown_shape(), subbed.get_shape())

  def testTemporaryVariable(self):
    with self.test_session(use_gpu=True):
      var = gen_state_ops._temporary_variable(
          [1, 2], dtypes.float32, var_name="foo")
      var = state_ops.assign(var, [[4.0, 5.0]])
      var = state_ops.assign_add(var, [[6.0, 7.0]])
      final = gen_state_ops._destroy_temporary_variable(var, var_name="foo")
      self.assertAllClose([[10.0, 12.0]], final.eval())

  def testDestroyNonexistentTemporaryVariable(self):
    with self.test_session(use_gpu=True):
      var = gen_state_ops._temporary_variable([1, 2], dtypes.float32)
      final = gen_state_ops._destroy_temporary_variable(var, var_name="bad")
      with self.assertRaises(errors.NotFoundError):
        final.eval()

  def testDuplicateTemporaryVariable(self):
    with self.test_session(use_gpu=True):
      var1 = gen_state_ops._temporary_variable(
          [1, 2], dtypes.float32, var_name="dup")
      var1 = state_ops.assign(var1, [[1.0, 2.0]])
      var2 = gen_state_ops._temporary_variable(
          [1, 2], dtypes.float32, var_name="dup")
      var2 = state_ops.assign(var2, [[3.0, 4.0]])
      final = var1 + var2
      with self.assertRaises(errors.AlreadyExistsError):
        final.eval()

  def testDestroyTemporaryVariableTwice(self):
    with self.test_session(use_gpu=True):
      var = gen_state_ops._temporary_variable([1, 2], dtypes.float32)
      val1 = gen_state_ops._destroy_temporary_variable(var, var_name="dup")
      val2 = gen_state_ops._destroy_temporary_variable(var, var_name="dup")
      final = val1 + val2
      with self.assertRaises(errors.NotFoundError):
        final.eval()

  def testTemporaryVariableNoLeak(self):
    with self.test_session(use_gpu=True):
      var = gen_state_ops._temporary_variable(
          [1, 2], dtypes.float32, var_name="bar")
      final = array_ops.identity(var)
      final.eval()

  def testTwoTemporaryVariablesNoLeaks(self):
    with self.test_session(use_gpu=True):
      var1 = gen_state_ops._temporary_variable(
          [1, 2], dtypes.float32, var_name="var1")
      var2 = gen_state_ops._temporary_variable(
          [1, 2], dtypes.float32, var_name="var2")
      final = var1 + var2
      final.eval()

  def testAssignDependencyAcrossDevices(self):
    with self.test_session(use_gpu=True):
      # The variable and an op to increment it are on the GPU.
      var = state_ops.variable_op([1], dtypes.float32)
      state_ops.assign(var, [1.0]).eval()
      increment = state_ops.assign_add(var, [1.0])
      with ops.control_dependencies([increment]):
        with ops.device("/cpu:0"):
          # This mul op is pinned to the CPU, but reads the variable from the
          # GPU. The test ensures that the dependency on 'increment' is still
          # honored, i.e., the Send and Recv from GPU to CPU should take place
          # only after the increment.
          result = math_ops.multiply(var, var)
      self.assertAllClose([4.0], result.eval())

  def testIsVariableInitialized(self):
    for use_gpu in [True, False]:
      with self.test_session(use_gpu=use_gpu):
        v0 = state_ops.variable_op([1, 2], dtypes.float32)
        self.assertEqual(False, variables.is_variable_initialized(v0).eval())
        state_ops.assign(v0, [[2.0, 3.0]]).eval()
        self.assertEqual(True, variables.is_variable_initialized(v0).eval())


if __name__ == "__main__":
  test.main()

"""
Support for Wink garage doors.

For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/garage_door.wink/
"""
import logging

from homeassistant.components.garage_door import GarageDoorDevice
from homeassistant.const import CONF_ACCESS_TOKEN

REQUIREMENTS = ['python-wink==0.6.4']


def setup_platform(hass, config, add_devices, discovery_info=None):
    """Setup the Wink garage door platform."""
    import pywink

    if discovery_info is None:
        token = config.get(CONF_ACCESS_TOKEN)

        if token is None:
            logging.getLogger(__name__).error(
                "Missing wink access_token. "
                "Get one at https://winkbearertoken.appspot.com/")
            return

        pywink.set_bearer_token(token)

    add_devices(WinkGarageDoorDevice(door) for door in
                pywink.get_garage_doors())


class WinkGarageDoorDevice(GarageDoorDevice):
    """Representation of a Wink garage door."""

    def __init__(self, wink):
        """Initialize the garage door."""
        self.wink = wink

    @property
    def unique_id(self):
        """Return the ID of this wink garage door."""
        return "{}.{}".format(self.__class__, self.wink.device_id())

    @property
    def name(self):
        """Return the name of the garage door if any."""
        return self.wink.name()

    def update(self):
        """Update the state of the garage door."""
        self.wink.update_state()

    @property
    def is_closed(self):
        """Return true if door is closed."""
        return self.wink.state() == 0

    @property
    def available(self):
        """True if connection == True."""
        return self.wink.available

    def close_door(self):
        """Close the door."""
        self.wink.set_state(0)

    def open_door(self):
        """Open the door."""
        self.wink.set_state(1)

#!/usr/bin/python
# -*- coding: utf-8 -*-

# (c) 2016, Ansible, inc
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'core'}


DOCUMENTATION = r'''
---
module: win_shell
short_description: Execute shell commands on target hosts.
version_added: 2.2
description:
     - The C(win_shell) module takes the command name followed by a list of space-delimited arguments.
       It is similar to the M(win_command) module, but runs
       the command via a shell (defaults to PowerShell) on the target host.
     - For non-Windows targets, use the M(shell) module instead.
options:
  free_form:
    description:
      - The C(win_shell) module takes a free form command to run.  There is no parameter actually named 'free form'.
        See the examples!
    required: true
  creates:
    description:
      - a path or path filter pattern; when the referenced path exists on the target host, the task will be skipped.
  removes:
    description:
      - a path or path filter pattern; when the referenced path B(does not) exist on the target host, the task will be skipped.
  chdir:
    description:
      - set the specified path as the current working directory before executing a command
  executable:
    description:
      - change the shell used to execute the command (eg, C(cmd)). The target shell must accept a C(/c) parameter followed by the raw command line to be
        executed.
notes:
   -  If you want to run an executable securely and predictably, it may be
      better to use the M(win_command) module instead. Best practices when writing
      playbooks will follow the trend of using M(win_command) unless C(win_shell) is
      explicitly required. When running ad-hoc commands, use your best judgement.
   -  WinRM will not return from a command execution until all child processes created have exited.
      Thus, it is not possible to use C(win_shell) to spawn long-running child or background processes.
      Consider creating a Windows service for managing background processes.
   - For non-Windows targets, use the M(shell) module instead.
   - See also M(win_command), M(raw)
author:
    - Matt Davis (@nitzmahone)
'''

EXAMPLES = r'''
# Execute a command in the remote shell; stdout goes to the specified
# file on the remote.
- win_shell: C:\somescript.ps1 >> c:\somelog.txt

# Change the working directory to somedir/ before executing the command.
- win_shell: C:\somescript.ps1 >> c:\somelog.txt chdir=c:\somedir

# You can also use the 'args' form to provide the options. This command
# will change the working directory to somedir/ and will only run when
# somedir/somelog.txt doesn't exist.
- win_shell: C:\somescript.ps1 >> c:\somelog.txt
  args:
    chdir: c:\somedir
    creates: c:\somelog.txt

# Run a command under a non-Powershell interpreter (cmd in this case)
- win_shell: echo %HOMEDIR%
  args:
    executable: cmd
  register: homedir_out
'''

RETURN = r'''
msg:
    description: changed
    returned: always
    type: boolean
    sample: True
start:
    description: The command execution start time
    returned: always
    type: string
    sample: '2016-02-25 09:18:26.429568'
end:
    description: The command execution end time
    returned: always
    type: string
    sample: '2016-02-25 09:18:26.755339'
delta:
    description: The command execution delta time
    returned: always
    type: string
    sample: '0:00:00.325771'
stdout:
    description: The command standard output
    returned: always
    type: string
    sample: 'Clustering node rabbit@slave1 with rabbit@master ...'
stderr:
    description: The command standard error
    returned: always
    type: string
    sample: 'ls: cannot access foo: No such file or directory'
cmd:
    description: The command executed by the task
    returned: always
    type: string
    sample: 'rabbitmqctl join_cluster rabbit@master'
rc:
    description: The command return code (0 means success)
    returned: always
    type: int
    sample: 0
stdout_lines:
    description: The command standard output split in lines
    returned: always
    type: list
    sample: [u'Clustering node rabbit@slave1 with rabbit@master ...']
'''

# coding: utf-8

from __future__ import unicode_literals
import pytest
import json
from boxsdk.object.file import File
from boxsdk.object.search import MetadataSearchFilters, MetadataSearchFilter


@pytest.fixture
def search_query():
    return 'myquery'


@pytest.fixture(params=(1, 20, 100))
def search_limit(request):
    return request.param


@pytest.fixture(params=(0, 10))
def search_offset(request):
    return request.param


@pytest.fixture(params=(None, 'file', 'folder'))
def search_result_type(request):
    return request.param


@pytest.fixture(params=(None, ('name',), ('name', 'description')))
def search_content_types(request):
    return request.param


@pytest.fixture
def search_value_based_filters():
    metadata_filters = MetadataSearchFilters()
    metadata_filter = MetadataSearchFilter(template_key='mytemplate', scope='enterprise')
    metadata_filter.add_value_based_filter(field_key='myfield', value='myvalue')
    metadata_filters.add_filter(metadata_filter)
    return metadata_filters


@pytest.fixture(params=(
    {'gt_value': 'mygtvalue'},
    {'lt_value': 'myltvalue'},
    {'gt_value': 'mygtvalue', 'lt_value': 'myltvalue'}
))
def search_range_filters(request):
    metadata_filters = MetadataSearchFilters()
    metadata_filter = MetadataSearchFilter(template_key='mytemplate', scope='enterprise')
    filter_params = {'field_key': 'myfield'}
    filter_params.update(request.param)
    metadata_filter.add_range_filter(**filter_params)
    metadata_filters.add_filter(metadata_filter)
    return metadata_filters


@pytest.fixture
def search_entries():
    return [
        {'id': '1234', 'type': 'file'}
    ]


@pytest.fixture
def search_response():
    return {
        'entries': search_entries(),
        'total_count': 0,
        'limit': 20,
        'offset': 0
    }


class Matcher(object):
    def __init__(self, compare, some_obj):
        self.compare = compare
        self.some_obj = some_obj

    def __eq__(self, other):
        return self.compare(self.some_obj, other)


def compare_params(self, other):
    if not isinstance(self, dict) or not isinstance(other, dict):
        return False
    for key in self:
        # We need to ensure that the JSON-encoded mdfilters matches regardless of key order
        if key == 'mdfilters':
            if json.loads(self['mdfilters']) != json.loads(other['mdfilters']):
                return False
        # For other keys, just ensure that they are equal
        elif key in ('type', 'content_types'):
            return self[key] is None or self[key] == other[key]
        else:
            if self[key] != other[key]:
                return False
    return True


def test_search_with_value_based_filters(
        mock_box_session,
        make_mock_box_request,
        test_search,
        search_query,
        search_limit,
        search_offset,
        search_value_based_filters,
        search_response,
        search_entries,
        search_result_type,
        search_content_types,
):
    # pylint:disable=redefined-outer-name
    mock_box_session.get.return_value, _ = make_mock_box_request(response=search_response)
    response = test_search.search(
        search_query,
        limit=search_limit,
        offset=search_offset,
        metadata_filters=search_value_based_filters,
        result_type=search_result_type,
        content_types=search_content_types,
    )
    assert response == [File(mock_box_session, search_entry['id'], search_entry) for search_entry in search_entries]

    mock_box_session.get.assert_called_once_with(
        test_search.get_url(),
        params=Matcher(compare_params, {
            'query': search_query,
            'limit': search_limit,
            'mdfilters': json.dumps(search_value_based_filters.as_list()),
            'offset': search_offset,
            'type': search_result_type,
            'content_types': ','.join(search_content_types) if search_content_types else search_content_types,
        })
    )


def test_search_with_range_filters(
        mock_box_session,
        make_mock_box_request,
        test_search,
        search_query,
        search_limit,
        search_offset,
        search_range_filters,
        search_response,
        search_entries,
        search_result_type,
        search_content_types,
):
    # pylint:disable=redefined-outer-name
    mock_box_session.get.return_value, _ = make_mock_box_request(response=search_response)
    response = test_search.search(
        search_query,
        limit=search_limit,
        offset=search_offset,
        metadata_filters=search_range_filters,
        result_type=search_result_type,
        content_types=search_content_types,
    )
    assert response == [File(mock_box_session, search_entry['id'], search_entry) for search_entry in search_entries]

    mock_box_session.get.assert_called_once_with(
        test_search.get_url(),
        params=Matcher(compare_params, {
            'query': search_query,
            'limit': search_limit,
            'mdfilters': json.dumps(search_range_filters.as_list()),
            'offset': search_offset,
            'type': search_result_type,
            'content_types': ','.join(search_content_types) if search_content_types else search_content_types,
        })
    )


def test_range_filter_without_gt_and_lt_will_fail_validation():
    metadata_filter = MetadataSearchFilter(template_key='mytemplate', scope='enterprise')
    with pytest.raises(ValueError):
        metadata_filter.add_range_filter(field_key='mykey')


def test_start_search_filters(test_search):
    filters = test_search.start_metadata_filters()
    assert isinstance(filters, MetadataSearchFilters)


def test_make_single_metadata_filter(test_search):
    template_key = 'mytemplate'
    scope = 'myscope'
    metadata_filter = test_search.make_single_metadata_filter(template_key, scope)
    assert isinstance(metadata_filter, MetadataSearchFilter)
    filter_as_dict = metadata_filter.as_dict()
    assert filter_as_dict['templateKey'] == template_key
    assert filter_as_dict['scope'] == scope

# Copyright (C) 2010 Brian Parma
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 1, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

import os
from xlgui.preferences import widgets
from xlgui import icons
from xl import xdg
from xl.nls import gettext as _

name = _('Multi-Alarm Clock')
basedir = os.path.dirname(os.path.realpath(__file__))
ui = os.path.join(basedir, "malrmclk.ui")

icons.MANAGER.add_icon_name_from_directory('clock',
    os.path.join(basedir, 'icons'))
icon = 'clock'


class FadingEnabledPreference(widgets.CheckPreference):
    name = 'plugin/multialarmclock/fading_on'
    default = True

class FadingConditional(widgets.CheckConditional):
    condition_preference_name = 'plugin/multialarmclock/fading_on'    

class RestartPlaylistPreference(widgets.CheckPreference):
    name = 'plugin/multialarmclock/restart_playlist_on'
    default = False
    
class FadeMinVolumePreference(widgets.SpinPreference, FadingConditional):
    name = 'plugin/multialarmclock/fade_min_volume'
    default = 0

    def __init__(self, prefs, widget):
        widgets.SpinPreference.__init__(self, prefs, widget)
        FadingConditional.__init__(self)
    
class FadeMaxVolumePreference(widgets.SpinPreference, FadingConditional):
    name = 'plugin/multialarmclock/fade_max_volume'
    default = 100
    
    def __init__(self, prefs, widget):
        widgets.SpinPreference.__init__(self, prefs, widget)
        FadingConditional.__init__(self)
    
class FadeIncrementPreference(widgets.SpinPreference, FadingConditional):
    name = 'plugin/multialarmclock/fade_increment'
    default = 1
    
    def __init__(self, prefs, widget):
        widgets.SpinPreference.__init__(self, prefs, widget)
        FadingConditional.__init__(self)
    
class FadeTimePreference(widgets.SpinPreference, FadingConditional):
    name = 'plugin/multialarmclock/fade_time'
    default = 30

    def __init__(self, prefs, widget):
        widgets.SpinPreference.__init__(self, prefs, widget)
        FadingConditional.__init__(self)
    

from __future__ import unicode_literals

from django.db import models

from guardian.compat import get_user_model
from guardian.conf import settings
from guardian.exceptions import WrongAppError
from guardian.core import ObjectPermissionChecker

class ObjectPermissionBackend(object):
    supports_object_permissions = True
    supports_anonymous_user = True
    supports_inactive_user = True

    def authenticate(self, username, password):
        return None

    def has_perm(self, user_obj, perm, obj=None):
        """
        Returns ``True`` if given ``user_obj`` has ``perm`` for ``obj``. If no
        ``obj`` is given, ``False`` is returned.

        .. note::

           Remember, that if user is not *active*, all checks would return
           ``False``.

        Main difference between Django's ``ModelBackend`` is that we can pass
        ``obj`` instance here and ``perm`` doesn't have to contain
        ``app_label`` as it can be retrieved from given ``obj``.

        **Inactive user support**

        If user is authenticated but inactive at the same time, all checks
        always returns ``False``.
        """
        # Backend checks only object permissions
        if obj is None:
            return False

        # Backend checks only permissions for Django models
        if not isinstance(obj, models.Model):
            return False

        # This is how we support anonymous users - simply try to retrieve User
        # instance and perform checks for that predefined user
        if not user_obj.is_authenticated():
            user_obj = get_user_model().objects.get(pk=settings.ANONYMOUS_USER_ID)

        # Do not check any further if user is not active
        if not user_obj.is_active:
            return False

        if len(perm.split('.')) > 1:
            app_label, perm = perm.split('.')
            if app_label != obj._meta.app_label:
                raise WrongAppError("Passed perm has app label of '%s' and "
                    "given obj has '%s'" % (app_label, obj._meta.app_label))

        check = ObjectPermissionChecker(user_obj)
        return check.has_perm(perm, obj)


import traceback
from typing import Any, Iterable, List, Tuple

from requests.exceptions import RequestException

from cloudbot import hook
from cloudbot.util import web


def get_attrs(obj: object) -> List[str]:
    """Returns a list of all of the attributes on an object,
    either from the __dict__ or from dir() if the object has no __dict__

    >>> class C:
    ...     a = 1
    ...     b = 2
    >>> [name for name in get_attrs(C()) if not is_dunder(name)]
    ['a', 'b']

    And with __slots__:

    >>> class C:
    ...     __slots__ = ('a', 'b')
    ...
    ...     def __init__(self):
    ...         self.a = 1
    ...         self.b = 1
    >>> [name for name in get_attrs(C()) if not is_dunder(name)]
    ['a', 'b']

    :param obj: The object to retrieve the attribute names from
    :return: A list of all attributes on `obj`
    """
    return dir(obj)


def is_dunder(name: str) -> bool:
    """
    Determines if a name represents a "dunder" (double underscore) method

    >>> is_dunder('__iter__')
    True
    >>> is_dunder('some_func')
    False

    :param name: The name to check
    :return: True if the name is a dunder, False otherwise
    """
    return len(name) > 4 and name.startswith('__') and name.endswith('__')


AttrList = Iterable[Tuple[str, Any]]


def dump_attrs(obj: object, ignore_dunder: bool = False) -> AttrList:
    """
    Dump a list of tuples of (name, value) for all attributes on an object

    >>> class C:
    ...     a = 1
    ...     b = 2
    >>> list(dump_attrs(C(), True))
    [('a', 1), ('b', 2)]

    And with __slots__:

    >>> class C:
    ...     __slots__ = ('a', 'b')
    ...
    ...     def __init__(self):
    ...         self.a = 1
    ...         self.b = 2

    >>> list(dump_attrs(C(), True))
    [('a', 1), ('b', 2)]

    :param obj: The object to retrieve attributes from
    :param ignore_dunder: Whether to ignore "dunder" fields and methods
    :return: An iterable of (name, value) tuples for each attribute on `obj`
    """
    for name in get_attrs(obj):
        if ignore_dunder and is_dunder(name):
            # Ignore dunder fields
            continue

        yield (name, getattr(obj, name, None))


def indent(lines: Iterable[str], size: int = 2, char: str = ' '):
    """
    Indent each line in an iterable and yield it, ignoring blank lines

    >>> list(indent(['a', 'b', '', 'c']))
    ['  a', '  b', '', '  c']

    :param lines: The iterable of lines to indent
    :param size: How large of an indent should be used
    :param char: What character should be used to indent
    :return: An iterable containing each line from `lines`, indented
    """
    for line in lines:
        if line:
            yield (char * size) + line
        else:
            yield line


def format_requests_exc(exc: RequestException) -> Iterable[str]:
    """
    Format a RequestException
    :param exc: The exception to format
    :return: An iterable of lines representing the formatted data
    """

    def _format(title, obj):
        if obj is not None:
            yield title
            yield from indent(format_attrs(obj))

    yield from _format("Request Info", exc.request)
    yield from _format("Response Info", exc.response)


SPECIAL_CASES = {
    RequestException: format_requests_exc,
}


def format_error_data(exc: Exception) -> Iterable[str]:
    yield repr(exc)
    yield from indent(format_attrs(exc, ignore_dunder=True))

    for typ, func in SPECIAL_CASES.items():
        if isinstance(exc, typ):
            yield from indent(func(exc))

    yield ''


def format_error_chain(exc: Exception) -> Iterable[str]:
    """
    Format a whole chain of exceptions, going up the list for
    each cause/context exception

    :param exc: The exception to format
    :return: An iterable of lines of the formatted data from the exception
    """
    while exc:
        yield from format_error_data(exc)
        # Get "direct cause of" or
        # "during handling of ..., another exception occurred" stack
        cause = getattr(exc, '__cause__', None)
        context = getattr(exc, '__context__', None)
        exc = cause or context


def format_attrs(obj: object, ignore_dunder: bool = False) -> Iterable[str]:
    """
    Format an object's attributes in an easy to read, multi-line format

    >>> class C:
    ...     a = 1
    ...     b = 2
    >>> list(format_attrs(C, True))
    ['a = 1', 'b = 2']

    :param obj: The object to inspect
    :param ignore_dunder: Whether to hide dunder methods/fields
    :return: An iterable of lines of formatted data
    """
    for k, v in dump_attrs(obj, ignore_dunder=ignore_dunder):
        yield '{} = {!r}'.format(k, v)


@hook.post_hook
def on_hook_end(error, launched_hook, launched_event, admin_log):
    if error is None:
        return

    should_broadcast = True
    messages = [
        "Error occurred in {}.{}".format(
            launched_hook.plugin.title, launched_hook.function_name
        )
    ]

    try:
        lines = traceback.format_exception(*error)
        last_line = lines[-1]
        messages.append(last_line.strip())
    except Exception:
        msg = traceback.format_exc()[-1]
        messages.append(
            "Error occurred while formatting error {}".format(msg)
        )
    else:
        try:
            url = web.paste('\n'.join(lines))
            messages.append("Traceback: " + url)
        except Exception:
            msg = traceback.format_exc()[-1]
            messages.append(
                "Error occurred while gathering traceback {}".format(msg)
            )

    try:
        lines = ["Event Data:"]
        lines.extend(indent(format_attrs(launched_event)))
        _, exc, _ = error

        lines.append("")
        lines.append("Error data:")
        lines.extend(indent(format_error_chain(exc)))

        url = web.paste('\n'.join(lines))
        messages.append("Event: " + url)
    except Exception:
        msg = traceback.format_exc()[-1]
        messages.append(
            "Error occurred while gathering error data {}".format(msg)
        )

    for message in messages:
        admin_log(message, should_broadcast)

# // license
# Copyright 2016, Free Software Foundation.
#
# This file is part of Solent.
#
# Solent is free software: you can redistribute it and/or modify it under the
# terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option)
# any later version.
#
# Solent is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# Solent. If not, see <http://www.gnu.org/licenses/>.
#
# // overview
# Here, we host a TCP server for a line console. A single client is able to
# connect. At this point, the server takes down its listen interface. This is
# not a blocking server, but shows the same behaviour to clients.
#
# There is an advance on the previous module in this series. Consider what
# would happen if the user submitted a long line, where the length exceeded
# the size of a single payload. Here, we filter all input through
# rail_line_finder. This calls back at the termination of a line, rather than
# making unreliable inferences about messages within payloads.
#
# This module serves an illustrative purpose. But if ever you need a netcat
# server such as this, please example solent.util.rail_line_console. It does
# pretty much the same as below, and saves you having to type it in.

from solent import Engine
from solent import RailLineFinder
from solent import SolentQuitException
from solent import log

I_NEARCAST = '''
    i message h
        i field h

    message init
    message exit

    message user_line
        field msg
'''

MTU = 1400

TCP_SERVER_ADDR = '0.0.0.0'
TCP_SERVER_PORT = 8000

class CogAppConsole:
    def __init__(self, cog_h, orb, engine):
        self.cog_h = cog_h
        self.orb = orb
        self.engine = engine
        #
        self.b_active = False
        self.tcp_server_addr = None
        self.tcp_server_port = None
        self.server_sid = None
        self.accept_sid = None
        #
        self.rail_line_finder = RailLineFinder()
        self.rail_line_finder.zero(
            rail_h='line_finder.only',
            cb_line_finder_event=self.cb_line_finder_event)
    def orb_close(self):
        if self.server_sid:
            self._stop_server()
        if self.accept_sid:
            self.engine.close_tcp_server(
                server_sid=self.server_sid)
    #
    def on_init(self):
        self.tcp_server_addr = TCP_SERVER_ADDR
        self.tcp_server_port = TCP_SERVER_PORT
        #
        self.b_active = True
        self._start_server()
    def on_exit(self):
        self.b_active = False
        self._stop_server()
    #
    def cb_line_finder_event(self, cs_line_finder_event):
        rail_h = cs_line_finder_event.rail_h
        msg = cs_line_finder_event.msg
        #
        self.nearcast.user_line(
            msg=msg)
    def cb_tcp_server_start(self, cs_tcp_server_start):
        engine = cs_tcp_server_start.engine
        server_sid = cs_tcp_server_start.server_sid
        addr = cs_tcp_server_start.addr
        port = cs_tcp_server_start.port
        #
        self.server_sid = server_sid
        log('cb_tcp_server_start, sid %s, at %s:%s'%(server_sid, addr, port))
    def cb_tcp_server_stop(self, cs_tcp_server_stop):
        engine = cs_tcp_server_stop.engine
        server_sid = cs_tcp_server_stop.server_sid
        msg = cs_tcp_server_stop.message
        #
        self.server_sid = None
        log('cb_tcp_server_stop, sid %s, %s'%(server_sid, msg))
    def cb_tcp_accept_connect(self, cs_tcp_accept_connect):
        engine = cs_tcp_accept_connect.engine
        server_sid = cs_tcp_accept_connect.server_sid
        accept_sid = cs_tcp_accept_connect.accept_sid
        accept_addr = cs_tcp_accept_connect.accept_addr
        accept_port = cs_tcp_accept_connect.accept_port
        #
        log('cb_tcp_accept_connect from %s:%s'%(
            accept_addr, accept_port))
        self.engine.close_tcp_server(
            server_sid=self.server_sid)
        self.accept_sid = accept_sid
        self.rail_line_finder.clear()
    def cb_tcp_accept_condrop(self, cs_tcp_accept_condrop):
        engine = cs_tcp_accept_condrop.engine
        server_sid = cs_tcp_accept_condrop.server_sid
        accept_sid = cs_tcp_accept_condrop.accept_sid
        #
        log('cb_tcp_accept_condrop from %s'%(
            accept_sid))
        self.accept_sid = None
        if self.b_active:
            self._start_server()
    def cb_tcp_accept_recv(self, cs_tcp_accept_recv):
        engine = cs_tcp_accept_recv.engine
        accept_sid = cs_tcp_accept_recv.accept_sid
        bb = cs_tcp_accept_recv.bb
        #
        msg = bb.decode('utf8')
        self.rail_line_finder.accept_string(
            s=msg)
    #
    def _start_server(self):
        self.engine.open_tcp_server(
            addr=self.tcp_server_addr,
            port=self.tcp_server_port,
            cb_tcp_server_start=self.cb_tcp_server_start,
            cb_tcp_server_stop=self.cb_tcp_server_stop,
            cb_tcp_accept_connect=self.cb_tcp_accept_connect,
            cb_tcp_accept_condrop=self.cb_tcp_accept_condrop,
            cb_tcp_accept_recv=self.cb_tcp_accept_recv)
    def _stop_server(self):
        self.engine.close_tcp_server(
            server_sid=self.server_sid)

class CogPrinter:
    def __init__(self, cog_h, orb, engine):
        self.cog_h = cog_h
        self.orb = orb
        self.engine = engine
    def on_user_line(self, msg):
        log("Received line [%s]"%msg)

def init(engine):
    orb = engine.init_orb(
        i_nearcast=I_NEARCAST)
    orb.init_cog(CogAppConsole)
    orb.init_cog(CogPrinter)
    #
    bridge = orb.init_autobridge()
    bridge.nc_init()

def main():
    engine = Engine(
        mtu=MTU)
    try:
        init(
            engine=engine)
        engine.event_loop()
    except KeyboardInterrupt:
        pass
    except SolentQuitException:
        pass
    finally:
        engine.close()

if __name__ == '__main__':
    main()


import logging
logger = logging.getLogger(name=__name__)
import pyqtgraph as pg
import numpy as np
import time
from qtpy import QtCore
from .test_redpitaya import TestRedpitaya
from .. import APP
from ..async_utils import sleep as async_sleep


class TestPyqtgraph(TestRedpitaya):
    """ This test case creates a maximally simplistic scope gui
    that continuously plots the data of both scope channels,
    and checks the obtainable frame rate.
    Frame rates down to 20 Hz are accepted """
    N = 2 ** 14
    cycles = 50  # cycles to average frame rate over
    frequency = 10.0
    duration = 1.0
    dt = 0.01  # maximum frame rate is 100 Hz
    REDPITAYA = False  # REDPITAYA=True tests the speed with Red Pitaya Scope
    timeout = 10.0  # timeout if the gui never plots anything

    def setup(self):
        self.t0 = np.linspace(0, self.duration, self.N)
        self.plotWidget = pg.plot(title="Realtime plotting benchmark")
        self.cycle = 0
        self.starttime = time.time()  # not yet the actual starttime, but needed for timeout
        if self.REDPITAYA:
            self.r.scope.setup(trigger_source='immediately', duration=self.duration)
        self.timer = QtCore.QTimer()
        self.timer.setInterval(1000*self.dt)
        self.timer.timeout.connect(self.update_plot)
        self.timer.start()

    def teardown(self):
        self.timer.stop()
        APP.processEvents()
        self.plotWidget.close()
        APP.processEvents()

    def update_plot(self):
        self.cycle += 1
        if self.cycle == 1:
            self.starttime = time.time()
        if self.cycle == self.cycles:
            self.endtime = time.time()
        if self.REDPITAYA:
            t = self.r.scope.times
            #y1 = self.r.scope.curve(ch=1, timeout=0)
            #y2 = self.r.scope.curve(ch=2, timeout=0)
            #self.r.scope.setup()
            y1 = self.r.scope._data_ch1_current
            y2 = self.r.scope._data_ch2_current
        else:
            t = self.t0 + (time.time()-self.starttime)
            phi = 2.0*np.pi*self.frequency*t
            y1 = np.sin(phi)
            y2 = np.cos(phi)
        if self.cycle == 1:
            self.c1 = self.plotWidget.plot(t, y1, pen='g')
            self.c2 = self.plotWidget.plot(t, y2, pen='r')
        else:
            self.c1.setData(t, y1)
            self.c2.setData(t, y2)

    def test_speed(self):
        # for now, this test is a cause of hangup
        # return
        # wait for the gui to display all required curves
        while self.cycle < self.cycles or (time.time() > self.timeout + self.starttime):
            # this is needed such that the test GUI actually plots something
            async_sleep(0.01)
        if self.cycle < self.cycles:
            assert False, "Must complete %d cycles before testing for speed!"%self.cycles
        else:
            # time per frame
            dt = (self.endtime - self.starttime) / self.cycles
            print("Frame rate: %f Hz"%(1.0/dt))
            dt *= 1e3
            print("Update period: %f ms" %(dt))
            # require at least 20 fps
            assert (dt < 50.0), \
                "Frame update time of %f ms with%s redpitaya scope is above specification of 50 ms!" \
                % ('out' if self.REDPITAYA else '', dt)

import os
import ftplib
import urllib2
from cStringIO import StringIO
from urlparse import urlparse
from posixpath import join as join_url_path


class AbstractAdapter(object):

    uri = None

    def __init__(self, uri=None):
        """Takes a URI in the form of ftp://username:password@server.com/"""

        if uri and isinstance(uri, str):
            uri = urlparse(uri)

        if uri:
            if uri.hostname:
                self.hostname = uri.hostname
                self.connect(uri.hostname, uri.port)
            else:
                self.hostname = 'localhost'

            if getattr(uri, 'username', False) and getattr(uri, 'password', False):
                self.login(uri.username, uri.password)

            if uri.path:
                self.cd(uri.path)

            self.uri = uri

    def __repr__(self):
        return u'<{0} {1}: {2}>'.format(self.__class__.__name__,
            self.hostname, self.pwd())

    def __del__(self):
        if hasattr(self, 'disconnect'):
            self.disconnect()

    def _open_file_or_string(self, data):
        data_type = type(data)
        if hasattr(data, 'read'):
            return data.read()
        elif data_type is str:
            return data
        else:
            raise NotImplementedError(
                "Unable to extract data from %s, should be str "
                "or file like object with a read method" % data_type)


class LocalFileAdapter(AbstractAdapter):
    """Transporter adapter for working with the local file system
    """

    path = "/"

    def cd(self, path="."):
        new_path = os.path.abspath(os.path.join(self.path, path))
        if os.path.exists(new_path):
            self.path = new_path
        else:
            raise OSError("Path {0} does not exist".format(new_path))

    def pwd(self, path=""):
        return os.path.join(self.path, path).rstrip('\/')

    def ls(self):
        return os.listdir(self.path)

    def mkdir(self, path):
        os.mkdir(os.path.join(self.pwd(), path))

    def mv(self, source, destination):
        os.rename(self.pwd(source), self.pwd(destination))

    def rm(self, path):
        path = os.path.join(self.path, path)
        os.unlink(path)

    def rmdir(self, path):
        path = os.path.join(self.path, path)
        os.rmdir(path)

    def get(self, path):
        path = os.path.join(self.path, path)
        return open(path, 'r+b')

    def put(self, path, data):
        data = self._open_file_or_string(data)
        path = os.path.join(self.path, path)

        new_file = open(path, 'w')
        new_file.write(data)
        new_file.close()
        return new_file


class FtpAdapter(AbstractAdapter):
    """Transporter adapter for working with FTP servers
    """

    ftp = None

    def connect(self, host, port=None):
        if self.ftp:
            self.disconnect()

        self.ftp = ftplib.FTP()
        self.ftp.connect(host, port)

    def login(self, username, password):
        self.ftp.login(user=username, passwd=password)

    def cd(self, path="."):
        self.ftp.cwd(path)

    def pwd(self, path=""):
        return os.path.join(self.ftp.pwd(), path).rstrip('\/')

    def ls(self):
        return self.ftp.nlst()

    def mkdir(self, path):
        self.ftp.mkd(os.path.join(self.pwd(), path))

    def mv(self, source, destination):
        self.ftp.rename(source, destination)

    def rm(self, path):
        self.ftp.delete(path)

    def rmdir(self, path):
        self.ftp.rmd(path)

    def get(self, path):
        io = StringIO()
        self.ftp.retrbinary(u'RETR %s' % path, io.write)
        io.seek(0)
        return io

    def put(self, path, data):
        data = StringIO(self._open_file_or_string(data))
        self.ftp.storbinary(u'STOR %s' % os.path.basename(path), data)

    def disconnect(self):
        if self.ftp:
            self.ftp.quit()
            self.ftp = None


class HttpAdapter(AbstractAdapter):

    host = None
    port = None
    path = '/'
    opener = None

    def connect(self, host, port):
        self.host = host
        self.port = port

    def login(self, username, password):
        manager = urllib2.HTTPPasswordMgrWithDefaultRealm()
        manager.add_password(None, self.hostname, username, password)
        handler = urllib2.HTTPDigestAuthHandler(manager)
        self.opener = urllib2.build_opener(handler)

    def cd(self, path="."):
        self.path = join_url_path(self.path, path)

    def get(self, path):
        url = self.uri.geturl()
        if self.opener:
            result = self.opener.open(url)
        else:
            result = urllib2.urlopen(url)
        return result

import os
from setuptools import setup

here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, "README.rst")).read()

# silly-ness to make tests work
try:
    import multiprocessing
    import logging
except ImportError:
    pass


def get_requires():
    with open(os.path.join(here, "requirements.txt"), "r") as f:
        return [line.strip() for line in f]


setup(
    name="tahrir-api",
    version="0.8.1",
    description="An API for interacting with the Tahrir database",
    long_description=README,
    license="GPLv3+",
    classifiers=[
        "Programming Language :: Python",
        "Framework :: Pyramid",
        "Topic :: Internet :: WWW/HTTP",
        "License :: OSI Approved :: GNU General Public License v3 or later(GPLv3+)",
    ],
    author="Ross Delinger",
    author_email="rdelinge@redhat.com",
    url="http://github.com/fedora-infra/tahrir-api",
    keywords="web sqlalchemy api",
    packages=["tahrir_api", "tahrir_api.scripts"],
    include_package_data=True,
    zip_safe=False,
    install_requires=get_requires(),
    tests_require=["nose"],
    test_suite="nose.collector",
    entry_points="""
      [console_scripts]
      initialize_tahrir_db = tahrir_api.scripts.initializedb:main
      populate_series_in_tahrir_db = tahrir_api.scripts.populateseries:main
      """,
)

# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt

from __future__ import unicode_literals
import frappe
from frappe import _
from frappe.utils import flt, today

def execute(filters=None):
	filters = frappe._dict(filters or {})
	return get_columns(), get_data(filters)

def get_columns():
	return [_("Item Code") + ":Link/Item:140", _("Item Name") + "::100", _("Description") + "::200",
		_("Item Group") + ":Link/Item Group:100", _("Brand") + ":Link/Brand:100", _("Warehouse") + ":Link/Warehouse:120",
		_("UOM") + ":Link/UOM:100", _("Actual Qty") + ":Float:100", _("Planned Qty") + ":Float:100",
		_("Requested Qty") + ":Float:110", _("Ordered Qty") + ":Float:100",
		_("Reserved Qty") + ":Float:100", _("Reserved Qty for Production") + ":Float:100",
		_("Reserved for sub contracting") + ":Float:100",
		_("Projected Qty") + ":Float:100", _("Reorder Level") + ":Float:100", _("Reorder Qty") + ":Float:100",
		_("Shortage Qty") + ":Float:100"]

def get_data(filters):
	bin_list = get_bin_list(filters)
	item_map = get_item_map(filters.get("item_code"))
	warehouse_company = {}
	data = []

	for bin in bin_list:
		item = item_map.get(bin.item_code)

		if not item:
			# likely an item that has reached its end of life
			continue

		# item = item_map.setdefault(bin.item_code, get_item(bin.item_code))
		company = warehouse_company.setdefault(bin.warehouse,
			frappe.db.get_value("Warehouse", bin.warehouse, "company"))

		if filters.brand and filters.brand != item.brand:
			continue

		elif filters.company and filters.company != company:
			continue

		re_order_level = re_order_qty = 0

		for d in item.get("reorder_levels"):
			if d.warehouse == bin.warehouse:
				re_order_level = d.warehouse_reorder_level
				re_order_qty = d.warehouse_reorder_qty

		shortage_qty = re_order_level - flt(bin.projected_qty) if (re_order_level or re_order_qty) else 0

		data.append([item.name, item.item_name, item.description, item.item_group, item.brand, bin.warehouse,
			item.stock_uom, bin.actual_qty, bin.planned_qty, bin.indented_qty, bin.ordered_qty,
			bin.reserved_qty, bin.reserved_qty_for_production, bin.reserved_qty_for_sub_contract,
			bin.projected_qty, re_order_level, re_order_qty, shortage_qty])

	return data

def get_bin_list(filters):
	conditions = []
	
	if filters.item_code:
		conditions.append("item_code = '%s' "%filters.item_code)
		
	if filters.warehouse:
		warehouse_details = frappe.db.get_value("Warehouse", filters.warehouse, ["lft", "rgt"], as_dict=1)

		if warehouse_details:
			conditions.append(" exists (select name from `tabWarehouse` wh \
				where wh.lft >= %s and wh.rgt <= %s and bin.warehouse = wh.name)"%(warehouse_details.lft,
				warehouse_details.rgt))

	bin_list = frappe.db.sql("""select item_code, warehouse, actual_qty, planned_qty, indented_qty,
		ordered_qty, reserved_qty, reserved_qty_for_production, reserved_qty_for_sub_contract, projected_qty
		from tabBin bin {conditions} order by item_code, warehouse
		""".format(conditions=" where " + " and ".join(conditions) if conditions else ""), as_dict=1)

	return bin_list

def get_item_map(item_code):
	"""Optimization: get only the item doc and re_order_levels table"""

	condition = ""
	if item_code:
		condition = 'and item_code = "{0}"'.format(frappe.db.escape(item_code, percent=False))

	items = frappe.db.sql("""select * from `tabItem` item
		where is_stock_item = 1
		and disabled=0
		{condition}
		and (end_of_life > %(today)s or end_of_life is null or end_of_life='0000-00-00')
		and exists (select name from `tabBin` bin where bin.item_code=item.name)"""\
		.format(condition=condition), {"today": today()}, as_dict=True)

	condition = ""
	if item_code:
		condition = 'where parent="{0}"'.format(frappe.db.escape(item_code, percent=False))

	reorder_levels = frappe._dict()
	for ir in frappe.db.sql("""select * from `tabItem Reorder` {condition}""".format(condition=condition), as_dict=1):
		if ir.parent not in reorder_levels:
			reorder_levels[ir.parent] = []

		reorder_levels[ir.parent].append(ir)

	item_map = frappe._dict()
	for item in items:
		item["reorder_levels"] = reorder_levels.get(item.name) or []
		item_map[item.name] = item

	return item_map

# -*- encoding: utf-8 -*-
# This file is distributed under the same license as the Django package.
#
from __future__ import unicode_literals

# The *_FORMAT strings use the Django date format syntax,
# see http://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
DATE_FORMAT = 'j N Y'
DATETIME_FORMAT = "j N Y, G.i.s"
TIME_FORMAT = 'G.i.s'
YEAR_MONTH_FORMAT = 'F Y'
MONTH_DAY_FORMAT = 'j F'
SHORT_DATE_FORMAT = 'd-m-Y'
SHORT_DATETIME_FORMAT = 'd-m-Y G.i.s'
FIRST_DAY_OF_WEEK = 1 #Monday

# The *_INPUT_FORMATS strings use the Python strftime format syntax,
# see http://docs.python.org/library/datetime.html#strftime-strptime-behavior
DATE_INPUT_FORMATS = (
    '%d-%m-%y', '%d/%m/%y',             # '25-10-09', 25/10/09'
    '%d-%m-%Y', '%d/%m/%Y',             # '25-10-2009', 25/10/2009'
    '%d %b %Y',                         # '25 Oct 2006',
    '%d %B %Y',                         # '25 October 2006'
)

TIME_INPUT_FORMATS = (
    '%H.%M.%S',                         # '14.30.59'
    '%H.%M',                            # '14.30'
)

DATETIME_INPUT_FORMATS = (
    '%d-%m-%Y %H.%M.%S',                # '25-10-2009 14.30.59'
    '%d-%m-%Y %H.%M.%S.%f',             # '25-10-2009 14.30.59.000200'
    '%d-%m-%Y %H.%M',                   # '25-10-2009 14.30'
    '%d-%m-%Y',                         # '25-10-2009'
    '%d-%m-%y %H.%M.%S',                # '25-10-09' 14.30.59'
    '%d-%m-%y %H.%M.%S.%f',             # '25-10-09' 14.30.59.000200'
    '%d-%m-%y %H.%M',                   # '25-10-09' 14.30'
    '%d-%m-%y',                         # '25-10-09''
    '%m/%d/%y %H.%M.%S',                # '10/25/06 14.30.59'
    '%m/%d/%y %H.%M.%S.%f',             # '10/25/06 14.30.59.000200'
    '%m/%d/%y %H.%M',                   # '10/25/06 14.30'
    '%m/%d/%y',                         # '10/25/06'
    '%m/%d/%Y %H.%M.%S',                # '25/10/2009 14.30.59'
    '%m/%d/%Y %H.%M.%S.%f',             # '25/10/2009 14.30.59.000200'
    '%m/%d/%Y %H.%M',                   # '25/10/2009 14.30'
    '%m/%d/%Y',                         # '10/25/2009'
)

DECIMAL_SEPARATOR = ','
THOUSAND_SEPARATOR = '.'
NUMBER_GROUPING = 3

# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""L2HMC on simple Gaussian mixture model with TensorFlow eager."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import sys

from absl import flags
import numpy as np
import tensorflow as tf
from tensorflow.contrib.eager.python.examples.l2hmc import l2hmc
try:
  import matplotlib.pyplot as plt  # pylint: disable=g-import-not-at-top
  HAS_MATPLOTLIB = True
except ImportError:
  HAS_MATPLOTLIB = False
tfe = tf.contrib.eager


def main(_):
  tf.enable_eager_execution()
  global_step = tf.train.get_or_create_global_step()
  global_step.assign(1)

  energy_fn, mean, covar = {
      "scg": l2hmc.get_scg_energy_fn(),
      "rw": l2hmc.get_rw_energy_fn()
  }[FLAGS.energy_fn]

  x_dim = 2
  train_iters = 5000
  eval_iters = 2000
  eps = 0.1
  n_steps = 10  # Chain length
  n_samples = 200
  record_loss_every = 100

  dynamics = l2hmc.Dynamics(
      x_dim=x_dim, minus_loglikelihood_fn=energy_fn, n_steps=n_steps, eps=eps)
  learning_rate = tf.train.exponential_decay(
      1e-3, global_step, 1000, 0.96, staircase=True)
  optimizer = tf.train.AdamOptimizer(learning_rate)
  checkpointer = tf.train.Checkpoint(
      optimizer=optimizer, dynamics=dynamics, global_step=global_step)

  if FLAGS.train_dir:
    summary_writer = tf.contrib.summary.create_file_writer(FLAGS.train_dir)
    if FLAGS.restore:
      latest_path = tf.train.latest_checkpoint(FLAGS.train_dir)
      checkpointer.restore(latest_path)
      print("Restored latest checkpoint at path:\"{}\" ".format(latest_path))
      sys.stdout.flush()

  if not FLAGS.restore:
    # Training
    if FLAGS.use_defun:
      # Use `tfe.deun` to boost performance when there are lots of small ops
      loss_fn = tfe.defun(l2hmc.compute_loss)
    else:
      loss_fn = l2hmc.compute_loss

    samples = tf.random_normal(shape=[n_samples, x_dim])
    for i in range(1, train_iters + 1):
      loss, samples, accept_prob = train_one_iter(
          dynamics,
          samples,
          optimizer,
          loss_fn=loss_fn,
          global_step=global_step)

      if i % record_loss_every == 0:
        print("Iteration {}, loss {:.4f}, x_accept_prob {:.4f}".format(
            i, loss.numpy(),
            accept_prob.numpy().mean()))
        if FLAGS.train_dir:
          with summary_writer.as_default():
            with tf.contrib.summary.always_record_summaries():
              tf.contrib.summary.scalar("Training loss", loss, step=global_step)
    print("Training complete.")
    sys.stdout.flush()

    if FLAGS.train_dir:
      saved_path = checkpointer.save(
          file_prefix=os.path.join(FLAGS.train_dir, "ckpt"))
      print("Saved checkpoint at path: \"{}\" ".format(saved_path))
      sys.stdout.flush()

  # Evaluation
  if FLAGS.use_defun:
    # Use tfe.deun to boost performance when there are lots of small ops
    apply_transition = tfe.defun(dynamics.apply_transition)
  else:
    apply_transition = dynamics.apply_transition

  samples = tf.random_normal(shape=[n_samples, x_dim])
  samples_history = []
  for i in range(eval_iters):
    samples_history.append(samples.numpy())
    _, _, _, samples = apply_transition(samples)
  samples_history = np.array(samples_history)
  print("Sampling complete.")
  sys.stdout.flush()

  # Mean and covariance of target distribution
  mean = mean.numpy()
  covar = covar.numpy()
  ac_spectrum = compute_ac_spectrum(samples_history, mean, covar)
  print("First 25 entries of the auto-correlation spectrum: {}".format(
      ac_spectrum[:25]))
  ess = compute_ess(ac_spectrum)
  print("Effective sample size per Metropolis-Hastings step: {}".format(ess))
  sys.stdout.flush()

  if FLAGS.train_dir:
    # Plot autocorrelation spectrum in tensorboard
    plot_step = tfe.Variable(1, trainable=False, dtype=tf.int64)

    for ac in ac_spectrum:
      with summary_writer.as_default():
        with tf.contrib.summary.always_record_summaries():
          tf.contrib.summary.scalar("Autocorrelation", ac, step=plot_step)
      plot_step.assign(plot_step + n_steps)

    if HAS_MATPLOTLIB:
      # Choose a single chain and plot the trajectory
      single_chain = samples_history[:, 0, :]
      xs = single_chain[:100, 0]
      ys = single_chain[:100, 1]
      plt.figure()
      plt.plot(xs, ys, color="orange", marker="o", alpha=0.6)  # Trained chain
      plt.savefig(os.path.join(FLAGS.train_dir, "single_chain.png"))


def train_one_iter(dynamics,
                   x,
                   optimizer,
                   loss_fn=l2hmc.compute_loss,
                   global_step=None):
  """Train the sampler for one iteration."""
  loss, grads, out, accept_prob = l2hmc.loss_and_grads(
      dynamics, x, loss_fn=loss_fn)
  optimizer.apply_gradients(
      zip(grads, dynamics.trainable_variables), global_step=global_step)

  return loss, out, accept_prob


def compute_ac_spectrum(samples_history, target_mean, target_covar):
  """Compute autocorrelation spectrum.

  Follows equation 15 from the L2HMC paper.

  Args:
    samples_history: Numpy array of shape [T, B, D], where T is the total
        number of time steps, B is the batch size, and D is the dimensionality
        of sample space.
    target_mean: 1D Numpy array of the mean of target(true) distribution.
    target_covar: 2D Numpy array representing a symmetric matrix for variance.
  Returns:
    Autocorrelation spectrum, Numpy array of shape [T-1].
  """

  # Using numpy here since eager is a bit slow due to the loop
  time_steps = samples_history.shape[0]
  trace = np.trace(target_covar)

  rhos = []
  for t in range(time_steps - 1):
    rho_t = 0.
    for tau in range(time_steps - t):
      v_tau = samples_history[tau, :, :] - target_mean
      v_tau_plus_t = samples_history[tau + t, :, :] - target_mean
      # Take dot product over observation dims and take mean over batch dims
      rho_t += np.mean(np.sum(v_tau * v_tau_plus_t, axis=1))

    rho_t /= trace * (time_steps - t)
    rhos.append(rho_t)

  return np.array(rhos)


def compute_ess(ac_spectrum):
  """Compute the effective sample size based on autocorrelation spectrum.

  This follows equation 16 from the L2HMC paper.

  Args:
    ac_spectrum: Autocorrelation spectrum
  Returns:
    The effective sample size
  """
  # Cutoff from the first value less than 0.05
  cutoff = np.argmax(ac_spectrum[1:] < .05)
  if cutoff == 0:
    cutoff = len(ac_spectrum)
  ess = 1. / (1. + 2. * np.sum(ac_spectrum[1:cutoff]))
  return ess


if __name__ == "__main__":
  flags.DEFINE_string(
      "train_dir",
      default=None,
      help="[Optional] Directory to store the training information")
  flags.DEFINE_boolean(
      "restore",
      default=False,
      help="[Optional] Restore the latest checkpoint from `train_dir` if True")
  flags.DEFINE_boolean(
      "use_defun",
      default=False,
      help="[Optional] Use `tfe.defun` to boost performance")
  flags.DEFINE_string(
      "energy_fn",
      default="scg",
      help="[Optional] The energy function used for experimentation"
      "Other options include `rw`")
  FLAGS = flags.FLAGS
  tf.app.run(main)

# -*- Mode: Python -*-
# vi:si:et:sw=4:sts=4:ts=4
#
# Flumotion - a streaming media server
# Copyright (C) 2008 Fluendo, S.L. (www.fluendo.com).
# All rights reserved.

# This file may be distributed and/or modified under the terms of
# the GNU General Public License version 2 as published by
# the Free Software Foundation.
# This file is distributed without any warranty; without even the implied
# warranty of merchantability or fitness for a particular purpose.
# See "LICENSE.GPL" in the source distribution for more information.

# Licensees having purchased or holding a valid Flumotion Advanced
# Streaming Server license may use this file in accordance with the
# Flumotion Advanced Streaming Server Commercial License Agreement.
# See "LICENSE.Flumotion" in the source distribution for more information.

# Headers in this file shall remain intact.

"""GnomeVFS backend for Virtual File System.
"""

import os

from twisted.internet.defer import succeed
from twisted.spread.flavors import Copyable, RemoteCopy
from twisted.spread.jelly import setUnjellyableForClass
from zope.interface import implements

from flumotion.common import log
from flumotion.common.errors import AccessDeniedError
from flumotion.common.interfaces import IDirectory, IFile

# gnomevfs is only imported inside nested scopes so that
# pychecker can ignore them, If pychecker ever gets fixed,
# move it back where it belongs
__pychecker__ = 'keepgoing'


class GnomeVFSFile(Copyable, RemoteCopy):
    """I am object implementing L{IFile} on top of GnomeVFS,
    see L{IFile} for more information.
    """
    implements(IFile)

    def __init__(self, parent, fileInfo):
        self.parent = parent
        self.filename = fileInfo.name
        self.iconNames = ['gnome-fs-regular']

    # IFile

    def getPath(self):
        return os.path.join(self.parent, self.filename)


class GnomeVFSDirectory(Copyable, RemoteCopy):
    """I am object implementing L{IDirectory} on top of GnomeVFS,
    see L{IDirectory} for more information.
    """
    implements(IDirectory)

    def __init__(self, path, name=None):
        import gnomevfs
        if not os.path.exists(path):
            self.path = '/'
        else:
            self.path = os.path.abspath(path)

        if name is None:
            fileInfo = gnomevfs.get_file_info(self.path)
            name = fileInfo.name
        self.filename = name
        self.iconNames = ['gnome-fs-directory']
        self._cachedFiles = None

    # IFile

    def getPath(self):
        return self.path

    # IDirectory

    def getFiles(self):
        return succeed(self._cachedFiles)

    def cacheFiles(self):
        """
        Fetches the files contained on the directory for posterior usage of
        them. This should be called on the worker side to work or the files
        wouldn't be the expected ones.
        """
        import gnomevfs
        log.debug('vfsgnome', 'getting files for %s' % (self.path, ))
        retval = []
        try:
            fileInfos = gnomevfs.open_directory(self.path)
        except gnomevfs.AccessDeniedError:
            raise AccessDeniedError
        if self.path != '/':
            retval.append(GnomeVFSDirectory(os.path.dirname(self.path),
                                            name='..'))
        for fileInfo in fileInfos:
            filename = fileInfo.name
            if filename.startswith('.'):
                continue
            if fileInfo.type == gnomevfs.FILE_TYPE_DIRECTORY:
                obj = GnomeVFSDirectory(os.path.join(self.path,
                                                     fileInfo.name))
            else:
                obj = GnomeVFSFile(self.path, fileInfo)
            retval.append(obj)
        log.log('vfsgnome', 'returning %r' % (retval, ))
        self._cachedFiles = retval


def registerGnomeVFSJelly():
    """Register the jelly used by the GnomeVFS VFS backend.
    """
    setUnjellyableForClass(GnomeVFSFile, GnomeVFSFile)
    setUnjellyableForClass(GnomeVFSDirectory, GnomeVFSDirectory)
    log.info('jelly', 'GnomeVFS registered')



espt_delim_atom_fields = set(["pos", "type", "v", "f", 
                              "bond", 
                              "temp", "gamma", 
                              "q", 
                              "quat", "omega", "torque", 
                              "rinertia", "fix", "unfix", "ext_force",
                              "exclude", "delete", 
                              "mass",
                              "dipm", "dip", "virtual",
                              "vs_relative", "distance", "vs_auto_relate_to"])



def LinesWSlashes(text):
    """ 
    Iterate over the lines contained in a string of text.
    Merge lines ending in backslashes.

    """

    current_line = ''
    for line in text.split('\n'):
        current_line += line
        if (len(line) > 0) and (line[-1] != '\\'):
            yield current_line
            current_line = ''
    if len(current_line) > 0:
        yield current_line




def SplitMultiDelims(line, delimiters):
    """
    Split a string into tokens using one or more (multi-character) delimiters.
    (Bug: The current version of this function does not preserve white space,
          but this should not matter.)

    """

    token = ''
    for sub_token in line.strip().split():
        if sub_token in delimiters:
            yield token
            yield sub_token
            token = ''
        elif len(token) > 0:
            token += ' ' + sub_token
        else:
            token += sub_token
    if len(token) > 0:
        yield token



def SplitAtomLine(line):
    l = []
    for token in SplitMultiDelims(line, espt_delim_atom_fields):
        l.append(token)
    return l

    # In this type of TCL command, all of the delimiters 
    #    (like 'pos', 'type', 'q', ...) 
    # are supposed to be followed by an argument.  If the last 
    # token on this line IS a delimiter, then this is a syntax error.

    if token in espt_delim_atom_fields:
        raise InputError("Error: Incomplete line:\n"
                         "\""+line+"\"\n")



def iEsptAtomCoords(tokens):
    #tokens = SplitMultiDelims(line)
    i = 0
    while i < len(tokens):
        if tokens[i] in set(['pos', 'fix', 'unfix']):
            assert(i+1 < len(tokens))
            yield i+1
            i += 1
        i += 1




def iEsptAtomVects(tokens):
    #tokens = SplitMultiDelims(line)
    i = 0
    while i < len(tokens):
        if tokens[i] in set(['dip', 'rinertia', 'v', 'f', 'omega', 'torque']):
            assert(i+1 < len(tokens))
            yield i+1
            i += 1
        i += 1


def iEsptAtomType(tokens):
    #tokens = SplitMultiDelims(line)
    i = 0
    while i < len(tokens):
        if tokens[i] == 'type':
            assert(i+1 < len(tokens))
            yield i+1
            i += 1
        i += 1

def iEsptAtomID(tokens):
    if len(tokens) > 1:
        return 1
    else:
        raise InputError("Error: Incomplete line:\n"
                         "\""+line+"\"\n")


#!/usr/bin/env python

import subprocess
import os
import sys
import argparse
import time
from subprocess import PIPE, STDOUT

null = open("/dev/null", "wb")

def wait(p):
    rc = p.wait()
    if rc != 0:
        p = play("sound/misc/compiler-failure.ogg")
        p.wait()
        assert p.returncode == 0
        sys.exit(rc)

def play(soundfile):
    p = subprocess.Popen(["play", soundfile], stdout=null, stderr=null)
    assert p.wait() == 0
    return p

def stage1():
    p = subprocess.Popen("(cd tgui; /bin/bash ./build.sh)", shell=True)
    wait(p)
    play("sound/misc/compiler-stage1.ogg")

def stage2(map):
    if map:
        txt = "-M{}".format(map)
    else:
        txt = ''
    args = "bash tools/travis/dm.sh {} tgstation.dme".format(txt)
    print(args)
    p = subprocess.Popen(args, shell=True)
    wait(p)

def stage3(profile_mode=False):
    start_time = time.time()
    play("sound/misc/compiler-stage2.ogg")
    logfile = open('server.log~','w')
    p = subprocess.Popen(
        "DreamDaemon tgstation.dmb 25001 -trusted",
        shell=True, stdout=PIPE, stderr=STDOUT)
    try:
        while p.returncode is None:
            stdout = p.stdout.readline()
            if "Initializations complete." in stdout:
                play("sound/misc/server-ready.ogg")
                time_taken = time.time() - start_time
                print("{} seconds taken to fully start".format(time_taken))
            if "Map is ready." in stdout:
                time_taken = time.time() - start_time
                print("{} seconds for initial map loading".format(time_taken))
                if profile_mode:
                    return time_taken
            sys.stdout.write(stdout)
            sys.stdout.flush()
            logfile.write(stdout)
    finally:
        logfile.flush()
        os.fsync(logfile.fileno())
        logfile.close()
        p.kill()


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('-s','---stage',default=1,type=int)
    parser.add_argument('--only',action='store_true')
    parser.add_argument('-m','--map',type=str)
    parser.add_argument('--profile-mode',action='store_true')
    args = parser.parse_args()
    stage = args.stage
    assert stage in (1,2,3)
    if stage == 1:
        stage1()
        if not args.only:
            stage = 2
    if stage == 2:
        stage2(args.map)
        if not args.only:
            stage = 3
    if stage == 3:
        value = stage3(profile_mode=args.profile_mode)
        with open('profile~', 'a') as f:
            f.write("{}\n".format(value))

if __name__=='__main__':
    try:
        main()
    except KeyboardInterrupt:
        pass

#!/usr/bin/env python
'discord-logger setup script.'

import os
from distutils.core import setup


def read(fname):
    'Utility function to read files.'
    return open(os.path.join(os.path.dirname(__file__), fname)).read()


LONG_DESCRIPTION = read('README.md').splitlines()
DESCRIPTION = LONG_DESCRIPTION[1]
KEYWORDS = [
    'discord',
    'data',
    'dump',
    'export',
    'message',
    'server',
    'channel',
    'dms',
    'script',
    'log',
    'logger',
    'logging'
]
REQUIRES = read('requirements.txt').splitlines()

setup(
    name='discord-logger',
    version='0.0.1',
    description=DESCRIPTION,
    long_description=LONG_DESCRIPTION,
    keywords=''.join(e + ' ' for e in KEYWORDS).strip(),
    author='Andrea Pascal',
    author_email='andrea@anodium.net',
    url='https://github.com/anodium/discord-logger',
    package_dir={
        'discord.logging': 'src/logging'
    },
    packages=[
        'discord.logging'
    ],
    scripts=[
        'src/dsclog'
    ],
    classifiers=[
        'Development Status :: 2 - Pre-Alpha',
        'Environment :: Console',
        'Environment :: No Input/Output (Daemon)',
        'Intended Audience :: Developers',
        'Intended Audience :: End Users/Desktop',
        'Intended Audience :: Information Technology',
        'Intended Audience :: System Administrators',
        'License :: OSI Approved',
        'License :: OSI Approved :: MIT License',
        'Natural Language :: English',
        'Operating System :: OS Independent',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3',
        'Programming Language :: Python :: 3 :: Only',
        'Programming Language :: Python :: 3.5',
        'Topic :: Communications',
        'Topic :: Communications :: Chat',
        'Topic :: Internet',
        'Topic :: Internet :: Log Analysis',
        'Topic :: System',
        'Topic :: System :: Archiving',
        'Topic :: System :: Archiving :: Backup',
        'Topic :: System :: Logging',
        'Topic :: Utilities'
    ],
    requires=REQUIRES
)

import os

from urllib2 import urlopen
import urllib
import json

from django.conf import settings
from django.db import connection
from django.utils.encoding import DjangoUnicodeDecodeError

from webapp import models

from webapp import config


#TODO: this one is nasty - either update the models or write a generic raw query in query.py

def run_query(query):
    print "running query: %s" % query
    print
    cursor = connection.cursor()
    cursor.execute(query)
    result = ()

    try:
        result = cursor.fetchall()

    except Exception as e:
        print e

    print ("query result: ", result)
    print

    return result


def get_book_info(field=False, keyword=False, is_exact=False, search_limit=config.SEARCH_MAX_ITEM, no_keyword=False):
    # the function will be get_book_info(columns, keyword)
    # columns: a list that contains columns that needs to be displayed
    # keyword: the keyword for searching books

    # NOTE: function is refactored, now accepts fields in the Readerware table
    # need more testing.

    # NOTE: returned value changed: now returns a list of dict,
    # i.e. result[0] is the original expected output.

    rows = run_query('select * from WEBAPP_CONFIGURATION where name like "%get_book_info%" and value = "1" ')

    query = 'select '
    need_join = 0
    title_at = None
    cover_at = None
    book_id_at = None
    title_indicator = u''
    cover_indicator = u''
    count = 0
    columns= []

    book_cover_config = models.WebappConfiguration.objects.filter(name = 'book_cover_api_config')

    result = []

    if not field and not keyword and not no_keyword:
        return result

    if rows:
        for item in rows:
            query += '%s.%s, ' % (item[3], item[5])
            columns.append(item[2])

            if item[2].lower() == 'title':
                title_at = count
                title_indicator = item[2]

            if item[2].lower() == 'cover':
                cover_at = count
                cover_indicator = item[2]

            if item[4]:
                need_join = 1

            count += 1

        query = query[:-2]

        columns.append('id')
        book_id_at = len(columns) - 1

        query += ', READERWARE.CALL_NUMBER '

        query += ' from READERWARE '

        if need_join:
            for item in rows:
                if item[4]:
                    query += 'left join %s on %s.%s = %s.%s ' % (item[3], item[4], item[7], item[3], item[6])

        if not no_keyword:
            if isinstance(keyword, list) and keyword:
                for index in range(0, len(keyword)):
                    if index != 0:
                        query += 'and '

                    else:
                        query += 'where '

                    if is_exact:
                        query += 'READERWARE.%s="%s" ' % (field, keyword[index])

                    else:
                        query += 'READERWARE.%s like "%%%s%%" ' % (field, keyword[index])
                    index += 1

            else:
                if is_exact:
                    query += 'where READERWARE.%s="%s" ' % (field, keyword)

                else:
                    query += 'where READERWARE.%s like "%%%s%%" ' % (field, keyword)


    query += 'limit %s' % search_limit

    query_result = run_query(query)

    if query_result:
        values = list(query_result[0])

        for item in query_result:
            values = list(item)

            if title_indicator:
                title = values[title_at]

            if values[cover_at]:
                cover = os.path.join(settings.STATIC_URL, values[cover_at])

            else:
                cover = get_book_cover_default()

            book_id = values[book_id_at]

            content = dict(zip(columns, values))

            if title_indicator:
                del content[title_indicator]
            if cover_indicator:
                del content[cover_indicator]

            del content['id']

            result.append({'id': book_id, 'title': title, 'cover': cover, 'content': content})

    return result


def get_book_cover_default():
    return config.DEFAULT_COVER_URL


def get_book_cover(keyword):
    #TODO: should be working, not tested
    result = u''

    try:
        result = models.BookCover.objects.filter(book_id = keyword).values('image_url')[0]['image_url']

    except Exception, e:
        print e

        #default image
        print 'image not found - using default image'
        result = get_book_cover_default()

    return result


def update_book_cover(keyword):
    result = False
    request = u''
    image_url = u''
    file_name = u''
    file_dir = u''

    file_dir = config.COVER_PATH

    item = models.Readerware.objects.filter(isbn = keyword)

    if item:
        book_id = item.values('rowkey')[0]['rowkey']

        all_api = models.WebappConfiguration.objects.filter(name__icontains = 'book_cover_api_get_by').values()

        for api in all_api:

            if api['value'] and not image_url:
                request = api['value'] + keyword + api['value_1']

                try:
                    image_url = json.loads(urlopen(request).read())[api['value_2']]

                except KeyError:
                    print 'cannot find image / json key does not match'
                    image_url = u''

                except Exception, e:
                    print e
                    image_url = u''

        if image_url:

            file_name = image_url.split('/')[-1]
            file_dir += file_name

            try:
                urllib.urlretrieve(image_url, os.path.join(settings.STATIC_PATH, file_dir))

            except Exception, e:
                print e

                file_name = None

            models.BookCover(book_id = book_id, image_dir = file_dir).save()

            result = True

        else:
            print 'no image found for book with given isbn (%s)' % keyword

    else:
        print 'book with given isbn (%s) does not exist in database.' % keyword

    return result


def update_book_cover_all():
    success_count = 0

    items = models.Readerware.objects.exclude(isbn__isnull = True)
    items_length = items.count()

    print 'updating %s books\' cover' % items_length
    print

    for index in range(0, items_length):
        print 'updating %s / %s book\'s cover' % (index + 1, items_length)
        #TODO: need to be updated when migrating to py3

        #TODO: known bug: UnicodeDecodeError will be thrown if the db uses BOM it should be fixed on the db side so exception is supressed.

        try:
            update_result = update_book_cover(items[index].isbn)
        except DjangoUnicodeDecodeError:
            print 'Unicode Error Encountered.'
            pass

        else:
            if update_result:
                success_count += 1

    print '%s / %s covers updated.' % (success_count, items_length)
    print

    return

# Copyright (c) 2012 ARM Limited
# All rights reserved.
#
# The license below extends only to copyright in the software and shall
# not be construed as granting a license to any other intellectual
# property including but not limited to intellectual property relating
# to a hardware implementation of the functionality of the software
# licensed hereunder.  You may use the software subject to the license
# terms below provided that you ensure that this notice is replicated
# unmodified and in its entirety in all distributions of the software,
# modified or unmodified, in source code or in binary form.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Andreas Sandberg

from m5.objects import *
from arm_generic import *
from O3_ARM_v7a import O3_ARM_v7a_3

root = LinuxArmFSSystemUniprocessor(machine_type='VExpress_EMM64',
                                    mem_mode='timing',
                                    mem_class=DDR3_1600_x64,
                                    cpu_class=O3_ARM_v7a_3,
                                    checker=True).create_root()

# -*- coding: utf-8 -*-
# Copyright (C) 2014 Canonical
#
# Authors:
#  Didier Roche
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU General Public License as published by the Free Software
# Foundation; version 3.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Tests for nodejs"""

from . import ContainerTests
import os
import subprocess
from ..large import test_nodejs
from ..tools import UMAKE, spawn_process


class NodejsInContainer(ContainerTests, test_nodejs.NodejsTests):
    """This will test the Nodejs integration inside a container"""

    def setUp(self):
        self.hosts = {443: ["nodejs.org"]}
        super().setUp()
        # override with container path
        self.installed_path = os.path.join(self.install_base_path, "nodejs", "nodejs-lang")

    def test_existing_prefix(self):
        subprocess.call(self.command_as_list(['echo', '''"prefix = test" > ~/.npmrc''']))
        self.child = spawn_process(self.command('{} nodejs'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        result = subprocess.check_output(self.command_as_list(['cat', '''~/.npmrc''']))
        self.assertEqual(result.rstrip().decode(), 'prefix = test')

    def test_existing_npmrc(self):
        subprocess.call(self.command_as_list(['echo', '''"test = 123" > ~/.npmrc''']))
        self.child = spawn_process(self.command('{} nodejs'.format(UMAKE)))
        self.expect_and_no_warn("Choose installation path: {}".format(self.installed_path))
        self.child.sendline("")
        result = subprocess.check_output(self.command_as_list(["cat", "~/.npmrc"]))
        self.assertEqual(result.rstrip().decode(), 'test = 123\r\nprefix = ${HOME}/.npm_modules')

#!/usr/bin/python
# Copyright: Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'network'}


DOCUMENTATION = """
---
module: nxos_command
extends_documentation_fragment: nxos
version_added: "2.1"
author: "Peter Sprygada (@privateip)"
short_description: Run arbitrary command on Cisco NXOS devices
description:
  - Sends an arbitrary command to an NXOS node and returns the results
    read from the device.  This module includes an
    argument that will cause the module to wait for a specific condition
    before returning or timing out if the condition is not met.
options:
  commands:
    description:
      - The commands to send to the remote NXOS device.  The resulting
        output from the command is returned.  If the I(wait_for)
        argument is provided, the module is not returned until the
        condition is satisfied or the number of retires as expired.
      - The I(commands) argument also accepts an alternative form
        that allows for complex values that specify the command
        to run and the output format to return.   This can be done
        on a command by command basis.  The complex argument supports
        the keywords C(command) and C(output) where C(command) is the
        command to run and C(output) is one of 'text' or 'json'.
    required: true
  wait_for:
    description:
      - Specifies what to evaluate from the output of the command
        and what conditionals to apply.  This argument will cause
        the task to wait for a particular conditional to be true
        before moving forward.   If the conditional is not true
        by the configured retries, the task fails.  See examples.
    aliases: ['waitfor']
    version_added: "2.2"
  match:
    description:
      - The I(match) argument is used in conjunction with the
        I(wait_for) argument to specify the match policy.  Valid
        values are C(all) or C(any).  If the value is set to C(all)
        then all conditionals in the I(wait_for) must be satisfied.  If
        the value is set to C(any) then only one of the values must be
        satisfied.
    default: all
    version_added: "2.2"
  retries:
    description:
      - Specifies the number of retries a command should by tried
        before it is considered failed.  The command is run on the
        target device every retry and evaluated against the I(wait_for)
        conditionals.
    default: 10
  interval:
    description:
      - Configures the interval in seconds to wait between retries
        of the command.  If the command does not pass the specified
        conditional, the interval indicates how to long to wait before
        trying the command again.
    default: 1
"""

EXAMPLES = """
---
- name: run show version on remote devices
  nxos_command:
    commands: show version

- name: run show version and check to see if output contains Cisco
  nxos_command:
    commands: show version
    wait_for: result[0] contains Cisco

- name: run multiple commands on remote nodes
  nxos_command:
    commands:
      - show version
      - show interfaces

- name: run multiple commands and evaluate the output
  nxos_command:
    commands:
      - show version
      - show interfaces
    wait_for:
      - result[0] contains Cisco
      - result[1] contains loopback0

- name: run commands and specify the output format
  nxos_command:
    commands:
      - command: show version
        output: json
"""

RETURN = """
stdout:
  description: The set of responses from the commands
  returned: always apart from low level errors (such as action plugin)
  type: list
  sample: ['...', '...']
stdout_lines:
  description: The value of stdout split into a list
  returned: always apart from low level errors (such as action plugin)
  type: list
  sample: [['...', '...'], ['...'], ['...']]
failed_conditions:
  description: The list of conditionals that have failed
  returned: failed
  type: list
  sample: ['...', '...']
"""
import time

from ansible.module_utils._text import to_text
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.network.common.parsing import Conditional, FailedConditionalError
from ansible.module_utils.network.common.utils import transform_commands, to_lines
from ansible.module_utils.network.nxos.nxos import nxos_argument_spec, run_commands


def parse_commands(module, warnings):
    commands = transform_commands(module)

    if module.check_mode:
        for item in list(commands):
            if not item['command'].startswith('show'):
                warnings.append(
                    'Only show commands are supported when using check mode, not '
                    'executing %s' % item['command']
                )
                commands.remove(item)

    return commands


def to_cli(obj):
    cmd = obj['command']
    if obj.get('output') == 'json':
        cmd += ' | json'
    return cmd


def main():
    """entry point for module execution
    """
    argument_spec = dict(
        # { command: <str>, output: <str>, prompt: <str>, response: <str> }
        commands=dict(type='list', required=True),

        wait_for=dict(type='list', aliases=['waitfor']),
        match=dict(default='all', choices=['any', 'all']),

        retries=dict(default=10, type='int'),
        interval=dict(default=1, type='int')
    )

    argument_spec.update(nxos_argument_spec)

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)

    warnings = list()
    result = {'changed': False, 'warnings': warnings}
    commands = parse_commands(module, warnings)
    wait_for = module.params['wait_for'] or list()

    try:
        conditionals = [Conditional(c) for c in wait_for]
    except AttributeError as exc:
        module.fail_json(msg=to_text(exc))

    retries = module.params['retries']
    interval = module.params['interval']
    match = module.params['match']

    while retries > 0:
        responses = run_commands(module, commands)

        for item in list(conditionals):
            try:
                if item(responses):
                    if match == 'any':
                        conditionals = list()
                        break
                    conditionals.remove(item)
            except FailedConditionalError as exc:
                module.fail_json(msg=to_text(exc))

        if not conditionals:
            break

        time.sleep(interval)
        retries -= 1

    if conditionals:
        failed_conditions = [item.raw for item in conditionals]
        msg = 'One or more conditional statements have not been satisfied'
        module.fail_json(msg=msg, failed_conditions=failed_conditions)

    result.update({
        'stdout': responses,
        'stdout_lines': list(to_lines(responses)),
    })

    module.exit_json(**result)


if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-
##############################################################################
#
#    Author: Nicolas Bessi
#    Copyright 2011-2012 Camptocamp SA
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
import logging

UNION_MAPPING = {'|': 'OR', '&': 'AND'}

logger = logging.getLogger('geoengine.sql.debug')

# TODO Refactor geo_search and dry up the get_**_sql code


def _get_geo_func(model, domain):
    """Map operator to function we do not want to override __getattr__"""
    current_field = model._columns[domain[0]]
    current_operator = current_field._geo_operator
    attr = "get_%s_sql" % (domain[1],)
    if not hasattr(current_operator, attr):
        raise ValueError(
            'Field %s does not support %s' % (current_field, domain[1]))
    func = getattr(current_operator, attr)
    return func


def geo_search(model, cursor, uid, domain=None, geo_domain=None, offset=0,
               limit=None, order=None, context=None):
    """Perform a geo search it allows direct domain:
    geo_search(
        r, uid, domaine=[('name', 'ilike', 'toto']),
        geo_domain=[('the_point',
                     'geo_intersect',
                     myshaply_obj or mywkt or mygeojson)])

    We can also support indirect geo_domain
        (‘geom’, ‘geo_operator’, {‘res.zip.poly’: [‘id’, ‘in’, [1,2,3]] })

    The supported operators are :
     * geo_greater
     * geo_lesser
     * geo_equal
     * geo_touch
     * geo_within
     * geo_contains
     * geo_intersect
    """
    domain = domain or []
    geo_domain = geo_domain or []
    context = context or {}
    model.pool.get('ir.model.access').check(cursor, uid, model._name, 'read')
    query = model._where_calc(
        cursor, uid, domain, active_test=True, context=context)
    model._apply_ir_rules(cursor, uid, query, 'read', context=context)
    order_by = ''
    if order:
        order_by = model._generate_order_by(order, query) or ''
    from_clause, where_clause, where_clause_params = query.get_sql()
    limit_str = limit and ' LIMIT %d' % limit or ''
    offset_str = offset and ' OFFSET %d' % offset or ''
    where_clause_arr = []
    if where_clause and where_clause_params:
        where_clause_arr.append(where_clause)
    # geosearch where clause generation
    MODE = ''
    UNION = 'AND'
    JOIN_MODE = '%s %s'
    for domain in geo_domain:
        if isinstance(domain, basestring):
            if domain == '!':
                MODE = 'NOT'
            if domain in UNION_MAPPING.keys():
                UNION = UNION_MAPPING[domain]
        if where_clause_arr:
            where_clause_arr.append(JOIN_MODE % (MODE, UNION))
        # We start computing geo spation SQL
        if isinstance(domain, (list, tuple)):
            if isinstance(domain[2], dict):
                # We are having indirect geo_operator like (‘geom’, ‘geo_...’,
                # {‘res.zip.poly’: [‘id’, ‘in’, [1,2,3]] })
                ref_search = domain[2]
                rel_where_statement = []
                for key in ref_search:
                    i = key.rfind('.')
                    rel_model = key[0:i]
                    rel_col = key[i + 1:]
                    rel_model = model.pool.get(rel_model)
                    from_clause += ', %s' % (rel_model._table,)
                    att_where_sql = u''
                    # we compute the attributes search on spatial rel
                    if ref_search[key]:
                        rel_query = rel_model._where_calc(
                            cursor, uid, ref_search[key], active_test=True,
                            context=context)
                        rel_res = rel_query.get_sql()
                        att_where_sql = rel_res[1]
                        where_clause_params += rel_res[2]
                    # we compute the spatial search on spatial rel
                    func = _get_geo_func(model, domain)
                    spatial_where_sql = func(
                        model._table, domain[0], domain[2], rel_col=rel_col,
                        rel_model=rel_model)
                    if att_where_sql:
                        rel_where_statement.append(
                            u"(%s AND %s)" % (att_where_sql,
                                              spatial_where_sql))
                    else:
                        rel_where_statement.append(
                            u"(%s)" % (spatial_where_sql))
                where_clause_arr.append(u"AND ".join(rel_where_statement))
            else:
                func = _get_geo_func(model, domain)
                where_sql = func(model._table, domain[0], domain[2])
                where_clause_arr.append(where_sql)
    if where_clause_arr:
        where_statement = " WHERE %s" % (u' '.join(where_clause_arr))
    else:
        where_statement = u''
    sql = 'SELECT "%s".id FROM ' % model._table + from_clause + \
        where_statement + order_by + limit_str + offset_str
    # logger.debug(cursor.mogrify(sql, where_clause_params))
    cursor.execute(sql, where_clause_params)
    res = cursor.fetchall()
    if res:
        return [x[0] for x in res]
    else:
        return []


class GeoOperator(object):

    def __init__(self, geo_field):
        self.geo_field = geo_field

    def get_rel_field(self, rel_col, rel_model):
        """Retrieves the expression to use in PostGIS statement for a spatial
           rel search"""
        try:
            rel_model._columns[rel_col]
        except Exception:
            raise Exception(
                'Model %s has no column %s' % (rel_model._name, rel_col))
        return "%s.%s" % (rel_model._table, rel_col)

    def _get_direct_como_op_sql(self, table, col, value, rel_col=None,
                                rel_model=None, op=''):
        """provide raw sql for geater and lesser operators"""
        if isinstance(value, (int, long, float)):
            if rel_col and rel_model:
                raise Exception(
                    'Area %s does not support int compare for relation '
                    'search' % (op,))
            return " ST_Area(%s.%s) %s %s" % (table, col, op, value)
        else:
            if rel_col and rel_model:
                compare_to = self.get_rel_field(rel_col, rel_model)
            else:
                base = self.geo_field.entry_to_shape(value, same_type=False)
                compare_to = base.wkt
            return " ST_Area(%s.%s) %s ST_Area(ST_GeomFromText('%s'))" % (
                table, col, op, compare_to)

    def _get_postgis_comp_sql(self, table, col, value, rel_col=None,
                              rel_model=None, op=''):
        """return raw sql for all search based on St_**(a, b) posgis operator
        """
        if rel_col and rel_model:
            compare_to = self.get_rel_field(rel_col, rel_model)
        else:
            base = self.geo_field.entry_to_shape(value, same_type=False)
            srid = self.geo_field._srid
            compare_to = "ST_GeomFromText('%s',%s)" % (base.wkt, srid)
        return " %s(%s.%s, %s)" % (op, table, col, compare_to)

    def get_geo_greater_sql(self, table, col, value, rel_col=None,
                            rel_model=None):
        """Returns raw sql for geo_greater operator
        (used for area comparison)
        """
        return self._get_direct_como_op_sql(table, col, value,
                                            rel_col, rel_model, op='>')

    def get_geo_lesser_sql(self, table, col, value, rel_col=None,
                           rel_model=None):
        """Returns raw sql for geo_lesser operator
        (used for area comparison)"""
        return self._get_direct_como_op_sql(table, col, value,
                                            rel_col, rel_model, op='<')

    def get_geo_equal_sql(self, table, col, value, rel_col=None,
                          rel_model=None):
        """Returns raw sql for geo_equal operator
        (used for equality comparison)
        """
        if rel_col and rel_model:
            compare_to = self.get_rel_field(rel_col, rel_model)
        else:
            base = self.geo_field.entry_to_shape(value, same_type=False)
            compare_to = "ST_GeomFromText('%s')" % (base.wkt,)
        return " %s.%s = %s" % (table, col, compare_to)

    def get_geo_intersect_sql(self, table, col, value, rel_col=None,
                              rel_model=None):
        """Returns raw sql for geo_intersec operator
        (used for spatial comparison)
        """
        return self._get_postgis_comp_sql(table, col, value,
                                          rel_col, rel_model,
                                          op='ST_Intersects')

    def get_geo_touch_sql(self, table, col, value, rel_col=None,
                          rel_model=None):
        """Returns raw sql for geo_touch operator
        (used for spatial comparison)
        """
        return self._get_postgis_comp_sql(table, col, value,
                                          rel_col, rel_model,
                                          op='ST_Touches')

    def get_geo_within_sql(self, table, col, value, rel_col=None,
                           rel_model=None):
        """Returns raw sql for geo_within operator
        (used for spatial comparison)
        """
        return self._get_postgis_comp_sql(table, col, value,
                                          rel_col, rel_model,
                                          op='ST_Within')

    def get_geo_contains_sql(self, table, col, value, rel_col=None,
                             rel_model=None):
        """Returns raw sql for geo_contains operator
        (used for spatial comparison)
        """
        return self._get_postgis_comp_sql(table, col, value,
                                          rel_col, rel_model,
                                          op='ST_Contains')

"""
AutoSlugField taken from django-extensions at
15d3eb305957cee4768dd86e44df1bdad341a10e
Uses Oscar's slugify function instead of Django's

Copyright (c) 2007 Michael Trier

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""

import re

from django.db.models import SlugField
from django.utils import six

from oscar.core.utils import slugify

try:
    from django.utils.encoding import force_unicode  # NOQA
except ImportError:
    from django.utils.encoding import force_text as force_unicode  # NOQA


class AutoSlugField(SlugField):
    """ AutoSlugField

    By default, sets editable=False, blank=True.

    Required arguments:

    populate_from
        Specifies which field or list of fields the slug is populated from.

    Optional arguments:

    separator
        Defines the used separator (default: '-')

    overwrite
        If set to True, overwrites the slug on every save (default: False)

    Inspired by SmileyChris' Unique Slugify snippet:
    http://www.djangosnippets.org/snippets/690/
    """
    def __init__(self, *args, **kwargs):
        kwargs.setdefault('blank', True)
        kwargs.setdefault('editable', False)

        populate_from = kwargs.pop('populate_from', None)
        if populate_from is None:
            raise ValueError("missing 'populate_from' argument")
        else:
            self._populate_from = populate_from
        self.separator = kwargs.pop('separator', six.u('-'))
        self.overwrite = kwargs.pop('overwrite', False)
        self.uppercase = kwargs.pop('uppercase', False)
        self.allow_duplicates = kwargs.pop('allow_duplicates', False)
        super(AutoSlugField, self).__init__(*args, **kwargs)

    def _slug_strip(self, value):
        """
        Cleans up a slug by removing slug separator characters that occur at
        the beginning or end of a slug.

        If an alternate separator is used, it will also replace any instances
        of the default '-' separator with the new separator.
        """
        re_sep = '(?:-|%s)' % re.escape(self.separator)
        value = re.sub('%s+' % re_sep, self.separator, value)
        return re.sub(r'^%s+|%s+$' % (re_sep, re_sep), '', value)

    def get_queryset(self, model_cls, slug_field):
        for field, model in model_cls._meta.get_fields_with_model():
            if model and field == slug_field:
                return model._default_manager.all()
        return model_cls._default_manager.all()

    def slugify_func(self, content):
        if content:
            return slugify(content)
        return ''

    def create_slug(self, model_instance, add):  # NOQA (too complex)
        # get fields to populate from and slug field to set
        if not isinstance(self._populate_from, (list, tuple)):
            self._populate_from = (self._populate_from, )
        slug_field = model_instance._meta.get_field(self.attname)

        # only set slug if empty and first-time save, or when overwrite=True
        if add and not getattr(model_instance, self.attname) or self.overwrite:
            # slugify the original field content and set next step to 2
            def slug_for_field(field):
                return self.slugify_func(getattr(model_instance, field))
            slug = self.separator.join(map(slug_for_field, self._populate_from))  # NOQA
            next = 2
        else:
            # get slug from the current model instance
            slug = getattr(model_instance, self.attname)
            # model_instance is being modified, and overwrite is False,
            # so instead of doing anything, just return the current slug
            return slug

        # strip slug depending on max_length attribute of the slug field
        # and clean-up
        slug_len = slug_field.max_length
        if slug_len:
            slug = slug[:slug_len]
        slug = self._slug_strip(slug)

        if self.uppercase:
            slug = slug.upper()

        original_slug = slug

        if self.allow_duplicates:
            return slug

        # exclude the current model instance from the queryset used in finding
        # the next valid slug
        queryset = self.get_queryset(model_instance.__class__, slug_field)
        if model_instance.pk:
            queryset = queryset.exclude(pk=model_instance.pk)

        # form a kwarg dict used to impliment any unique_together contraints
        kwargs = {}
        for params in model_instance._meta.unique_together:
            if self.attname in params:
                for param in params:
                    kwargs[param] = getattr(model_instance, param, None)
        kwargs[self.attname] = slug

        # increases the number while searching for the next valid slug
        # depending on the given slug, clean-up
        while not slug or queryset.filter(**kwargs):
            slug = original_slug
            end = '%s%s' % (self.separator, next)
            end_len = len(end)
            if slug_len and len(slug) + end_len > slug_len:
                slug = slug[:slug_len - end_len]
                slug = self._slug_strip(slug)
            slug = '%s%s' % (slug, end)
            kwargs[self.attname] = slug
            next += 1
        return slug

    def pre_save(self, model_instance, add):
        value = force_unicode(self.create_slug(model_instance, add))
        setattr(model_instance, self.attname, value)
        return value

    def get_internal_type(self):
        return "SlugField"

    def deconstruct(self):
        name, path, args, kwargs = super(AutoSlugField, self).deconstruct()
        kwargs['populate_from'] = self._populate_from
        if not self.separator == six.u('-'):
            kwargs['separator'] = self.separator
        if self.overwrite is not False:
            kwargs['overwrite'] = True
        if self.allow_duplicates is not False:
            kwargs['allow_duplicates'] = True
        return name, path, args, kwargs

from __future__ import absolute_import

import anyjson
import os
import sys

from kombu.exceptions import VersionMismatch

# avoid json implementation inconsistencies.
try:
    import json  # noqa
    anyjson.force_implementation("json")
except ImportError:
    anyjson.force_implementation("simplejson")


def find_distribution_modules(name=__name__, file=__file__):
    current_dist_depth = len(name.split(".")) - 1
    current_dist = os.path.join(os.path.dirname(file),
                                *([os.pardir] * current_dist_depth))
    abs = os.path.abspath(current_dist)
    dist_name = os.path.basename(abs)

    for dirpath, dirnames, filenames in os.walk(abs):
        package = (dist_name + dirpath[len(abs):]).replace("/", ".")
        if "__init__.py" in filenames:
            yield package
            for filename in filenames:
                if filename.endswith(".py") and filename != "__init__.py":
                    yield ".".join([package, filename])[:-3]


def import_all_modules(name=__name__, file=__file__, skip=[]):
    for module in find_distribution_modules(name, file):
        if module not in skip:
            print("preimporting %r for coverage..." % (module, ))
            try:
                __import__(module)
            except (ImportError, VersionMismatch, AttributeError):
                pass


def is_in_coverage():
    return (os.environ.get("COVER_ALL_MODULES") or
            "--with-coverage3" in sys.argv)


def setup_django_env():
    try:
        from django.conf import settings
    except ImportError:
        return

    if not settings.configured:
        settings.configure(DATABASES={"default": {
                                "ENGINE": "django.db.backends.sqlite3",
                                "NAME": ":memory:"}},
                           DATABASE_ENGINE="sqlite3",
                           DATABASE_NAME=":memory:",
                           INSTALLED_APPS=("kombu.transport.django", ))


def setup():
    # so coverage sees all our modules.
    setup_django_env()
    if is_in_coverage():
        import_all_modules()

# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright (c) 2011 OpenStack Foundation
# All Rights Reserved.
#
#    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.

"""Policy Engine For Glance"""

import json
import os.path

from oslo.config import cfg

from glance.common import exception
import glance.domain.proxy
import glance.openstack.common.log as logging
from glance.openstack.common import policy

LOG = logging.getLogger(__name__)

policy_opts = [
    cfg.StrOpt('policy_file', default='policy.json',
               help=_('The location of the policy file.')),
    cfg.StrOpt('policy_default_rule', default='default',
               help=_('The default policy to use.')),
]

CONF = cfg.CONF
CONF.register_opts(policy_opts)


DEFAULT_RULES = {
    'context_is_admin': policy.RoleCheck('role', 'admin'),
    'default': policy.TrueCheck(),
    'manage_image_cache': policy.RoleCheck('role', 'admin'),
}


class Enforcer(object):
    """Responsible for loading and enforcing rules"""

    def __init__(self):
        self.default_rule = CONF.policy_default_rule
        self.policy_path = self._find_policy_file()
        self.policy_file_mtime = None
        self.policy_file_contents = None
        self.load_rules()

    def set_rules(self, rules):
        """Create a new Rules object based on the provided dict of rules"""
        rules_obj = policy.Rules(rules, self.default_rule)
        policy.set_rules(rules_obj)

    def add_rules(self, rules):
        """Add new rules to the Rules object"""
        if policy._rules:
            rules_obj = policy.Rules(rules)
            policy._rules.update(rules_obj)
        else:
            self.set_rules(rules)

    def load_rules(self):
        """Set the rules found in the json file on disk"""
        if self.policy_path:
            rules = self._read_policy_file()
            rule_type = ""
        else:
            rules = DEFAULT_RULES
            rule_type = "default "

        text_rules = dict((k, str(v)) for k, v in rules.items())
        msg = (_('Loaded %(rule_type)spolicy rules: %(text_rules)s') %
               {'rule_type': rule_type, 'text_rules': text_rules})
        LOG.debug(msg)

        self.set_rules(rules)

    @staticmethod
    def _find_policy_file():
        """Locate the policy json data file"""
        policy_file = CONF.find_file(CONF.policy_file)
        if policy_file:
            return policy_file
        else:
            LOG.warn(_('Unable to find policy file'))
            return None

    def _read_policy_file(self):
        """Read contents of the policy file

        This re-caches policy data if the file has been changed.
        """
        mtime = os.path.getmtime(self.policy_path)
        if not self.policy_file_contents or mtime != self.policy_file_mtime:
            LOG.debug(_("Loading policy from %s") % self.policy_path)
            with open(self.policy_path) as fap:
                raw_contents = fap.read()
                rules_dict = json.loads(raw_contents)
                self.policy_file_contents = dict(
                    (k, policy.parse_rule(v))
                    for k, v in rules_dict.items())
            self.policy_file_mtime = mtime
        return self.policy_file_contents

    def _check(self, context, rule, target, *args, **kwargs):
        """Verifies that the action is valid on the target in this context.

           :param context: Glance request context
           :param rule: String representing the action to be checked
           :param object: Dictionary representing the object of the action.
           :raises: `glance.common.exception.Forbidden`
           :returns: A non-False value if access is allowed.
        """
        credentials = {
            'roles': context.roles,
            'user': context.user,
            'tenant': context.tenant,
        }

        return policy.check(rule, target, credentials, *args, **kwargs)

    def enforce(self, context, action, target):
        """Verifies that the action is valid on the target in this context.

           :param context: Glance request context
           :param action: String representing the action to be checked
           :param object: Dictionary representing the object of the action.
           :raises: `glance.common.exception.Forbidden`
           :returns: A non-False value if access is allowed.
        """
        return self._check(context, action, target,
                           exception.Forbidden, action=action)

    def check(self, context, action, target):
        """Verifies that the action is valid on the target in this context.

           :param context: Glance request context
           :param action: String representing the action to be checked
           :param object: Dictionary representing the object of the action.
           :returns: A non-False value if access is allowed.
        """
        return self._check(context, action, target)

    def check_is_admin(self, context):
        """Check if the given context is associated with an admin role,
           as defined via the 'context_is_admin' RBAC rule.

           :param context: Glance request context
           :returns: A non-False value if context role is admin.
        """
        target = context.to_dict()
        return self.check(context, 'context_is_admin', target)


class ImageRepoProxy(glance.domain.proxy.Repo):

    def __init__(self, image_repo, context, policy):
        self.context = context
        self.policy = policy
        self.image_repo = image_repo
        proxy_kwargs = {'context': self.context, 'policy': self.policy}
        super(ImageRepoProxy, self).__init__(image_repo,
                                             item_proxy_class=ImageProxy,
                                             item_proxy_kwargs=proxy_kwargs)

    def get(self, image_id):
        self.policy.enforce(self.context, 'get_image', {})
        return super(ImageRepoProxy, self).get(image_id)

    def list(self, *args, **kwargs):
        self.policy.enforce(self.context, 'get_images', {})
        return super(ImageRepoProxy, self).list(*args, **kwargs)

    def save(self, image):
        self.policy.enforce(self.context, 'modify_image', {})
        return super(ImageRepoProxy, self).save(image)

    def add(self, image):
        self.policy.enforce(self.context, 'add_image', {})
        return super(ImageRepoProxy, self).add(image)


class ImageProxy(glance.domain.proxy.Image):

    def __init__(self, image, context, policy):
        self.image = image
        self.context = context
        self.policy = policy
        super(ImageProxy, self).__init__(image)

    @property
    def visibility(self):
        return self.image.visibility

    @visibility.setter
    def visibility(self, value):
        if value == 'public':
            self.policy.enforce(self.context, 'publicize_image', {})
        self.image.visibility = value

    @property
    def locations(self):
        return ImageLocationsProxy(self.image.locations,
                                   self.context, self.policy)

    @locations.setter
    def locations(self, value):
        if not isinstance(value, (list, ImageLocationsProxy)):
            raise exception.Invalid(_('Invalid locations: %s') % value)
        self.policy.enforce(self.context, 'set_image_location', {})
        new_locations = list(value)
        if (set([loc['url'] for loc in self.image.locations]) -
                set([loc['url'] for loc in new_locations])):
            self.policy.enforce(self.context, 'delete_image_location', {})
        self.image.locations = new_locations

    def delete(self):
        self.policy.enforce(self.context, 'delete_image', {})
        return self.image.delete()

    def get_data(self, *args, **kwargs):
        self.policy.enforce(self.context, 'download_image', {})
        return self.image.get_data(*args, **kwargs)

    def get_member_repo(self, **kwargs):
        member_repo = self.image.get_member_repo(**kwargs)
        return ImageMemberRepoProxy(member_repo, self.context, self.policy)


class ImageFactoryProxy(glance.domain.proxy.ImageFactory):

    def __init__(self, image_factory, context, policy):
        self.image_factory = image_factory
        self.context = context
        self.policy = policy
        proxy_kwargs = {'context': self.context, 'policy': self.policy}
        super(ImageFactoryProxy, self).__init__(image_factory,
                                                proxy_class=ImageProxy,
                                                proxy_kwargs=proxy_kwargs)

    def new_image(self, **kwargs):
        if kwargs.get('visibility') == 'public':
            self.policy.enforce(self.context, 'publicize_image', {})
        return super(ImageFactoryProxy, self).new_image(**kwargs)


class ImageMemberFactoryProxy(glance.domain.proxy.ImageMembershipFactory):

    def __init__(self, member_factory, context, policy):
        super(ImageMemberFactoryProxy, self).__init__(
            member_factory,
            image_proxy_class=ImageProxy,
            image_proxy_kwargs={'context': context, 'policy': policy})


class ImageMemberRepoProxy(glance.domain.proxy.Repo):

    def __init__(self, member_repo, context, policy):
        self.member_repo = member_repo
        self.context = context
        self.policy = policy

    def add(self, member):
        self.policy.enforce(self.context, 'add_member', {})
        return self.member_repo.add(member)

    def get(self, member_id):
        self.policy.enforce(self.context, 'get_member', {})
        return self.member_repo.get(member_id)

    def save(self, member):
        self.policy.enforce(self.context, 'modify_member', {})
        return self.member_repo.save(member)

    def list(self, *args, **kwargs):
        self.policy.enforce(self.context, 'get_members', {})
        return self.member_repo.list(*args, **kwargs)

    def remove(self, member):
        self.policy.enforce(self.context, 'delete_member', {})
        return self.member_repo.remove(member)


class ImageLocationsProxy(object):

    __hash__ = None

    def __init__(self, locations, context, policy):
        self.locations = locations
        self.context = context
        self.policy = policy

    def __contains__(self, uri):
        return uri in self.locations

    def __len__(self):
        return len(self.locations)

    def __cast(self, other):
        if isinstance(other, ImageLocationsProxy):
            return other.locations
        else:
            return other

    def __cmp__(self, other):
        return cmp(self.locations, self.__cast(other))

    def __iter__(self):
        return iter(self.locations)

    def _get_checker(action, func_name):
        def _checker(self, *args, **kwargs):
            self.policy.enforce(self.context, action, {})
            assert hasattr(self.locations, func_name)
            method = getattr(self.locations, func_name)
            return method(*args, **kwargs)
        return _checker

    count = _get_checker('get_image_location', 'count')
    index = _get_checker('get_image_location', 'index')
    __getitem__ = _get_checker('get_image_location', '__getitem__')
    __contains__ = _get_checker('get_image_location', '__contains__')
    __len__ = _get_checker('get_image_location', '__len__')
    __cast = _get_checker('get_image_location', '__cast')
    __cmp__ = _get_checker('get_image_location', '__cmp__')
    __iter__ = _get_checker('get_image_location', '__iter__')

    append = _get_checker('set_image_location', 'append')
    extend = _get_checker('set_image_location', 'extend')
    insert = _get_checker('set_image_location', 'insert')
    reverse = _get_checker('set_image_location', 'reverse')
    __iadd__ = _get_checker('set_image_location', '__iadd__')
    __setitem__ = _get_checker('set_image_location', '__setitem__')

    pop = _get_checker('delete_image_location', 'pop')
    remove = _get_checker('delete_image_location', 'remove')
    __delitem__ = _get_checker('delete_image_location', '__delitem__')
    __delslice__ = _get_checker('delete_image_location', '__delslice__')

    del _get_checker

# Copyright 2012 Cloudbase Solutions Srl
#
#    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.

from oslo_log import log as oslo_logging

from cloudbaseinit import conf as cloudbaseinit_conf
from cloudbaseinit import exception
from cloudbaseinit.utils import classloader


CONF = cloudbaseinit_conf.CONF
LOG = oslo_logging.getLogger(__name__)


def get_metadata_service():
    # Return the first service that loads correctly
    cl = classloader.ClassLoader()
    for class_path in CONF.metadata_services:
        service = cl.load_class(class_path)()
        try:
            if service.load():
                return service
        except Exception as ex:
            LOG.error("Failed to load metadata service '%s'" % class_path)
            LOG.exception(ex)
    raise exception.MetadaNotFoundException("No available service found")

#!/usr/bin/python

import sys
import re
import io

definitionToSourceLocationMap = dict() # dict of tuple(parentClass, fieldName) to sourceLocation
fieldAssignDict = dict() # dict of tuple(parentClass, fieldName) to (set of values)

# clang does not always use exactly the same numbers in the type-parameter vars it generates
# so I need to substitute them to ensure we can match correctly.
normalizeTypeParamsRegex = re.compile(r"type-parameter-\d+-\d+")
def normalizeTypeParams( line ):
    return normalizeTypeParamsRegex.sub("type-parameter-?-?", line)

# reading as binary (since we known it is pure ascii) is much faster than reading as unicode
with io.open("loplugin.singlevalfields.log", "rb", buffering=1024*1024) as txt:
    for line in txt:
        tokens = line.strip().split("\t")
        if tokens[0] == "defn:":
            parentClass = normalizeTypeParams(tokens[1])
            fieldName = normalizeTypeParams(tokens[2])
            sourceLocation = tokens[3]
            fieldInfo = (parentClass, fieldName)
            definitionToSourceLocationMap[fieldInfo] = sourceLocation
        elif tokens[0] == "asgn:":
            parentClass = normalizeTypeParams(tokens[1])
            fieldName = normalizeTypeParams(tokens[2])
            assignValue = tokens[3]
            fieldInfo = (parentClass, fieldName)
            if not fieldInfo in fieldAssignDict:
                fieldAssignDict[fieldInfo] = set()
            fieldAssignDict[fieldInfo].add(assignValue)

tmp1list = list()
for fieldInfo, assignValues in fieldAssignDict.iteritems():
    v0 = fieldInfo[0] + " " + fieldInfo[1]
    v1 = (",".join(assignValues))
    v2 = ""
    if fieldInfo not in definitionToSourceLocationMap:
        continue
    v2 = definitionToSourceLocationMap[fieldInfo]
    if len(assignValues) != 1:
        continue
    if "?" in assignValues:
        continue
    #if len(assignValues - set(["0", "1", "-1", "nullptr"])) > 0:
    #    continue
    # ignore things which are locally declared but are actually redeclarations of things from 3rd party code
    containingClass = fieldInfo[0]
    if containingClass == "_mwmhints":
        continue
    # ignore things which are representations of on-disk structures
    if containingClass in ["SEPr", "WW8Dop", "BmpInfoHeader", "BmpFileHeader", "Exif::ExifIFD",
            "sw::WW8FFData", "FFDataHeader", "INetURLHistory_Impl::head_entry", "ImplPPTParaPropSet", "SvxSwAutoFormatFlags",
            "T602ImportFilter::T602ImportFilter::format602struct", "DataNode"]:
        continue
    if v2.startswith("hwpfilter/source"):
        continue
    # ignore things which are representations of structures from external code
    if v2.startswith("desktop/unx/source/splashx.c"):
        continue
    # Windows-only
    if containingClass in ["SfxAppData_Impl", "sfx2::ImplDdeItem", "SvFileStream",
            "DdeService", "DdeTopic", "DdeItem", "DdeConnection", "connectivity::sdbcx::OUser", "connectivity::sdbcx::OGroup", "connectivity::sdbcx::OCatalog",
            "cairocanvas::SpriteHelper"]:
        continue
    if v2.startswith("include/svl/svdde.hxx") or v2.startswith("embeddedobj/source/inc/oleembobj.hxx"):
        continue
    # Some of our supported compilers don't do constexpr, which means o3tl::typed_flags can't be 'static const'
    if containingClass in ["WaitWindow_Impl"]:
        continue
    tmp1list.append((v0,v1,v2))

# sort results by filename:lineno
def natural_sort_key(s, _nsre=re.compile('([0-9]+)')):
    return [int(text) if text.isdigit() else text.lower()
            for text in re.split(_nsre, s)]
tmp1list.sort(key=lambda v: natural_sort_key(v[2]))

# print out the results
with open("compilerplugins/clang/singlevalfields.results", "wt") as f:
    for v in tmp1list:
        f.write(v[2] + "\n")
        f.write("    " + v[0] + "\n")
        f.write("    " + v[1] + "\n")



import unittest
import xml.etree.cElementTree as ET
from DDEXUI.ddex.deal import Deal
from datetime import date

class DealTests(unittest.TestCase):

    def setUp(self):
        self.use_type = "PermanentDownload"
        self.territory = "BE"
        self.start_date = date(1987,2,20)
        self.preorder_date = date(1987,2,19)
        self.preorder_preview_date = date(1987,2,18)
        deal = Deal("PayAsYouGoModel", self.use_type, self.territory, self.start_date, self.preorder_date, self.preorder_preview_date)
        self.element = deal.write()

    def test_should_have_commercial_model_type(self):
        self.assertEqual(self.element.find("./DealTerms/CommercialModelType").text, "PayAsYouGoModel")

    def test_should_have_use_type(self):
        self.assertEqual(self.element.find("./DealTerms/Usage/UseType").text, self.use_type)

    def test_should_have_territory_code(self):
        self.assertEqual(self.element.find("./DealTerms/TerritoryCode").text, self.territory)

    def test_should_have_start_date(self):
        self.assertEqual(self.element.find("./DealTerms/ValidityPeriod/StartDate").text, "1987-02-20") 

    def test_should_have_preorder_date(self):
        self.assertEqual(self.element.find("./DealTerms/PreorderReleaseDate").text, "1987-02-19") 

    def test_should_have_preorder_preview_date(self):
        self.assertEqual(self.element.find("./DealTerms/PreorderPreviewDate").text, "1987-02-18") 

import datetime
import unittest

from django.utils.dateparse import parse_duration
from django.utils.duration import duration_iso_string, duration_string


class TestDurationString(unittest.TestCase):

    def test_simple(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5)
        self.assertEqual(duration_string(duration), '01:03:05')

    def test_days(self):
        duration = datetime.timedelta(days=1, hours=1, minutes=3, seconds=5)
        self.assertEqual(duration_string(duration), '1 01:03:05')

    def test_microseconds(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5, microseconds=12345)
        self.assertEqual(duration_string(duration), '01:03:05.012345')

    def test_negative(self):
        duration = datetime.timedelta(days=-1, hours=1, minutes=3, seconds=5)
        self.assertEqual(duration_string(duration), '-1 01:03:05')


class TestParseDurationRoundtrip(unittest.TestCase):

    def test_simple(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5)
        self.assertEqual(parse_duration(duration_string(duration)), duration)

    def test_days(self):
        duration = datetime.timedelta(days=1, hours=1, minutes=3, seconds=5)
        self.assertEqual(parse_duration(duration_string(duration)), duration)

    def test_microseconds(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5, microseconds=12345)
        self.assertEqual(parse_duration(duration_string(duration)), duration)

    def test_negative(self):
        duration = datetime.timedelta(days=-1, hours=1, minutes=3, seconds=5)
        self.assertEqual(parse_duration(duration_string(duration)), duration)


class TestISODurationString(unittest.TestCase):

    def test_simple(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5)
        self.assertEqual(duration_iso_string(duration), 'P0DT01H03M05S')

    def test_days(self):
        duration = datetime.timedelta(days=1, hours=1, minutes=3, seconds=5)
        self.assertEqual(duration_iso_string(duration), 'P1DT01H03M05S')

    def test_microseconds(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5, microseconds=12345)
        self.assertEqual(duration_iso_string(duration), 'P0DT01H03M05.012345S')

    def test_negative(self):
        duration = -1 * datetime.timedelta(days=1, hours=1, minutes=3, seconds=5)
        self.assertEqual(duration_iso_string(duration), '-P1DT01H03M05S')


class TestParseISODurationRoundtrip(unittest.TestCase):

    def test_simple(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5)
        self.assertEqual(parse_duration(duration_iso_string(duration)), duration)

    def test_days(self):
        duration = datetime.timedelta(days=1, hours=1, minutes=3, seconds=5)
        self.assertEqual(parse_duration(duration_iso_string(duration)), duration)

    def test_microseconds(self):
        duration = datetime.timedelta(hours=1, minutes=3, seconds=5, microseconds=12345)
        self.assertEqual(parse_duration(duration_iso_string(duration)), duration)

    def test_negative(self):
        duration = datetime.timedelta(days=-1, hours=1, minutes=3, seconds=5)
        self.assertEqual(parse_duration(duration_iso_string(duration)).total_seconds(), duration.total_seconds())

# -*- coding: utf-8 -*-
# vim: autoindent shiftwidth=4 expandtab textwidth=120 tabstop=4 softtabstop=4

###############################################################################
# OpenLP - Open Source Lyrics Projection                                      #
# --------------------------------------------------------------------------- #
# Copyright (c) 2008-2015 OpenLP Developers                                   #
# --------------------------------------------------------------------------- #
# This program is free software; you can redistribute it and/or modify it     #
# under the terms of the GNU General Public License as published by the Free  #
# Software Foundation; version 2 of the License.                              #
#                                                                             #
# This program is distributed in the hope that it will be useful, but WITHOUT #
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       #
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for    #
# more details.                                                               #
#                                                                             #
# You should have received a copy of the GNU General Public License along     #
# with this program; if not, write to the Free Software Foundation, Inc., 59  #
# Temple Place, Suite 330, Boston, MA 02111-1307 USA                          #
###############################################################################

import sys
from PyQt4 import QtGui, QtCore
from ctypes import *
from ctypes.wintypes import RECT


class PPTViewer(QtGui.QWidget):
    """
    Standalone Test Harness for the pptviewlib library
    """
    def __init__(self, parent=None):
        super(PPTViewer, self).__init__(parent)
        self.pptid = -1
        self.setWindowTitle('PowerPoint Viewer Test')

        ppt_label = QtGui.QLabel('Open PowerPoint file')
        slide_label = QtGui.QLabel('Go to slide #')
        self.pptEdit = QtGui.QLineEdit()
        self.slideEdit = QtGui.QLineEdit()
        x_label = QtGui.QLabel('X pos')
        y_label = QtGui.QLabel('Y pos')
        width_label = QtGui.QLabel('Width')
        height_label = QtGui.QLabel('Height')
        self.xEdit = QtGui.QLineEdit('100')
        self.yEdit = QtGui.QLineEdit('100')
        self.widthEdit = QtGui.QLineEdit('900')
        self.heightEdit = QtGui.QLineEdit('700')
        self.total = QtGui.QLabel()
        ppt_btn = QtGui.QPushButton('Open')
        ppt_dlg_btn = QtGui.QPushButton('...')
        folder_label = QtGui.QLabel('Slide .bmp path')
        self.folderEdit = QtGui.QLineEdit('slide')
        slide_btn = QtGui.QPushButton('Go')
        prev = QtGui.QPushButton('Prev')
        next = QtGui.QPushButton('Next')
        blank = QtGui.QPushButton('Blank')
        unblank = QtGui.QPushButton('Unblank')
        restart = QtGui.QPushButton('Restart')
        close = QtGui.QPushButton('Close')
        resume = QtGui.QPushButton('Resume')
        stop = QtGui.QPushButton('Stop')
        grid = QtGui.QGridLayout()
        row = 0
        grid.addWidget(folder_label, 0, 0)
        grid.addWidget(self.folderEdit, 0, 1)
        row += 1
        grid.addWidget(x_label, row, 0)
        grid.addWidget(self.xEdit, row, 1)
        grid.addWidget(y_label, row, 2)
        grid.addWidget(self.yEdit, row, 3)
        row += 1
        grid.addWidget(width_label, row, 0)
        grid.addWidget(self.widthEdit, row, 1)
        grid.addWidget(height_label, row, 2)
        grid.addWidget(self.heightEdit, row, 3)
        row += 1
        grid.addWidget(ppt_label, row, 0)
        grid.addWidget(self.pptEdit, row, 1)
        grid.addWidget(ppt_dlg_btn, row, 2)
        grid.addWidget(ppt_btn, row, 3)
        row += 1
        grid.addWidget(slide_label, row, 0)
        grid.addWidget(self.slideEdit, row, 1)
        grid.addWidget(slide_btn, row, 2)
        row += 1
        grid.addWidget(prev, row, 0)
        grid.addWidget(next, row, 1)
        row += 1
        grid.addWidget(blank, row, 0)
        grid.addWidget(unblank, row, 1)
        row += 1
        grid.addWidget(restart, row, 0)
        grid.addWidget(close, row, 1)
        row += 1
        grid.addWidget(stop, row, 0)
        grid.addWidget(resume, row, 1)
        self.connect(ppt_btn, QtCore.SIGNAL('clicked()'), self.openClick)
        self.connect(ppt_dlg_btn, QtCore.SIGNAL('clicked()'), self.openDialog)
        self.connect(slide_btn, QtCore.SIGNAL('clicked()'), self.gotoClick)
        self.connect(prev, QtCore.SIGNAL('clicked()'), self.prevClick)
        self.connect(next, QtCore.SIGNAL('clicked()'), self.nextClick)
        self.connect(blank, QtCore.SIGNAL('clicked()'), self.blankClick)
        self.connect(unblank, QtCore.SIGNAL('clicked()'), self.unblankClick)
        self.connect(restart, QtCore.SIGNAL('clicked()'), self.restartClick)
        self.connect(close, QtCore.SIGNAL('clicked()'), self.closeClick)
        self.connect(stop, QtCore.SIGNAL('clicked()'), self.stopClick)
        self.connect(resume, QtCore.SIGNAL('clicked()'), self.resumeClick)
        self.setLayout(grid)
        self.resize(300, 150)

    def prevClick(self):
        if self.pptid < 0:
            return
        self.pptdll.PrevStep(self.pptid)
        self.updateCurrSlide()
        app.processEvents()

    def nextClick(self):
        if self.pptid < 0:
            return
        self.pptdll.NextStep(self.pptid)
        self.updateCurrSlide()
        app.processEvents()

    def blankClick(self):
        if self.pptid < 0:
            return
        self.pptdll.Blank(self.pptid)
        app.processEvents()

    def unblankClick(self):
        if self.pptid < 0:
            return
        self.pptdll.Unblank(self.pptid)
        app.processEvents()

    def restartClick(self):
        if self.pptid < 0:
            return
        self.pptdll.RestartShow(self.pptid)
        self.updateCurrSlide()
        app.processEvents()

    def stopClick(self):
        if self.pptid < 0:
            return
        self.pptdll.Stop(self.pptid)
        app.processEvents()

    def resumeClick(self):
        if self.pptid < 0:
            return
        self.pptdll.Resume(self.pptid)
        app.processEvents()

    def closeClick(self):
        if self.pptid < 0:
            return
        self.pptdll.ClosePPT(self.pptid)
        self.pptid = -1
        app.processEvents()

    def openClick(self):
        oldid = self.pptid
        rect = RECT(int(self.xEdit.text()), int(self.yEdit.text()),
                    int(self.widthEdit.text()), int(self.heightEdit.text()))
        filename = str(self.pptEdit.text().replace('/', '\\'))
        folder = str(self.folderEdit.text().replace('/', '\\'))
        print(filename, folder)
        self.pptid = self.pptdll.OpenPPT(filename, None, rect, folder)
        print('id: ' + str(self.pptid))
        if oldid >= 0:
            self.pptdll.ClosePPT(oldid)
        slides = self.pptdll.GetSlideCount(self.pptid)
        print('slidecount: ' + str(slides))
        self.total.setNum(self.pptdll.GetSlideCount(self.pptid))
        self.updateCurrSlide()

    def updateCurrSlide(self):
        if self.pptid < 0:
            return
        slide = str(self.pptdll.GetCurrentSlide(self.pptid))
        print('currslide: ' + slide)
        self.slideEdit.setText(slide)
        app.processEvents()

    def gotoClick(self):
        if self.pptid < 0:
            return
        print(self.slideEdit.text())
        self.pptdll.GotoSlide(self.pptid, int(self.slideEdit.text()))
        self.updateCurrSlide()
        app.processEvents()

    def openDialog(self):
        self.pptEdit.setText(QtGui.QFileDialog.getOpenFileName(self, 'Open file'))

if __name__ == '__main__':
    pptdll = cdll.LoadLibrary(r'pptviewlib.dll')
    pptdll.SetDebug(1)
    print('Begin...')
    app = QtGui.QApplication(sys.argv)
    window = PPTViewer()
    window.pptdll = pptdll
    window.show()
    sys.exit(app.exec_())

from sympy.mpmath.libmpf import *
from sympy.mpmath import mpf, mp

from random import randint, choice, seed

all_modes = [round_floor, round_ceiling, round_down, round_up, round_nearest]

fb = from_bstr
fi = from_int
ff = from_float


def test_div_1_3():
    a = fi(1)
    b = fi(3)
    c = fi(-1)

    # floor rounds down, ceiling rounds up
    assert mpf_div(a, b, 7, round_floor)   == fb('0.01010101')
    assert mpf_div(a, b, 7, round_ceiling) == fb('0.01010110')
    assert mpf_div(a, b, 7, round_down)    == fb('0.01010101')
    assert mpf_div(a, b, 7, round_up)      == fb('0.01010110')
    assert mpf_div(a, b, 7, round_nearest) == fb('0.01010101')

    # floor rounds up, ceiling rounds down
    assert mpf_div(c, b, 7, round_floor)   == fb('-0.01010110')
    assert mpf_div(c, b, 7, round_ceiling) == fb('-0.01010101')
    assert mpf_div(c, b, 7, round_down)    == fb('-0.01010101')
    assert mpf_div(c, b, 7, round_up)      == fb('-0.01010110')
    assert mpf_div(c, b, 7, round_nearest) == fb('-0.01010101')

def test_mpf_divi_1_3():
    a = 1
    b = fi(3)
    c = -1
    assert mpf_rdiv_int(a, b, 7, round_floor)   == fb('0.01010101')
    assert mpf_rdiv_int(a, b, 7, round_ceiling) == fb('0.01010110')
    assert mpf_rdiv_int(a, b, 7, round_down)    == fb('0.01010101')
    assert mpf_rdiv_int(a, b, 7, round_up)      == fb('0.01010110')
    assert mpf_rdiv_int(a, b, 7, round_nearest) == fb('0.01010101')
    assert mpf_rdiv_int(c, b, 7, round_floor)   == fb('-0.01010110')
    assert mpf_rdiv_int(c, b, 7, round_ceiling) == fb('-0.01010101')
    assert mpf_rdiv_int(c, b, 7, round_down)    == fb('-0.01010101')
    assert mpf_rdiv_int(c, b, 7, round_up)      == fb('-0.01010110')
    assert mpf_rdiv_int(c, b, 7, round_nearest) == fb('-0.01010101')


def test_div_300():

    q = fi(1000000)
    a = fi(300499999)    # a/q is a little less than a half-integer
    b = fi(300500000)    # b/q exactly a half-integer
    c = fi(300500001)    # c/q is a little more than a half-integer

    # Check nearest integer rounding (prec=9 as 2**8 < 300 < 2**9)

    assert mpf_div(a, q, 9, round_down) == fi(300)
    assert mpf_div(b, q, 9, round_down) == fi(300)
    assert mpf_div(c, q, 9, round_down) == fi(300)
    assert mpf_div(a, q, 9, round_up) == fi(301)
    assert mpf_div(b, q, 9, round_up) == fi(301)
    assert mpf_div(c, q, 9, round_up) == fi(301)

    # Nearest even integer is down
    assert mpf_div(a, q, 9, round_nearest) == fi(300)
    assert mpf_div(b, q, 9, round_nearest) == fi(300)
    assert mpf_div(c, q, 9, round_nearest) == fi(301)

    # Nearest even integer is up
    a = fi(301499999)
    b = fi(301500000)
    c = fi(301500001)
    assert mpf_div(a, q, 9, round_nearest) == fi(301)
    assert mpf_div(b, q, 9, round_nearest) == fi(302)
    assert mpf_div(c, q, 9, round_nearest) == fi(302)


def test_tight_integer_division():
    # Test that integer division at tightest possible precision is exact
    N = 100
    seed(1)
    for i in range(N):
        a = choice([1, -1]) * randint(1, 1<<randint(10, 100))
        b = choice([1, -1]) * randint(1, 1<<randint(10, 100))
        p = a * b
        width = bitcount(abs(b)) - trailing(b)
        a = fi(a); b = fi(b); p = fi(p)
        for mode in all_modes:
            assert mpf_div(p, a, width, mode) == b


def test_epsilon_rounding():
    # Verify that mpf_div uses infinite precision; this result will
    # appear to be exactly 0.101 to a near-sighted algorithm

    a = fb('0.101' + ('0'*200) + '1')
    b = fb('1.10101')
    c = mpf_mul(a, b, 250, round_floor) # exact
    assert mpf_div(c, b, bitcount(a[1]), round_floor) == a # exact

    assert mpf_div(c, b, 2, round_down) == fb('0.10')
    assert mpf_div(c, b, 3, round_down) == fb('0.101')
    assert mpf_div(c, b, 2, round_up) == fb('0.11')
    assert mpf_div(c, b, 3, round_up) == fb('0.110')
    assert mpf_div(c, b, 2, round_floor) == fb('0.10')
    assert mpf_div(c, b, 3, round_floor) == fb('0.101')
    assert mpf_div(c, b, 2, round_ceiling) == fb('0.11')
    assert mpf_div(c, b, 3, round_ceiling) == fb('0.110')

    # The same for negative numbers
    a = fb('-0.101' + ('0'*200) + '1')
    b = fb('1.10101')
    c = mpf_mul(a, b, 250, round_floor)
    assert mpf_div(c, b, bitcount(a[1]), round_floor) == a

    assert mpf_div(c, b, 2, round_down) == fb('-0.10')
    assert mpf_div(c, b, 3, round_up) == fb('-0.110')

    # Floor goes up, ceiling goes down
    assert mpf_div(c, b, 2, round_floor) == fb('-0.11')
    assert mpf_div(c, b, 3, round_floor) == fb('-0.110')
    assert mpf_div(c, b, 2, round_ceiling) == fb('-0.10')
    assert mpf_div(c, b, 3, round_ceiling) == fb('-0.101')


def test_mod():
    mp.dps = 15
    assert mpf(234) % 1 == 0
    assert mpf(-3) % 256 == 253
    assert mpf(0.25) % 23490.5 == 0.25
    assert mpf(0.25) % -23490.5 == -23490.25
    assert mpf(-0.25) % 23490.5 == 23490.25
    assert mpf(-0.25) % -23490.5 == -0.25
    # Check that these cases are handled efficiently
    assert mpf('1e10000000000') % 1 == 0
    assert mpf('1.23e-1000000000') % 1 == mpf('1.23e-1000000000')
    # test __rmod__
    assert 3 % mpf('1.75') == 1.25

def test_div_negative_rnd_bug():
    mp.dps = 15
    assert (-3) / mpf('0.1531879017645047') == mpf('-19.583791966887116')
    assert mpf('-2.6342475750861301') / mpf('0.35126216427941814') == mpf('-7.4993775104985909')

import agents as ag

def HW2Agent() -> object:
    x = 0
    def program(percept):
        bump, status = percept
        lastAction = program.oldActions[-1]
        prevAction = program.oldActions[-2]
        # if lastAction == 'Suck':
        # lastAction = prevAction
        if status == 'Dirty':
            action = 'Suck'
        else:
            if lastAction == 'Suck':
                lastBump, lastStatus, = program.oldPercepts[-1]
                if prevAction == 'Right' or prevAction == 'NoOp' :
                    if bump == 'None':
                        action = 'Right'
                    else:
                        action = 'Up'
                if prevAction == 'Up':
                    if bump == 'None':
                        x = program.oldActions[-3]
                        action = x
                    else:
                        action = 'down'
                if prevAction == 'Left':
                    if bump == 'None':
                        action = 'Left'
                    else:
                        action = 'Up'
                if prevAction == 'Down':
                    if bump == 'None':
                        action = 'Down'
                    else:
                        action = 'Left'
            else:
                lastBump, lastStatus,  = program.oldPercepts[-1]
                if lastAction == 'NoOp' or lastAction == 'Right':
                    if bump == 'None':
                        action = 'Right'
                    else:
                        action = 'Up'

                if lastAction == 'Up':
                    if bump == 'None' and prevAction == 'Right':
                        action = 'Left'
                    else:
                        if bump == 'None' and prevAction == 'Left':
                            action = 'Right'
                        else:
                            action = 'Down'
                if lastAction == 'Left':
                    if bump == 'None':
                        action = 'Left'
                    else:
                        action = 'Up'

                if lastAction == 'Down':
                    aAction = Downs.__sizeof__()
                    if bump == 'None':
                        action = 'Down'
                    else:
                        if aAction == 'left':
                            action = 'Right'
                        else:
                            action = 'Left'

        # print(prevAction)
        if action == 'Down':
            Downs.append(action)

        program.oldPercepts.append(percept)
        program.oldActions.append(action)
        return action


    # assign static variables here
    program.oldPercepts = [('None', 'Clean')]
    program.oldActions = ['NoOp', 'NoOp']
    Downs = [1]



    agt = ag.Agent(program)
    # assign class attributes here:
    # agt.direction = ag.Direction('left')

    return agt
from django.core.exceptions import ImproperlyConfigured, ObjectDoesNotExist
from django.http import Http404
from django.utils.encoding import smart_str
from django.utils.translation import ugettext as _
from django.views.generic.base import TemplateResponseMixin, View


class SingleObjectMixin(object):
    """
    Provides the ability to retrieve a single object for further manipulation.
    """
    model = None
    queryset = None
    slug_field = 'slug'
    context_object_name = None
    slug_url_kwarg = 'slug'
    pk_url_kwarg = 'pk'

    def get_object(self, queryset=None):
        """
        Returns the object the view is displaying.

        By default this requires `self.queryset` and a `pk` or `slug` argument
        in the URLconf, but subclasses can override this to return any object.
        """
        # Use a custom queryset if provided; this is required for subclasses
        # like DateDetailView
        if queryset is None:
            queryset = self.get_queryset()

        # Next, try looking up by primary key.
        pk = self.kwargs.get(self.pk_url_kwarg, None)
        slug = self.kwargs.get(self.slug_url_kwarg, None)
        if pk is not None:
            queryset = queryset.filter(pk=pk)

        # Next, try looking up by slug.
        elif slug is not None:
            slug_field = self.get_slug_field()
            queryset = queryset.filter(**{slug_field: slug})

        # If none of those are defined, it's an error.
        else:
            raise AttributeError(u"Generic detail view %s must be called with "
                                 u"either an object pk or a slug."
                                 % self.__class__.__name__)

        try:
            obj = queryset.get()
        except ObjectDoesNotExist:
            raise Http404(_(u"No %(verbose_name)s found matching the query") %
                          {'verbose_name': queryset.model._meta.verbose_name})
        return obj

    def get_queryset(self):
        """
        Get the queryset to look an object up against. May not be called if
        `get_object` is overridden.
        """
        if self.queryset is None:
            if self.model:
                return self.model._default_manager.all()
            else:
                raise ImproperlyConfigured(u"%(cls)s is missing a queryset. Define "
                                           u"%(cls)s.model, %(cls)s.queryset, or override "
                                           u"%(cls)s.get_object()." % {
                                                'cls': self.__class__.__name__
                                        })
        return self.queryset._clone()

    def get_slug_field(self):
        """
        Get the name of a slug field to be used to look up by slug.
        """
        return self.slug_field

    def get_context_object_name(self, obj):
        """
        Get the name to use for the object.
        """
        if self.context_object_name:
            return self.context_object_name
        elif hasattr(obj, '_meta'):
            return smart_str(obj._meta.object_name.lower())
        else:
            return None

    def get_context_data(self, **kwargs):
        context = kwargs
        context_object_name = self.get_context_object_name(self.object)
        if context_object_name:
            context[context_object_name] = self.object
        return context


class BaseDetailView(SingleObjectMixin, View):
    def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        context = self.get_context_data(object=self.object)
        return self.render_to_response(context)


class SingleObjectTemplateResponseMixin(TemplateResponseMixin):
    template_name_field = None
    template_name_suffix = '_detail'

    def get_template_names(self):
        """
        Return a list of template names to be used for the request. Must return
        a list. May not be called if get_template is overridden.
        """
        try:
            names = super(SingleObjectTemplateResponseMixin, self).get_template_names()
        except ImproperlyConfigured:
            # If template_name isn't specified, it's not a problem --
            # we just start with an empty list.
            names = []

        # If self.template_name_field is set, grab the value of the field
        # of that name from the object; this is the most specific template
        # name, if given.
        if self.object and self.template_name_field:
            name = getattr(self.object, self.template_name_field, None)
            if name:
                names.insert(0, name)

        # The least-specific option is the default <app>/<model>_detail.html;
        # only use this if the object in question is a model.
        if hasattr(self.object, '_meta'):
            names.append("%s/%s%s.html" % (
                self.object._meta.app_label,
                self.object._meta.object_name.lower(),
                self.template_name_suffix
            ))
        elif hasattr(self, 'model') and hasattr(self.model, '_meta'):
            names.append("%s/%s%s.html" % (
                self.model._meta.app_label,
                self.model._meta.object_name.lower(),
                self.template_name_suffix
            ))
        return names


class DetailView(SingleObjectTemplateResponseMixin, BaseDetailView):
    """
    Render a "detail" view of an object.

    By default this is a model instance looked up from `self.queryset`, but the
    view will support display of *any* object by overriding `self.get_object()`.
    """

#!/usr/bin/python
#
# Python client for checking periodically for posted actions
# on the Red Hat Network servers.
#
# Copyright (c) 2000--2012 Red Hat, Inc.
#
# This software is licensed to you under the GNU General Public License,
# version 2 (GPLv2). There is NO WARRANTY for this software, express or
# implied, including the implied warranties of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. You should have received a copy of GPLv2
# along with this software; if not, see
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
#
# Red Hat trademarks are not licensed under GPLv2. No permission is
# granted to use or replicate Red Hat trademarks that are incorporated
# in this software or its documentation.
#
# In addition, as a special exception, the copyright holders give
# permission to link the code of portions of this program with the
# OpenSSL library under certain conditions as described in each
# individual source file, and distribute linked combinations
# including the two.
# You must obey the GNU General Public License in all respects
# for all of the code used other than OpenSSL.  If you modify
# file(s) with this exception, you may extend this exception to your
# version of the file(s), but you are not obligated to do so.  If you
# do not wish to do so, delete this exception statement from your
# version.  If you delete this exception statement from all source
# files in the program, then also delete it here.
import os
import sys
import socket

from OpenSSL import SSL
sys.path.append("/usr/share/rhn/")

from up2date_client import getMethod
from up2date_client import up2dateErrors
from up2date_client import up2dateAuth
from up2date_client import up2dateLog
from up2date_client import rpcServer
from up2date_client import config
from up2date_client import clientCaps
from up2date_client import capabilities
from up2date_client import rhncli, rhnserver

from rhn import rhnLockfile
import xmlrpclib

cfg = config.initUp2dateConfig()
log = up2dateLog.initLog()

# action version we understand
ACTION_VERSION = 2

# lock file to check if we're disabled at the server's request
DISABLE_FILE = "/etc/sysconfig/rhn/disable"

# Actions that will run each time we execute.
LOCAL_ACTIONS = [("packages.checkNeedUpdate", ("rhnsd=1",))]


class CheckCli(rhncli.RhnCli):

    def __init__(self):
        super(CheckCli, self).__init__()

        self.rhns_ca_cert = cfg['sslCACert']
        self.server = None

    def main(self):
        """ Process all the actions we have in the queue. """
        CheckCli.__check_instance_lock()
        CheckCli.__check_rhn_disabled()
        CheckCli.__check_has_system_id()

        self.server = CheckCli.__get_server()

        CheckCli.__update_system_id()

        self.__run_remote_actions()
        CheckCli.__run_local_actions()

        s = rhnserver.RhnServer()
        if s.capabilities.hasCapability('staging_content', 1) and cfg['stagingContent'] != 0:
             self.__check_future_actions()

        sys.exit(0)

    def __get_action(self, status_report):
        try:
            action = self.server.queue.get(up2dateAuth.getSystemId(),
                ACTION_VERSION, status_report)

            return action
        except xmlrpclib.Fault, f:
            if f.faultCode == -31:
                raise up2dateErrors.InsuffMgmntEntsError(f.faultString), None, sys.exc_info()[2]
            else:
                print "Could not retrieve action item from server %s" % self.server
                print "Error code: %d%s" % (f.faultCode, f.faultString)
            sys.exit(-1)
        # XXX: what if no SSL in socket?
        except socket.sslerror:
            print "ERROR: SSL handshake to %s failed" % self.server
            print """
            This could signal that you are *NOT* talking to a server
            whose certificate was signed by a Certificate Authority
            listed in the %s file or that the
            RHNS-CA-CERT file is invalid.""" % self.rhns_ca_cert
            sys.exit(-1)
        except socket.error:
            print "Could not retrieve action from %s.\n"\
                  "Possible networking problem?" % str(self.server)
            sys.exit(-1)
        except up2dateErrors.ServerCapabilityError, e:
            print e
            sys.exit(1)
        except SSL.Error, e:
            print "ERROR: SSL errors detected"
            print "%s" % e
            sys.exit(-1)

    def __query_future_actions(self, time_window):
        try:
            actions = self.server.queue.get_future_actions(up2dateAuth.getSystemId(),
                time_window)
            return actions
        except xmlrpclib.Fault, f:
            if f.faultCode == -31:
                raise up2dateErrors.InsuffMgmntEntsError(f.faultString), None, sys.exc_info()[2]
            else:
                print "Could not retrieve action item from server %s" % self.server
                print "Error code: %d%s" % (f.faultCode, f.faultString)
            sys.exit(-1)
        # XXX: what if no SSL in socket?
        except socket.sslerror:
            print "ERROR: SSL handshake to %s failed" % self.server
            print """
            This could signal that you are *NOT* talking to a server
            whose certificate was signed by a Certificate Authority
            listed in the %s file or that the
            RHNS-CA-CERT file is invalid.""" % self.rhns_ca_cert
            sys.exit(-1)
        except socket.error:
            print "Could not retrieve action from %s.\n"\
                  "Possible networking problem?" % str(self.server)
            sys.exit(-1)
        except up2dateErrors.ServerCapabilityError, e:
            print e
            sys.exit(1)
        except SSL.Error, e:
            print "ERROR: SSL errors detected"
            print "%s" % e
            sys.exit(-1)

    def __fetch_future_action(self, action):
        """ Fetch one specific action from rhnParent """
        # TODO
        pass

    def __check_future_actions(self):
        """ Retrieve scheduled actions and cache them if possible """
        time_window = cfg['stagingContentWindow'] or 24;
        actions = self.__query_future_actions(time_window)
        for action in actions:
            self.handle_action(action, cache_only=1)

    def __run_remote_actions(self):
        # the list of caps the client needs
        caps = capabilities.Capabilities()

        status_report = CheckCli.__build_status_report()

        action = self.__get_action(status_report)
        while action != "" and action != {}:
            self.__verify_server_capabilities(caps)

            if self.is_valid_action(action):
                try:
                    up2dateAuth.updateLoginInfo()
                except up2dateErrors.ServerCapabilityError, e:
                    print e
                    sys.exit(1)
                self.handle_action(action)

            action = self.__get_action(status_report)

    def __verify_server_capabilities(self, caps):
        response_headers = self.server.get_response_headers()
        caps.populate(response_headers)
        # do we actually want to validte here?
        try:
            caps.validate()
        except up2dateErrors.ServerCapabilityError, e:
            print e
            sys.exit(1)

    def __parse_action_data(self, action):
        """ Parse action data and returns (method, params) """
        data = action['action']
        parser, decoder = xmlrpclib.getparser()
        parser.feed(data.encode("utf-8"))
        parser.close()
        params = decoder.close()
        method = decoder.getmethodname()
        return (method, params)

    def submit_response(self, action_id, status, message, data):
        """ Submit a response for an action_id. """

        # get a new server object with fresh headers
        self.server = CheckCli.__get_server()

        try:
            ret = self.server.queue.submit(up2dateAuth.getSystemId(),
                                      action_id, status, message, data)
        except xmlrpclib.Fault, f:
            print "Could not submit results to server %s" % self.server
            print "Error code: %d%s" % (f.faultCode, f.faultString)
            sys.exit(-1)
        # XXX: what if no SSL in socket?
        except socket.sslerror:
            print "ERROR: SSL handshake to %s failed" % self.server
            print """
            This could signal that you are *NOT* talking to a server
            whose certificate was signed by a Certificate Authority
            listed in the %s file or that the
            RHNS-CA-CERT file is invalid.""" % self.rhns_ca_cert
            sys.exit(-1)
        except socket.error:
            print "Could not submit to %s.\n"\
                  "Possible networking problem?" % str(self.server)
            sys.exit(-1)
        return ret

    def handle_action(self, action, cache_only=None):
        """ Wrapper handler for the action we're asked to do. """
        log.log_debug("handle_action", action)
        log.log_debug("handle_action actionid = %s, version = %s" % (
            action['id'], action['version']))

        (method, params) = self.__parse_action_data(action)
        (status, message, data) = CheckCli.__run_action(method, params, {'cache_only': cache_only})
        ret = 0
        if not cache_only:
            log.log_debug("Sending back response", (status, message, data))
            ret = self.submit_response(action['id'], status, message, data)
        return ret


    def is_valid_action(self, action):
        log.log_debug("check_action", action)

        # be very paranoid of what we get back
        if type(action) != type({}):
            print "Got unparseable action response from server"
            sys.exit(-1)

        for key in ['id', 'version', 'action']:
            if not action.has_key(key):
                print "Got invalid response - missing '%s'" % key
                sys.exit(-1)
        try:
            ver = int(action['version'])
        except ValueError:
            ver = -1
        if ver > ACTION_VERSION or ver < 0:
            print "Got unknown action version %d" % ver
            print action
            # the -99 here is kind of magic
            self.submit_response(action["id"],
                            xmlrpclib.Fault(-99, "Can not handle this version"))
            return False
        return True

    @staticmethod
    def __get_server():
        """ Initialize a server connection and set up capability info. """
        server = rpcServer.getServer()

        # load the new client caps if they exist
        clientCaps.loadLocalCaps()

        headerlist = clientCaps.caps.headerFormat()
        for (headerName, value) in headerlist:
            server.add_header(headerName, value)

        return server

    @staticmethod
    def __update_system_id():
        try:
            up2dateAuth.maybeUpdateVersion()
        except up2dateErrors.CommunicationError, e:
            print e
            sys.exit(1)

    @staticmethod
    def __build_status_report():
        status_report = {}
        status_report["uname"] = os.uname()

        if os.access("/proc/uptime", os.R_OK):
            uptime = open("/proc/uptime", "r").read().split()
            try:
                status_report["uptime"] = map(int, map(float, uptime))
            except (TypeError, ValueError):
                status_report["uptime"] = map(lambda a: a[:-3], uptime)
            except:
                pass

        return status_report

    @staticmethod
    def __run_local_actions():
        """
        Hit any actions that we want to always run.

        If we want to run any actions everytime rhnsd runs rhn_check,
        we can add them to the list LOCAL_ACTIONS
        """

        for method_params in LOCAL_ACTIONS:
            method = method_params[0]
            params =  method_params[1]
            (status, message, data) = CheckCli.__run_action(method, params)
            log.log_debug("local action status: ", (status, message, data))

    @staticmethod
    def __do_call(method, params, kwargs={}):
        log.log_debug("do_call ", method, params, kwargs)

        method = getMethod.getMethod(method, "/usr/share/rhn/", "actions")
        retval = method(*params, **kwargs)

        return retval

    @staticmethod
    def __run_action(method, params, kwargs={}):
        try:
            (status, message, data) = CheckCli.__do_call(method, params, kwargs)
        except getMethod.GetMethodException:
            log.log_debug("Attempt to call an unsupported action", method,
                params)
            status = 6
            message = "Invalid function call attempted"
            data = {}
        except:
            log.log_exception(*sys.exc_info())
            # The action code failed in some way. let's let the server know.
            status = 6,
            message = "Fatal error in Python code occurred"
            data = {}
        return (status, message, data)

    @staticmethod
    def __check_rhn_disabled():
        """ If we're disabled, go down (almost) quietly. """
        if os.path.exists(DISABLE_FILE):
            print "RHN service is disabled. Check %s" % DISABLE_FILE
            sys.exit(0)

    @staticmethod
    def __check_has_system_id():
        """ Retrieve the system_id. This is required. """
        if not up2dateAuth.getSystemId():
            print "ERROR: unable to read system id."
            sys.exit(-1)

    @staticmethod
    def __check_instance_lock():
        lock = None
        try:
            lock = rhnLockfile.Lockfile('/var/run/rhn_check.pid')
        except rhnLockfile.LockfileLockedException, e:
            sys.stderr.write(rhncli.utf8_encode(_("Attempting to run more than one instance of rhn_check. Exiting.\n")))
            sys.exit(0)

if __name__ == "__main__":
    cli = CheckCli()
    cli.run()

from .__about__ import (__author__, __copyright__, __doc__, __email__, __license__, __summary__,
                        __title__, __url__, __version__)

import os
import sys
if sys.platform.startswith("linux"):
    # When the _pybinding C++ extension is compiled with MKL, it requires specific
    # dlopen flags on Linux: RTLD_GLOBAL. This will not play nice with some scipy
    # modules, i.e. it will produce segfaults. As a workaround, specific modules
    # are imported first with default dlopenflags.
    # After that, RTLD_GLOBAL must be set for MKL to load properly. It's not possible
    # to set RTLD_GLOBAL, import _pybinding and then reset to default flags. This is
    # fundamentally an MKL issue which makes it difficult to resolve. This workaround
    # is the best solution at the moment.
    import scipy.sparse.linalg
    import scipy.spatial
    sys.setdlopenflags(sys.getdlopenflags() | os.RTLD_GLOBAL)

import _pybinding as _cpp

from .model import *
from .lattice import *
from .shape import *
from .modifier import *
from .results import *

from .chebyshev import *
from .parallel import parallel_for, parallelize

from . import (constants, greens, parallel, pltutils, results, solver, system, utils)


def tests(options=None, plugins=None):
    """Run the tests

    Parameters
    ----------
    options : list or str
        Command line options for pytest (excluding target file_or_dir).
    plugins : list
        Plugin objects to be auto-registered during initialization.
    """
    import pytest
    import pathlib
    import matplotlib as mpl
    from .utils.misc import cd

    args = options or []
    if isinstance(args, str):
        args = args.split()
    module_path = pathlib.Path(__file__).parent

    if (module_path / 'tests').exists():
        # tests are inside installed package -> use read-only mode
        args.append('--failpath=' + os.getcwd() + '/failed')
        with cd(module_path), pltutils.backend('Agg'):
            args += ['-c', str(module_path / 'tests/local.cfg'), str(module_path)]
            error_code = pytest.main(args, plugins)
    else:
        # tests are in dev environment -> use development mode
        with cd(module_path.parent), pltutils.backend('Agg'):
            error_code = pytest.main(args, plugins)

    return error_code or None

# Author: Ingmar Stapel 
# Usage: Servo test program
# URL: http://www.raspberry-pi-car.com/top-story-en/raspberry-pi-controlling-servo-motors/7028
# Version: 0.1 beta

import RPi.GPIO as GPIO
import time
import os

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)

# Now we will start with a PWM signal at 50Hz at pin 11. 
# 50Hz should work for many servos very will. If not you can play with 
# the frequency if you like.	
Servo = GPIO.PWM(4, 50)
#Servo.start(2.5)

while True:

					
	# This command sets the left position of the servo
	#Servo.start(2.5)

	# Now the program asks for the direction the servo should turn.
	input = raw_input("Selection: ") 

	if(input == "r"):
		Servo.start(12.5)
		print "Right"
		stepslength = 12.5 / 20
		for Counter in range(int(20)):
			Servo.ChangeDutyCycle(stepslength * (Counter + 1))
			print stepslength * (Counter + 1)
			time.sleep(1)
		#Servo.stop()

	elif(input == "l"):
		Servo.start(2.5)
		print "Left"
		stepslength = 12.5 / 10
		for Counter in range(int(10)):
			Servo.ChangeDutyCycle(stepslength * (Counter + 1))
			print stepslength * (Counter + 1)
			time.sleep(1)
		Servo.stop()

	elif(input == "s"):
		print "Stop"
		Servo.stop()

	# input not valid
	else:
		print "input not valid!"

import unittest
import sys

from test import test_support

class G:
    'Sequence using __getitem__'
    def __init__(self, seqn):
        self.seqn = seqn
    def __getitem__(self, i):
        return self.seqn[i]

class I:
    'Sequence using iterator protocol'
    def __init__(self, seqn):
        self.seqn = seqn
        self.i = 0
    def __iter__(self):
        return self
    def next(self):
        if self.i >= len(self.seqn): raise StopIteration
        v = self.seqn[self.i]
        self.i += 1
        return v

class Ig:
    'Sequence using iterator protocol defined with a generator'
    def __init__(self, seqn):
        self.seqn = seqn
        self.i = 0
    def __iter__(self):
        for val in self.seqn:
            yield val

class X:
    'Missing __getitem__ and __iter__'
    def __init__(self, seqn):
        self.seqn = seqn
        self.i = 0
    def next(self):
        if self.i >= len(self.seqn): raise StopIteration
        v = self.seqn[self.i]
        self.i += 1
        return v

class E:
    'Test propagation of exceptions'
    def __init__(self, seqn):
        self.seqn = seqn
        self.i = 0
    def __iter__(self):
        return self
    def next(self):
        3 // 0

class N:
    'Iterator missing next()'
    def __init__(self, seqn):
        self.seqn = seqn
        self.i = 0
    def __iter__(self):
        return self

class EnumerateTestCase(unittest.TestCase):

    enum = enumerate
    seq, res = 'abc', [(0,'a'), (1,'b'), (2,'c')]

    def test_basicfunction(self):
        self.assertEqual(type(self.enum(self.seq)), self.enum)
        e = self.enum(self.seq)
        self.assertEqual(iter(e), e)
        self.assertEqual(list(self.enum(self.seq)), self.res)
        self.enum.__doc__

    def test_getitemseqn(self):
        self.assertEqual(list(self.enum(G(self.seq))), self.res)
        e = self.enum(G(''))
        self.assertRaises(StopIteration, e.next)

    def test_iteratorseqn(self):
        self.assertEqual(list(self.enum(I(self.seq))), self.res)
        e = self.enum(I(''))
        self.assertRaises(StopIteration, e.next)

    def test_iteratorgenerator(self):
        self.assertEqual(list(self.enum(Ig(self.seq))), self.res)
        e = self.enum(Ig(''))
        self.assertRaises(StopIteration, e.next)

    def test_noniterable(self):
        self.assertRaises(TypeError, self.enum, X(self.seq))

    def test_illformediterable(self):
        self.assertRaises(TypeError, list, self.enum(N(self.seq)))

    def test_exception_propagation(self):
        self.assertRaises(ZeroDivisionError, list, self.enum(E(self.seq)))

    def test_argumentcheck(self):
        self.assertRaises(TypeError, self.enum) # no arguments
        self.assertRaises(TypeError, self.enum, 1) # wrong type (not iterable)
        self.assertRaises(TypeError, self.enum, 'abc', 'a') # wrong type
        self.assertRaises(TypeError, self.enum, 'abc', 2, 3) # too many arguments

    def test_tuple_reuse(self):
        # Tests an implementation detail where tuple is reused
        # whenever nothing else holds a reference to it
        self.assertEqual(len(set(map(id, list(enumerate(self.seq))))), len(self.seq))
        self.assertEqual(len(set(map(id, enumerate(self.seq)))), min(1,len(self.seq)))

class MyEnum(enumerate):
    pass

class SubclassTestCase(EnumerateTestCase):

    enum = MyEnum

class TestEmpty(EnumerateTestCase):

    seq, res = '', []

class TestBig(EnumerateTestCase):

    seq = range(10,20000,2)
    res = zip(range(20000), seq)

class TestReversed(unittest.TestCase):

    def test_simple(self):
        class A:
            def __getitem__(self, i):
                if i < 5:
                    return str(i)
                raise StopIteration
            def __len__(self):
                return 5
        for data in 'abc', range(5), tuple(enumerate('abc')), A(), xrange(1,17,5):
            self.assertEqual(list(data)[::-1], list(reversed(data)))
        self.assertRaises(TypeError, reversed, {})
        # don't allow keyword arguments
        self.assertRaises(TypeError, reversed, [], a=1)

    def test_xrange_optimization(self):
        x = xrange(1)
        self.assertEqual(type(reversed(x)), type(iter(x)))

    def test_len(self):
        # This is an implementation detail, not an interface requirement
        from test.test_iterlen import len
        for s in ('hello', tuple('hello'), list('hello'), xrange(5)):
            self.assertEqual(len(reversed(s)), len(s))
            r = reversed(s)
            list(r)
            self.assertEqual(len(r), 0)
        class SeqWithWeirdLen:
            called = False
            def __len__(self):
                if not self.called:
                    self.called = True
                    return 10
                raise ZeroDivisionError
            def __getitem__(self, index):
                return index
        r = reversed(SeqWithWeirdLen())
        self.assertRaises(ZeroDivisionError, len, r)


    def test_gc(self):
        class Seq:
            def __len__(self):
                return 10
            def __getitem__(self, index):
                return index
        s = Seq()
        r = reversed(s)
        s.r = r

    def test_args(self):
        self.assertRaises(TypeError, reversed)
        self.assertRaises(TypeError, reversed, [], 'extra')

    def test_bug1229429(self):
        # this bug was never in reversed, it was in
        # PyObject_CallMethod, and reversed_new calls that sometimes.
        if not hasattr(sys, "getrefcount"):
            return
        def f():
            pass
        r = f.__reversed__ = object()
        rc = sys.getrefcount(r)
        for i in range(10):
            try:
                reversed(f)
            except TypeError:
                pass
            else:
                self.fail("non-callable __reversed__ didn't raise!")
        self.assertEqual(rc, sys.getrefcount(r))


class TestStart(EnumerateTestCase):

    enum = lambda i: enumerate(i, start=11)
    seq, res = 'abc', [(1, 'a'), (2, 'b'), (3, 'c')]


class TestLongStart(EnumerateTestCase):

    enum = lambda i: enumerate(i, start=sys.maxint+1)
    seq, res = 'abc', [(sys.maxint+1,'a'), (sys.maxint+2,'b'),
                       (sys.maxint+3,'c')]


def test_main(verbose=None):
    testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig,
                   TestReversed)
    test_support.run_unittest(*testclasses)

    # verify reference counting
    import sys
    if verbose and hasattr(sys, "gettotalrefcount"):
        counts = [None] * 5
        for i in xrange(len(counts)):
            test_support.run_unittest(*testclasses)
            counts[i] = sys.gettotalrefcount()
        print counts

if __name__ == "__main__":
    test_main(verbose=True)

# -*- coding: utf-8 -*-

#################################################################################################

import os

import xbmc
import xbmcaddon
import xbmcvfs

from mutagen.flac import FLAC, Picture
from mutagen.id3 import ID3
from mutagen import id3
import base64

import read_embyserver as embyserver
import utils

#################################################################################################

# Helper for the music library, intended to fix missing song ID3 tags on Emby

def logMsg(msg, lvl=1):
    utils.logMsg("%s %s" % ("Emby", "musictools"), msg, lvl)

def getRealFileName(filename, isTemp=False):
    #get the filename path accessible by python if possible...
    
    if not xbmcvfs.exists(filename):
        logMsg( "File does not exist! %s" %(filename), 0)
        return (False, "")
    
    #if we use os.path method on older python versions (sunch as some android builds), we need to pass arguments as string
    if os.path.supports_unicode_filenames:
        checkfile = filename
    else:
        checkfile = filename.encode("utf-8")
    
    # determine if our python module is able to access the file directly...
    if os.path.exists(checkfile):
        filename = filename
    elif os.path.exists(checkfile.replace("smb://","\\\\").replace("/","\\")):
        filename = filename.replace("smb://","\\\\").replace("/","\\")
    else:
        #file can not be accessed by python directly, we copy it for processing...
        isTemp = True
        if "/" in filename: filepart = filename.split("/")[-1]
        else: filepart = filename.split("\\")[-1]
        tempfile = "special://temp/"+filepart
        xbmcvfs.copy(filename, tempfile)
        filename = xbmc.translatePath(tempfile).decode("utf-8")
        
    return (isTemp,filename)

def getEmbyRatingFromKodiRating(rating):
    # Translation needed between Kodi/ID3 rating and emby likes/favourites:
    # 3+ rating in ID3 = emby like
    # 5+ rating in ID3 = emby favourite
    # rating 0 = emby dislike
    # rating 1-2 = emby no likes or dislikes (returns 1 in results)
    favourite = False
    deletelike = False
    like = False
    if (rating >= 3): like = True
    if (rating == 0): like = False
    if (rating == 1 or rating == 2): deletelike = True
    if (rating >= 5): favourite = True
    return(like, favourite, deletelike)

def getAdditionalSongTags(embyid, emby_rating, API, kodicursor, emby_db, enableimportsongrating, enableexportsongrating, enableupdatesongrating):
    
    emby = embyserver.Read_EmbyServer()

    previous_values = None
    filename = API.getFilePath()
    rating = 0
    emby_rating = int(round(emby_rating, 0))
    
    #get file rating and comment tag from file itself.
    if enableimportsongrating:
        file_rating, comment, hasEmbeddedCover = getSongTags(filename)
    else: 
        file_rating = 0
        comment = ""
        hasEmbeddedCover = False
        

    emby_dbitem = emby_db.getItem_byId(embyid)
    try:
        kodiid = emby_dbitem[0]
    except TypeError:
        # Item is not in database.
        currentvalue = None
    else:
        query = "SELECT rating FROM song WHERE idSong = ?"
        kodicursor.execute(query, (kodiid,))
        try:
            currentvalue = int(round(float(kodicursor.fetchone()[0]),0))
        except: currentvalue = None
    
    # Only proceed if we actually have a rating from the file
    if file_rating is None and currentvalue:
        return (currentvalue, comment, False)
    elif file_rating is None and not currentvalue:
        return (emby_rating, comment, False)
    
    logMsg("getAdditionalSongTags --> embyid: %s - emby_rating: %s - file_rating: %s - current rating in kodidb: %s" %(embyid, emby_rating, file_rating, currentvalue))
    
    updateFileRating = False
    updateEmbyRating = False

    if currentvalue != None:
        # we need to translate the emby values...
        if emby_rating == 1 and currentvalue == 2:
            emby_rating = 2
        if emby_rating == 3 and currentvalue == 4:
            emby_rating = 4
            
        #if updating rating into file is disabled, we ignore the rating in the file...
        if not enableupdatesongrating:
            file_rating = currentvalue
        #if convert emby likes/favourites convert to song rating is disabled, we ignore the emby rating...
        if not enableexportsongrating:
            emby_rating = currentvalue
            
        if (emby_rating == file_rating) and (file_rating != currentvalue):
            #the rating has been updated from kodi itself, update change to both emby ands file
            rating = currentvalue
            updateFileRating = True
            updateEmbyRating = True
        elif (emby_rating != currentvalue) and (file_rating == currentvalue):
            #emby rating changed - update the file
            rating = emby_rating
            updateFileRating = True  
        elif (file_rating != currentvalue) and (emby_rating == currentvalue):
            #file rating was updated, sync change to emby
            rating = file_rating
            updateEmbyRating = True
        elif (emby_rating != currentvalue) and (file_rating != currentvalue):
            #both ratings have changed (corner case) - the highest rating wins...
            if emby_rating > file_rating:
                rating = emby_rating
                updateFileRating = True
            else:
                rating = file_rating
                updateEmbyRating = True
        else:
            #nothing has changed, just return the current value
            rating = currentvalue
    else:      
        # no rating yet in DB
        if enableimportsongrating:
            #prefer the file rating
            rating = file_rating
            #determine if we should also send the rating to emby server
            if enableexportsongrating:
                if emby_rating == 1 and file_rating == 2:
                    emby_rating = 2
                if emby_rating == 3 and file_rating == 4:
                    emby_rating = 4
                if emby_rating != file_rating:
                    updateEmbyRating = True
                
        elif enableexportsongrating:
            #set the initial rating to emby value
            rating = emby_rating
        
    if updateFileRating and enableupdatesongrating:
        updateRatingToFile(rating, filename)
        
    if updateEmbyRating and enableexportsongrating:
        # sync details to emby server. Translation needed between ID3 rating and emby likes/favourites:
        like, favourite, deletelike = getEmbyRatingFromKodiRating(rating)
        utils.window("ignore-update-%s" %embyid, "true") #set temp windows prop to ignore the update from webclient update
        emby.updateUserRating(embyid, like, favourite, deletelike)
    
    return (rating, comment, hasEmbeddedCover)
        
def getSongTags(file):
    # Get the actual ID3 tags for music songs as the server is lacking that info
    rating = 0
    comment = ""
    hasEmbeddedCover = False
    
    isTemp,filename = getRealFileName(file)
    logMsg( "getting song ID3 tags for " + filename)
    
    try:
        ###### FLAC FILES #############
        if filename.lower().endswith(".flac"):
            audio = FLAC(filename)
            if audio.get("comment"):
                comment = audio.get("comment")[0]
            for pic in audio.pictures:
                if pic.type == 3 and pic.data:
                    #the file has an embedded cover
                    hasEmbeddedCover = True
            if audio.get("rating"):
                rating = float(audio.get("rating")[0])
                #flac rating is 0-100 and needs to be converted to 0-5 range
                if rating > 5: rating = (rating / 100) * 5
        
        ###### MP3 FILES #############
        elif filename.lower().endswith(".mp3"):
            audio = ID3(filename)
            
            if audio.get("APIC:Front Cover"):
                if audio.get("APIC:Front Cover").data:
                    hasEmbeddedCover = True
            
            if audio.get("comment"):
                comment = audio.get("comment")[0]
            if audio.get("POPM:Windows Media Player 9 Series"):
                if audio.get("POPM:Windows Media Player 9 Series").rating:
                    rating = float(audio.get("POPM:Windows Media Player 9 Series").rating)
                    #POPM rating is 0-255 and needs to be converted to 0-5 range
                    if rating > 5: rating = (rating / 255) * 5
        else:
            logMsg( "Not supported fileformat or unable to access file: %s" %(filename))
        
        #the rating must be a round value
        rating = int(round(rating,0))
    
    except Exception as e:
        #file in use ?
        utils.logMsg("Exception in getSongTags", str(e),0)
        rating = None
    
    #remove tempfile if needed....
    if isTemp: xbmcvfs.delete(filename)
        
    return (rating, comment, hasEmbeddedCover)

def updateRatingToFile(rating, file):
    #update the rating from Emby to the file
    
    f = xbmcvfs.File(file)
    org_size = f.size()
    f.close()
    
    #create tempfile
    if "/" in file: filepart = file.split("/")[-1]
    else: filepart = file.split("\\")[-1]
    tempfile = "special://temp/"+filepart
    xbmcvfs.copy(file, tempfile)
    tempfile = xbmc.translatePath(tempfile).decode("utf-8")
    
    logMsg( "setting song rating: %s for filename: %s - using tempfile: %s" %(rating,file,tempfile))
    
    if not tempfile:
        return
    
    try:
        if tempfile.lower().endswith(".flac"):
            audio = FLAC(tempfile)
            calcrating = int(round((float(rating) / 5) * 100, 0))
            audio["rating"] = str(calcrating)
            audio.save()
        elif tempfile.lower().endswith(".mp3"):
            audio = ID3(tempfile)
            calcrating = int(round((float(rating) / 5) * 255, 0))
            audio.add(id3.POPM(email="Windows Media Player 9 Series", rating=calcrating, count=1))
            audio.save()
        else:
            logMsg( "Not supported fileformat: %s" %(tempfile))
            
        #once we have succesfully written the flags we move the temp file to destination, otherwise not proceeding and just delete the temp
        #safety check: we check the file size of the temp file before proceeding with overwite of original file
        f = xbmcvfs.File(tempfile)
        checksum_size = f.size()
        f.close()
        if checksum_size >= org_size:
            xbmcvfs.delete(file)
            xbmcvfs.copy(tempfile,file)
        else:
            logMsg( "Checksum mismatch for filename: %s - using tempfile: %s  -  not proceeding with file overwite!" %(rating,file,tempfile))
        
        #always delete the tempfile
        xbmcvfs.delete(tempfile)
            
    except Exception as e:
        #file in use ?
        logMsg("Exception in updateRatingToFile %s" %e,0)
        
    
    
import unittest

from zope.testing import doctestunit
from zope.component import testing
from Testing import ZopeTestCase as ztc

from Products.Five import zcml
from Products.Five import fiveconfigure
from Products.PloneTestCase import PloneTestCase as ptc
from Products.PloneTestCase.layer import PloneSite
ptc.setupPloneSite()

import uwosh.flashpage

class TestCase(ptc.PloneTestCase):
    class layer(PloneSite):
        @classmethod
        def setUp(cls):
            fiveconfigure.debug_mode = True
            zcml.load_config('configure.zcml',
                             uwosh.flashpage)
            fiveconfigure.debug_mode = False

        @classmethod
        def tearDown(cls):
            pass


def test_suite():
    return unittest.TestSuite([

        # Unit tests
        #doctestunit.DocFileSuite(
        #    'README.txt', package='uwosh.flashpage',
        #    setUp=testing.setUp, tearDown=testing.tearDown),

        #doctestunit.DocTestSuite(
        #    module='uwosh.flashpage.mymodule',
        #    setUp=testing.setUp, tearDown=testing.tearDown),


        # Integration tests that use PloneTestCase
        #ztc.ZopeDocFileSuite(
        #    'README.txt', package='uwosh.flashpage',
        #    test_class=TestCase),

        #ztc.FunctionalDocFileSuite(
        #    'browser.txt', package='uwosh.flashpage',
        #    test_class=TestCase),

        ])

if __name__ == '__main__':
    unittest.main(defaultTest='test_suite')

data = (
'ssal',    # 0x00
'ssalg',    # 0x01
'ssalm',    # 0x02
'ssalb',    # 0x03
'ssals',    # 0x04
'ssalt',    # 0x05
'ssalp',    # 0x06
'ssalh',    # 0x07
'ssam',    # 0x08
'ssab',    # 0x09
'ssabs',    # 0x0a
'ssas',    # 0x0b
'ssass',    # 0x0c
'ssang',    # 0x0d
'ssaj',    # 0x0e
'ssac',    # 0x0f
'ssak',    # 0x10
'ssat',    # 0x11
'ssap',    # 0x12
'ssah',    # 0x13
'ssae',    # 0x14
'ssaeg',    # 0x15
'ssaegg',    # 0x16
'ssaegs',    # 0x17
'ssaen',    # 0x18
'ssaenj',    # 0x19
'ssaenh',    # 0x1a
'ssaed',    # 0x1b
'ssael',    # 0x1c
'ssaelg',    # 0x1d
'ssaelm',    # 0x1e
'ssaelb',    # 0x1f
'ssaels',    # 0x20
'ssaelt',    # 0x21
'ssaelp',    # 0x22
'ssaelh',    # 0x23
'ssaem',    # 0x24
'ssaeb',    # 0x25
'ssaebs',    # 0x26
'ssaes',    # 0x27
'ssaess',    # 0x28
'ssaeng',    # 0x29
'ssaej',    # 0x2a
'ssaec',    # 0x2b
'ssaek',    # 0x2c
'ssaet',    # 0x2d
'ssaep',    # 0x2e
'ssaeh',    # 0x2f
'ssya',    # 0x30
'ssyag',    # 0x31
'ssyagg',    # 0x32
'ssyags',    # 0x33
'ssyan',    # 0x34
'ssyanj',    # 0x35
'ssyanh',    # 0x36
'ssyad',    # 0x37
'ssyal',    # 0x38
'ssyalg',    # 0x39
'ssyalm',    # 0x3a
'ssyalb',    # 0x3b
'ssyals',    # 0x3c
'ssyalt',    # 0x3d
'ssyalp',    # 0x3e
'ssyalh',    # 0x3f
'ssyam',    # 0x40
'ssyab',    # 0x41
'ssyabs',    # 0x42
'ssyas',    # 0x43
'ssyass',    # 0x44
'ssyang',    # 0x45
'ssyaj',    # 0x46
'ssyac',    # 0x47
'ssyak',    # 0x48
'ssyat',    # 0x49
'ssyap',    # 0x4a
'ssyah',    # 0x4b
'ssyae',    # 0x4c
'ssyaeg',    # 0x4d
'ssyaegg',    # 0x4e
'ssyaegs',    # 0x4f
'ssyaen',    # 0x50
'ssyaenj',    # 0x51
'ssyaenh',    # 0x52
'ssyaed',    # 0x53
'ssyael',    # 0x54
'ssyaelg',    # 0x55
'ssyaelm',    # 0x56
'ssyaelb',    # 0x57
'ssyaels',    # 0x58
'ssyaelt',    # 0x59
'ssyaelp',    # 0x5a
'ssyaelh',    # 0x5b
'ssyaem',    # 0x5c
'ssyaeb',    # 0x5d
'ssyaebs',    # 0x5e
'ssyaes',    # 0x5f
'ssyaess',    # 0x60
'ssyaeng',    # 0x61
'ssyaej',    # 0x62
'ssyaec',    # 0x63
'ssyaek',    # 0x64
'ssyaet',    # 0x65
'ssyaep',    # 0x66
'ssyaeh',    # 0x67
'sseo',    # 0x68
'sseog',    # 0x69
'sseogg',    # 0x6a
'sseogs',    # 0x6b
'sseon',    # 0x6c
'sseonj',    # 0x6d
'sseonh',    # 0x6e
'sseod',    # 0x6f
'sseol',    # 0x70
'sseolg',    # 0x71
'sseolm',    # 0x72
'sseolb',    # 0x73
'sseols',    # 0x74
'sseolt',    # 0x75
'sseolp',    # 0x76
'sseolh',    # 0x77
'sseom',    # 0x78
'sseob',    # 0x79
'sseobs',    # 0x7a
'sseos',    # 0x7b
'sseoss',    # 0x7c
'sseong',    # 0x7d
'sseoj',    # 0x7e
'sseoc',    # 0x7f
'sseok',    # 0x80
'sseot',    # 0x81
'sseop',    # 0x82
'sseoh',    # 0x83
'sse',    # 0x84
'sseg',    # 0x85
'ssegg',    # 0x86
'ssegs',    # 0x87
'ssen',    # 0x88
'ssenj',    # 0x89
'ssenh',    # 0x8a
'ssed',    # 0x8b
'ssel',    # 0x8c
'sselg',    # 0x8d
'sselm',    # 0x8e
'sselb',    # 0x8f
'ssels',    # 0x90
'sselt',    # 0x91
'sselp',    # 0x92
'sselh',    # 0x93
'ssem',    # 0x94
'sseb',    # 0x95
'ssebs',    # 0x96
'sses',    # 0x97
'ssess',    # 0x98
'sseng',    # 0x99
'ssej',    # 0x9a
'ssec',    # 0x9b
'ssek',    # 0x9c
'sset',    # 0x9d
'ssep',    # 0x9e
'sseh',    # 0x9f
'ssyeo',    # 0xa0
'ssyeog',    # 0xa1
'ssyeogg',    # 0xa2
'ssyeogs',    # 0xa3
'ssyeon',    # 0xa4
'ssyeonj',    # 0xa5
'ssyeonh',    # 0xa6
'ssyeod',    # 0xa7
'ssyeol',    # 0xa8
'ssyeolg',    # 0xa9
'ssyeolm',    # 0xaa
'ssyeolb',    # 0xab
'ssyeols',    # 0xac
'ssyeolt',    # 0xad
'ssyeolp',    # 0xae
'ssyeolh',    # 0xaf
'ssyeom',    # 0xb0
'ssyeob',    # 0xb1
'ssyeobs',    # 0xb2
'ssyeos',    # 0xb3
'ssyeoss',    # 0xb4
'ssyeong',    # 0xb5
'ssyeoj',    # 0xb6
'ssyeoc',    # 0xb7
'ssyeok',    # 0xb8
'ssyeot',    # 0xb9
'ssyeop',    # 0xba
'ssyeoh',    # 0xbb
'ssye',    # 0xbc
'ssyeg',    # 0xbd
'ssyegg',    # 0xbe
'ssyegs',    # 0xbf
'ssyen',    # 0xc0
'ssyenj',    # 0xc1
'ssyenh',    # 0xc2
'ssyed',    # 0xc3
'ssyel',    # 0xc4
'ssyelg',    # 0xc5
'ssyelm',    # 0xc6
'ssyelb',    # 0xc7
'ssyels',    # 0xc8
'ssyelt',    # 0xc9
'ssyelp',    # 0xca
'ssyelh',    # 0xcb
'ssyem',    # 0xcc
'ssyeb',    # 0xcd
'ssyebs',    # 0xce
'ssyes',    # 0xcf
'ssyess',    # 0xd0
'ssyeng',    # 0xd1
'ssyej',    # 0xd2
'ssyec',    # 0xd3
'ssyek',    # 0xd4
'ssyet',    # 0xd5
'ssyep',    # 0xd6
'ssyeh',    # 0xd7
'sso',    # 0xd8
'ssog',    # 0xd9
'ssogg',    # 0xda
'ssogs',    # 0xdb
'sson',    # 0xdc
'ssonj',    # 0xdd
'ssonh',    # 0xde
'ssod',    # 0xdf
'ssol',    # 0xe0
'ssolg',    # 0xe1
'ssolm',    # 0xe2
'ssolb',    # 0xe3
'ssols',    # 0xe4
'ssolt',    # 0xe5
'ssolp',    # 0xe6
'ssolh',    # 0xe7
'ssom',    # 0xe8
'ssob',    # 0xe9
'ssobs',    # 0xea
'ssos',    # 0xeb
'ssoss',    # 0xec
'ssong',    # 0xed
'ssoj',    # 0xee
'ssoc',    # 0xef
'ssok',    # 0xf0
'ssot',    # 0xf1
'ssop',    # 0xf2
'ssoh',    # 0xf3
'sswa',    # 0xf4
'sswag',    # 0xf5
'sswagg',    # 0xf6
'sswags',    # 0xf7
'sswan',    # 0xf8
'sswanj',    # 0xf9
'sswanh',    # 0xfa
'sswad',    # 0xfb
'sswal',    # 0xfc
'sswalg',    # 0xfd
'sswalm',    # 0xfe
'sswalb',    # 0xff
)

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import migrations, models
import django.db.models.deletion
import lambdainst.models
from django.conf import settings
import datetime


class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name='GiftCode',
            fields=[
                ('id', models.AutoField(serialize=False, primary_key=True, verbose_name='ID', auto_created=True)),
                ('code', models.CharField(default=lambdainst.models.random_gift_code, max_length=32)),
                ('time', models.DurationField(default=datetime.timedelta(30))),
                ('created', models.DateTimeField(null=True, auto_now_add=True)),
                ('single_use', models.BooleanField(default=True)),
                ('free_only', models.BooleanField(default=True)),
                ('available', models.BooleanField(default=True)),
                ('comment', models.TextField(blank=True)),
                ('created_by', models.ForeignKey(related_name='created_giftcode_set', null=True, blank=True, to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'verbose_name_plural': 'Gift Codes',
                'verbose_name': 'Gift Code',
            },
        ),
        migrations.CreateModel(
            name='GiftCodeUser',
            fields=[
                ('id', models.AutoField(serialize=False, primary_key=True, verbose_name='ID', auto_created=True)),
                ('date', models.DateTimeField(null=True, auto_now_add=True)),
                ('code', models.ForeignKey(to='lambdainst.GiftCode')),
                ('user', models.ForeignKey(to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'verbose_name_plural': 'Gift Code Users',
                'verbose_name': 'Gift Code User',
            },
        ),
        migrations.CreateModel(
            name='VPNUser',
            fields=[
                ('id', models.AutoField(serialize=False, primary_key=True, verbose_name='ID', auto_created=True)),
                ('notes', models.TextField(blank=True)),
                ('expiration', models.DateTimeField(null=True, blank=True)),
                ('last_expiry_notice', models.DateTimeField(null=True, blank=True)),
                ('notify_expiration', models.BooleanField(default=True)),
                ('trial_periods_given', models.IntegerField(default=0)),
                ('last_vpn_auth', models.DateTimeField(null=True, blank=True)),
                ('referrer_used', models.BooleanField(default=False)),
                ('referrer', models.ForeignKey(related_name='referrals', null=True, on_delete=django.db.models.deletion.SET_NULL, blank=True, to=settings.AUTH_USER_MODEL)),
                ('user', models.OneToOneField(to=settings.AUTH_USER_MODEL)),
            ],
            options={
                'verbose_name_plural': 'VPN Users',
                'verbose_name': 'VPN User',
            },
        ),
        migrations.AddField(
            model_name='giftcode',
            name='users',
            field=models.ManyToManyField(through='lambdainst.GiftCodeUser', to=settings.AUTH_USER_MODEL),
        ),
    ]

"""
pgoapi - Pokemon Go API
Copyright (c) 2016 tjado <https://github.com/tejado>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
OR OTHER DEALINGS IN THE SOFTWARE.

Author: tjado <https://github.com/tejado>
"""

import struct
import re

from importlib import import_module
from s2sphere import CellId, LatLng
from google.protobuf.internal import encoder
from geopy.geocoders import GoogleV3


def f2i(float):
  return struct.unpack('<Q', struct.pack('<d', float))[0]

def f2h(float):
  return hex(struct.unpack('<Q', struct.pack('<d', float))[0])

def h2f(hex):
  return struct.unpack('<d', struct.pack('<Q', int(hex,16)))[0]
  
def to_camel_case(value):
  def camelcase():
    while True:
      yield str.capitalize

  c = camelcase()
  return "".join(c.next()(x) if x else '_' for x in value.split("_"))

def get_pos_by_name(location_name):
    prog = re.compile("^(\-?\d+\.\d+)?,\s*(\-?\d+\.\d+?)$")
    res = prog.match(location_name)
    latitude, longitude, altitude = None, None, None
    if res:
        latitude, longitude, altitude = float(res.group(1)), float(res.group(2)), 0
    elif location_name:
        geolocator = GoogleV3()
        loc = geolocator.geocode(location_name)
        if loc:
            latitude, longitude, altitude = loc.latitude, loc.longitude, loc.altitude
    
    return (latitude, longitude, altitude)
    

def get_class(cls):
    module_, class_ = cls.rsplit('.', 1)
    class_ = getattr(import_module(module_), class_)
    return class_
    
def get_cellid(lat, long):
    origin = CellId.from_lat_lng(LatLng.from_degrees(lat, long)).parent(15)
    walk = [origin.id()]

    # 10 before and 10 after
    next = origin.next()
    prev = origin.prev()
    for i in range(10):
        walk.append(prev.id())
        walk.append(next.id())
        next = next.next()
        prev = prev.prev()
    return ''.join(map(encode, sorted(walk)))

def encode(cellid):
    output = []
    encoder._VarintEncoder()(output.append, cellid)
    return ''.join(output)

import math

def viterbi(dict_tag, dict_word, obs, states, start_p, trans_p, emit_p):
    V = [{}]
    path = ['']
    epsilon = 0.00000000000000000001
 
    # Initialize base cases (t == 0)
    # Actually it will already be <s>

    max_v = -1.0 / epsilon / 1000
    for y in states:
        temp_emit = emit_p[dict_tag[y]][dict_word[obs[0]]]
        if temp_emit < epsilon:
            temp_emit = epsilon
        V[0][y] = math.log(start_p[y]) + math.log(temp_emit)
        if max_v < V[0][y]: 
            max_v = V[0][y]          
            path[0] = y
 
    # Run Viterbi for t > 0
    for t in range(1, len(obs)):
         
        V.append({})
        path.append('')
        max_v = -1.0 / epsilon
        for y in states:
            
            if y == "<s>":
                V[t][y] = max_v
            else:
                temp = list()
                for y0 in states: 
                    temp_trans = trans_p[dict_tag[y0]][dict_tag[y]]
                    if temp_trans < epsilon:
                        temp_trans = epsilon
                    temp_prev_v = V[t-1][y0]
                    if temp_prev_v < epsilon:
                        temp_prev_v = epsilon
                    temp.append((math.log(temp_prev_v) + math.log(temp_trans)))

                temp_emit = emit_p[dict_tag[y]][dict_word[obs[t]]]
                if temp_emit < epsilon:
                    temp_emit = epsilon
                prob = math.log(temp_emit) + max(temp)
                V[t][y] = prob
                if max_v < prob:              
                    max_v = prob
                    path[t] = y

    # Outputting the Viterbi path    
    return path
#!/usr/bin/python
#
# linearize.py:  Construct a linear, no-fork, best version of the blockchain.
#
#
# Copyright (c) 2013 The Bitcoin developers
# Distributed under the MIT/X11 software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
#

import json
import struct
import re
import base64
import httplib
import sys

ERR_SLEEP = 15
MAX_NONCE = 1000000L

settings = {}

class BitcoinRPC:
	OBJID = 1

	def __init__(self, host, port, username, password):
		authpair = "%s:%s" % (username, password)
		self.authhdr = "Basic %s" % (base64.b64encode(authpair))
		self.conn = httplib.HTTPConnection(host, port, False, 30)
	def rpc(self, method, params=None):
		self.OBJID += 1
		obj = { 'version' : '1.1',
			'method' : method,
			'id' : self.OBJID }
		if params is None:
			obj['params'] = []
		else:
			obj['params'] = params
		self.conn.request('POST', '/', json.dumps(obj),
			{ 'Authorization' : self.authhdr,
			  'Content-type' : 'application/json' })

		resp = self.conn.getresponse()
		if resp is None:
			print "JSON-RPC: no response"
			return None

		body = resp.read()
		resp_obj = json.loads(body)
		if resp_obj is None:
			print "JSON-RPC: cannot JSON-decode body"
			return None
		if 'error' in resp_obj and resp_obj['error'] != None:
			return resp_obj['error']
		if 'result' not in resp_obj:
			print "JSON-RPC: no result in object"
			return None

		return resp_obj['result']
	def getblock(self, hash, verbose=True):
		return self.rpc('getblock', [hash, verbose])
	def getblockhash(self, index):
		return self.rpc('getblockhash', [index])

def getblock(rpc, settings, n):
	hash = rpc.getblockhash(n)
	hexdata = rpc.getblock(hash, False)
	data = hexdata.decode('hex')

	return data

def get_blocks(settings):
	rpc = BitcoinRPC(settings['host'], settings['port'],
			 settings['rpcuser'], settings['rpcpassword'])

	outf = open(settings['output'], 'ab')

	for height in xrange(settings['min_height'], settings['max_height']+1):
		data = getblock(rpc, settings, height)

		outhdr = settings['netmagic']
		outhdr += struct.pack("<i", len(data))

		outf.write(outhdr)
		outf.write(data)

		if (height % 1000) == 0:
			sys.stdout.write("Wrote block " + str(height) + "\n")

if __name__ == '__main__':
	if len(sys.argv) != 2:
		print "Usage: linearize.py CONFIG-FILE"
		sys.exit(1)

	f = open(sys.argv[1])
	for line in f:
		# skip comment lines
		m = re.search('^\s*#', line)
		if m:
			continue

		# parse key=value lines
		m = re.search('^(\w+)\s*=\s*(\S.*)$', line)
		if m is None:
			continue
		settings[m.group(1)] = m.group(2)
	f.close()

	if 'netmagic' not in settings:
		settings['netmagic'] = 'f9beb4d9'
	if 'output' not in settings:
		settings['output'] = 'bootstrap.dat'
	if 'host' not in settings:
		settings['host'] = '127.0.0.1'
	if 'port' not in settings:
		settings['port'] = 8332
	if 'min_height' not in settings:
		settings['min_height'] = 0
	if 'max_height' not in settings:
		settings['max_height'] = 279000
	if 'rpcuser' not in settings or 'rpcpassword' not in settings:
		print "Missing username and/or password in cfg file"
		sys.exit(1)

	settings['netmagic'] = settings['netmagic'].decode('hex')
	settings['port'] = int(settings['port'])
	settings['min_height'] = int(settings['min_height'])
	settings['max_height'] = int(settings['max_height'])

	get_blocks(settings)



from scrapy.exceptions import IgnoreRequest, NotConfigured

from .http import WebdriverActionRequest, WebdriverRequest
from .manager import WebdriverManager


class WebdriverSpiderMiddleware(object):
    """This middleware coordinates concurrent webdriver access attempts."""
    def __init__(self, crawler):
        self.manager = WebdriverManager(crawler)

    @classmethod
    def from_crawler(cls, crawler):
        try:
            return cls(crawler)
        except Exception as e:
            raise NotConfigured('WEBDRIVER_BROWSER is misconfigured: %r (%r)'
                % (crawler.settings.get('WEBDRIVER_BROWSER'), e))

    def process_start_requests(self, start_requests, spider):
        """Return start requests, with some reordered by the manager.

        The reordering occurs as a result of some requests waiting to gain
        access to the webdriver instance. Those waiting requests are queued up
        in the manager, from which we pop the next in line after we release the
        webdriver instance while processing spider output.

        """
        return self._process_requests(start_requests, start=True)

    def process_spider_output(self, response, result, spider):
        """Return spider result, with some requests reordered by the manager.

        See ``process_start_requests`` for a description of the reordering.

        """
        for item_or_request in self._process_requests(result):
            yield item_or_request
        if isinstance(response.request, WebdriverRequest):
            # We are here because the current request holds the webdriver lock.
            # That lock was kept for the entire duration of the response
            # parsing callback to keep the webdriver instance intact, and we
            # now release it.
            self.manager.release(response.request.url)
            next_request = self.manager.acquire_next()
            if next_request is not WebdriverRequest.WAITING:
                yield next_request.replace(dont_filter=True)

    def _process_requests(self, items_or_requests, start=False):
        """Acquire the webdriver manager when it's available for requests."""
        error_msg = "WebdriverRequests from start_requests can't be in-page."
        for request in iter(items_or_requests):
            if isinstance(request, WebdriverRequest):
                if start and isinstance(request, WebdriverActionRequest):
                    raise IgnoreRequest(error_msg)
                request = self.manager.acquire(request)
                if request is WebdriverRequest.WAITING:
                    continue  # Request has been enqueued, so drop it.
            yield request

"""
Combination of multiple media players into one for a universal controller.

For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/media_player.universal/
"""
from copy import copy
import logging

import voluptuous as vol

from homeassistant.components.media_player import (
    MediaPlayerDevice, PLATFORM_SCHEMA)
from homeassistant.components.media_player.const import (
    ATTR_APP_ID, ATTR_APP_NAME, ATTR_INPUT_SOURCE, ATTR_INPUT_SOURCE_LIST,
    ATTR_MEDIA_ALBUM_ARTIST, ATTR_MEDIA_ALBUM_NAME, ATTR_MEDIA_ARTIST,
    ATTR_MEDIA_CHANNEL, ATTR_MEDIA_CONTENT_ID, ATTR_MEDIA_CONTENT_TYPE,
    ATTR_MEDIA_DURATION, ATTR_MEDIA_EPISODE, ATTR_MEDIA_PLAYLIST,
    ATTR_MEDIA_POSITION, ATTR_MEDIA_POSITION_UPDATED_AT, ATTR_MEDIA_SEASON,
    ATTR_MEDIA_SEEK_POSITION, ATTR_MEDIA_SERIES_TITLE, ATTR_MEDIA_SHUFFLE,
    ATTR_MEDIA_TITLE, ATTR_MEDIA_TRACK, ATTR_MEDIA_VOLUME_LEVEL,
    ATTR_MEDIA_VOLUME_MUTED, DOMAIN, SERVICE_CLEAR_PLAYLIST,
    SERVICE_PLAY_MEDIA, SERVICE_SELECT_SOURCE, SUPPORT_CLEAR_PLAYLIST,
    SUPPORT_SELECT_SOURCE, SUPPORT_SHUFFLE_SET, SUPPORT_TURN_OFF,
    SUPPORT_TURN_ON, SUPPORT_VOLUME_MUTE, SUPPORT_VOLUME_SET,
    SUPPORT_VOLUME_STEP)
from homeassistant.const import (
    ATTR_ENTITY_ID, ATTR_ENTITY_PICTURE, ATTR_SUPPORTED_FEATURES, CONF_NAME,
    CONF_STATE, CONF_STATE_TEMPLATE, SERVICE_MEDIA_NEXT_TRACK,
    SERVICE_MEDIA_PAUSE, SERVICE_MEDIA_PLAY, SERVICE_MEDIA_PLAY_PAUSE,
    SERVICE_MEDIA_PREVIOUS_TRACK, SERVICE_MEDIA_SEEK, SERVICE_MEDIA_STOP,
    SERVICE_SHUFFLE_SET, SERVICE_TURN_OFF, SERVICE_TURN_ON,
    SERVICE_VOLUME_DOWN, SERVICE_VOLUME_MUTE, SERVICE_VOLUME_SET,
    SERVICE_VOLUME_UP, STATE_IDLE, STATE_OFF, STATE_ON, STATE_UNAVAILABLE)
from homeassistant.core import callback
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.service import async_call_from_config

_LOGGER = logging.getLogger(__name__)

ATTR_ACTIVE_CHILD = 'active_child'
ATTR_DATA = 'data'

CONF_ATTRS = 'attributes'
CONF_CHILDREN = 'children'
CONF_COMMANDS = 'commands'
CONF_SERVICE = 'service'
CONF_SERVICE_DATA = 'service_data'

OFF_STATES = [STATE_IDLE, STATE_OFF, STATE_UNAVAILABLE]

ATTRS_SCHEMA = cv.schema_with_slug_keys(cv.string)
CMD_SCHEMA = cv.schema_with_slug_keys(cv.SERVICE_SCHEMA)

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_NAME): cv.string,
    vol.Optional(CONF_CHILDREN, default=[]): cv.entity_ids,
    vol.Optional(CONF_COMMANDS, default={}): CMD_SCHEMA,
    vol.Optional(CONF_ATTRS, default={}):
        vol.Or(cv.ensure_list(ATTRS_SCHEMA), ATTRS_SCHEMA),
    vol.Optional(CONF_STATE_TEMPLATE): cv.template
}, extra=vol.REMOVE_EXTRA)


async def async_setup_platform(hass, config, async_add_entities,
                               discovery_info=None):
    """Set up the universal media players."""
    player = UniversalMediaPlayer(
        hass,
        config.get(CONF_NAME),
        config.get(CONF_CHILDREN),
        config.get(CONF_COMMANDS),
        config.get(CONF_ATTRS),
        config.get(CONF_STATE_TEMPLATE)
    )

    async_add_entities([player])


class UniversalMediaPlayer(MediaPlayerDevice):
    """Representation of an universal media player."""

    def __init__(self, hass, name, children,
                 commands, attributes, state_template=None):
        """Initialize the Universal media device."""
        self.hass = hass
        self._name = name
        self._children = children
        self._cmds = commands
        self._attrs = {}
        for key, val in attributes.items():
            attr = val.split('|', 1)
            if len(attr) == 1:
                attr.append(None)
            self._attrs[key] = attr
        self._child_state = None
        self._state_template = state_template
        if state_template is not None:
            self._state_template.hass = hass

    async def async_added_to_hass(self):
        """Subscribe to children and template state changes.

        This method must be run in the event loop and returns a coroutine.
        """
        @callback
        def async_on_dependency_update(*_):
            """Update ha state when dependencies update."""
            self.async_schedule_update_ha_state(True)

        depend = copy(self._children)
        for entity in self._attrs.values():
            depend.append(entity[0])
        if self._state_template is not None:
            for entity in self._state_template.extract_entities():
                depend.append(entity)

        self.hass.helpers.event.async_track_state_change(
            list(set(depend)), async_on_dependency_update)

    def _entity_lkp(self, entity_id, state_attr=None):
        """Look up an entity state."""
        state_obj = self.hass.states.get(entity_id)

        if state_obj is None:
            return

        if state_attr:
            return state_obj.attributes.get(state_attr)
        return state_obj.state

    def _override_or_child_attr(self, attr_name):
        """Return either the override or the active child for attr_name."""
        if attr_name in self._attrs:
            return self._entity_lkp(
                self._attrs[attr_name][0], self._attrs[attr_name][1])

        return self._child_attr(attr_name)

    def _child_attr(self, attr_name):
        """Return the active child's attributes."""
        active_child = self._child_state
        return active_child.attributes.get(attr_name) if active_child else None

    async def _async_call_service(self, service_name, service_data=None,
                                  allow_override=False):
        """Call either a specified or active child's service."""
        if service_data is None:
            service_data = {}

        if allow_override and service_name in self._cmds:
            await async_call_from_config(
                self.hass, self._cmds[service_name],
                variables=service_data, blocking=True,
                validate_config=False)
            return

        active_child = self._child_state
        if active_child is None:
            # No child to call service on
            return

        service_data[ATTR_ENTITY_ID] = active_child.entity_id

        await self.hass.services.async_call(
            DOMAIN, service_name, service_data, blocking=True)

    @property
    def should_poll(self):
        """No polling needed."""
        return False

    @property
    def master_state(self):
        """Return the master state for entity or None."""
        if self._state_template is not None:
            return self._state_template.async_render()
        if CONF_STATE in self._attrs:
            master_state = self._entity_lkp(
                self._attrs[CONF_STATE][0], self._attrs[CONF_STATE][1])
            return master_state if master_state else STATE_OFF

        return None

    @property
    def name(self):
        """Return the name of universal player."""
        return self._name

    @property
    def state(self):
        """Return the current state of media player.

        Off if master state is off
        else Status of first active child
        else master state or off
        """
        master_state = self.master_state  # avoid multiple lookups
        if (master_state == STATE_OFF) or (self._state_template is not None):
            return master_state

        active_child = self._child_state
        if active_child:
            return active_child.state

        return master_state if master_state else STATE_OFF

    @property
    def volume_level(self):
        """Volume level of entity specified in attributes or active child."""
        return self._override_or_child_attr(ATTR_MEDIA_VOLUME_LEVEL)

    @property
    def is_volume_muted(self):
        """Boolean if volume is muted."""
        return self._override_or_child_attr(ATTR_MEDIA_VOLUME_MUTED) \
            in [True, STATE_ON]

    @property
    def media_content_id(self):
        """Return the content ID of current playing media."""
        return self._child_attr(ATTR_MEDIA_CONTENT_ID)

    @property
    def media_content_type(self):
        """Return the content type of current playing media."""
        return self._child_attr(ATTR_MEDIA_CONTENT_TYPE)

    @property
    def media_duration(self):
        """Return the duration of current playing media in seconds."""
        return self._child_attr(ATTR_MEDIA_DURATION)

    @property
    def media_image_url(self):
        """Image url of current playing media."""
        return self._child_attr(ATTR_ENTITY_PICTURE)

    @property
    def entity_picture(self):
        """
        Return image of the media playing.

        The universal media player doesn't use the parent class logic, since
        the url is coming from child entity pictures which have already been
        sent through the API proxy.
        """
        return self.media_image_url

    @property
    def media_title(self):
        """Title of current playing media."""
        return self._child_attr(ATTR_MEDIA_TITLE)

    @property
    def media_artist(self):
        """Artist of current playing media (Music track only)."""
        return self._child_attr(ATTR_MEDIA_ARTIST)

    @property
    def media_album_name(self):
        """Album name of current playing media (Music track only)."""
        return self._child_attr(ATTR_MEDIA_ALBUM_NAME)

    @property
    def media_album_artist(self):
        """Album artist of current playing media (Music track only)."""
        return self._child_attr(ATTR_MEDIA_ALBUM_ARTIST)

    @property
    def media_track(self):
        """Track number of current playing media (Music track only)."""
        return self._child_attr(ATTR_MEDIA_TRACK)

    @property
    def media_series_title(self):
        """Return the title of the series of current playing media (TV)."""
        return self._child_attr(ATTR_MEDIA_SERIES_TITLE)

    @property
    def media_season(self):
        """Season of current playing media (TV Show only)."""
        return self._child_attr(ATTR_MEDIA_SEASON)

    @property
    def media_episode(self):
        """Episode of current playing media (TV Show only)."""
        return self._child_attr(ATTR_MEDIA_EPISODE)

    @property
    def media_channel(self):
        """Channel currently playing."""
        return self._child_attr(ATTR_MEDIA_CHANNEL)

    @property
    def media_playlist(self):
        """Title of Playlist currently playing."""
        return self._child_attr(ATTR_MEDIA_PLAYLIST)

    @property
    def app_id(self):
        """ID of the current running app."""
        return self._child_attr(ATTR_APP_ID)

    @property
    def app_name(self):
        """Name of the current running app."""
        return self._child_attr(ATTR_APP_NAME)

    @property
    def source(self):
        """Return the current input source of the device."""
        return self._override_or_child_attr(ATTR_INPUT_SOURCE)

    @property
    def source_list(self):
        """List of available input sources."""
        return self._override_or_child_attr(ATTR_INPUT_SOURCE_LIST)

    @property
    def shuffle(self):
        """Boolean if shuffling is enabled."""
        return self._override_or_child_attr(ATTR_MEDIA_SHUFFLE)

    @property
    def supported_features(self):
        """Flag media player features that are supported."""
        flags = self._child_attr(ATTR_SUPPORTED_FEATURES) or 0

        if SERVICE_TURN_ON in self._cmds:
            flags |= SUPPORT_TURN_ON
        if SERVICE_TURN_OFF in self._cmds:
            flags |= SUPPORT_TURN_OFF

        if any([cmd in self._cmds for cmd in [SERVICE_VOLUME_UP,
                                              SERVICE_VOLUME_DOWN]]):
            flags |= SUPPORT_VOLUME_STEP
        if SERVICE_VOLUME_SET in self._cmds:
            flags |= SUPPORT_VOLUME_SET

        if SERVICE_VOLUME_MUTE in self._cmds and \
                ATTR_MEDIA_VOLUME_MUTED in self._attrs:
            flags |= SUPPORT_VOLUME_MUTE

        if SERVICE_SELECT_SOURCE in self._cmds:
            flags |= SUPPORT_SELECT_SOURCE

        if SERVICE_CLEAR_PLAYLIST in self._cmds:
            flags |= SUPPORT_CLEAR_PLAYLIST

        if SERVICE_SHUFFLE_SET in self._cmds and \
                ATTR_MEDIA_SHUFFLE in self._attrs:
            flags |= SUPPORT_SHUFFLE_SET

        return flags

    @property
    def device_state_attributes(self):
        """Return device specific state attributes."""
        active_child = self._child_state
        return {ATTR_ACTIVE_CHILD: active_child.entity_id} \
            if active_child else {}

    @property
    def media_position(self):
        """Position of current playing media in seconds."""
        return self._child_attr(ATTR_MEDIA_POSITION)

    @property
    def media_position_updated_at(self):
        """When was the position of the current playing media valid."""
        return self._child_attr(ATTR_MEDIA_POSITION_UPDATED_AT)

    def async_turn_on(self):
        """Turn the media player on.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_TURN_ON, allow_override=True)

    def async_turn_off(self):
        """Turn the media player off.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_TURN_OFF, allow_override=True)

    def async_mute_volume(self, mute):
        """Mute the volume.

        This method must be run in the event loop and returns a coroutine.
        """
        data = {ATTR_MEDIA_VOLUME_MUTED: mute}
        return self._async_call_service(
            SERVICE_VOLUME_MUTE, data, allow_override=True)

    def async_set_volume_level(self, volume):
        """Set volume level, range 0..1.

        This method must be run in the event loop and returns a coroutine.
        """
        data = {ATTR_MEDIA_VOLUME_LEVEL: volume}
        return self._async_call_service(
            SERVICE_VOLUME_SET, data, allow_override=True)

    def async_media_play(self):
        """Send play command.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_MEDIA_PLAY)

    def async_media_pause(self):
        """Send pause command.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_MEDIA_PAUSE)

    def async_media_stop(self):
        """Send stop command.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_MEDIA_STOP)

    def async_media_previous_track(self):
        """Send previous track command.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_MEDIA_PREVIOUS_TRACK)

    def async_media_next_track(self):
        """Send next track command.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_MEDIA_NEXT_TRACK)

    def async_media_seek(self, position):
        """Send seek command.

        This method must be run in the event loop and returns a coroutine.
        """
        data = {ATTR_MEDIA_SEEK_POSITION: position}
        return self._async_call_service(SERVICE_MEDIA_SEEK, data)

    def async_play_media(self, media_type, media_id, **kwargs):
        """Play a piece of media.

        This method must be run in the event loop and returns a coroutine.
        """
        data = {ATTR_MEDIA_CONTENT_TYPE: media_type,
                ATTR_MEDIA_CONTENT_ID: media_id}
        return self._async_call_service(SERVICE_PLAY_MEDIA, data)

    def async_volume_up(self):
        """Turn volume up for media player.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_VOLUME_UP, allow_override=True)

    def async_volume_down(self):
        """Turn volume down for media player.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(
            SERVICE_VOLUME_DOWN, allow_override=True)

    def async_media_play_pause(self):
        """Play or pause the media player.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_MEDIA_PLAY_PAUSE)

    def async_select_source(self, source):
        """Set the input source.

        This method must be run in the event loop and returns a coroutine.
        """
        data = {ATTR_INPUT_SOURCE: source}
        return self._async_call_service(
            SERVICE_SELECT_SOURCE, data, allow_override=True)

    def async_clear_playlist(self):
        """Clear players playlist.

        This method must be run in the event loop and returns a coroutine.
        """
        return self._async_call_service(SERVICE_CLEAR_PLAYLIST)

    def async_set_shuffle(self, shuffle):
        """Enable/disable shuffling.

        This method must be run in the event loop and returns a coroutine.
        """
        data = {ATTR_MEDIA_SHUFFLE: shuffle}
        return self._async_call_service(
            SERVICE_SHUFFLE_SET, data, allow_override=True)

    async def async_update(self):
        """Update state in HA."""
        for child_name in self._children:
            child_state = self.hass.states.get(child_name)
            if child_state and child_state.state not in OFF_STATES:
                self._child_state = child_state
                return
        self._child_state = None

#!/usr/bin/env python
# encoding: utf-8
# Antoine Dechaume 2011

"""
Detect the PGI C compiler
"""

import sys, re
from waflib.Configure import conf
from waflib.Tools.compiler_c import c_compiler
c_compiler['linux'].append('pgicc')

@conf
def find_pgi_compiler(conf, var, name):
	"""
	Find the program name, and execute it to ensure it really is itself.
	"""
	if sys.platform == 'cygwin':
		conf.fatal('The PGI compiler does not work on Cygwin')

	v = conf.env
	cc = None
	if v[var]: cc = v[var]
	elif var in conf.environ: cc = conf.environ[var]
	if not cc: cc = conf.find_program(name, var=var)
	if not cc: conf.fatal('PGI Compiler (%s) was not found' % name)

	v[var + '_VERSION'] = conf.get_pgi_version(cc)
	v[var] = cc
	v[var + '_NAME'] = 'pgi'

@conf
def get_pgi_version(conf, cc):
	"""Find the version of a pgi compiler."""
	version_re = re.compile(r"The Portland Group", re.I).search
	cmd = cc + ['-V', '-E'] # Issue 1078, prevent wrappers from linking

	try:
		out, err = conf.cmd_and_log(cmd, output=0)
	except Exception:
		conf.fatal('Could not find pgi compiler %r' % cmd)

	if out: match = version_re(out)
	else: match = version_re(err)

	if not match:
		conf.fatal('Could not verify PGI signature')

	cmd = cc + ['-help=variable']
	try:
		out, err = conf.cmd_and_log(cmd, output=0)
	except Exception:
		conf.fatal('Could not find pgi compiler %r' % cmd)

	version = re.findall('^COMPVER\s*=(.*)', out, re.M)
	if len(version) != 1:
		conf.fatal('Could not determine the compiler version')
	return version[0]

def configure(conf):
	conf.find_pgi_compiler('CC', 'pgcc')
	conf.find_ar()
	conf.gcc_common_flags()
	conf.cc_load_tools()
	conf.cc_add_flags()
	conf.link_add_flags()


from helper import unittest, PillowTestCase

from PIL import Image


class TestImagePutAlpha(PillowTestCase):

    def test_interface(self):

        im = Image.new("RGBA", (1, 1), (1, 2, 3, 0))
        self.assertEqual(im.getpixel((0, 0)), (1, 2, 3, 0))

        im = Image.new("RGBA", (1, 1), (1, 2, 3))
        self.assertEqual(im.getpixel((0, 0)), (1, 2, 3, 255))

        im.putalpha(Image.new("L", im.size, 4))
        self.assertEqual(im.getpixel((0, 0)), (1, 2, 3, 4))

        im.putalpha(5)
        self.assertEqual(im.getpixel((0, 0)), (1, 2, 3, 5))

    def test_promote(self):

        im = Image.new("L", (1, 1), 1)
        self.assertEqual(im.getpixel((0, 0)), 1)

        im.putalpha(2)
        self.assertEqual(im.mode, 'LA')
        self.assertEqual(im.getpixel((0, 0)), (1, 2))

        im = Image.new("RGB", (1, 1), (1, 2, 3))
        self.assertEqual(im.getpixel((0, 0)), (1, 2, 3))

        im.putalpha(4)
        self.assertEqual(im.mode, 'RGBA')
        self.assertEqual(im.getpixel((0, 0)), (1, 2, 3, 4))

    def test_readonly(self):

        im = Image.new("RGB", (1, 1), (1, 2, 3))
        im.readonly = 1

        im.putalpha(4)
        self.assertFalse(im.readonly)
        self.assertEqual(im.mode, 'RGBA')
        self.assertEqual(im.getpixel((0, 0)), (1, 2, 3, 4))


if __name__ == '__main__':
    unittest.main()

# End of file

# -*- coding: utf-8 -*-
"""Test Module for sphinx_rtd_theme."""


class Foo:

    r"""Docstring for class Foo.

    This text tests for the formatting of docstrings generated from output
    ``sphinx.ext.autodoc``. Which contain reST, but sphinx nests it in the
    ``<dl>``, and ``<dt>`` tags. Also, ``<tt>`` is used for class, method names
    and etc, but those will *always* have the ``.descname`` or
    ``.descclassname`` class.

    Normal ``<tt>`` (like the <tt> I just wrote here) needs to be shown with
    the same style as anything else with ````this type of markup````.

    It's common for programmers to give a code example inside of their
    docstring::

        from test_py_module import Foo

        myclass = Foo()
        myclass.dothismethod('with this argument')
        myclass.flush()

        print(myclass)

    """

    #: Doc comment for class attribute Foo.bar.
    #: It can have multiple lines.
    bar = 1

    flox = 1.5   #: Doc comment for Foo.flox. One line only.

    baz = 2
    """Docstring for class attribute Foo.baz."""

    def __init__(self, qux, spam=False):
        """Start the Foo.

        :param qux: The first argument to initialize class.
        :type qux: string
        :param spam: Spam me yes or no...
        :type spam: bool

        """
        #: Doc comment for instance attribute qux.
        self.qux = 3

        self.spam = 4
        """Docstring for instance attribute spam."""

    def add(self, val1, val2):
        """Return the added values.

        :param val1: First number to add.
        :type val1: int
        :param val2: Second number to add.
        :type val2: int
        :rtype: int

        """

        return val1 + val2

    def capitalize(self, myvalue):
        """Return a string as uppercase.

        :param myvalue: String to change
        :type myvalue: string
        :rtype: string

        """

        return myvalue.upper()

    def another_function(self, a, b, **kwargs):
        """
        Here is another function.

        :param a: The number of green hats you own.
        :type a: int

        :param b: The number of non-green hats you own.
        :type b: int

        :param kwargs: Additional keyword arguments. Each keyword parameter
                       should specify the name of your favorite cuisine.
                       The values should be floats, specifying the mean price
                       of your favorite dish in that cooking style.
        :type kwargs: float

        :returns: A 2-tuple.  The first element is the mean price of all dishes
                  across cuisines.  The second element is the total number of
                  hats you own: :math:`a + b`.
        :rtype: tuple

        :raises ValueError: When ``a`` is not an integer.

        """
        return sum(kwargs.values()) / len(kwargs), a + b

#!/usr/bin/python
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

DOCUMENTATION = '''
---
module: cloudwatchevent_rule
short_description: Manage CloudWatch Event rules and targets
description:
  - This module creates and manages CloudWatch event rules and targets.
version_added: "2.2"
extends_documentation_fragment:
  - aws
author: "Jim Dalton (@jsdalton) <jim.dalton@gmail.com>"
requirements:
  - python >= 2.6
  - boto3
notes:
  - A rule must contain at least an I(event_pattern) or I(schedule_expression). A
    rule can have both an I(event_pattern) and a I(schedule_expression), in which
    case the rule will trigger on matching events as well as on a schedule.
  - When specifying targets, I(input) and I(input_path) are mutually-exclusive
    and optional parameters.
options:
  name:
    description:
      - The name of the rule you are creating, updating or deleting. No spaces
        or special characters allowed (i.e. must match C([\.\-_A-Za-z0-9]+))
    required: true
  schedule_expression:
    description:
      - A cron or rate expression that defines the schedule the rule will
        trigger on. For example, C(cron(0 20 * * ? *)), C(rate(5 minutes))
    required: false
  event_pattern:
    description:
      - A string pattern (in valid JSON format) that is used to match against
        incoming events to determine if the rule should be triggered
    required: false
  state:
    description:
      - Whether the rule is present (and enabled), disabled, or absent
    choices: ["present", "disabled", "absent"]
    default: present
    required: false
  description:
    description:
      - A description of the rule
    required: false
  role_arn:
    description:
      - The Amazon Resource Name (ARN) of the IAM role associated with the rule
    required: false
  targets:
    description:
      - "A dictionary array of targets to add to or update for the rule, in the
        form C({ id: [string], arn: [string], input: [valid JSON string], input_path: [valid JSONPath string] }).
        I(id) [required] is the unique target assignment ID. I(arn) (required)
        is the Amazon Resource Name associated with the target. I(input)
        (optional) is a JSON object that will override the event data when
        passed to the target.  I(input_path) (optional) is a JSONPath string
        (e.g. C($.detail)) that specifies the part of the event data to be
        passed to the target. If neither I(input) nor I(input_path) is
        specified, then the entire event is passed to the target in JSON form."
    required: false
'''

EXAMPLES = '''
- cloudwatchevent_rule:
    name: MyCronTask
    schedule_expression: "cron(0 20 * * ? *)"
    description: Run my scheduled task
    targets:
      - id: MyTargetId
        arn: arn:aws:lambda:us-east-1:123456789012:function:MyFunction

- cloudwatchevent_rule:
    name: MyDisabledCronTask
    schedule_expression: "cron(5 minutes)"
    description: Run my disabled scheduled task
    state: disabled
    targets:
      - id: MyOtherTargetId
        arn: arn:aws:lambda:us-east-1:123456789012:function:MyFunction
        input: '{"foo": "bar"}'

- cloudwatchevent_rule:
    name: MyCronTask
    state: absent
'''

RETURN = '''
rule:
    description: CloudWatch Event rule data
    returned: success
    type: dict
    sample: "{ 'arn': 'arn:aws:events:us-east-1:123456789012:rule/MyCronTask', 'description': 'Run my scheduled task', 'name': 'MyCronTask', 'schedule_expression': 'cron(0 20 * * ? *)', 'state': 'ENABLED' }"
targets:
    description: CloudWatch Event target(s) assigned to the rule
    returned: success
    type: list
    sample: "[{ 'arn': 'arn:aws:lambda:us-east-1:123456789012:function:MyFunction', 'id': 'MyTargetId' }]"
'''


class CloudWatchEventRule(object):
    def __init__(self, module, name, client, schedule_expression=None,
                 event_pattern=None, description=None, role_arn=None):
        self.name = name
        self.client = client
        self.changed = False
        self.schedule_expression = schedule_expression
        self.event_pattern = event_pattern
        self.description = description
        self.role_arn = role_arn

    def describe(self):
        """Returns the existing details of the rule in AWS"""
        try:
            rule_info = self.client.describe_rule(Name=self.name)
        except botocore.exceptions.ClientError as e:
            error_code = e.response.get('Error', {}).get('Code')
            if error_code == 'ResourceNotFoundException':
                return {}
            raise
        return self._snakify(rule_info)

    def put(self, enabled=True):
        """Creates or updates the rule in AWS"""
        request = {
            'Name': self.name,
            'State': "ENABLED" if enabled else "DISABLED",
        }
        if self.schedule_expression:
            request['ScheduleExpression'] = self.schedule_expression
        if self.event_pattern:
            request['EventPattern'] = self.event_pattern
        if self.description:
            request['Description'] = self.description
        if self.role_arn:
            request['RoleArn'] = self.role_arn
        response = self.client.put_rule(**request)
        self.changed = True
        return response

    def delete(self):
        """Deletes the rule in AWS"""
        self.remove_all_targets()
        response = self.client.delete_rule(Name=self.name)
        self.changed = True
        return response

    def enable(self):
        """Enables the rule in AWS"""
        response = self.client.enable_rule(Name=self.name)
        self.changed = True
        return response

    def disable(self):
        """Disables the rule in AWS"""
        response = self.client.disable_rule(Name=self.name)
        self.changed = True
        return response

    def list_targets(self):
        """Lists the existing targets for the rule in AWS"""
        try:
            targets = self.client.list_targets_by_rule(Rule=self.name)
        except botocore.exceptions.ClientError as e:
            error_code = e.response.get('Error', {}).get('Code')
            if error_code == 'ResourceNotFoundException':
                return []
            raise
        return self._snakify(targets)['targets']

    def put_targets(self, targets):
        """Creates or updates the provided targets on the rule in AWS"""
        if not targets:
            return
        request = {
            'Rule': self.name,
            'Targets': self._targets_request(targets),
        }
        response = self.client.put_targets(**request)
        self.changed = True
        return response

    def remove_targets(self, target_ids):
        """Removes the provided targets from the rule in AWS"""
        if not target_ids:
            return
        request = {
            'Rule': self.name,
            'Ids': target_ids
        }
        response = self.client.remove_targets(**request)
        self.changed = True
        return response

    def remove_all_targets(self):
        """Removes all targets on rule"""
        targets = self.list_targets()
        return self.remove_targets([t['id'] for t in targets])

    def _targets_request(self, targets):
        """Formats each target for the request"""
        targets_request = []
        for target in targets:
            target_request = {
                'Id': target['id'],
                'Arn': target['arn']
            }
            if 'input' in target:
                target_request['Input'] = target['input']
            if 'input_path' in target:
                target_request['InputPath'] = target['input_path']
            targets_request.append(target_request)
        return targets_request

    def _snakify(self, dict):
        """Converts cammel case to snake case"""
        return camel_dict_to_snake_dict(dict)


class CloudWatchEventRuleManager(object):
    RULE_FIELDS = ['name', 'event_pattern', 'schedule_expression', 'description', 'role_arn']

    def __init__(self, rule, targets):
        self.rule = rule
        self.targets = targets

    def ensure_present(self, enabled=True):
        """Ensures the rule and targets are present and synced"""
        rule_description = self.rule.describe()
        if rule_description:
            # Rule exists so update rule, targets and state
            self._sync_rule(enabled)
            self._sync_targets()
            self._sync_state(enabled)
        else:
            # Rule does not exist, so create new rule and targets
            self._create(enabled)

    def ensure_disabled(self):
        """Ensures the rule and targets are present, but disabled, and synced"""
        self.ensure_present(enabled=False)

    def ensure_absent(self):
        """Ensures the rule and targets are absent"""
        rule_description = self.rule.describe()
        if not rule_description:
            # Rule doesn't exist so don't need to delete
            return
        self.rule.delete()

    def fetch_aws_state(self):
        """Retrieves rule and target state from AWS"""
        aws_state = {
            'rule': {},
            'targets': [],
            'changed': self.rule.changed
        }
        rule_description = self.rule.describe()
        if not rule_description:
            return aws_state

        # Don't need to include response metadata noise in response
        del rule_description['response_metadata']

        aws_state['rule'] = rule_description
        aws_state['targets'].extend(self.rule.list_targets())
        return aws_state

    def _sync_rule(self, enabled=True):
        """Syncs local rule state with AWS"""
        if not self._rule_matches_aws():
            self.rule.put(enabled)

    def _sync_targets(self):
        """Syncs local targets with AWS"""
        # Identify and remove extraneous targets on AWS
        target_ids_to_remove = self._remote_target_ids_to_remove()
        if target_ids_to_remove:
            self.rule.remove_targets(target_ids_to_remove)

        # Identify targets that need to be added or updated on AWS
        targets_to_put = self._targets_to_put()
        if targets_to_put:
            self.rule.put_targets(targets_to_put)

    def _sync_state(self, enabled=True):
        """Syncs local rule state with AWS"""
        remote_state = self._remote_state()
        if enabled and remote_state != 'ENABLED':
            self.rule.enable()
        elif not enabled and remote_state != 'DISABLED':
            self.rule.disable()

    def _create(self, enabled=True):
        """Creates rule and targets on AWS"""
        self.rule.put(enabled)
        self.rule.put_targets(self.targets)

    def _rule_matches_aws(self):
        """Checks if the local rule data matches AWS"""
        aws_rule_data = self.rule.describe()

        # The rule matches AWS only if all rule data fields are equal
        # to their corresponding local value defined in the task
        return all([
            getattr(self.rule, field) == aws_rule_data.get(field, None)
            for field in self.RULE_FIELDS
        ])

    def _targets_to_put(self):
        """Returns a list of targets that need to be updated or added remotely"""
        remote_targets = self.rule.list_targets()
        return [t for t in self.targets if t not in remote_targets]

    def _remote_target_ids_to_remove(self):
        """Returns a list of targets that need to be removed remotely"""
        target_ids = [t['id'] for t in self.targets]
        remote_targets = self.rule.list_targets()
        return [
            rt['id'] for rt in remote_targets if rt['id'] not in target_ids
        ]

    def _remote_state(self):
        """Returns the remote state from AWS"""
        description = self.rule.describe()
        if not description:
            return
        return description['state']


def get_cloudwatchevents_client(module):
    """Returns a boto3 client for accessing CloudWatch Events"""
    try:
        region, ec2_url, aws_conn_kwargs = get_aws_connection_info(module,
                                                                   boto3=True)
        if not region:
            module.fail_json(msg="Region must be specified as a parameter, in \
                             EC2_REGION or AWS_REGION environment variables \
                             or in boto configuration file")
        return boto3_conn(module, conn_type='client',
                          resource='events',
                          region=region, endpoint=ec2_url,
                          **aws_conn_kwargs)
    except boto3.exception.NoAuthHandlerFound as e:
        module.fail_json(msg=str(e))


def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
        name                 = dict(required=True),
        schedule_expression  = dict(),
        event_pattern        = dict(),
        state                = dict(choices=['present', 'disabled', 'absent'],
                                    default='present'),
        description          = dict(),
        role_arn             = dict(),
        targets              = dict(type='list', default=[]),
    ))
    module = AnsibleModule(argument_spec=argument_spec)

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 required for this module')

    rule_data = dict(
        [(rf, module.params.get(rf)) for rf in CloudWatchEventRuleManager.RULE_FIELDS]
    )
    targets = module.params.get('targets')
    state = module.params.get('state')

    cwe_rule = CloudWatchEventRule(module,
                                   client=get_cloudwatchevents_client(module),
                                   **rule_data)
    cwe_rule_manager = CloudWatchEventRuleManager(cwe_rule, targets)

    if state == 'present':
        cwe_rule_manager.ensure_present()
    elif state == 'disabled':
        cwe_rule_manager.ensure_disabled()
    elif state == 'absent':
        cwe_rule_manager.ensure_absent()
    else:
        module.fail_json(msg="Invalid state '{0}' provided".format(state))

    module.exit_json(**cwe_rule_manager.fetch_aws_state())


# import module snippets
from ansible.module_utils.basic import *
from ansible.module_utils.ec2 import *


if __name__ == '__main__':
    main()

"""
Command to manually re-post open ended submissions to the grader.
"""
from django.contrib.auth.models import User
from django.core.management.base import BaseCommand
from optparse import make_option

from xmodule.modulestore.django import modulestore
from opaque_keys.edx.locations import SlashSeparatedCourseKey
from xmodule.open_ended_grading_classes.openendedchild import OpenEndedChild
from xmodule.open_ended_grading_classes.open_ended_module import OpenEndedModule

from courseware.courses import get_course

from instructor.utils import get_module_for_student


class Command(BaseCommand):
    """
    Command to manually re-post open ended submissions to the grader.
    """

    help = ("Usage: openended_post <course_id> <problem_location> <student_ids.txt> <hostname> --dry-run --task-number=<task_number>\n"
            "The text file should contain a User.id in each line.")

    option_list = BaseCommand.option_list + (
        make_option('-n', '--dry-run',
                    action='store_true', dest='dry_run', default=False,
                    help="Do everything except send the submission to the grader. "),
        make_option('--task-number',
                    type='int', default=0,
                    help="Task number that needs to be submitted."),
    )

    def handle(self, *args, **options):

        dry_run = options['dry_run']
        task_number = options['task_number']

        if len(args) == 4:
            course_id = SlashSeparatedCourseKey.from_deprecated_string(args[0])
            location = course_id.make_usage_key_from_deprecated_string(args[1])
            students_ids = [line.strip() for line in open(args[2])]
            hostname = args[3]
        else:
            print self.help
            return

        try:
            course = get_course(course_id)
        except ValueError as err:
            print err
            return

        descriptor = modulestore().get_item(location, depth=0)
        if descriptor is None:
            print "Location not found in course"
            return

        if dry_run:
            print "Doing a dry run."

        students = User.objects.filter(id__in=students_ids).order_by('username')
        print "Number of students: {0}".format(students.count())

        for student in students:
            post_submission_for_student(student, course, location, task_number, dry_run=dry_run, hostname=hostname)


def post_submission_for_student(student, course, location, task_number, dry_run=True, hostname=None):
    """If the student's task child_state is ASSESSING post submission to grader."""

    print "{0}:{1}".format(student.id, student.username)

    request = DummyRequest()
    request.user = student
    request.host = hostname

    try:
        module = get_module_for_student(student, location, request=request)
        if module is None:
            print "  WARNING: No state found."
            return False

        latest_task = module.child_module.get_task_number(task_number)
        if latest_task is None:
            print "  WARNING: No task state found."
            return False

        if not isinstance(latest_task, OpenEndedModule):
            print " ERROR: Not an OpenEndedModule task."
            return False

        latest_task_state = latest_task.child_state

        if latest_task_state == OpenEndedChild.INITIAL:
            print "  WARNING: No submission."
        elif latest_task_state == OpenEndedChild.POST_ASSESSMENT or latest_task_state == OpenEndedChild.DONE:
            print "  WARNING: Submission already graded."
        elif latest_task_state == OpenEndedChild.ASSESSING:
            latest_answer = latest_task.latest_answer()
            if dry_run:
                print "  Skipped sending submission to grader: {0!r}".format(latest_answer[:100].encode('utf-8'))
            else:
                latest_task.send_to_grader(latest_answer, latest_task.system)
                print "  Sent submission to grader: {0!r}".format(latest_answer[:100].encode('utf-8'))
                return True
        else:
            print "WARNING: Invalid task_state: {0}".format(latest_task_state)
    except Exception as err:  # pylint: disable=broad-except
        print err

    return False


class DummyRequest(object):
    """Dummy request"""

    META = {}

    def __init__(self):
        self.session = {}
        self.user = None
        self.host = None
        self.secure = True

    def get_host(self):
        """Return a default host."""
        return self.host

    def is_secure(self):
        """Always secure."""
        return self.secure

import unittest

from hcsvlab_robochef.utils.serialiser import *
from hcsvlab_robochef.utils.statistics import *


def unittests():
    return unittest.makeSuite(UnitTest)


class UnitTest(unittest.TestCase):
    configmanager.configinit()
    corpus_basedir = configmanager.get_config("CORPUS_BASEDIR", "../input/")
    fileHandler = FileHandler()


    def testEntityConversion(self):
        self.assertEqual(replaceEntitiesInStr("what <is> going </is> on"), u"what <is> going </is> on")
        self.assertEqual(replaceEntitiesInStr("what <is> go&para;ing </is> on"), u"what <is> go\u00b6ing </is> on")
        self.assertEqual(putLTBack(replaceEntitiesInStr("what does <= mean?")), "what does <= mean?")


    def testFileHandlerOnDirectoryWithDataAndValidExtension(self):
        resultSet = self.fileHandler.getFiles(self.corpus_basedir + 'ace', inclusionPredicate=r'^ace_.\.txt')
        self.assertEqual(len(resultSet), 17)


    def testFileHandlerOnDirectoryWithDataAndInvalidExtension(self):
        resultSet = self.fileHandler.getFiles(self.corpus_basedir + 'ace', inclusionPredicate=r'\w+.rdf')
        self.assertEqual(len(resultSet), 0)


    def testFileHandlerOnInvalidDirectory(self):
        resultSet = self.fileHandler.getFiles('../input/nonexistentfolder', inclusionPredicate=r'\w+.rdf')
        self.assertEqual(len(resultSet), 0)


    def testSuccessfulFilePatternMatch(self):
        result = self.fileHandler.isMatch("testFile.rdf", r"\w+.rdf", r"\w+-raw.txt")
        self.assertTrue(result)


    def testUnsuccessfulFilePatternMatch(self):
        result = self.fileHandler.isMatch("testFile-raw.rdf", r"\w+.rdf", r"\w+-raw.rdf")
        self.assertFalse(result)


    def testSizeOfMissingFile(self):
        self.assertEqual(self.fileHandler.getFileSize('missingFile.rdf'), 0)


    def testSizeOfDirectory(self):
        self.assertEqual(self.fileHandler.getFileSize(self.corpus_basedir), 0)


    def testSizeOfKnownFile(self):
        self.assertEqual(self.fileHandler.getFileSize(self.corpus_basedir + 'ace/ace_a.txt'), 579959)


    def testSizeOfAudioFile(self):
        self.assertEqual(self.fileHandler.getFileSize(self.corpus_basedir + 'md/S1219s1.wav'), 135752)


    def testSizeOfSourceString(self):
        stats = Statistics()
        lines = open(self.corpus_basedir + 'ace/ace_a.txt', 'r').read()
        meta_dict = {}
        stats.append_item_stats(lines, meta_dict)
        self.assertEqual(self.fileHandler.getFileSize(self.corpus_basedir + 'ace/ace_a.txt'), meta_dict['filesize'])


    def testWordCountOnMissingFile(self):
        stats = Statistics()
        self.assertEqual(stats.get_word_count('missingFile.txt'), 0)


    def testWordCountOnAudioFile(self):
        stats = Statistics()
        self.assertEqual(stats.get_word_count(self.corpus_basedir + 'md/S1219s1.wav'), 0)


    def testWordCountOnTxtFile(self):
        stats = Statistics()
        self.assertEqual(stats.get_word_count(self.corpus_basedir + 'ace/ace_a.txt'), 92466)


    def testWordCountOnEmptyString(self):
        stats = Statistics()
        self.assertEqual(stats.get_sample_wordcount(''), 0)


    def testWordCountOnSingleLetter(self):
        stats = Statistics()
        self.assertEqual(stats.get_sample_wordcount('A'), 1)


    def testWordCountOnWordSeparatedByHyphens(self):
        stats = Statistics()
        self.assertEqual(stats.get_sample_wordcount('One-World-Alliance'), 1)


    def testWordCountOnWordWithNestedTags(self):
        stats = Statistics()
        self.assertEqual(stats.get_sample_wordcount('One-<World>World</World>-Alliance'), 3)


    def testWordCountOnWordWithNestedTagsAndNoHyphens(self):
        stats = Statistics()
        self.assertEqual(stats.get_sample_wordcount('One <World>World</World> Alliance'), 3)


    def testWordCountOnWordWithNestedMalformedTagsAndNoHyphens(self):
        stats = Statistics()
        self.assertEqual(stats.get_sample_wordcount('One <World>World Alliance'), 3)


    def testWordCountOnWordWithMultipleTagsAndNoSpaces(self):
        stats = Statistics()
        self.assertEqual(stats.get_sample_wordcount('One<World>World</World><Alliance>Alliance</Alliance>'), 3)


    def testToFindExistingCompatriotFile(self):
        compatriot = self.fileHandler.findCompatriot(self.corpus_basedir + 'griffith', 'GCSAusE06.doc', '^[\w\d-]+.mp3',
                                                     '^[\w\d-]+.doc')
        self.assertEqual(self.corpus_basedir + 'griffith/aa323c84-7483-10a3-d8b6-603a7f5d852a_1/GCSAusE06.mp3',
                         compatriot)


    def testToFindNonExistingCompatriotFile(self):
        compatriot = self.fileHandler.findCompatriot(self.corpus_basedir + 'griffith', 'GCSAusE99.doc', '^[\w\d-]+.mp3',
                                                     '^[\w\d-]+.doc')
        self.assertEqual(None, compatriot)


    def testGenerateOfMetaDict(self):
        serialiser = Serialiser('/tmp')
        res = serialiser._Serialiser__gen_text_document_metadata('GCSAusE01', 'Text', 'http://www.google.com/')

        self.assertEqual(res, {'documenttitle': 'GCSAusE01#Text', 'filetype': 'Text', 'filename': 'GCSAusE01-plain.txt',
                               'id': 'GCSAusE01#Text', 'filesize': 22})


    def testAddToDictionariesWithNonExistingKey(self):
        dict1 = {'1': 1, '2': 2}
        dict2 = {'3': 3}

        res = add_to_dictionary('3', dict1, dict2)
        self.assertEqual(res, {'1': 1, '2': 2, '3': {'3': 3}})


    def testAddDictionariesWithExistingKey(self):
        dict1 = {'1': 1, '2': 2}
        dict2 = {'2': {'3': 3}}

        res = add_to_dictionary('2', dict1, dict2)
        self.assertEqual(res, {'1': 1, '2': {'3': 3}})


    def testAddDictionariesWithExistingKey1(self):
        dict1 = {'1': 1, '2': {'a': 'a', 'b': 'b'}}
        dict2 = {'c': 'c'}

        dict1 = add_to_dictionary('2', dict1, dict2)
        self.assertEqual(dict1, {'1': 1, '2': {'a': 'a', 'b': 'b', 'c': 'c'}})
#  Explain and drop some links here
from collections import namedtuple, defaultdict
import csv
import os

from samr.transformations import StatelessTransform
from samr.settings import DATA_PATH


FIELDS = ("Entry, Source, Positiv, Negativ, Pstv, Affil, Ngtv, Hostile, Strong,"
          " Power, Weak, Submit, Active, Passive, Pleasur, Pain, Feel, Arousal,"
          " EMOT, Virtue, Vice, Ovrst, Undrst, Academ, Doctrin, Econ, Exch, "
          "ECON, Exprsv, Legal, Milit, Polit, POLIT, Relig, Role, COLL, Work, "
          "Ritual, SocRel, Race, Kin, MALE, Female, Nonadlt, HU, ANI, PLACE, "
          "Social, Region, Route, Aquatic, Land, Sky, Object, Tool, Food, "
          "Vehicle, BldgPt, ComnObj, NatObj, BodyPt, ComForm, COM, Say, Need, "
          "Goal, Try, Means, Persist, Complet, Fail, NatrPro, Begin, Vary, "
          "Increas, Decreas, Finish, Stay, Rise, Exert, Fetch, Travel, Fall, "
          "Think, Know, Causal, Ought, Perceiv, Compare, Eval, EVAL, Solve, "
          "Abs, ABS, Quality, Quan, NUMB, ORD, CARD, FREQ, DIST, Time, TIME, "
          "Space, POS, DIM, Rel, COLOR, Self, Our, You, Name, Yes, No, Negate, "
          "Intrj, IAV, DAV, SV, IPadj, IndAdj, PowGain, PowLoss, PowEnds, "
          "PowAren, PowCon, PowCoop, PowAuPt, PowPt, PowDoct, PowAuth, PowOth, "
          "PowTot, RcEthic, RcRelig, RcGain, RcLoss, RcEnds, RcTot, RspGain, "
          "RspLoss, RspOth, RspTot, AffGain, AffLoss, AffPt, AffOth, AffTot, "
          "WltPt, WltTran, WltOth, WltTot, WlbGain, WlbLoss, WlbPhys, WlbPsyc, "
          "WlbPt, WlbTot, EnlGain, EnlLoss, EnlEnds, EnlPt, EnlOth, EnlTot, "
          "SklAsth, SklPt, SklOth, SklTot, TrnGain, TrnLoss, TranLw, MeansLw, "
          "EndsLw, ArenaLw, PtLw, Nation, Anomie, NegAff, PosAff, SureLw, If, "
          "NotLw, TimeSpc, FormLw, Othtags, Defined")

InquirerLexEntry = namedtuple("InquirerLexEntry", FIELDS)
FIELDS = InquirerLexEntry._fields


class InquirerLexTransform(StatelessTransform):
    _corpus = []
    _use_fields = [FIELDS.index(x) for x in "Positiv Negativ IAV Strong".split()]

    def transform(self, X, y=None):
        """
        `X` is expected to be a list of `str` instances containing the phrases.
        Return value is a list of `str` containing different amounts of the
        words "Positiv_Positiv", "Negativ_Negativ", "IAV_IAV", "Strong_Strong"
        based on the sentiments given to the input words by the Hardvard
        Inquirer lexicon.
        """
        corpus = self._get_corpus()
        result = []
        for phrase in X:
            newphrase = []
            for word in phrase.split():
                newphrase.extend(corpus.get(word.lower(), []))
            result.append(" ".join(newphrase))
        return result

    def _get_corpus(self):
        """
        Private method used to cache a dictionary with the Harvard Inquirer
        corpus.
        """
        if not self._corpus:
            corpus = defaultdict(list)
            it = csv.reader(open(os.path.join(DATA_PATH, "inquirerbasicttabsclean")),
                            delimiter="\t")
            next(it)  # Drop header row
            for row in it:
                entry = InquirerLexEntry(*row)
                xs = []
                for i in self._use_fields:
                    name, x = FIELDS[i], entry[i]
                    if x:
                        xs.append("{}_{}".format(name, x))
                name = entry.Entry.lower()
                if "#" in name:
                    name = name[:name.index("#")]
                corpus[name].extend(xs)
            self._corpus.append(dict(corpus))
        return self._corpus[0]

from __future__ import absolute_import
# Copyright (c) 2010-2015 openpyxl

"""Manage individual cells in a spreadsheet.

The Cell class is required to know its value and type, display options,
and any other features of an Excel cell.  Utilities for referencing
cells using Excel's 'A1' column/row nomenclature are also provided.

"""

__docformat__ = "restructuredtext en"

# Python stdlib imports
import datetime
import re

from openpyxl.compat import (
    unicode,
    basestring,
    bytes,
    NUMERIC_TYPES,
    range,
    deprecated,
)
from openpyxl.utils.units import (
    DEFAULT_ROW_HEIGHT,
    DEFAULT_COLUMN_WIDTH
)
from openpyxl.utils.datetime  import (
    to_excel,
    time_to_days,
    timedelta_to_days,
    from_excel
    )
from openpyxl.utils.exceptions import (
    IllegalCharacterError
)
from openpyxl.utils.units import points_to_pixels
from openpyxl.utils import (
    get_column_letter,
    column_index_from_string,
)
from openpyxl.styles import numbers, is_date_format
from openpyxl.styles.styleable import StyleableObject
from openpyxl.worksheet.hyperlink import Hyperlink

# constants


TIME_TYPES = (datetime.datetime, datetime.date, datetime.time, datetime.timedelta)
STRING_TYPES = (basestring, unicode, bytes)
KNOWN_TYPES = NUMERIC_TYPES + TIME_TYPES + STRING_TYPES + (bool, type(None))

PERCENT_REGEX = re.compile(r'^\-?(?P<number>[0-9]*\.?[0-9]*\s?)\%$')
TIME_REGEX = re.compile(r"""
^(?: # HH:MM and HH:MM:SS
(?P<hour>[0-1]{0,1}[0-9]{2}):
(?P<minute>[0-5][0-9]):?
(?P<second>[0-5][0-9])?$)
|
^(?: # MM:SS.
([0-5][0-9]):
([0-5][0-9])?\.
(?P<microsecond>\d{1,6}))
""", re.VERBOSE)
NUMBER_REGEX = re.compile(r'^-?([\d]|[\d]+\.[\d]*|\.[\d]+|[1-9][\d]+\.?[\d]*)((E|e)[-+]?[\d]+)?$')
ILLEGAL_CHARACTERS_RE = re.compile(r'[\000-\010]|[\013-\014]|[\016-\037]')

ERROR_CODES = ('#NULL!', '#DIV/0!', '#VALUE!', '#REF!', '#NAME?', '#NUM!',
               '#N/A')


class Cell(StyleableObject):
    """Describes cell associated properties.

    Properties of interest include style, type, value, and address.

    """
    __slots__ = (
        'row',
        'col_idx',
        '_value',
        'data_type',
        'parent',
        '_hyperlink',
        '_comment',
                 )

    ERROR_CODES = ERROR_CODES

    TYPE_STRING = 's'
    TYPE_FORMULA = 'f'
    TYPE_NUMERIC = 'n'
    TYPE_BOOL = 'b'
    TYPE_NULL = 'n'
    TYPE_INLINE = 'inlineStr'
    TYPE_ERROR = 'e'
    TYPE_FORMULA_CACHE_STRING = 'str'

    VALID_TYPES = (TYPE_STRING, TYPE_FORMULA, TYPE_NUMERIC, TYPE_BOOL,
                   TYPE_NULL, TYPE_INLINE, TYPE_ERROR, TYPE_FORMULA_CACHE_STRING)


    def __init__(self, worksheet, column=None, row=None, value=None, col_idx=None, style_array=None):
        super(Cell, self).__init__(worksheet, style_array)
        self.row = row
        # _value is the stored value, while value is the displayed value
        self._value = None
        self._hyperlink = None
        self.data_type = 'n'
        if value is not None:
            self.value = value
        self._comment = None
        if column is not None:
            col_idx = column_index_from_string(column)
        self.col_idx = col_idx


    @property
    def coordinate(self):
        return '%s%d' % (self.column, self.row)

    @property
    def column(self):
        return get_column_letter(self.col_idx)

    @property
    def encoding(self):
        return self.parent.encoding

    @property
    def base_date(self):
        return self.parent.parent.excel_base_date

    @property
    def guess_types(self):
        return getattr(self.parent.parent, '_guess_types', False)

    def __repr__(self):
        return unicode("<Cell %s.%s>") % (self.parent.title, self.coordinate)

    def check_string(self, value):
        """Check string coding, length, and line break character"""
        if value is None:
            return
        # convert to unicode string
        if not isinstance(value, unicode):
            value = unicode(value, self.encoding)
        value = unicode(value)
        # string must never be longer than 32,767 characters
        # truncate if necessary
        value = value[:32767]
        if next(ILLEGAL_CHARACTERS_RE.finditer(value), None):
            raise IllegalCharacterError
        return value

    def check_error(self, value):
        """Tries to convert Error" else N/A"""
        try:
            return unicode(value)
        except:
            return unicode('#N/A')

    def set_explicit_value(self, value=None, data_type=TYPE_STRING):
        """Coerce values according to their explicit type"""
        if data_type not in self.VALID_TYPES:
            raise ValueError('Invalid data type: %s' % data_type)
        if isinstance(value, STRING_TYPES):
            value = self.check_string(value)
        self._value = value
        self.data_type = data_type


    @deprecated("Method is private")
    def bind_value(self, value):
        self._bind_value(value)


    def _bind_value(self, value):
        """Given a value, infer the correct data type"""

        self.data_type = "n"

        if value is True or value is False:
            self.data_type = self.TYPE_BOOL

        elif isinstance(value, NUMERIC_TYPES):
            pass

        elif isinstance(value, NUMERIC_TYPES):
            self.data_type = self.TYPE_NUMERIC

        elif isinstance(value, TIME_TYPES):
            self.data_type = self.TYPE_NUMERIC
            value = self._cast_datetime(value)

        elif isinstance(value, STRING_TYPES):
            value = self.check_string(value)
            self.data_type = self.TYPE_STRING
            if len(value) > 1 and value.startswith("="):
                self.data_type = self.TYPE_FORMULA
            elif value in self.ERROR_CODES:
                self.data_type = self.TYPE_ERROR
            elif self.guess_types:
                value = self._infer_value(value)

        elif value is not None:
            raise ValueError("Cannot convert {0} to Excel".format(value))

        self._value = value


    @deprecated("Method is private")
    def infer_value(self, value):
        return self._infer_value(value)


    def _infer_value(self, value):
        """Given a string, infer type and formatting options."""
        if not isinstance(value, unicode):
            value = str(value)

        # number detection
        v = self._cast_numeric(value)
        if v is None:
            # percentage detection
            v = self._cast_percentage(value)
        if v is None:
            # time detection
            v = self._cast_time(value)
        if v is not None:
            self.data_type = self.TYPE_NUMERIC
            return v

        return value


    def _cast_numeric(self, value):
        """Explicity convert a string to a numeric value"""
        if NUMBER_REGEX.match(value):
            try:
                return int(value)
            except ValueError:
                return float(value)

    def _cast_percentage(self, value):
        """Explicitly convert a string to numeric value and format as a
        percentage"""
        match = PERCENT_REGEX.match(value)
        if match:
            self.number_format = numbers.FORMAT_PERCENTAGE
            return float(match.group('number')) / 100


    def _cast_time(self, value):
        """Explicitly convert a string to a number and format as datetime or
        time"""
        match = TIME_REGEX.match(value)
        if match:
            if match.group("microsecond") is not None:
                value = value[:12]
                pattern = "%M:%S.%f"
                fmt = numbers.FORMAT_DATE_TIME5
            elif match.group('second') is None:
                fmt = numbers.FORMAT_DATE_TIME3
                pattern = "%H:%M"
            else:
                pattern = "%H:%M:%S"
                fmt = numbers.FORMAT_DATE_TIME6
            value = datetime.datetime.strptime(value, pattern)
            self.number_format = fmt
            return time_to_days(value)


    def _cast_datetime(self, value):
        """Convert Python datetime to Excel and set formatting"""
        if isinstance(value, datetime.datetime):
            value = to_excel(value, self.base_date)
            self.number_format = numbers.FORMAT_DATE_DATETIME
        elif isinstance(value, datetime.date):
            value = to_excel(value, self.base_date)
            self.number_format = numbers.FORMAT_DATE_YYYYMMDD2
        elif isinstance(value, datetime.time):
            value = time_to_days(value)
            self.number_format = numbers.FORMAT_DATE_TIME6
        elif isinstance(value, datetime.timedelta):
            value = timedelta_to_days(value)
            self.number_format = numbers.FORMAT_DATE_TIMEDELTA
        return value

    @property
    def value(self):
        """Get or set the value held in the cell.
            ':rtype: depends on the value (string, float, int or '
            ':class:`datetime.datetime`)'"""
        value = self._value
        if value is not None and self.is_date:
            value = from_excel(value, self.base_date)
        return value

    @value.setter
    def value(self, value):
        """Set the value and infer type and display options."""
        self._bind_value(value)

    @property
    def internal_value(self):
        """Always returns the value for excel."""
        return self._value

    @property
    def hyperlink(self):
        """Return the hyperlink target or an empty string"""
        return self._hyperlink

    @hyperlink.setter
    def hyperlink(self, val):
        """Set value and display for hyperlinks in a cell.
        Automatically sets the `value` of the cell with link text,
        but you can modify it afterwards by setting the `value`
        property, and the hyperlink will remain."""
        self._hyperlink = Hyperlink(ref=self.coordinate, target=val)
        self.parent.hyperlinks.add(self)
        if self._value is None:
            self.value = val

    @property
    def is_date(self):
        """Whether the value is formatted as a date

        :rtype: bool
        """
        if self.data_type == "n" and self.number_format != "General":
            return is_date_format(self.number_format)
        return False

    def offset(self, row=0, column=0):
        """Returns a cell location relative to this cell.

        :param row: number of rows to offset
        :type row: int

        :param column: number of columns to offset
        :type column: int

        :rtype: :class:`openpyxl.cell.Cell`
        """
        offset_column = self.col_idx + column
        offset_row = self.row + row
        return self.parent.cell(column=offset_column, row=offset_row)

    @property
    def anchor(self):
        """ returns the expected position of a cell in pixels from the top-left
            of the sheet. For example, A1 anchor should be (0,0).

            :rtype: tuple(int, int)
        """
        left_columns = (column_index_from_string(self.column) - 1)
        column_dimensions = self.parent.column_dimensions
        left_anchor = 0
        default_width = points_to_pixels(DEFAULT_COLUMN_WIDTH)

        for col_idx in range(left_columns):
            letter = get_column_letter(col_idx + 1)
            if letter in column_dimensions:
                cdw = column_dimensions.get(letter).width or default_width
                if cdw > 0:
                    left_anchor += points_to_pixels(cdw)
                    continue
            left_anchor += default_width

        row_dimensions = self.parent.row_dimensions
        top_anchor = 0
        top_rows = (self.row - 1)
        default_height = points_to_pixels(DEFAULT_ROW_HEIGHT)
        for row_idx in range(1, top_rows + 1):
            if row_idx in row_dimensions:
                rdh = row_dimensions[row_idx].height or default_height
                if rdh > 0:
                    top_anchor += points_to_pixels(rdh)
                    continue
            top_anchor += default_height

        return (left_anchor, top_anchor)

    @property
    def comment(self):
        """ Returns the comment associated with this cell

            :rtype: :class:`openpyxl.comments.Comment`
        """
        return self._comment

    @comment.setter
    def comment(self, value):

        # Ensure the number of comments for the parent worksheet is up-to-date
        if value is None and self._comment is not None:
            self.parent._comment_count -= 1
        if value is not None and self._comment is None:
            self.parent._comment_count += 1

        if value is not None:
            value.parent = self
        elif value is None and self._comment:
            self._comment.parent = None
        self._comment = value

'''
app: filehandarticles_mgr
'''
from django.conf.urls import patterns, url

urlpatterns = patterns('filehand.views',
    url(r'^$', 'index', name='index'),
    
    url(r'^newArticle/$', 'newArticle', name='newArticle'),
    
    url(r'^articlesMgr_1/(.*)/(.*)$', 'articlesMgr_1', name='articlesMgr_1'),
    url(r'^articlesMgr_2/(.*)/(.*)$', 'articlesMgr_2', name='articlesMgr_2'),
    
    url(r'^classify_new/(.+)$', 'classify_new', name='classify_new'),
    url(r'^classify_obsolete/(.+)$', 'classify_obsolete', name='classify_obsolete'),
    
    url(r'^articlesUserCanEdit_1/$', 'articlesUserCanEdit_1', name='articlesUserCanEdit_1'),
    url(r'^articlesUserCanEdit_2/$', 'articlesUserCanEdit_2', name='articlesUserCanEdit_2'),
    
    url(r'^articlesWithPermissionList/$', 'articlesWithPermissionList', name='articlesWithPermissionList'),
    
    #url(r'^article_display/(.+)/([\w]+)$', 'article_display', name='article_display'),
    url(r'^article_display/(.+.html)/([\w]+)$', 'article_display', name='article_display'),
    #url(r'^articleEdit/(.+)$', 'articleEdit', name='articleEdit'),
    #url(r'^articleEdit/([\w. ]*)$', 'articleEdit', name='articleEdit'),
    url(r'^articleEdit/(.+.html)/([\w]+)$', 'articleEdit', name='articleEdit'),
    #url(r'^articleEdit/(.*)$', 'articleEdit', name='articleEdit'),
    
    url(r'^addClas', 'addClas', name='addClas'),
    url(r'^articlePermissions/(.*)/(.*)$', 'articlePermissions', name='articlePermissions'),
    url(r'^uploadArticleImages/(.*)$', 'uploadArticleImages', name='uploadArticleImages'),
    url(r'^modalinfo/(.*)$', 'modalinfo', name='modalinfo'),

    url(r'^add_clas_get_options/([\w\ ]+)$', 'add_clas_get_options', name='add_clas_get_options'),
    url(r'^add_subClas_get_options/([\w\ ]+)$', 'add_subClas_get_options', name='add_subClas_get_options'),
    url(r'^add_docType_get_options/([\w\ ]+)$', 'add_docType_get_options', name='add_docType_get_options'),
    
    url(r'^gallery$', 'gallery', name='gallery'),
    
    url(r'^gallery_lg/(.*)$', 'gallery_lg', name='gallery_lg'),
    
    url(r'^articles_collect', 'articles_collect', name='articles_collect'),
    
    url(r'^user_page', 'user_page', name='user'),
)

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models, migrations
from django.conf import settings


class Migration(migrations.Migration):

    dependencies = [
        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
    ]

    operations = [
        migrations.CreateModel(
            name='Comment',
            fields=[
                ('comment_id', models.AutoField(serialize=False, primary_key=True)),
                ('name', models.CharField(max_length=100)),
                ('email', models.EmailField(max_length=75)),
                ('comment_text', models.TextField()),
            ],
            options={
                'db_table': 'comments',
            },
            bases=(models.Model,),
        ),
        migrations.CreateModel(
            name='Post',
            fields=[
                ('post_id', models.AutoField(serialize=False, primary_key=True)),
                ('title', models.CharField(max_length=100)),
                ('body', models.TextField()),
                ('publication_date', models.DateField()),
                ('author_id', models.ForeignKey(to=settings.AUTH_USER_MODEL)),
                ('comment_id', models.ManyToManyField(to='Blog.Comment', db_table=b'post_comments')),
            ],
            options={
                'db_table': 'posts',
            },
            bases=(models.Model,),
        ),
        migrations.CreateModel(
            name='Tag',
            fields=[
                ('tag_id', models.AutoField(serialize=False, primary_key=True)),
                ('name', models.CharField(max_length=100)),
            ],
            options={
                'db_table': 'tags',
            },
            bases=(models.Model,),
        ),
        migrations.AddField(
            model_name='post',
            name='tag_id',
            field=models.ManyToManyField(to='Blog.Tag', db_table=b'post_tags'),
            preserve_default=True,
        ),
    ]

# Extension to format a paragraph

# Does basic, standard text formatting, and also understands Python
# comment blocks.  Thus, for editing Python source code, this
# extension is really only suitable for reformatting these comment
# blocks or triple-quoted strings.

# Known problems with comment reformatting:
# * If there is a selection marked, and the first line of the
#   selection is not complete, the block will probably not be detected
#   as comments, and will have the normal "text formatting" rules
#   applied.
# * If a comment block has leading whitespace that mixes tabs and
#   spaces, they will not be considered part of the same block.
# * Fancy comments, like this bulleted list, arent handled :-)

import re
from configHandler import idleConf

class FormatParagraph:

    menudefs = [
        ('format', [   # /s/edit/format   dscherer@cmu.edu
            ('Format Paragraph', '<<format-paragraph>>'),
         ])
    ]

    def __init__(self, editwin):
        self.editwin = editwin

    def close(self):
        self.editwin = None

    def format_paragraph_event(self, event):
        maxformatwidth = int(idleConf.GetOption('main','FormatParagraph','paragraph'))
        text = self.editwin.text
        first, last = self.editwin.get_selection_indices()
        if first and last:
            data = text.get(first, last)
            comment_header = ''
        else:
            first, last, comment_header, data = \
                    find_paragraph(text, text.index("insert"))
        if comment_header:
            # Reformat the comment lines - convert to text sans header.
            lines = data.split("\n")
            lines = map(lambda st, l=len(comment_header): st[l:], lines)
            data = "\n".join(lines)
            # Reformat to maxformatwidth chars or a 20 char width, whichever is greater.
            format_width = max(maxformatwidth - len(comment_header), 20)
            newdata = reformat_paragraph(data, format_width)
            # re-split and re-insert the comment header.
            newdata = newdata.split("\n")
            # If the block ends in a \n, we dont want the comment
            # prefix inserted after it. (Im not sure it makes sense to
            # reformat a comment block that isnt made of complete
            # lines, but whatever!)  Can't think of a clean soltution,
            # so we hack away
            block_suffix = ""
            if not newdata[-1]:
                block_suffix = "\n"
                newdata = newdata[:-1]
            builder = lambda item, prefix=comment_header: prefix+item
            newdata = '\n'.join(map(builder, newdata)) + block_suffix
        else:
            # Just a normal text format
            newdata = reformat_paragraph(data, maxformatwidth)
        text.tag_remove("sel", "1.0", "end")
        if newdata != data:
            text.mark_set("insert", first)
            text.undo_block_start()
            text.delete(first, last)
            text.insert(first, newdata)
            text.undo_block_stop()
        else:
            text.mark_set("insert", last)
        text.see("insert")
        return "break"

def find_paragraph(text, mark):
    lineno, col = map(int, mark.split("."))
    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
    while text.compare("%d.0" % lineno, "<", "end") and is_all_white(line):
        lineno = lineno + 1
        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
    first_lineno = lineno
    comment_header = get_comment_header(line)
    comment_header_len = len(comment_header)
    while get_comment_header(line)==comment_header and \
              not is_all_white(line[comment_header_len:]):
        lineno = lineno + 1
        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
    last = "%d.0" % lineno
    # Search back to beginning of paragraph
    lineno = first_lineno - 1
    line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
    while lineno > 0 and \
              get_comment_header(line)==comment_header and \
              not is_all_white(line[comment_header_len:]):
        lineno = lineno - 1
        line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
    first = "%d.0" % (lineno+1)
    return first, last, comment_header, text.get(first, last)

def reformat_paragraph(data, limit):
    lines = data.split("\n")
    i = 0
    n = len(lines)
    while i < n and is_all_white(lines[i]):
        i = i+1
    if i >= n:
        return data
    indent1 = get_indent(lines[i])
    if i+1 < n and not is_all_white(lines[i+1]):
        indent2 = get_indent(lines[i+1])
    else:
        indent2 = indent1
    new = lines[:i]
    partial = indent1
    while i < n and not is_all_white(lines[i]):
        # XXX Should take double space after period (etc.) into account
        words = re.split("(\s+)", lines[i])
        for j in range(0, len(words), 2):
            word = words[j]
            if not word:
                continue # Can happen when line ends in whitespace
            if len((partial + word).expandtabs()) > limit and \
               partial != indent1:
                new.append(partial.rstrip())
                partial = indent2
            partial = partial + word + " "
            if j+1 < len(words) and words[j+1] != " ":
                partial = partial + " "
        i = i+1
    new.append(partial.rstrip())
    # XXX Should reformat remaining paragraphs as well
    new.extend(lines[i:])
    return "\n".join(new)

def is_all_white(line):
    return re.match(r"^\s*$", line) is not None

def get_indent(line):
    return re.match(r"^(\s*)", line).group()

def get_comment_header(line):
    m = re.match(r"^(\s*#*)", line)
    if m is None: return ""
    return m.group(1)

# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# MIT License. See license.txt

from __future__ import unicode_literals
import frappe, os

from frappe.model.document import Document

class ModuleDef(Document):
	__doclink__ = "https://frappe.io/docs/models/core/module_def"
	def on_update(self):
		"""If in `developer_mode`, create folder for module and
			add in `modules.txt` of app if missing."""
		if frappe.conf.get("developer_mode"):
			self.create_modules_folder()
			self.add_to_modules_txt()

	def create_modules_folder(self):
		"""Creates a folder `[app]/[module]` and adds `__init__.py`"""
		module_path = frappe.get_app_path(self.app_name, self.name)
		if not os.path.exists(module_path):
			os.mkdir(module_path)
			with open(os.path.join(module_path, "__init__.py"), "w") as f:
				f.write("")

	def add_to_modules_txt(self):
		"""Adds to `[app]/modules.txt`"""
		modules = None
		if not frappe.local.module_app.get(frappe.scrub(self.name)):
			with open(frappe.get_app_path(self.app_name, "modules.txt"), "r") as f:
				content = f.read()
				if not self.name in content.splitlines():
					modules = filter(None, content.splitlines())
					modules.append(self.name)

			if modules:
				with open(frappe.get_app_path(self.app_name, "modules.txt"), "w") as f:
					f.write("\n".join(modules))

				frappe.clear_cache()
				frappe.setup_module_map()





import os
import signal
import sys
import socket, time
import cv
from PIL import Image
from numpy import array
import ImageFilter

# This makes sure the path which python uses to find things when using import
# can find all our code.
sys.path.insert(0, os.path.abspath('..'))
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

# Import qt modules (platform independant)
import ardrone.util.qtcompat as qt
QtCore = qt.import_module('QtCore')
QtNetwork = qt.import_module('QtNetwork')

# Import other objects
from ardrone.core.controlloop import ControlLoop
from ardrone.platform import qt as platform
import ardrone.core.videopacket as videopacket
#from ardrone.aruco import detect_markers

class imageProcessor(object):
        def __init__(self):
                pass

        def detect_markers (self, frame):

                #convert prep
                cv.SaveImage("frame.png", frame)

                #load greyscale image
                img = cv.LoadImageM("frame.png",cv.CV_LOAD_IMAGE_GRAYSCALE)
                #load colour image for displaying
                im = cv.LoadImageM("frame.png");


                 cv.Smooth(img, img, cv.CV_GAUSSIAN,5)

                   
                return im  
 

class imageViewer(object):

        win_title = "Drone Video Feed"

        def __init__(self):
                # Create a QtCoreApplication loop (NB remember to use QApplication instead if wanting GUI features)
                self.app = QtCore.QCoreApplication(sys.argv)

                # Wire up Ctrl-C to call QApplication.quit()
                signal.signal(signal.SIGINT, lambda *args: self.app.quit())

                # Initialise the drone control loop and attempt to open a connection.
                connection = platform.Connection()
                self._control = ControlLoop(connection, video_cb=None, navdata_cb=None)

                # Create a window in which to place frames
                cv.NamedWindow(self.win_title, cv.CV_WINDOW_AUTOSIZE) #probably no need to autosize

                # Set up a UDP listening socket on port 5562 which calls readData upon socket activity
                self.socket = QtNetwork.QUdpSocket()
                if not self.socket.bind(QtNetwork.QHostAddress.Any, 5562):
                        raise RuntimeError('Error binding to port: %s' % (self.socket.errorString()))
                self.socket.readyRead.connect(self.readData)

                # Create decoder object
                self._vid_decoder = videopacket.Decoder(self.showImage)
                
                # Create imageProcessor object
                self._img_processor = imageProcessor()
                
                # Start video on drone
                self._control.start_video()
                
        def run(self):
                self.app.exec_()
                
        def readData(self):
                """Called when there is some interesting data to read on the video socket."""
                while self.socket.hasPendingDatagrams():
                        sz = self.socket.pendingDatagramSize()
                        (data, host, port) = self.socket.readDatagram(sz)

                # Some hack to account for PySide vs. PyQt differences
                if qt.USES_PYSIDE:
                        data = data.data()
                
                # Decode video data and pass result to showImage
                self._vid_decoder.decode(data)
                        
        def showImage(self, data):
                """
                Displays argument image in window using openCV.
                data argument must be a string containing a 16 bit unsigned RGB image (RGB16 == RGB565).
                """

                # Create OpenCV header and read in drone video data as RGB565
                iplimage = cv.CreateImageHeader((320,240), cv.IPL_DEPTH_8U, 2)          
                cv.SetData(iplimage, data)
                
                # Convert image to RGB888 which is more OpenCV friendly
                RGBimage = cv.CreateImage((320,240), cv.IPL_DEPTH_8U, 3)
                cv.CvtColor(iplimage, RGBimage, cv.CV_BGR5652BGR)
                
                # Add labels for any markers present
                RGBimage = self._img_processor.detect_markers(RGBimage)
                
                # Show image
                cv.ShowImage(self.win_title, RGBimage)
                                
if (__name__ == '__main__'):
  image_app = imageViewer()
  image_app.run()

# Django settings for evesch project.
import os, sys

PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__.decode('utf-8')))
ENVIRONMENT_ROOT = os.path.abspath(os.path.join(PROJECT_ROOT, '..', '..', '..'))
HTDOCS_ROOT = os.path.abspath(os.path.join(ENVIRONMENT_ROOT, 'htdocs'))
LOG_ROOT = os.path.abspath(os.path.join(ENVIRONMENT_ROOT, 'var', 'log'))
sys.path.insert(0, os.path.join(PROJECT_ROOT, "core"))

DEBUG = True
TEMPLATE_DEBUG = DEBUG

ADMINS = (
     # ('joe', 'joe@evesch.com'),
)

MANAGERS = ADMINS
AUTH_USER_MODEL = 'euser.eUser'

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
        'NAME': os.path.join(ENVIRONMENT_ROOT, 'data', 'evesch.db'),
        # The following settings are not used with sqlite3:
        'USER': 'evesch',
        'PASSWORD': '',
        'HOST': '',
        'PORT': '',
    }
}


# Hosts/domain names that are valid for this site; required if DEBUG is False
# See https://docs.djangoproject.com/en/1.5/ref/settings/#allowed-hosts
ALLOWED_HOSTS = []

INTERNAL_IPS = ('127.0.0.1','localhost',)



# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# If running in a Windows environment this must be set to the same as your
# system time zone.
TIME_ZONE = 'America/Chicago'

# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'
#LANGUAGE_CODE = 'de'

SITE_ID = 1

# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True

# Absolute path to the directory that holds media.
# Example: "/home/media/media.lawrence.com/"

MEDIA_ROOT = os.path.abspath(os.path.join(HTDOCS_ROOT,  'media'))
# URL that handles the media served from MEDIA_ROOT. Make sure to use a
# trailing slash if there is a path component (optional in other cases).
# Examples: "http://media.lawrence.com", "http://example.com/media/"
MEDIA_URL = '/media/'


# Absolute path to the directory static files should be collected to.
# Don't put anything in this directory yourself; store your static files
# in apps' "static/" subdirectories and in STATICFILES_DIRS.
# Example: "/var/www/example.com/static/"
STATIC_ROOT = os.path.join(HTDOCS_ROOT,  'static') 

# URL prefix for static files.
# Example: "http://example.com/static/", "http://static.example.com/"
STATIC_URL = '/static/'

# Additional locations of static files
STATICFILES_DIRS = (
    # Put strings here, like "/home/html/static" or "C:/www/django/static".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
    os.path.join(PROJECT_ROOT, 'static'),
)

# List of finder classes that know how to find static files in
# various locations.
STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
#    'django.contrib.staticfiles.finders.DefaultStorageFinder',
)


# Make this unique, and don't share it with anybody.
SECRET_KEY = '@+@m7a_u8)0*i$a#-rhfc+m&h$=@rqza8x^g8yaw&*3#34f5ml(9gd41jh'


# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
    'django.template.loaders.filesystem.Loader',
    'django.template.loaders.app_directories.Loader',
)

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'pagination.middleware.PaginationMiddleware',
    'evesch.core.middleware.StripWhitespaceMiddleware.StripWhitespaceMiddleware',
    'evesch.core.middleware.threadlocals.ThreadLocals',
#    'debug_toolbar.middleware.DebugToolbarMiddleware',
)

ROOT_URLCONF = 'evesch.urls'

# Python dotted path to the WSGI application used by Django's runserver.
WSGI_APPLICATION = 'evesch.wsgi.application'

TEMPLATE_CONTEXT_PROCESSORS = (
    "django.core.context_processors.request",
    "django.contrib.auth.context_processors.auth",
    "django.core.context_processors.media",
    "django.core.context_processors.static",
    "django.core.context_processors.i18n",
    "django.contrib.messages.context_processors.messages",
)


TEMPLATE_DIRS = (
    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
    os.path.join(PROJECT_ROOT, 'templates'),
)

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'south',
    'rosetta',   # used for easily editing i18n files
    'pagination',
    'django_extensions',
    'south',

    'evesch.core',
    'evesch.org',
    'evesch.org.avatar',
    'evesch.egroup',
    'evesch.euser',
    'evesch.event',
    'evesch.ecalendar',
    'evesch.core.feed',
#    'core.debug_toolbar',  # adds debug toolbar that shows various stats
    'evesch.core.ajax_filtered_fields', 
    'evesch.report',
    'evesch.post',

)

# max size for profie photo uploads (in KB)
MAX_PHOTO_UPLOAD_SIZE = 2000

# A sample logging configuration. The only tangible logging
# performed by this configuration is to send an email to
# the site admins on every HTTP 500 error when DEBUG=False.
# See http://docs.djangoproject.com/en/dev/topics/logging for
# more details on how to customize your logging configuration.
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse'
        }
    },
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'handlers': {
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'class': 'django.utils.log.AdminEmailHandler'
        },
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
        },
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': os.path.join(LOG_ROOT, "evesch-django.log"),
            'formatter': 'verbose'
        },
    },
    'loggers': {
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': True,
        },
        'evesch': {
            'handlers': ['file', 'console'],
            'level': 'DEBUG',
            'propagate': True,
        },
    }
}

# -*- coding: utf-8 -*-
"""Run test to import MT940 IBAN ING import."""
##############################################################################
#
#    Copyright (C) 2015 Therp BV <http://therp.nl>.
#
#    All other contributions are (C) by their respective contributors
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from openerp.addons.account_bank_statement_import.tests import (
    TestStatementFile)


class TestImport(TestStatementFile):
    """Run test to import MT940 ING import."""

    def test_old_statement_import(self):
        """Test correct creation of single statement from old format."""
        self._test_statement_import(
            'account_bank_statement_import_mt940_nl_ing', 'test-ing-old.940',
            'NL77INGB0574908765-2014-01-20',
            start_balance=662.23, end_balance=564.35
        )

    def test_statement_import(self):
        """Test correct creation of single statement."""
        transactions = [
            {
                'remote_account': 'NL32INGB0000012345',
                'transferred_amount': 1.56,
                'value_date': '2014-02-20',
                'ref': 'EV12341REP1231456T1234',
            },
        ]
        self._test_statement_import(
            'account_bank_statement_import_mt940_nl_ing', 'test-ing.940',
            'NL77INGB0574908765-2014-02-20',
            start_balance=662.23, end_balance=564.35,
            transactions=transactions
        )

#
# QAPI command marshaller generator
#
# Copyright IBM, Corp. 2011
# Copyright (C) 2014-2015 Red Hat, Inc.
#
# Authors:
#  Anthony Liguori <aliguori@us.ibm.com>
#  Michael Roth    <mdroth@linux.vnet.ibm.com>
#  Markus Armbruster <armbru@redhat.com>
#
# This work is licensed under the terms of the GNU GPL, version 2.
# See the COPYING file in the top-level directory.

from ordereddict import OrderedDict
from qapi import *
import re

def generate_command_decl(name, args, ret_type):
    arglist=""
    for argname, argtype, optional in parse_args(args):
        argtype = c_type(argtype, is_param=True)
        if optional:
            arglist += "bool has_%s, " % c_name(argname)
        arglist += "%s %s, " % (argtype, c_name(argname))
    return mcgen('''
%(ret_type)s qmp_%(name)s(%(args)sError **errp);
''',
                 ret_type=c_type(ret_type), name=c_name(name),
                 args=arglist).strip()

def gen_err_check(errvar):
    if errvar:
        return mcgen('''
if (local_err) {
    goto out;
}
''')
    return ''

def gen_sync_call(name, args, ret_type, indent=0):
    ret = ""
    arglist=""
    retval=""
    if ret_type:
        retval = "retval = "
    for argname, argtype, optional in parse_args(args):
        if optional:
            arglist += "has_%s, " % c_name(argname)
        arglist += "%s, " % (c_name(argname))
    push_indent(indent)
    ret = mcgen('''
%(retval)sqmp_%(name)s(%(args)s&local_err);

''',
                name=c_name(name), args=arglist, retval=retval).rstrip()
    if ret_type:
        ret += "\n" + gen_err_check('local_err')
        ret += "\n" + mcgen(''''
%(marshal_output_call)s
''',
                            marshal_output_call=gen_marshal_output_call(name, ret_type)).rstrip()
    pop_indent(indent)
    return ret.rstrip()


def gen_marshal_output_call(name, ret_type):
    if not ret_type:
        return ""
    return "qmp_marshal_output_%s(retval, ret, &local_err);" % c_name(name)

def gen_visitor_input_containers_decl(args, obj):
    ret = ""

    push_indent()
    if len(args) > 0:
        ret += mcgen('''
QmpInputVisitor *mi = qmp_input_visitor_new_strict(%(obj)s);
QapiDeallocVisitor *md;
Visitor *v;
''',
                     obj=obj)
    pop_indent()

    return ret.rstrip()

def gen_visitor_input_vars_decl(args):
    ret = ""
    push_indent()
    for argname, argtype, optional in parse_args(args):
        if optional:
            ret += mcgen('''
bool has_%(argname)s = false;
''',
                         argname=c_name(argname))
        if is_c_ptr(argtype):
            ret += mcgen('''
%(argtype)s %(argname)s = NULL;
''',
                         argname=c_name(argname), argtype=c_type(argtype))
        else:
            ret += mcgen('''
%(argtype)s %(argname)s = {0};
''',
                         argname=c_name(argname), argtype=c_type(argtype))

    pop_indent()
    return ret.rstrip()

def gen_visitor_input_block(args, dealloc=False):
    ret = ""
    errparg = '&local_err'
    errarg = 'local_err'

    if len(args) == 0:
        return ret

    push_indent()

    if dealloc:
        errparg = 'NULL'
        errarg = None;
        ret += mcgen('''
qmp_input_visitor_cleanup(mi);
md = qapi_dealloc_visitor_new();
v = qapi_dealloc_get_visitor(md);
''')
    else:
        ret += mcgen('''
v = qmp_input_get_visitor(mi);
''')

    for argname, argtype, optional in parse_args(args):
        if optional:
            ret += mcgen('''
visit_optional(v, &has_%(c_name)s, "%(name)s", %(errp)s);
''',
                         c_name=c_name(argname), name=argname, errp=errparg)
            ret += gen_err_check(errarg)
            ret += mcgen('''
if (has_%(c_name)s) {
''',
                         c_name=c_name(argname))
            push_indent()
        ret += mcgen('''
visit_type_%(visitor)s(v, &%(c_name)s, "%(name)s", %(errp)s);
''',
                     c_name=c_name(argname), name=argname, argtype=argtype,
                     visitor=type_name(argtype), errp=errparg)
        ret += gen_err_check(errarg)
        if optional:
            pop_indent()
            ret += mcgen('''
}
''')

    if dealloc:
        ret += mcgen('''
qapi_dealloc_visitor_cleanup(md);
''')
    pop_indent()
    return ret.rstrip()

def gen_marshal_output(name, args, ret_type, middle_mode):
    if not ret_type:
        return ""

    ret = mcgen('''
static void qmp_marshal_output_%(c_name)s(%(c_ret_type)s ret_in, QObject **ret_out, Error **errp)
{
    Error *local_err = NULL;
    QmpOutputVisitor *mo = qmp_output_visitor_new();
    QapiDeallocVisitor *md;
    Visitor *v;

    v = qmp_output_get_visitor(mo);
    visit_type_%(visitor)s(v, &ret_in, "unused", &local_err);
    if (local_err) {
        goto out;
    }
    *ret_out = qmp_output_get_qobject(mo);

out:
    error_propagate(errp, local_err);
    qmp_output_visitor_cleanup(mo);
    md = qapi_dealloc_visitor_new();
    v = qapi_dealloc_get_visitor(md);
    visit_type_%(visitor)s(v, &ret_in, "unused", NULL);
    qapi_dealloc_visitor_cleanup(md);
}
''',
                c_ret_type=c_type(ret_type), c_name=c_name(name),
                visitor=type_name(ret_type))

    return ret

def gen_marshal_input_decl(name, args, ret_type, middle_mode):
    ret = 'void qmp_marshal_input_%s(QDict *args, QObject **ret, Error **errp)' % c_name(name)
    if not middle_mode:
        ret = "static " + ret
    return ret

def gen_marshal_input(name, args, ret_type, middle_mode):
    hdr = gen_marshal_input_decl(name, args, ret_type, middle_mode)

    ret = mcgen('''
%(header)s
{
    Error *local_err = NULL;
''',
                header=hdr)

    if ret_type:
        if is_c_ptr(ret_type):
            retval = "    %s retval = NULL;" % c_type(ret_type)
        else:
            retval = "    %s retval;" % c_type(ret_type)
        ret += mcgen('''
%(retval)s
''',
                     retval=retval)

    if len(args) > 0:
        ret += mcgen('''
%(visitor_input_containers_decl)s
%(visitor_input_vars_decl)s

%(visitor_input_block)s

''',
                     visitor_input_containers_decl=gen_visitor_input_containers_decl(args, "QOBJECT(args)"),
                     visitor_input_vars_decl=gen_visitor_input_vars_decl(args),
                     visitor_input_block=gen_visitor_input_block(args))
    else:
        ret += mcgen('''

    (void)args;
''')

    ret += mcgen('''
%(sync_call)s
''',
                 sync_call=gen_sync_call(name, args, ret_type, indent=4))
    if re.search('^ *goto out\\;', ret, re.MULTILINE):
        ret += mcgen('''

out:
''')
    ret += mcgen('''
    error_propagate(errp, local_err);
%(visitor_input_block_cleanup)s
}
''',
                 visitor_input_block_cleanup=gen_visitor_input_block(args,
                                                                     dealloc=True))
    return ret

def gen_registry(commands):
    registry=""
    push_indent()
    for cmd in commands:
        options = 'QCO_NO_OPTIONS'
        if not cmd.get('success-response', True):
            options = 'QCO_NO_SUCCESS_RESP'

        registry += mcgen('''
qmp_register_command("%(name)s", qmp_marshal_input_%(c_name)s, %(opts)s);
''',
                     name=cmd['command'], c_name=c_name(cmd['command']),
                     opts=options)
    pop_indent()
    ret = mcgen('''
static void qmp_init_marshal(void)
{
%(registry)s
}

qapi_init(qmp_init_marshal);
''',
                registry=registry.rstrip())
    return ret

middle_mode = False

(input_file, output_dir, do_c, do_h, prefix, opts) = \
    parse_command_line("m", ["middle"])

for o, a in opts:
    if o in ("-m", "--middle"):
        middle_mode = True

exprs = parse_schema(input_file)
commands = filter(lambda expr: expr.has_key('command'), exprs)
commands = filter(lambda expr: not expr.has_key('gen'), commands)

c_comment = '''
/*
 * schema-defined QMP->QAPI command dispatch
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */
'''
h_comment = '''
/*
 * schema-defined QAPI function prototypes
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */
'''

(fdef, fdecl) = open_output(output_dir, do_c, do_h, prefix,
                            'qmp-marshal.c', 'qmp-commands.h',
                            c_comment, h_comment)

fdef.write(mcgen('''
#include "qemu-common.h"
#include "qemu/module.h"
#include "qapi/qmp/types.h"
#include "qapi/qmp/dispatch.h"
#include "qapi/visitor.h"
#include "qapi/qmp-output-visitor.h"
#include "qapi/qmp-input-visitor.h"
#include "qapi/dealloc-visitor.h"
#include "%(prefix)sqapi-types.h"
#include "%(prefix)sqapi-visit.h"
#include "%(prefix)sqmp-commands.h"

''',
                prefix=prefix))

fdecl.write(mcgen('''
#include "%(prefix)sqapi-types.h"
#include "qapi/qmp/qdict.h"
#include "qapi/error.h"

''',
                 prefix=prefix))

for cmd in commands:
    arglist = []
    ret_type = None
    if cmd.has_key('data'):
        arglist = cmd['data']
    if cmd.has_key('returns'):
        ret_type = cmd['returns']
    ret = generate_command_decl(cmd['command'], arglist, ret_type) + "\n"
    fdecl.write(ret)
    if ret_type:
        ret = gen_marshal_output(cmd['command'], arglist, ret_type, middle_mode) + "\n"
        fdef.write(ret)

    if middle_mode:
        fdecl.write('%s;\n' % gen_marshal_input_decl(cmd['command'], arglist, ret_type, middle_mode))

    ret = gen_marshal_input(cmd['command'], arglist, ret_type, middle_mode) + "\n"
    fdef.write(ret)

if not middle_mode:
    ret = gen_registry(commands)
    fdef.write(ret)

close_output(fdef, fdecl)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""

"""
import csv
import errno
import json
import logging
import os
import re
import shutil
import tarfile
import time
from six import text_type as unicodestr
import dateutil.parser
import pytz
import requests

from .. import pg_wikipedia
from ..config import NotConfigured
from ..metadata.pandata import Pandata
from ..metadata.pg_rdf import pg_rdf_to_json, htm_modified
from ..parameters import GITHUB_ORG

RDF_URL = "https://www.gutenberg.org/cache/epub/feeds/rdf-files.tar.bz2"
RDF_PATH = "/tmp/rdf.tar.bz2"
# 1 day
RDF_MAX_AGE = 60 * 60 * 24

# sourced from http://www.gutenberg.org/MIRRORS.ALL
MIRRORS = {'default': 'ftp://gutenberg.pglaf.org/mirrors/gutenberg/'}
utc = pytz.UTC

with open(os.path.join(
    os.path.dirname(__file__),
    '../data/gutenberg_descriptions.json'
)) as descfile:
    DESCS = json.load(descfile)

descs = {}
for desc in DESCS:
    descs[desc['identifier'][32:]] = desc['description']
repo_list = []
with open(os.path.join(os.path.dirname(__file__), '../data/GITenberg_repo_list.tsv')) as repofile:
    for row in csv.reader(repofile, delimiter='\t', quotechar='"'):
        repo_list.append(row)
repo_for_pgid = {int(pgid): value for (pgid, value) in repo_list}
last_pgid = repo_list[-1][0]

missing_list = []
with open(os.path.join(os.path.dirname(__file__), '../data/missing.tsv')) as missingfile:
    for row in csv.reader(missingfile, delimiter='\t', quotechar='"'):
        missing_list.append(row)
missing_pgid = {int(pgid): value for (pgid, reason, value) in missing_list}

def get_all_repo_names():
    """Yields the full names of all the book repositories."""
    for repo in repo_for_pgid.values():
        yield '%s/%s' % (GITHUB_ORG, repo)

def get_repo_name(repo_name):
    if re.match(r'^\d+$', repo_name):
        try:
            repo_name = repo_for_pgid[int(repo_name)]
        except KeyError:
            pass
    return repo_name

class NoRDFError(Exception):
    pass

class BookMetadata(Pandata):
    def __init__(self, book, rdf_library='./rdf_library', enrich=True, datafile=None):
        if datafile:
            super(BookMetadata, self).__init__(datafile=datafile)
            self.rdf_path = "{0}/{1}/pg{1}.rdf".format(
                book.rdf_library, book.book_id
            )
            return
        self.book = book
        try:
            assert os.path.exists(rdf_library)
        except Exception as e:
            raise NotConfigured(e)
        self.rdf_path = "{0}/{1}/pg{1}.rdf".format(
            rdf_library, self.book.book_id
        )
        self.parse_rdf()
        if enrich:
            self.enrich()

    def parse_rdf(self):
        """ Parses the relevant PG rdf file
        """
        try:
            self.metadata = pg_rdf_to_json(self.rdf_path)
        except IOError as e:
            raise NoRDFError(e)

        if not self.authnames():
            self.author = ''
        elif len(self.authnames()) == 1:
            self.author = self.authnames()[0]
        else:
            self.author = "Various"

    def enrich(self):
        description = pg_wikipedia.get_pg_summary(self.book.book_id)
        if not description:
            description = descs.get(self.book.book_id, '')
        else:
            description = description + '\n From Wikipedia (CC BY-SA).'
            self.identifiers.update({'wikidata': pg_wikipedia.get_wd_id(self.book.book_id)})
            self.metadata['wikipedia'] = pg_wikipedia.get_pg_links(self.book.book_id)
        if not description:
            description = self.description
        self.metadata['description'] = description

    def pg_modified(self):
        mod_str = htm_modified(self.rdf_path)
        return utc.localize(dateutil.parser.parse(mod_str))

class Rdfcache(object):
    downloading = False

    def __init__(self, rdf_library='./rdf_library'):
        if rdf_library.endswith('/cache/epub'):
            # because unzipping the archive creates ./cache/epub
            self.rdf_library_dir = rdf_library[0:-11]
        else:
            self.rdf_library_dir = rdf_library

    def download_rdf(self, force=False):
        """Ensures a fresh-enough RDF file is downloaded and extracted.

        Returns True on error."""
        if self.downloading:
            return True

        if not force and (os.path.exists(RDF_PATH) and
                (time.time() - os.path.getmtime(RDF_PATH)) < RDF_MAX_AGE):
            return False
        self.downloading = True
        logging.info('Re-downloading RDF library from %s' % RDF_URL)
        try:
            shutil.rmtree(os.path.join(self.rdf_library_dir, 'cache'))
        except OSError as e:
            # Ignore not finding the directory to remove.
            if e.errno != errno.ENOENT:
                raise

        try:
            with open(RDF_PATH, 'wb') as f:
                with requests.get(RDF_URL, stream=True) as r:
                    shutil.copyfileobj(r.raw, f)
        except requests.exceptions.RequestException as e:
            logging.error(e)
            return True

        try:
            with tarfile.open(RDF_PATH, 'r') as f:
                f.extractall(self.rdf_library_dir)
        except tarfile.TarError as e:
            logging.error(e)
            try:
                os.unlink(RDF_PATH)
            except:
                pass
            return True
        self.downloading = False
        return False

    def get_repos_to_upload(self):
        pg_id = int(last_pgid) + 1
        more = True
        pg_ids = []
        while more:
            new_rdffile = os.path.join(
                self.rdf_library_dir,
                'cache',
                'epub',
                unicodestr(pg_id),
                'pg{}.rdf'.format(pg_id)
            )
            if os.path.exists(new_rdffile):
                pg_ids.append(pg_id)
                pg_id += 1
            else:
                if pg_id in missing_pgid:
                    pg_id += 1
                else:
                    more = False
        return pg_ids

from __future__ import unicode_literals

import re

from .common import InfoExtractor
from ..utils import int_or_none


class LiveLeakIE(InfoExtractor):
    _VALID_URL = r'https?://(?:\w+\.)?liveleak\.com/view\?.*?\b[it]=(?P<id>[\w_]+)'
    _TESTS = [{
        'url': 'http://www.liveleak.com/view?i=757_1364311680',
        'md5': '0813c2430bea7a46bf13acf3406992f4',
        'info_dict': {
            'id': '757_1364311680',
            'ext': 'mp4',
            'description': 'extremely bad day for this guy..!',
            'uploader': 'ljfriel2',
            'title': 'Most unlucky car accident',
            'thumbnail': r're:^https?://.*\.jpg$'
        }
    }, {
        'url': 'http://www.liveleak.com/view?i=f93_1390833151',
        'md5': 'd3f1367d14cc3c15bf24fbfbe04b9abf',
        'info_dict': {
            'id': 'f93_1390833151',
            'ext': 'mp4',
            'description': 'German Television Channel NDR does an exclusive interview with Edward Snowden.\r\nUploaded on LiveLeak cause German Television thinks the rest of the world isn\'t intereseted in Edward Snowden.',
            'uploader': 'ARD_Stinkt',
            'title': 'German Television does first Edward Snowden Interview (ENGLISH)',
            'thumbnail': r're:^https?://.*\.jpg$'
        }
    }, {
        # Prochan embed
        'url': 'http://www.liveleak.com/view?i=4f7_1392687779',
        'md5': '42c6d97d54f1db107958760788c5f48f',
        'info_dict': {
            'id': '4f7_1392687779',
            'ext': 'mp4',
            'description': "The guy with the cigarette seems amazingly nonchalant about the whole thing...  I really hope my friends' reactions would be a bit stronger.\r\n\r\nAction-go to 0:55.",
            'uploader': 'CapObveus',
            'title': 'Man is Fatally Struck by Reckless Car While Packing up a Moving Truck',
            'age_limit': 18,
        },
        'skip': 'Video is dead',
    }, {
        # Covers https://github.com/ytdl-org/youtube-dl/pull/5983
        # Multiple resolutions
        'url': 'http://www.liveleak.com/view?i=801_1409392012',
        'md5': 'c3a449dbaca5c0d1825caecd52a57d7b',
        'info_dict': {
            'id': '801_1409392012',
            'ext': 'mp4',
            'description': 'Happened on 27.7.2014. \r\nAt 0:53 you can see people still swimming at near beach.',
            'uploader': 'bony333',
            'title': 'Crazy Hungarian tourist films close call waterspout in Croatia',
            'thumbnail': r're:^https?://.*\.jpg$'
        }
    }, {
        # Covers https://github.com/ytdl-org/youtube-dl/pull/10664#issuecomment-247439521
        'url': 'http://m.liveleak.com/view?i=763_1473349649',
        'add_ie': ['Youtube'],
        'info_dict': {
            'id': '763_1473349649',
            'ext': 'mp4',
            'title': 'Reporters and public officials ignore epidemic of black on asian violence in Sacramento | Colin Flaherty',
            'description': 'Colin being the warrior he is and showing the injustice Asians in Sacramento are being subjected to.',
            'uploader': 'Ziz',
            'upload_date': '20160908',
            'uploader_id': 'UCEbta5E_jqlZmEJsriTEtnw'
        },
        'params': {
            'skip_download': True,
        },
    }, {
        'url': 'https://www.liveleak.com/view?i=677_1439397581',
        'info_dict': {
            'id': '677_1439397581',
            'title': 'Fuel Depot in China Explosion caught on video',
        },
        'playlist_count': 3,
    }, {
        'url': 'https://www.liveleak.com/view?t=HvHi_1523016227',
        'only_matching': True,
    }, {
        # No original video
        'url': 'https://www.liveleak.com/view?t=C26ZZ_1558612804',
        'only_matching': True,
    }]

    @staticmethod
    def _extract_urls(webpage):
        return re.findall(
            r'<iframe[^>]+src="(https?://(?:\w+\.)?liveleak\.com/ll_embed\?[^"]*[ift]=[\w_]+[^"]+)"',
            webpage)

    def _real_extract(self, url):
        video_id = self._match_id(url)
        webpage = self._download_webpage(url, video_id)

        video_title = self._og_search_title(webpage).replace('LiveLeak.com -', '').strip()
        video_description = self._og_search_description(webpage)
        video_uploader = self._html_search_regex(
            r'By:.*?(\w+)</a>', webpage, 'uploader', fatal=False)
        age_limit = int_or_none(self._search_regex(
            r'you confirm that you are ([0-9]+) years and over.',
            webpage, 'age limit', default=None))
        video_thumbnail = self._og_search_thumbnail(webpage)

        entries = self._parse_html5_media_entries(url, webpage, video_id)
        if not entries:
            # Maybe an embed?
            embed_url = self._search_regex(
                r'<iframe[^>]+src="((?:https?:)?//(?:www\.)?(?:prochan|youtube)\.com/embed[^"]+)"',
                webpage, 'embed URL')
            return {
                '_type': 'url_transparent',
                'url': embed_url,
                'id': video_id,
                'title': video_title,
                'description': video_description,
                'uploader': video_uploader,
                'age_limit': age_limit,
            }

        for idx, info_dict in enumerate(entries):
            formats = []
            for a_format in info_dict['formats']:
                if not a_format.get('height'):
                    a_format['height'] = int_or_none(self._search_regex(
                        r'([0-9]+)p\.mp4', a_format['url'], 'height label',
                        default=None))
                formats.append(a_format)

                # Removing '.*.mp4' gives the raw video, which is essentially
                # the same video without the LiveLeak logo at the top (see
                # https://github.com/ytdl-org/youtube-dl/pull/4768)
                orig_url = re.sub(r'\.mp4\.[^.]+', '', a_format['url'])
                if a_format['url'] != orig_url:
                    format_id = a_format.get('format_id')
                    format_id = 'original' + ('-' + format_id if format_id else '')
                    if self._is_valid_url(orig_url, video_id, format_id):
                        formats.append({
                            'format_id': format_id,
                            'url': orig_url,
                            'preference': 1,
                        })
            self._sort_formats(formats)
            info_dict['formats'] = formats

            # Don't append entry ID for one-video pages to keep backward compatibility
            if len(entries) > 1:
                info_dict['id'] = '%s_%s' % (video_id, idx + 1)
            else:
                info_dict['id'] = video_id

            info_dict.update({
                'title': video_title,
                'description': video_description,
                'uploader': video_uploader,
                'age_limit': age_limit,
                'thumbnail': video_thumbnail,
            })

        return self.playlist_result(entries, video_id, video_title)


class LiveLeakEmbedIE(InfoExtractor):
    _VALID_URL = r'https?://(?:www\.)?liveleak\.com/ll_embed\?.*?\b(?P<kind>[ift])=(?P<id>[\w_]+)'

    # See generic.py for actual test cases
    _TESTS = [{
        'url': 'https://www.liveleak.com/ll_embed?i=874_1459135191',
        'only_matching': True,
    }, {
        'url': 'https://www.liveleak.com/ll_embed?f=ab065df993c1',
        'only_matching': True,
    }]

    def _real_extract(self, url):
        kind, video_id = re.match(self._VALID_URL, url).groups()

        if kind == 'f':
            webpage = self._download_webpage(url, video_id)
            liveleak_url = self._search_regex(
                r'(?:logourl\s*:\s*|window\.open\()(?P<q1>[\'"])(?P<url>%s)(?P=q1)' % LiveLeakIE._VALID_URL,
                webpage, 'LiveLeak URL', group='url')
        else:
            liveleak_url = 'http://www.liveleak.com/view?%s=%s' % (kind, video_id)

        return self.url_result(liveleak_url, ie=LiveLeakIE.ie_key())

# -*- encoding: utf-8 -*-
##############################################################################
#
#   sale_automatic_workflow for OpenERP
#   Copyright (C) 2011 Akretion Sébastien BEAU <sebastien.beau@akretion.com>
#   Copyright 2013 Camptocamp SA (author: Guewen Baconnier)
#
#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU Affero General Public License as
#   published by the Free Software Foundation, either version 3 of the
#   License, or (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU Affero General Public License for more details.
#
#   You should have received a copy of the GNU Affero General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

{
    'name': 'Sale Automatic Workflow',
    'version': '0.2',
    'category': 'Generic Modules/Others',
    'license': 'AGPL-3',
    'author': "Akretion,Camptocamp,Odoo Community Association (OCA)",
    'website': 'http://www.akretion.com/',
    'depends': ['sale_stock',
                ],
    'data': ['sale_view.xml',
             'sale_workflow.xml',
             'sale_workflow_process_view.xml',
             'automatic_workflow_data.xml',
             'security/ir.model.access.csv',
             ],
    'installable': True,
}

#!/usr/bin/python

# (c) 2016, NetApp, Inc
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#
ANSIBLE_METADATA = {'metadata_version': '1.0',
                    'status': ['preview'],
                    'supported_by': 'community'}


DOCUMENTATION = """
---
module: netapp_e_volume_copy
short_description: Create volume copy pairs
description:
    - Create and delete snapshots images on volume groups for NetApp E-series storage arrays.
version_added: '2.2'
author: Kevin Hulquest (@hulquest)
options:
    api_username:
        required: true
        description:
        - The username to authenticate with the SANtricity WebServices Proxy or embedded REST API.
    api_password:
        required: true
        description:
        - The password to authenticate with the SANtricity WebServices Proxy or embedded REST API.
    api_url:
        required: true
        description:
        - The url to the SANtricity WebServices Proxy or embedded REST API, for example C(https://prod-1.wahoo.acme.com/devmgr/v2).
    validate_certs:
        required: false
        default: true
        description:
        - Should https certificates be validated?
    source_volume_id:
        description:
            - The the id of the volume copy source.
            - If used, must be paired with destination_volume_id
            - Mutually exclusive with volume_copy_pair_id, and search_volume_id
    destination_volume_id:
        description:
            - The the id of the volume copy destination.
            - If used, must be paired with source_volume_id
            - Mutually exclusive with volume_copy_pair_id, and search_volume_id
    volume_copy_pair_id:
        description:
            - The the id of a given volume copy pair
            - Mutually exclusive with destination_volume_id, source_volume_id, and search_volume_id
            - Can use to delete or check presence of volume pairs
            - Must specify this or (destination_volume_id and source_volume_id)
    state:
        description:
            - Whether the specified volume copy pair should exist or not.
        required: True
        choices: ['present', 'absent']
    create_copy_pair_if_does_not_exist:
        description:
            - Defines if a copy pair will be created if it does not exist.
            - If set to True destination_volume_id and source_volume_id are required.
        choices: [True, False]
        default: True
    start_stop_copy:
        description:
            - starts a re-copy or stops a copy in progress
            - "Note: If you stop the initial file copy before it it done the copy pair will be destroyed"
            - Requires volume_copy_pair_id
    search_volume_id:
        description:
            - Searches for all valid potential target and source volumes that could be used in a copy_pair
            - Mutually exclusive with volume_copy_pair_id, destination_volume_id and source_volume_id
"""
RESULTS = """
"""
EXAMPLES = """
---
msg:
    description: Success message
    returned: success
    type: string
    sample: Json facts for the volume copy that was created.
"""
RETURN = """
msg:
    description: Success message
    returned: success
    type: string
    sample: Created Volume Copy Pair with ID
"""

import json

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.pycompat24 import get_exception
from ansible.module_utils.urls import open_url
from ansible.module_utils.six.moves.urllib.error import HTTPError

HEADERS = {
    "Content-Type": "application/json",
    "Accept": "application/json",
}


def request(url, data=None, headers=None, method='GET', use_proxy=True,
            force=False, last_mod_time=None, timeout=10, validate_certs=True,
            url_username=None, url_password=None, http_agent=None, force_basic_auth=True, ignore_errors=False):
    try:
        r = open_url(url=url, data=data, headers=headers, method=method, use_proxy=use_proxy,
                     force=force, last_mod_time=last_mod_time, timeout=timeout, validate_certs=validate_certs,
                     url_username=url_username, url_password=url_password, http_agent=http_agent,
                     force_basic_auth=force_basic_auth)
    except HTTPError:
        err = get_exception()
        r = err.fp

    try:
        raw_data = r.read()
        if raw_data:
            data = json.loads(raw_data)
        else:
            raw_data = None
    except:
        if ignore_errors:
            pass
        else:
            raise Exception(raw_data)

    resp_code = r.getcode()

    if resp_code >= 400 and not ignore_errors:
        raise Exception(resp_code, data)
    else:
        return resp_code, data


def find_volume_copy_pair_id_from_source_volume_id_and_destination_volume_id(params):
    get_status = 'storage-systems/%s/volume-copy-jobs' % params['ssid']
    url = params['api_url'] + get_status

    (rc, resp) = request(url, method='GET', url_username=params['api_username'],
                         url_password=params['api_password'], headers=HEADERS,
                         validate_certs=params['validate_certs'])

    volume_copy_pair_id = None
    for potential_copy_pair in resp:
        if potential_copy_pair['sourceVolume'] == params['source_volume_id']:
            if potential_copy_pair['sourceVolume'] == params['source_volume_id']:
                volume_copy_pair_id = potential_copy_pair['id']

    return volume_copy_pair_id


def create_copy_pair(params):
    get_status = 'storage-systems/%s/volume-copy-jobs' % params['ssid']
    url = params['api_url'] + get_status

    rData = {
        "sourceId": params['source_volume_id'],
        "targetId": params['destination_volume_id']
    }

    (rc, resp) = request(url, data=json.dumps(rData), ignore_errors=True, method='POST',
                         url_username=params['api_username'], url_password=params['api_password'], headers=HEADERS,
                         validate_certs=params['validate_certs'])
    if rc != 200:
        return False, (rc, resp)
    else:
        return True, (rc, resp)


def delete_copy_pair_by_copy_pair_id(params):
    get_status = 'storage-systems/%s/volume-copy-jobs/%s?retainRepositories=false' % (
        params['ssid'], params['volume_copy_pair_id'])
    url = params['api_url'] + get_status

    (rc, resp) = request(url, ignore_errors=True, method='DELETE',
                         url_username=params['api_username'], url_password=params['api_password'], headers=HEADERS,
                         validate_certs=params['validate_certs'])
    if rc != 204:
        return False, (rc, resp)
    else:
        return True, (rc, resp)


def find_volume_copy_pair_id_by_volume_copy_pair_id(params):
    get_status = 'storage-systems/%s/volume-copy-jobs/%s?retainRepositories=false' % (
        params['ssid'], params['volume_copy_pair_id'])
    url = params['api_url'] + get_status

    (rc, resp) = request(url, ignore_errors=True, method='DELETE',
                         url_username=params['api_username'], url_password=params['api_password'], headers=HEADERS,
                         validate_certs=params['validate_certs'])
    if rc != 200:
        return False, (rc, resp)
    else:
        return True, (rc, resp)


def start_stop_copy(params):
    get_status = 'storage-systems/%s/volume-copy-jobs-control/%s?control=%s' % (
        params['ssid'], params['volume_copy_pair_id'], params['start_stop_copy'])
    url = params['api_url'] + get_status

    (response_code, response_data) = request(url, ignore_errors=True, method='POST',
                                             url_username=params['api_username'], url_password=params['api_password'],
                                             headers=HEADERS,
                                             validate_certs=params['validate_certs'])

    if response_code == 200:
        return True, response_data[0]['percentComplete']
    else:
        return False, response_data


def check_copy_status(params):
    get_status = 'storage-systems/%s/volume-copy-jobs-control/%s' % (
        params['ssid'], params['volume_copy_pair_id'])
    url = params['api_url'] + get_status

    (response_code, response_data) = request(url, ignore_errors=True, method='GET',
                                             url_username=params['api_username'], url_password=params['api_password'],
                                             headers=HEADERS,
                                             validate_certs=params['validate_certs'])

    if response_code == 200:
        if response_data['percentComplete'] != -1:

            return True, response_data['percentComplete']
        else:
            return False, response_data['percentComplete']
    else:
        return False, response_data


def find_valid_copy_pair_targets_and_sources(params):
    get_status = 'storage-systems/%s/volumes' % params['ssid']
    url = params['api_url'] + get_status

    (response_code, response_data) = request(url, ignore_errors=True, method='GET',
                                             url_username=params['api_username'], url_password=params['api_password'],
                                             headers=HEADERS,
                                             validate_certs=params['validate_certs'])

    if response_code == 200:
        source_capacity = None
        candidates = []
        for volume in response_data:
            if volume['id'] == params['search_volume_id']:
                source_capacity = volume['capacity']
            else:
                candidates.append(volume)

        potential_sources = []
        potential_targets = []

        for volume in candidates:
            if volume['capacity'] > source_capacity:
                if volume['volumeCopyTarget'] is False:
                    if volume['volumeCopySource'] is False:
                        potential_targets.append(volume['id'])
            else:
                if volume['volumeCopyTarget'] is False:
                    if volume['volumeCopySource'] is False:
                        potential_sources.append(volume['id'])

        return potential_targets, potential_sources

    else:
        raise Exception("Response [%s]" % response_code)


def main():
    module = AnsibleModule(argument_spec=dict(
        source_volume_id=dict(type='str'),
        destination_volume_id=dict(type='str'),
        copy_priority=dict(required=False, default=0, type='int'),
        ssid=dict(required=True, type='str'),
        api_url=dict(required=True),
        api_username=dict(required=False),
        api_password=dict(required=False, no_log=True),
        validate_certs=dict(required=False, default=True),
        targetWriteProtected=dict(required=False, default=True, type='bool'),
        onlineCopy=dict(required=False, default=False, type='bool'),
        volume_copy_pair_id=dict(type='str'),
        status=dict(required=True, choices=['present', 'absent'], type='str'),
        create_copy_pair_if_does_not_exist=dict(required=False, default=True, type='bool'),
        start_stop_copy=dict(required=False, choices=['start', 'stop'], type='str'),
        search_volume_id=dict(type='str'),
    ),
        mutually_exclusive=[['volume_copy_pair_id', 'destination_volume_id'],
                            ['volume_copy_pair_id', 'source_volume_id'],
                            ['volume_copy_pair_id', 'search_volume_id'],
                            ['search_volume_id', 'destination_volume_id'],
                            ['search_volume_id', 'source_volume_id'],
                            ],
        required_together=[['source_volume_id', 'destination_volume_id'],
                           ],
        required_if=[["create_copy_pair_if_does_not_exist", True, ['source_volume_id', 'destination_volume_id'], ],
                     ["start_stop_copy", 'stop', ['volume_copy_pair_id'], ],
                     ["start_stop_copy", 'start', ['volume_copy_pair_id'], ],
                     ]

    )
    params = module.params

    if not params['api_url'].endswith('/'):
        params['api_url'] += '/'

    # Check if we want to search
    if params['search_volume_id'] is not None:
        try:
            potential_targets, potential_sources = find_valid_copy_pair_targets_and_sources(params)
        except:
            e = get_exception()
            module.fail_json(msg="Failed to find valid copy pair candidates. Error [%s]" % str(e))

        module.exit_json(changed=False,
                         msg=' Valid source devices found: %s Valid target devices found: %s' % (len(potential_sources), len(potential_targets)),
                         search_volume_id=params['search_volume_id'],
                         valid_targets=potential_targets,
                         valid_sources=potential_sources)

    # Check if we want to start or stop a copy operation
    if params['start_stop_copy'] == 'start' or params['start_stop_copy'] == 'stop':

        # Get the current status info
        currenty_running, status_info = check_copy_status(params)

        # If we want to start
        if params['start_stop_copy'] == 'start':

            # If we have already started
            if currenty_running is True:
                module.exit_json(changed=False, msg='Volume Copy Pair copy has started.',
                                 volume_copy_pair_id=params['volume_copy_pair_id'], percent_done=status_info)
            # If we need to start
            else:

                start_status, info = start_stop_copy(params)

                if start_status is True:
                    module.exit_json(changed=True, msg='Volume Copy Pair copy has started.',
                                     volume_copy_pair_id=params['volume_copy_pair_id'], percent_done=info)
                else:
                    module.fail_json(msg="Could not start volume copy pair Error: %s" % info)

        # If we want to stop
        else:
            # If it has already stopped
            if currenty_running is False:
                module.exit_json(changed=False, msg='Volume Copy Pair copy is stopped.',
                                 volume_copy_pair_id=params['volume_copy_pair_id'])

            # If we need to stop it
            else:
                start_status, info = start_stop_copy(params)

                if start_status is True:
                    module.exit_json(changed=True, msg='Volume Copy Pair copy has been stopped.',
                                     volume_copy_pair_id=params['volume_copy_pair_id'])
                else:
                    module.fail_json(msg="Could not stop volume copy pair Error: %s" % info)

    # If we want the copy pair to exist we do this stuff
    if params['status'] == 'present':

        # We need to check if it exists first
        if params['volume_copy_pair_id'] is None:
            params['volume_copy_pair_id'] = find_volume_copy_pair_id_from_source_volume_id_and_destination_volume_id(
                params)

        # If no volume copy pair is found we need need to make it.
        if params['volume_copy_pair_id'] is None:

            # In order to create we can not do so with just a volume_copy_pair_id

            copy_began_status, (rc, resp) = create_copy_pair(params)

            if copy_began_status is True:
                module.exit_json(changed=True, msg='Created Volume Copy Pair with ID: %s' % resp['id'])
            else:
                module.fail_json(msg="Could not create volume copy pair Code: %s Error: %s" % (rc, resp))

        # If it does exist we do nothing
        else:
            # We verify that it exists
            exist_status, (exist_status_code, exist_status_data) = find_volume_copy_pair_id_by_volume_copy_pair_id(
                params)

            if exist_status:
                module.exit_json(changed=False,
                                 msg=' Volume Copy Pair with ID: %s exists' % params['volume_copy_pair_id'])
            else:
                if exist_status_code == 404:
                    module.fail_json(
                        msg=' Volume Copy Pair with ID: %s does not exist. Can not create without source_volume_id and destination_volume_id' %
                            params['volume_copy_pair_id'])
                else:
                    module.fail_json(msg="Could not find volume copy pair Code: %s Error: %s" % (
                        exist_status_code, exist_status_data))

        module.fail_json(msg="Done")

    # If we want it to not exist we do this
    else:

        if params['volume_copy_pair_id'] is None:
            params['volume_copy_pair_id'] = find_volume_copy_pair_id_from_source_volume_id_and_destination_volume_id(
                params)

        # We delete it by the volume_copy_pair_id
        delete_status, (delete_status_code, delete_status_data) = delete_copy_pair_by_copy_pair_id(params)

        if delete_status is True:
            module.exit_json(changed=True,
                             msg=' Volume Copy Pair with ID: %s was deleted' % params['volume_copy_pair_id'])
        else:
            if delete_status_code == 404:
                module.exit_json(changed=False,
                                 msg=' Volume Copy Pair with ID: %s does not exist' % params['volume_copy_pair_id'])
            else:
                module.fail_json(msg="Could not delete volume copy pair Code: %s Error: %s" % (
                    delete_status_code, delete_status_data))


if __name__ == '__main__':
    main()

#   Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
#
# 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.

import paddle.fluid.core as core
import unittest
import numpy as np


class TestSelectedRows(unittest.TestCase):
    def test_selected_rows(self):
        place = core.CPUPlace()
        height = 10
        rows = [0, 4, 7]
        row_numel = 12
        selected_rows = core.SelectedRows(rows, height)
        np_array = np.ones((len(rows), row_numel)).astype("float32")
        np_array[0, 0] = 2.0
        np_array[2, 8] = 4.0
        tensor = selected_rows.get_tensor()
        tensor.set(np_array, place)

        # compare rows
        self.assertEqual(0, selected_rows.rows()[0])
        self.assertEqual(4, selected_rows.rows()[1])
        self.assertEqual(7, selected_rows.rows()[2])

        # compare height
        self.assertEqual(10, selected_rows.height())

        # compare tensor
        self.assertAlmostEqual(2.0,
                               selected_rows.get_tensor().get_float_element(0))
        self.assertAlmostEqual(1.0,
                               selected_rows.get_tensor().get_float_element(1))
        self.assertAlmostEqual(
            4.0,
            selected_rows.get_tensor().get_float_element(2 * row_numel + 8))


if __name__ == "__main__":
    unittest.main()

# This file is part of Invenio.
# Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2014 CERN.
#
# Invenio is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of the
# License, or (at your option) any later version.
#
# Invenio is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Invenio; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

__revision__ = "$Id$"

import re
import MySQLdb
import urllib

from six import iteritems

from invenio.base.globals import cfg
from invenio.config import \
     CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS, \
     CFG_CERN_SITE, \
     CFG_SITE_LANG, \
     CFG_SITE_SUPPORT_EMAIL, \
     CFG_SITE_ADMIN_EMAIL, \
     CFG_SITE_SECURE_URL, \
     CFG_VERSION, \
     CFG_SITE_RECORD
from invenio.modules.access.engine import acc_authorize_action
from invenio.modules.access.local_config import CFG_EXTERNAL_AUTHENTICATION, \
    SUPERADMINROLE, CFG_EXTERNAL_AUTH_DEFAULT
from invenio.legacy.dbquery import run_sql
from invenio.legacy.webuser import getUid, get_user_preferences, \
        collect_user_info
from invenio.modules.access.control import acc_find_user_role_actions
from invenio.base.i18n import gettext_set_language
from invenio.legacy.external_authentication import InvenioWebAccessExternalAuthError

import invenio.legacy.template
websession_templates = invenio.legacy.template.load('websession')

from invenio.modules import apikeys as web_api_key

def perform_info(req, ln):
    """Display the main features of CDS personalize"""
    uid = getUid(req)

    user_info = collect_user_info(req)
    return websession_templates.tmpl_account_info(
            ln = ln,
            uid = uid,
            guest = int(user_info['guest']),
            CFG_CERN_SITE = CFG_CERN_SITE,
           )

def perform_display_external_user_settings(settings, ln):
    """show external user settings which is a dictionary."""
    _ = gettext_set_language(ln)
    html_settings = ""
    print_settings = False
    settings_keys = settings.keys()
    settings_keys.sort()
    for key in settings_keys:
        value = settings[key]
        if key.startswith("EXTERNAL_") and not "HIDDEN_" in key:
            print_settings = True
            key = key[9:].capitalize()
            html_settings += websession_templates.tmpl_external_setting(ln, key, value)
    return print_settings and websession_templates.tmpl_external_user_settings(ln, html_settings) or ""

def perform_youradminactivities(user_info, ln):
    """Return text for the `Your Admin Activities' box.  Analyze
       whether user UID has some admin roles, and if yes, then print
       suitable links for the actions he can do.  If he's not admin,
       print a simple non-authorized message."""
    your_role_actions = acc_find_user_role_actions(user_info)
    your_roles = []
    your_admin_activities = []
    guest = int(user_info['guest'])
    for (role, action) in your_role_actions:
        if role not in your_roles:
            your_roles.append(role)
        if action not in your_admin_activities:
            your_admin_activities.append(action)

    if SUPERADMINROLE in your_roles:
        for action in ("runbibedit", "cfgbibformat", "cfgoaiharvest", "cfgoairepository", "cfgbibrank", "cfgbibindex", "cfgwebaccess", "cfgwebcomment", "cfgwebsearch", "cfgwebsubmiit", "cfgbibknowledge", "runbatchuploader"):
            if action not in your_admin_activities:
                your_admin_activities.append(action)

    return websession_templates.tmpl_account_adminactivities(
             ln = ln,
             uid = user_info['uid'],
             guest = guest,
             roles = your_roles,
             activities = your_admin_activities,
           )

def perform_display_account(req, username, bask, aler, sear, msgs, loan, grps, sbms, appr, admn, ln, comments):
    """Display a dynamic page that shows the user's account."""

    # load the right message language
    _ = gettext_set_language(ln)

    uid = getUid(req)
    user_info = collect_user_info(req)
    #your account
    if int(user_info['guest']):
        user = "guest"
        login = "%s/youraccount/login?ln=%s" % (CFG_SITE_SECURE_URL, ln)
        accBody = _("You are logged in as guest. You may want to %(x_url_open)slogin%(x_url_close)s as a regular user.") %\
            {'x_url_open': '<a href="' + login + '">',
             'x_url_close': '</a>'}
        accBody += "<br /><br />"
        bask=aler=msgs=comments= _("The %(x_fmt_open)sguest%(x_fmt_close)s users need to %(x_url_open)sregister%(x_url_close)s first") %\
            {'x_fmt_open': '<strong class="headline">',
             'x_fmt_close': '</strong>',
             'x_url_open': '<a href="' + login + '">',
             'x_url_close': '</a>'}
        sear= _("No queries found")
    else:
        user = username
        accBody = websession_templates.tmpl_account_body(
                    ln = ln,
                    user = user,
                  )

    #Display warnings if user is superuser
    roles = acc_find_user_role_actions(user_info)
    warnings = "0"
    warning_list = []
    for role in roles:
        if "superadmin" in role:
            warnings = "1"
            break

    if warnings == "1":
        warning_list.extend(superuser_account_warnings())

    # Display the warning if the email of the user is autogenerated
    email_autogenerated_warning = external_user_warning(uid)

    if email_autogenerated_warning:
        warnings = "1"
        warning_list.append(email_autogenerated_warning)

    #check if tickets ok
    tickets = (acc_authorize_action(user_info, 'runbibedit')[0] == 0)

    return websession_templates.tmpl_account_page(
             ln = ln,
             warnings = warnings,
             warning_list = warning_list,
             accBody = accBody,
             baskets = bask,
             alerts = aler,
             searches = sear,
             messages = msgs,
             loans = loan,
             groups = grps,
             submissions = sbms,
             approvals = appr,
             tickets = tickets,
             administrative = admn,
             comments = comments,
           )

def superuser_account_warnings():
    """Check to see whether admin accounts have default / blank password etc. Returns a list"""
    warning_array = []

    #Try and connect to the mysql database with the default invenio password
    try:
        conn = MySQLdb.connect (host = cfg['CFG_DATABASE_HOST'],
                                user = "root",
                                passwd = "my123p$ss",
                                db = "mysql")
        conn.close()
        warning_array.append("warning_mysql_password_equal_to_invenio_password")
    except:
        pass

    #Try and connect to the invenio database with the default invenio password
    try:
        conn = MySQLdb.connect (host = cfg['CFG_DATABASE_HOST'],
                                user = "invenio",
                                passwd = "my123p$ss",
                                db = cfg['CFG_DATABASE_NAME'])
        conn.close ()
        warning_array.append("warning_invenio_password_equal_to_default")
    except:
        pass

    #Check if the admin password is empty
    res = run_sql("SELECT password, email from user where nickname = 'admin'")
    if res:
        res1 = run_sql("SELECT email from user where nickname = 'admin' and password = AES_ENCRYPT(%s,'')", (res[0][1], ))
    else:
        # no account nick-named `admin' exists; keep on going
        res1 = []

    for user in res1:
        warning_array.append("warning_empty_admin_password")

    #Check if the admin email has been changed from the default
    if (CFG_SITE_ADMIN_EMAIL == "info@invenio-software.org" or CFG_SITE_SUPPORT_EMAIL == "info@invenio-software.org") and CFG_CERN_SITE == 0:
        warning_array.append("warning_site_support_email_equal_to_default")

    #Check for a new release of Invenio
    try:
        find = re.compile('Invenio v[0-9]+.[0-9]+.[0-9]+(\-rc[0-9])? is released')

        webFile = urllib.urlopen("http://invenio-software.org/repo/invenio/tree/RELEASE-NOTES")

        temp = ""
        version = ""
        version1 = ""
        while 1:
            temp = webFile.readline()
            match1 = find.match(temp)
            try:
                version = match1.group()
                break
            except:
                pass
            if not temp:
                break

        webFile.close()
        submatch = re.compile('[0-9]+.[0-9]+.[0-9]+(\-rc[0-9])?')
        version1 = submatch.search(version)
        web_version = version1.group().split(".")

        local_version = CFG_VERSION.split(".")

        if web_version[0] > local_version[0]:
            warning_array.append("note_new_release_available")
        elif web_version[0] == local_version[0] and web_version[1] > local_version[1]:
            warning_array.append("note_new_release_available")
        elif web_version[0] == local_version[0] and web_version[1] == local_version[1] and web_version[2] > local_version[2]:
            warning_array.append("note_new_release_available")
    except:
        warning_array.append("error_cannot_download_release_notes")

    return warning_array

def template_account(title, body, ln):
    """It is a template for print each of the options from the user's account."""
    return websession_templates.tmpl_account_template(
             ln = ln,
             title = title,
             body = body
           )

def warning_guest_user(type, ln=CFG_SITE_LANG):
    """It returns an alert message,showing that the user is a guest user and should log into the system."""

    # load the right message language
    _ = gettext_set_language(ln)

    return websession_templates.tmpl_warning_guest_user(
             ln = ln,
             type = type,
           )


def perform_delete(ln):
    """Delete  the account of the user, not implement yet."""
    # TODO
    return websession_templates.tmpl_account_delete(ln = ln)

def perform_set(email, ln, can_config_bibcatalog=False,
                can_config_profiling=False, verbose=0, csrf_token=''):
    """Perform_set(email,password): edit your account parameters, email and
    password.
    If can_config_bibcatalog is True, show the bibcatalog dialog (if configured).
    """

    try:
        res = run_sql("SELECT id, nickname FROM user WHERE email=%s", (email,))
        uid = res[0][0]
        nickname = res[0][1]
    except IndexError:
        uid = 0
        nickname = ""

    CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS_LOCAL = CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS
    prefs = get_user_preferences(uid)
    if prefs['login_method'] in CFG_EXTERNAL_AUTHENTICATION and CFG_EXTERNAL_AUTHENTICATION[prefs['login_method']] is not None:
        CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS_LOCAL = 3

    out = websession_templates.tmpl_user_preferences(
             ln = ln,
             email = email,
             email_disabled = (CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS_LOCAL >= 2),
             password_disabled = (CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS_LOCAL >= 3),
             nickname = nickname,
             csrf_token = csrf_token
           )
    if len(CFG_EXTERNAL_AUTHENTICATION) > 1:
        try:
            uid = run_sql("SELECT id FROM user where email=%s", (email,))
            uid = uid[0][0]
        except IndexError:
            uid = 0
        current_login_method = prefs['login_method']
        methods = CFG_EXTERNAL_AUTHENTICATION.keys()

        # Filtering out methods that don't provide user_exists to check if
        # a user exists in the external auth method before letting him/her
        # to switch.

        for method in methods:
            if CFG_EXTERNAL_AUTHENTICATION[method] is not None:
                try:
                    if not CFG_EXTERNAL_AUTHENTICATION[method].user_exists(email):
                        methods.remove(method)
                except (AttributeError, InvenioWebAccessExternalAuthError, NotImplementedError):
                    methods.remove(method)
        methods.sort()

        if len(methods) > 1:
            out += websession_templates.tmpl_user_external_auth(
                    ln = ln,
                    methods = methods,
                    current = current_login_method,
                    method_disabled = (CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS >= 4),
                    csrf_token = csrf_token,
                )

    current_group_records = prefs.get('websearch_group_records', 10)
    show_latestbox = prefs.get('websearch_latestbox', True)
    show_helpbox = prefs.get('websearch_helpbox', True)
    out += websession_templates.tmpl_user_websearch_edit(
                ln = ln,
                current = current_group_records,
                show_latestbox = show_latestbox,
                show_helpbox = show_helpbox,
                csrf_token = csrf_token,
                )

    preferred_lang = prefs.get('language', ln)
    out += websession_templates.tmpl_user_lang_edit(
                ln = ln,
                preferred_lang = preferred_lang,
                csrf_token = csrf_token,
                )

    keys_info = web_api_key.show_web_api_keys(uid=uid)
    out+=websession_templates.tmpl_user_api_key(
                ln = ln,
                keys_info = keys_info,
                csrf_token = csrf_token,
                )

    #show this dialog only if the system has been configured to use a ticket system
    from invenio.config import CFG_BIBCATALOG_SYSTEM
    if CFG_BIBCATALOG_SYSTEM and can_config_bibcatalog:
        bibcatalog_username = prefs.get('bibcatalog_username', "")
        bibcatalog_password = prefs.get('bibcatalog_password', "")
        out += websession_templates.tmpl_user_bibcatalog_auth(bibcatalog_username,
                                                              bibcatalog_password, ln=ln,
                                                              csrf_token=csrf_token)

    if can_config_profiling:
        out += websession_templates.tmpl_user_profiling_settings(ln=ln,
                                                                 enable_profiling=prefs.get('enable_profiling'),
                                                                 csrf_token=csrf_token)

    if verbose >= 9:
        for key, value in prefs.items():
            out += "<b>%s</b>:%s<br />" % (key, value)
    out += perform_display_external_user_settings(prefs, ln)
    return out

def create_register_page_box(referer='', ln=CFG_SITE_LANG):
    """Register a new account."""
    return websession_templates.tmpl_register_page(
             referer = referer,
             ln = ln,
             level = CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS,
           )

#  create_login_page_box(): ask for the user's email and password, for login into the system
def create_login_page_box(referer='', ln=CFG_SITE_LANG):
    # List of referer regexep and message to print

    _ = gettext_set_language(ln)

    login_referrer2msg = (
        (re.compile(r"/search"), "<p>" + _("This collection is restricted.  If you think you have right to access it, please authenticate yourself.") + "</p>"),
        (re.compile(r"/%s/\d+/files/.+" % CFG_SITE_RECORD), "<p>" + _("This file is restricted.  If you think you have right to access it, please authenticate yourself.") + "</p>"),
        (re.compile(r"openid-invalid"), "<p>" + _("The OpenID identifier is invalid") + "</p>"),
        (re.compile(r"openid-python"), "<p>%s</p><p>%s</p>" % (_("python-openid package must be installed: run make install-openid-package or download manually from https://github.com/openid/python-openid/"), _("Please inform the <a href='mailto%(x_email)s'>administator</a>", x_email=CFG_SITE_ADMIN_EMAIL))),
        (re.compile(r"oauth-rauth"), "<p>%s</p><p>%s</p>" % (_("rauth package must be installed: run make install-oauth-package or download manually from https://github.com/litl/rauth/"), _("Please inform the <a href='mailto%(x_email)s'>administator</a>", x_email=CFG_SITE_ADMIN_EMAIL))),
        (re.compile(r"oauth-config"), "<p>%s</p><p>%s</p>" % (_("The configuration isn't set properly"), _("Please inform the <a href='mailto%(x_email)s'>administator</a>", x_email=CFG_SITE_ADMIN_EMAIL))),
        (re.compile(r"connection-error"), "<p>%s</p>" % (_("Cannot connect the provider. Please try again later."))),
    )

    msg = ""
    for regexp, txt in login_referrer2msg:
        if regexp.search(referer):
            msg = txt
            break

    internal = None
    for system in CFG_EXTERNAL_AUTHENTICATION.keys():
        if CFG_EXTERNAL_AUTHENTICATION[system] is None:
            internal = system
            break
    register_available = CFG_ACCESS_CONTROL_LEVEL_ACCOUNTS <= 1 and internal
    ## Let's retrieve all the login method that are not dedicated to robots
    methods = [method[0] for method in iteritems(CFG_EXTERNAL_AUTHENTICATION) if not method[1] or not method[1].robot_login_method_p()]
    methods.sort()

    return websession_templates.tmpl_login_form(
             ln = ln,
             referer = referer,
             internal = internal,
             register_available = register_available,
             methods = methods,
             selected_method = CFG_EXTERNAL_AUTH_DEFAULT,
             msg = msg,
           )


# perform_logout: display the message of not longer authorized,
def perform_logout(req, ln):
    return websession_templates.tmpl_account_logout(ln = ln)

#def perform_lost: ask the user for his email, in order to send him the lost password
def perform_lost(ln):
    return websession_templates.tmpl_lost_password_form(ln)

#def perform_reset_password: ask the user for a new password to reset the lost one
def perform_reset_password(ln, email, reset_key, msg=''):
    return websession_templates.tmpl_reset_password_form(ln, email, reset_key, msg)

# perform_emailSent(email): confirm that the password has been emailed to 'email' address
def perform_emailSent(email, ln):
    return websession_templates.tmpl_account_emailSent(ln = ln, email = email)

# peform_emailMessage : display a error message when the email introduced is not correct, and sugest to try again
def perform_emailMessage(eMsg, ln):
    return websession_templates.tmpl_account_emailMessage( ln = ln,
                                           msg = eMsg
                                         )

# perform_back(): template for return to a previous page, used for login,register and setting
def perform_back(mess, url, linkname, ln='en'):
    return websession_templates.tmpl_back_form(
             ln = ln,
             message = mess,
             url = url,
             link = linkname,
           )

def external_user_warning(uid):
    """
    Returns 'email_auto_generated' if the email of the user is auto-generated.

    @param uid: user id
    @type uid: int

    @rtype: ''|'email_auto_generated'
    """
    from invenio.modules.access.local_config import CFG_TEMP_EMAIL_ADDRESS

    query = """
        SELECT      email
        FROM        user
        WHERE       id=%s
    """

    params = (uid, )
    email = run_sql(query, params)[0][0]

    regexp = re.compile(CFG_TEMP_EMAIL_ADDRESS % "\w+", re.IGNORECASE)

    query = """
        SELECT      *
        FROM        userEXT
        WHERE       id_user=%s
    """

    if run_sql(query, params) and re.match(regexp, email):
        return 'email_auto_generated'

    return ''

#!/usr/bin/env python
''' Sample externpasscheck script for use with voicemail.conf

Copyright (C) 2010, Digium, Inc.
Russell Bryant <russell@digium.com>

The externpasscheck option in voicemail.conf allows an external script to
validate passwords when a user is changing it.  The script can enforce password
strength rules.  This script is an example of doing so and implements a check
on password length, a password with too many identical consecutive numbers, or
a password made up of sequential digits.
'''

import sys
import re


# Set this to the required minimum length for a password
REQUIRED_LENGTH = 6


# Regular expressions that match against invalid passwords
REGEX_BLACKLIST = [
    ("(?P<digit>\d)(?P=digit){%d}" % (REQUIRED_LENGTH - 1),
        "%d consective numbers that are the same" % REQUIRED_LENGTH)
]


# Exact passwords that are forbidden.  If the string of digits specified here
# is found in any part of the password specified, it is considered invalid.
PW_BLACKLIST = [
    "123456",
    "234567",
    "345678",
    "456789",
    "567890",
    "098765",
    "987654",
    "876543",
    "765432",
    "654321"
]


mailbox, context, old_pw, new_pw = sys.argv[1:5]

# Enforce a password length of at least 6 characters
if len(new_pw) < REQUIRED_LENGTH:
    print "INVALID: Password is too short (%d) - must be at least %d" % \
            (len(new_pw), REQUIRED_LENGTH)
    sys.exit(0)

for regex, error in REGEX_BLACKLIST:
    if re.search(regex, new_pw):
        print "INVALID: %s" % error
        sys.exit(0)

for pw in PW_BLACKLIST:
    if new_pw.find(pw) != -1:
        print "INVALID: %s is forbidden in a password" % pw
        sys.exit(0)

print "VALID"

sys.exit(0)

#!/usr/bin/env python
#
# Copyright 2004,2007,2010,2011 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

from gnuradio import gr, gr_unittest
import math

class test_pll_freqdet (gr_unittest.TestCase):

    def setUp (self):
        self.tb = gr.top_block()

    def tearDown (self):
        self.tb = None

    def test_pll_freqdet (self):
        expected_result = (0.0,
                           4.33888922882e-08,
                           0.367369994515,
                           1.08135249597,
                           2.10983253908,
                           3.42221529438,
                           4.98940390402,
                           6.78379190842,
                           8.77923286024,
                           10.9510106794,
                           13.2758363182,
                           15.7317829127,
                           18.2982902299,
                           20.9561068599,
                           23.6755271122,
                           26.452952094,
                           29.2731265301,
                           32.1219053479,
                           34.9862418188,
                           37.8540971414,
                           40.7144315483,
                           43.5571390869,
                           46.3730179743,
                           49.1537231663,
                           51.8917218889,
                           54.58026103,
                           57.2015358514,
                           59.7513664199,
                           62.2380533124,
                           64.657612252,
                           67.006640002,
                           69.2822432184,
                           71.4820384499,
                           73.6041047056,
                           75.6469478817,
                           77.6094829742,
                           79.4909866472,
                           81.2911031615,
                           83.0097850853,
                           84.6355598352,
                           86.1820937186,
                           87.6504420946,
                           89.0418441206,
                           90.3577286819,
                           91.5996432431,
                           92.7692775646,
                           93.8684162704,
                           94.8989269904,
                           95.8627662892,
                           96.7619381633,
                           97.598505899,
                           98.362769679,
                           99.0579904444,
                           99.6992633875,
                           100.288805948,
                           100.828805921,
                           101.321421457,
                           101.76878699,
                           102.17300138,
                           102.536116055,
                           102.860158727,
                           103.147085962,
                           103.398830608,
                           103.617254366,
                           103.792467691,
                           103.939387906,
                           104.060030865,
                           104.15631756,
                           104.230085975,
                           104.283067372,
                           104.316933727,
                           104.333238432,
                           104.333440018,
                           104.318914008,
                           104.290941063,
                           104.250742554,
                           104.187634452,
                           104.103822339,
                           104.013227468,
                           103.916810336,
                           103.815448432,
                           103.709936239,
                           103.600997093,
                           103.489283183,
                           103.375351833,
                           103.259712936,
                           103.142828952,
                           103.025091195,
                           102.90686726,
                           102.776726069,
                           102.648078982,
                           102.521459607,
                           102.397294831,
                           102.275999684,
                           102.157882471,
                           102.043215927,
                           101.93218978,
                           101.824958181,
                           101.72159228,
                           101.622151366)

        sampling_freq = 10e3
        freq = sampling_freq / 100

        loop_bw = math.pi/100.0
        maxf = 1
        minf = -1

        src = gr.sig_source_c (sampling_freq, gr.GR_COS_WAVE, freq, 1.0)
        pll = gr.pll_freqdet_cf(loop_bw, maxf, minf)
        head = gr.head (gr.sizeof_float, int (freq))
        dst = gr.vector_sink_f ()

        self.tb.connect (src, pll, head)
        self.tb.connect (head, dst)

        self.tb.run ()
        dst_data = dst.data ()

        # convert it from normalized frequency to absolute frequency (Hz)
        dst_data = [i*(sampling_freq/(2*math.pi)) for i in dst_data]

        self.assertFloatTuplesAlmostEqual (expected_result, dst_data, 3)

if __name__ == '__main__':
    gr_unittest.run(test_pll_freqdet, "test_pll_freqdet.xml")

"""Pythonic command-line interface parser that will make you smile.

 * http://docopt.org
 * Repository and issue-tracker: https://github.com/docopt/docopt
 * Licensed under terms of MIT license (see LICENSE-MIT)
 * Copyright (c) 2013 Vladimir Keleshev, vladimir@keleshev.com

"""
import sys
import re


__all__ = ['docopt']
__version__ = '0.6.2'


class DocoptLanguageError(Exception):

    """Error in construction of usage-message by developer."""


class DocoptExit(SystemExit):

    """Exit in case user invoked program with incorrect arguments."""

    usage = ''

    def __init__(self, message=''):
        SystemExit.__init__(self, (message + '\n' + self.usage).strip())


class Pattern(object):

    def __eq__(self, other):
        return repr(self) == repr(other)

    def __hash__(self):
        return hash(repr(self))

    def fix(self):
        self.fix_identities()
        self.fix_repeating_arguments()
        return self

    def fix_identities(self, uniq=None):
        """Make pattern-tree tips point to same object if they are equal."""
        if not hasattr(self, 'children'):
            return self
        uniq = list(set(self.flat())) if uniq is None else uniq
        for i, c in enumerate(self.children):
            if not hasattr(c, 'children'):
                assert c in uniq
                self.children[i] = uniq[uniq.index(c)]
            else:
                c.fix_identities(uniq)

    def fix_repeating_arguments(self):
        """Fix elements that should accumulate/increment values."""
        either = [list(c.children) for c in self.either.children]
        for case in either:
            for e in [c for c in case if case.count(c) > 1]:
                if type(e) is Argument or type(e) is Option and e.argcount:
                    if e.value is None:
                        e.value = []
                    elif type(e.value) is not list:
                        e.value = e.value.split()
                if type(e) is Command or type(e) is Option and e.argcount == 0:
                    e.value = 0
        return self

    @property
    def either(self):
        """Transform pattern into an equivalent, with only top-level Either."""
        # Currently the pattern will not be equivalent, but more "narrow",
        # although good enough to reason about list arguments.
        ret = []
        groups = [[self]]
        while groups:
            children = groups.pop(0)
            types = [type(c) for c in children]
            if Either in types:
                either = [c for c in children if type(c) is Either][0]
                children.pop(children.index(either))
                for c in either.children:
                    groups.append([c] + children)
            elif Required in types:
                required = [c for c in children if type(c) is Required][0]
                children.pop(children.index(required))
                groups.append(list(required.children) + children)
            elif Optional in types:
                optional = [c for c in children if type(c) is Optional][0]
                children.pop(children.index(optional))
                groups.append(list(optional.children) + children)
            elif AnyOptions in types:
                optional = [c for c in children if type(c) is AnyOptions][0]
                children.pop(children.index(optional))
                groups.append(list(optional.children) + children)
            elif OneOrMore in types:
                oneormore = [c for c in children if type(c) is OneOrMore][0]
                children.pop(children.index(oneormore))
                groups.append(list(oneormore.children) * 2 + children)
            else:
                ret.append(children)
        return Either(*[Required(*e) for e in ret])


class ChildPattern(Pattern):

    def __init__(self, name, value=None):
        self.name = name
        self.value = value

    def __repr__(self):
        return '%s(%r, %r)' % (self.__class__.__name__, self.name, self.value)

    def flat(self, *types):
        return [self] if not types or type(self) in types else []

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        pos, match = self.single_match(left)
        if match is None:
            return False, left, collected
        left_ = left[:pos] + left[pos + 1:]
        same_name = [a for a in collected if a.name == self.name]
        if type(self.value) in (int, list):
            if type(self.value) is int:
                increment = 1
            else:
                increment = ([match.value] if type(match.value) is str
                             else match.value)
            if not same_name:
                match.value = increment
                return True, left_, collected + [match]
            same_name[0].value += increment
            return True, left_, collected
        return True, left_, collected + [match]


class ParentPattern(Pattern):

    def __init__(self, *children):
        self.children = list(children)

    def __repr__(self):
        return '%s(%s)' % (self.__class__.__name__,
                           ', '.join(repr(a) for a in self.children))

    def flat(self, *types):
        if type(self) in types:
            return [self]
        return sum([c.flat(*types) for c in self.children], [])


class Argument(ChildPattern):

    def single_match(self, left):
        for n, p in enumerate(left):
            if type(p) is Argument:
                return n, Argument(self.name, p.value)
        return None, None

    @classmethod
    def parse(cls, source):
        name = re.findall('(<\S*?>)', source)[0]
        value = re.findall('\[default: (.*)\]', source, flags=re.I)
        return cls(name, value[0] if value else None)


class Command(Argument):

    def __init__(self, name, value=False):
        self.name = name
        self.value = value

    def single_match(self, left):
        for n, p in enumerate(left):
            if type(p) is Argument:
                if p.value == self.name:
                    return n, Command(self.name, True)
                else:
                    break
        return None, None


class Option(ChildPattern):

    def __init__(self, short=None, long=None, argcount=0, value=False):
        assert argcount in (0, 1)
        self.short, self.long = short, long
        self.argcount, self.value = argcount, value
        self.value = None if value is False and argcount else value

    @classmethod
    def parse(cls, option_description):
        short, long, argcount, value = None, None, 0, False
        options, _, description = option_description.strip().partition('  ')
        options = options.replace(',', ' ').replace('=', ' ')
        for s in options.split():
            if s.startswith('--'):
                long = s
            elif s.startswith('-'):
                short = s
            else:
                argcount = 1
        if argcount:
            matched = re.findall('\[default: (.*)\]', description, flags=re.I)
            value = matched[0] if matched else None
        return cls(short, long, argcount, value)

    def single_match(self, left):
        for n, p in enumerate(left):
            if self.name == p.name:
                return n, p
        return None, None

    @property
    def name(self):
        return self.long or self.short

    def __repr__(self):
        return 'Option(%r, %r, %r, %r)' % (self.short, self.long,
                                           self.argcount, self.value)


class Required(ParentPattern):

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        l = left
        c = collected
        for p in self.children:
            matched, l, c = p.match(l, c)
            if not matched:
                return False, left, collected
        return True, l, c


class Optional(ParentPattern):

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        for p in self.children:
            m, left, collected = p.match(left, collected)
        return True, left, collected


class AnyOptions(Optional):

    """Marker/placeholder for [options] shortcut."""


class OneOrMore(ParentPattern):

    def match(self, left, collected=None):
        assert len(self.children) == 1
        collected = [] if collected is None else collected
        l = left
        c = collected
        l_ = None
        matched = True
        times = 0
        while matched:
            # could it be that something didn't match but changed l or c?
            matched, l, c = self.children[0].match(l, c)
            times += 1 if matched else 0
            if l_ == l:
                break
            l_ = l
        if times >= 1:
            return True, l, c
        return False, left, collected


class Either(ParentPattern):

    def match(self, left, collected=None):
        collected = [] if collected is None else collected
        outcomes = []
        for p in self.children:
            matched, _, _ = outcome = p.match(left, collected)
            if matched:
                outcomes.append(outcome)
        if outcomes:
            return min(outcomes, key=lambda outcome: len(outcome[1]))
        return False, left, collected


class TokenStream(list):

    def __init__(self, source, error):
        self += source.split() if hasattr(source, 'split') else source
        self.error = error

    def move(self):
        return self.pop(0) if len(self) else None

    def current(self):
        return self[0] if len(self) else None


def parse_long(tokens, options):
    """long ::= '--' chars [ ( ' ' | '=' ) chars ] ;"""
    long, eq, value = tokens.move().partition('=')
    assert long.startswith('--')
    value = None if eq == value == '' else value
    similar = [o for o in options if o.long == long]
    if tokens.error is DocoptExit and similar == []:  # if no exact match
        similar = [o for o in options if o.long and o.long.startswith(long)]
    if len(similar) > 1:  # might be simply specified ambiguously 2+ times?
        raise tokens.error('%s is not a unique prefix: %s?' %
                           (long, ', '.join(o.long for o in similar)))
    elif len(similar) < 1:
        argcount = 1 if eq == '=' else 0
        o = Option(None, long, argcount)
        options.append(o)
        if tokens.error is DocoptExit:
            o = Option(None, long, argcount, value if argcount else True)
    else:
        o = Option(similar[0].short, similar[0].long,
                   similar[0].argcount, similar[0].value)
        if o.argcount == 0:
            if value is not None:
                raise tokens.error('%s must not have an argument' % o.long)
        else:
            if value is None:
                if tokens.current() is None:
                    raise tokens.error('%s requires argument' % o.long)
                value = tokens.move()
        if tokens.error is DocoptExit:
            o.value = value if value is not None else True
    return [o]


def parse_shorts(tokens, options):
    """shorts ::= '-' ( chars )* [ [ ' ' ] chars ] ;"""
    token = tokens.move()
    assert token.startswith('-') and not token.startswith('--')
    left = token.lstrip('-')
    parsed = []
    while left != '':
        short, left = '-' + left[0], left[1:]
        similar = [o for o in options if o.short == short]
        if len(similar) > 1:
            raise tokens.error('%s is specified ambiguously %d times' %
                               (short, len(similar)))
        elif len(similar) < 1:
            o = Option(short, None, 0)
            options.append(o)
            if tokens.error is DocoptExit:
                o = Option(short, None, 0, True)
        else:  # why copying is necessary here?
            o = Option(short, similar[0].long,
                       similar[0].argcount, similar[0].value)
            value = None
            if o.argcount != 0:
                if left == '':
                    if tokens.current() is None:
                        raise tokens.error('%s requires argument' % short)
                    value = tokens.move()
                else:
                    value = left
                    left = ''
            if tokens.error is DocoptExit:
                o.value = value if value is not None else True
        parsed.append(o)
    return parsed


def parse_pattern(source, options):
    tokens = TokenStream(re.sub(r'([\[\]\(\)\|]|\.\.\.)', r' \1 ', source),
                         DocoptLanguageError)
    result = parse_expr(tokens, options)
    if tokens.current() is not None:
        raise tokens.error('unexpected ending: %r' % ' '.join(tokens))
    return Required(*result)


def parse_expr(tokens, options):
    """expr ::= seq ( '|' seq )* ;"""
    seq = parse_seq(tokens, options)
    if tokens.current() != '|':
        return seq
    result = [Required(*seq)] if len(seq) > 1 else seq
    while tokens.current() == '|':
        tokens.move()
        seq = parse_seq(tokens, options)
        result += [Required(*seq)] if len(seq) > 1 else seq
    return [Either(*result)] if len(result) > 1 else result


def parse_seq(tokens, options):
    """seq ::= ( atom [ '...' ] )* ;"""
    result = []
    while tokens.current() not in [None, ']', ')', '|']:
        atom = parse_atom(tokens, options)
        if tokens.current() == '...':
            atom = [OneOrMore(*atom)]
            tokens.move()
        result += atom
    return result


def parse_atom(tokens, options):
    """atom ::= '(' expr ')' | '[' expr ']' | 'options'
             | long | shorts | argument | command ;
    """
    token = tokens.current()
    result = []
    if token in '([':
        tokens.move()
        matching, pattern = {'(': [')', Required], '[': [']', Optional]}[token]
        result = pattern(*parse_expr(tokens, options))
        if tokens.move() != matching:
            raise tokens.error("unmatched '%s'" % token)
        return [result]
    elif token == 'options':
        tokens.move()
        return [AnyOptions()]
    elif token.startswith('--') and token != '--':
        return parse_long(tokens, options)
    elif token.startswith('-') and token not in ('-', '--'):
        return parse_shorts(tokens, options)
    elif token.startswith('<') and token.endswith('>') or token.isupper():
        return [Argument(tokens.move())]
    else:
        return [Command(tokens.move())]


def parse_argv(tokens, options, options_first=False):
    """Parse command-line argument vector.

    If options_first:
        argv ::= [ long | shorts ]* [ argument ]* [ '--' [ argument ]* ] ;
    else:
        argv ::= [ long | shorts | argument ]* [ '--' [ argument ]* ] ;

    """
    parsed = []
    while tokens.current() is not None:
        if tokens.current() == '--':
            return parsed + [Argument(None, v) for v in tokens]
        elif tokens.current().startswith('--'):
            parsed += parse_long(tokens, options)
        elif tokens.current().startswith('-') and tokens.current() != '-':
            parsed += parse_shorts(tokens, options)
        elif options_first:
            return parsed + [Argument(None, v) for v in tokens]
        else:
            parsed.append(Argument(None, tokens.move()))
    return parsed


def parse_defaults(doc):
    # in python < 2.7 you can't pass flags=re.MULTILINE
    split = re.split('\n *(<\S+?>|-\S+?)', doc)[1:]
    split = [s1 + s2 for s1, s2 in zip(split[::2], split[1::2])]
    options = [Option.parse(s) for s in split if s.startswith('-')]
    #arguments = [Argument.parse(s) for s in split if s.startswith('<')]
    #return options, arguments
    return options


def printable_usage(doc):
    # in python < 2.7 you can't pass flags=re.IGNORECASE
    usage_split = re.split(r'([Uu][Ss][Aa][Gg][Ee]:)', doc)
    if len(usage_split) < 3:
        raise DocoptLanguageError('"usage:" (case-insensitive) not found.')
    if len(usage_split) > 3:
        raise DocoptLanguageError('More than one "usage:" (case-insensitive).')
    return re.split(r'\n\s*\n', ''.join(usage_split[1:]))[0].strip()


def formal_usage(printable_usage):
    pu = printable_usage.split()[1:]  # split and drop "usage:"
    return '( ' + ' '.join(') | (' if s == pu[0] else s for s in pu[1:]) + ' )'


def extras(help, version, options, doc):
    if help and any((o.name in ('-h', '--help')) and o.value for o in options):
        print(doc.strip("\n"))
        sys.exit()
    if version and any(o.name == '--version' and o.value for o in options):
        print(version)
        sys.exit()


class Dict(dict):
    def __repr__(self):
        return '{%s}' % ',\n '.join('%r: %r' % i for i in sorted(self.items()))


def docopt(doc, argv=None, help=True, version=None, options_first=False):
    """Parse `argv` based on command-line interface described in `doc`.

    `docopt` creates your command-line interface based on its
    description that you pass as `doc`. Such description can contain
    --options, <positional-argument>, commands, which could be
    [optional], (required), (mutually | exclusive) or repeated...

    Parameters
    ----------
    doc : str
        Description of your command-line interface.
    argv : list of str, optional
        Argument vector to be parsed. sys.argv[1:] is used if not
        provided.
    help : bool (default: True)
        Set to False to disable automatic help on -h or --help
        options.
    version : any object
        If passed, the object will be printed if --version is in
        `argv`.
    options_first : bool (default: False)
        Set to True to require options preceed positional arguments,
        i.e. to forbid options and positional arguments intermix.

    Returns
    -------
    args : dict
        A dictionary, where keys are names of command-line elements
        such as e.g. "--verbose" and "<path>", and values are the
        parsed values of those elements.

    Example
    -------
    >>> from docopt import docopt
    >>> doc = '''
    Usage:
        my_program tcp <host> <port> [--timeout=<seconds>]
        my_program serial <port> [--baud=<n>] [--timeout=<seconds>]
        my_program (-h | --help | --version)

    Options:
        -h, --help  Show this screen and exit.
        --baud=<n>  Baudrate [default: 9600]
    '''
    >>> argv = ['tcp', '127.0.0.1', '80', '--timeout', '30']
    >>> docopt(doc, argv)
    {'--baud': '9600',
     '--help': False,
     '--timeout': '30',
     '--version': False,
     '<host>': '127.0.0.1',
     '<port>': '80',
     'serial': False,
     'tcp': True}

    See also
    --------
    * For video introduction see http://docopt.org
    * Full documentation is available in README.rst as well as online
      at https://github.com/docopt/docopt#readme

    """
    if argv is None:
        argv = sys.argv[1:]
    DocoptExit.usage = printable_usage(doc)
    options = parse_defaults(doc)
    pattern = parse_pattern(formal_usage(DocoptExit.usage), options)
    # [default] syntax for argument is disabled
    #for a in pattern.flat(Argument):
    #    same_name = [d for d in arguments if d.name == a.name]
    #    if same_name:
    #        a.value = same_name[0].value
    argv = parse_argv(TokenStream(argv, DocoptExit), list(options),
                      options_first)
    pattern_options = set(pattern.flat(Option))
    for ao in pattern.flat(AnyOptions):
        doc_options = parse_defaults(doc)
        ao.children = list(set(doc_options) - pattern_options)
        #if any_options:
        #    ao.children += [Option(o.short, o.long, o.argcount)
        #                    for o in argv if type(o) is Option]
    extras(help, version, argv, doc)
    matched, left, collected = pattern.fix().match(argv)
    if matched and left == []:  # better error message if left?
        return Dict((a.name, a.value) for a in (pattern.flat() + collected))
    raise DocoptExit()

# Copyright 2020 Tensorforce Team. All Rights Reserved.
#
# 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.
# ==============================================================================

import unittest

from tensorforce import Agent, Environment, Runner

from test.unittest_base import UnittestBase


class TestDocumentation(UnittestBase, unittest.TestCase):

    def test_environment(self):
        self.start_tests(name='getting-started-environment')

        environment = Environment.create(
            environment='gym', level='CartPole', max_episode_timesteps=50
        )
        self.finished_test()

        environment = Environment.create(environment='gym', level='CartPole-v1')
        self.finished_test()

        environment = Environment.create(
            environment='test/data/environment.json', max_episode_timesteps=50
        )
        self.finished_test()

        environment = Environment.create(
            environment='test.data.custom_env', max_episode_timesteps=10
        )
        self.finished_test()

        from test.data.custom_env import CustomEnvironment
        environment = Environment.create(
            environment=CustomEnvironment, max_episode_timesteps=10
        )
        self.finished_test()

    def test_agent(self):
        self.start_tests(name='getting-started-agent')

        environment = Environment.create(
            environment='gym', level='CartPole', max_episode_timesteps=50
        )
        self.finished_test()

        agent = Agent.create(
            agent='tensorforce', environment=environment, update=64,
            optimizer=dict(optimizer='adam', learning_rate=1e-3),
            objective='policy_gradient', reward_estimation=dict(horizon=20)
        )
        self.finished_test()

        agent = Agent.create(
            agent='ppo', environment=environment, batch_size=10, learning_rate=1e-3
        )
        self.finished_test()

        agent = Agent.create(agent='test/data/agent.json', environment=environment)
        self.finished_test()

    def test_execution(self):
        self.start_tests(name='getting-started-execution')

        runner = Runner(
            agent='test/data/agent.json', environment=dict(environment='gym', level='CartPole'),
            max_episode_timesteps=10
        )
        runner.run(num_episodes=10)
        runner.run(num_episodes=5, evaluation=True)
        runner.close()
        self.finished_test()

        runner = Runner(
            agent='test/data/agent.json', environment=dict(environment='gym', level='CartPole'),
            max_episode_timesteps=50, num_parallel=5, remote='multiprocessing'
        )
        runner.run(num_episodes=10)
        runner.close()
        self.finished_test()

        # Create agent and environment
        environment = Environment.create(
            environment='test/data/environment.json', max_episode_timesteps=10
        )
        agent = Agent.create(agent='test/data/agent.json', environment=environment)

        # Train for 100 episodes
        for _ in range(10):
            states = environment.reset()
            terminal = False
            while not terminal:
                actions = agent.act(states=states)
                states, terminal, reward = environment.execute(actions=actions)
                agent.observe(terminal=terminal, reward=reward)

        # Train for 100 episodes
        for _ in range(10):
            episode_states = list()
            episode_internals = list()
            episode_actions = list()
            episode_terminal = list()
            episode_reward = list()

            states = environment.reset()
            internals = agent.initial_internals()
            terminal = False
            while not terminal:
                episode_states.append(states)
                episode_internals.append(internals)
                actions, internals = agent.act(states=states, internals=internals, independent=True)
                episode_actions.append(actions)
                states, terminal, reward = environment.execute(actions=actions)
                episode_terminal.append(terminal)
                episode_reward.append(reward)

            agent.experience(
                states=episode_states, internals=episode_internals, actions=episode_actions,
                terminal=episode_terminal, reward=episode_reward
            )
            agent.update()

        # Evaluate for 100 episodes
        sum_rewards = 0.0
        for _ in range(10):
            states = environment.reset()
            internals = agent.initial_internals()
            terminal = False
            while not terminal:
                actions, internals = agent.act(
                    states=states, internals=internals,
                    deterministic=True, independent=True
                )
                states, terminal, reward = environment.execute(actions=actions)
                sum_rewards += reward

        print('Mean episode reward:', sum_rewards / 100)

        # Close agent and environment
        agent.close()
        environment.close()

        self.finished_test()

    def test_readme(self):
        self.start_tests(name='readme')

        # ====================

        from tensorforce import Agent, Environment

        # Pre-defined or custom environment
        environment = Environment.create(
            environment='gym', level='CartPole', max_episode_timesteps=500
        )

        # Instantiate a Tensorforce agent
        agent = Agent.create(
            agent='tensorforce',
            environment=environment,  # alternatively: states, actions, (max_episode_timesteps)
            memory=1000,
            update=dict(unit='timesteps', batch_size=64),
            optimizer=dict(type='adam', learning_rate=3e-4),
            policy=dict(network='auto'),
            objective='policy_gradient',
            reward_estimation=dict(horizon=20)
        )

        # Train for 300 episodes
        for _ in range(1):

            # Initialize episode
            states = environment.reset()
            terminal = False

            while not terminal:
                # Episode timestep
                actions = agent.act(states=states)
                states, terminal, reward = environment.execute(actions=actions)
                agent.observe(terminal=terminal, reward=reward)

        agent.close()
        environment.close()

        # ====================

        self.finished_test()

    def test_modules(self):
        self.start_tests(name='modules')

        # distributions
        self.unittest(
            policy=dict(distributions=dict(
                float=dict(type='gaussian', stddev_mode='global'),
                bounded_action=dict(type='beta')
            ))
        )

        # layers
        import tensorflow as tf
        self.unittest(
            states=dict(type='float', shape=(2,), min_value=-1.0, max_value=2.0),
            policy=dict(network=[
                (lambda x: tf.clip_by_value(x, -1.0, 1.0)),
                dict(type='dense', size=8, activation='tanh')
            ])
        )

        # memories
        self.unittest(
            memory=100
        )

        # networks
        self.unittest(
            states=dict(type='float', shape=(2,), min_value=1.0, max_value=2.0),
            policy=dict(network=[
                dict(type='dense', size=8, activation='tanh'),
                dict(type='dense', size=8, activation='tanh')
            ])
        )
        self.unittest(
            states=dict(
                observation=dict(type='float', shape=(4, 4, 3), min_value=-1.0, max_value=1.0),
                attributes=dict(type='int', shape=(4, 2), num_values=5)
            ),
            policy=[
                [
                    dict(type='retrieve', tensors=['observation']),
                    dict(type='conv2d', size=8),
                    dict(type='flatten'),
                    dict(type='register', tensor='obs-embedding')
                ],
                [
                    dict(type='retrieve', tensors=['attributes']),
                    dict(type='embedding', size=8),
                    dict(type='flatten'),
                    dict(type='register', tensor='attr-embedding')
                ],
                [
                    dict(
                        type='retrieve', tensors=['obs-embedding', 'attr-embedding'],
                        aggregation='concat'
                    ),
                    dict(type='dense', size=16)
                ]
            ]
        )

        # optimizers
        self.unittest(
            optimizer=dict(
                optimizer='adam', learning_rate=1e-3, clipping_threshold=1e-2,
                multi_step=3, subsampling_fraction=8, linesearch_iterations=3,
                doublecheck_update=True
            )
        )

        # parameters
        self.unittest(
            exploration=0.1
        )
        self.unittest(
            optimizer=dict(optimizer='adam', learning_rate=dict(
                type='exponential', unit='timesteps', num_steps=2,
                initial_value=0.01, decay_rate=0.5
            ))
        )
        self.unittest(
            reward_estimation=dict(horizon=dict(
                type='linear', unit='episodes', num_steps=2,
                initial_value=2, final_value=6
            ))
        )

        # preprocessing
        self.unittest(
            states=dict(type='float', shape=(8, 8, 3), min_value=-1.0, max_value=2.0),
            state_preprocessing=[
                dict(type='image', height=4, width=4, grayscale=True),
                dict(type='exponential_normalization', decay=0.999)
            ],
            reward_preprocessing=dict(type='clipping', lower=-1.0, upper=1.0)
        )

        # policy
        self.unittest(
            states=dict(type='float', shape=(2,), min_value=-1.0, max_value=2.0),
            policy=[
                dict(type='dense', size=8, activation='tanh'),
                dict(type='dense', size=8, activation='tanh')
            ]
        )
        self.unittest(
            states=dict(type='float', shape=(2,), min_value=-1.0, max_value=2.0),
            policy=dict(network='auto')
        )
        self.unittest(
            states=dict(type='float', shape=(2,), min_value=-1.0, max_value=2.0),
            policy=dict(
                type='parametrized_distributions',
                network=[
                    dict(type='dense', size=8, activation='tanh'),
                    dict(type='dense', size=8, activation='tanh')
                ],
                distributions=dict(
                    float=dict(type='gaussian', stddev_mode='global'),
                    bounded_action=dict(type='beta')
                ),
                temperature=dict(
                    type='decaying', decay='exponential', unit='episodes',
                    num_steps=2, initial_value=0.01, decay_rate=0.5
                )
            )
        )
        self.unittest(
            states=dict(type='float', shape=(2,), min_value=-1.0, max_value=2.0),
            actions=dict(
                action1=dict(type='int', shape=(), num_values=5),
                action2=dict(type='float', shape=(), min_value=-1.0, max_value=1.0)
            ),
            policy=dict(
                type='parametrized_distributions',
                network=[
                    dict(type='dense', size=64),
                    dict(type='register', tensor='action1-embedding'),
                    dict(type='dense', size=64)
                    # Final output implicitly used for remaining actions
                ],
                single_output=False
            )
        )

    def test_masking(self):
        self.start_tests(name='masking')

        agent, environment = self.prepare(
            states=dict(type='float', shape=(10,), min_value=-1.0, max_value=2.0),
            actions=dict(type='int', shape=(), num_values=3)
        )
        states = environment.reset()
        assert 'state' in states and 'action_mask' in states
        states['action_mask'] = [True, False, True]

        action = agent.act(states=states)
        assert action != 1

        agent.close()
        environment.close()
        self.finished_test()

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.

import unittest

import pytest
from parameterized import parameterized

from airflow.models.dag import DAG
from airflow.operators.generic_transfer import GenericTransfer
from airflow.providers.mysql.hooks.mysql import MySqlHook
from airflow.providers.postgres.hooks.postgres import PostgresHook
from airflow.utils import timezone
from tests.providers.mysql.hooks.test_mysql import MySqlContext

DEFAULT_DATE = timezone.datetime(2015, 1, 1)
DEFAULT_DATE_ISO = DEFAULT_DATE.isoformat()
DEFAULT_DATE_DS = DEFAULT_DATE_ISO[:10]
TEST_DAG_ID = 'unit_test_dag'


@pytest.mark.backend("mysql")
class TestMySql(unittest.TestCase):
    def setUp(self):
        args = {'owner': 'airflow', 'start_date': DEFAULT_DATE}
        dag = DAG(TEST_DAG_ID, default_args=args)
        self.dag = dag

    def tearDown(self):
        drop_tables = {'test_mysql_to_mysql', 'test_airflow'}
        with MySqlHook().get_conn() as conn:
            for table in drop_tables:
                conn.execute(f"DROP TABLE IF EXISTS {table}")

    @parameterized.expand(
        [
            ("mysqlclient",),
            ("mysql-connector-python",),
        ]
    )
    def test_mysql_to_mysql(self, client):
        with MySqlContext(client):
            sql = "SELECT * FROM connection;"
            op = GenericTransfer(
                task_id='test_m2m',
                preoperator=[
                    "DROP TABLE IF EXISTS test_mysql_to_mysql",
                    "CREATE TABLE IF NOT EXISTS test_mysql_to_mysql LIKE connection",
                ],
                source_conn_id='airflow_db',
                destination_conn_id='airflow_db',
                destination_table="test_mysql_to_mysql",
                sql=sql,
                dag=self.dag,
            )
            op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)


@pytest.mark.backend("postgres")
class TestPostgres(unittest.TestCase):
    def setUp(self):
        args = {'owner': 'airflow', 'start_date': DEFAULT_DATE}
        dag = DAG(TEST_DAG_ID, default_args=args)
        self.dag = dag

    def tearDown(self):
        tables_to_drop = ['test_postgres_to_postgres', 'test_airflow']
        with PostgresHook().get_conn() as conn:
            with conn.cursor() as cur:
                for table in tables_to_drop:
                    cur.execute(f"DROP TABLE IF EXISTS {table}")

    def test_postgres_to_postgres(self):
        sql = "SELECT * FROM INFORMATION_SCHEMA.TABLES LIMIT 100;"
        op = GenericTransfer(
            task_id='test_p2p',
            preoperator=[
                "DROP TABLE IF EXISTS test_postgres_to_postgres",
                "CREATE TABLE IF NOT EXISTS test_postgres_to_postgres (LIKE INFORMATION_SCHEMA.TABLES)",
            ],
            source_conn_id='postgres_default',
            destination_conn_id='postgres_default',
            destination_table="test_postgres_to_postgres",
            sql=sql,
            dag=self.dag,
        )
        op.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)

# Copyright: (c) 2017, Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

from ansible.plugins.action import ActionBase


class ActionModule(ActionBase):

    def run(self, tmp=None, task_vars=None):
        del tmp  # tmp no longer has any effect

        try:
            self._task.args['_raw_params'] = self._task.args.pop('cmd')
        except KeyError:
            pass
        shell_action = self._shared_loader_obj.action_loader.get('ansible.legacy.shell',
                                                                 task=self._task,
                                                                 connection=self._connection,
                                                                 play_context=self._play_context,
                                                                 loader=self._loader,
                                                                 templar=self._templar,
                                                                 shared_loader_obj=self._shared_loader_obj)
        result = shell_action.run(task_vars=task_vars)
        result.pop('failed', None)
        return result

from pymavlink import mavutil

from dronekit import connect
from dronekit.test import with_sitl

from dronekit.test.sitl import assert_command_ack


@with_sitl
def test_gyro_calibration(connpath):
    """Request gyroscope calibration, and check for the COMMAND_ACK."""

    vehicle = connect(connpath, wait_ready=True)

    with assert_command_ack(vehicle, mavutil.mavlink.MAV_CMD_PREFLIGHT_CALIBRATION, timeout=30):
        vehicle.send_calibrate_gyro()

    vehicle.close()


@with_sitl
def test_magnetometer_calibration(connpath):
    """Request magnetometer calibration, and check for the COMMAND_ACK."""

    vehicle = connect(connpath, wait_ready=True)

    with assert_command_ack(
        vehicle,
        mavutil.mavlink.MAV_CMD_DO_START_MAG_CAL,
        timeout=30,
        ack_result=mavutil.mavlink.MAV_RESULT_UNSUPPORTED,  # TODO: change when APM is upgraded
    ):
        vehicle.send_calibrate_magnetometer()

    vehicle.close()


@with_sitl
def test_simple_accelerometer_calibration(connpath):
    """Request simple accelerometer calibration, and check for the COMMAND_ACK."""

    vehicle = connect(connpath, wait_ready=True)

    with assert_command_ack(
        vehicle,
        mavutil.mavlink.MAV_CMD_PREFLIGHT_CALIBRATION,
        timeout=30,
        ack_result=mavutil.mavlink.MAV_RESULT_FAILED,
    ):
        vehicle.send_calibrate_accelerometer(simple=True)

    vehicle.close()


@with_sitl
def test_accelerometer_calibration(connpath):
    """Request accelerometer calibration, and check for the COMMAND_ACK."""

    vehicle = connect(connpath, wait_ready=True)

    # The calibration is expected to fail because in the SITL we don't tilt the Vehicle.
    # We just check that the command isn't denied or unsupported.
    with assert_command_ack(
        vehicle,
        mavutil.mavlink.MAV_CMD_PREFLIGHT_CALIBRATION,
        timeout=30,
        ack_result=mavutil.mavlink.MAV_RESULT_FAILED,
    ):
        vehicle.send_calibrate_accelerometer(simple=False)

    vehicle.close()


@with_sitl
def test_board_level_calibration(connpath):
    """Request board level calibration, and check for the COMMAND_ACK."""

    vehicle = connect(connpath, wait_ready=True)

    with assert_command_ack(vehicle, mavutil.mavlink.MAV_CMD_PREFLIGHT_CALIBRATION, timeout=30):
        vehicle.send_calibrate_vehicle_level()

    vehicle.close()


@with_sitl
def test_barometer_calibration(connpath):
    """Request barometer calibration, and check for the COMMAND_ACK."""

    vehicle = connect(connpath, wait_ready=True)

    with assert_command_ack(vehicle, mavutil.mavlink.MAV_CMD_PREFLIGHT_CALIBRATION, timeout=30):
        vehicle.send_calibrate_barometer()

    vehicle.close()

# Copyright 2016 Google Inc. All rights reserved.
#
# 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.

"""Define Stackdriver Logging API Metrics."""

from gcloud.exceptions import NotFound


class Metric(object):
    """Metrics represent named filters for log entries.

    See:
    https://cloud.google.com/logging/docs/api/ref_v2beta1/rest/v2beta1/projects.metrics

    :type name: string
    :param name: the name of the metric

    :type filter_: string
    :param filter_: the advanced logs filter expression defining the entries
                   tracked by the metric.  If not passed, the instance should
                   already exist, to be refreshed via :meth:`reload`.

    :type client: :class:`gcloud.logging.client.Client`
    :param client: A client which holds credentials and project configuration
                   for the metric (which requires a project).

    :type description: string
    :param description: an optional description of the metric.
    """
    def __init__(self, name, filter_=None, client=None, description=''):
        self.name = name
        self._client = client
        self.filter_ = filter_
        self.description = description

    @property
    def client(self):
        """Clent bound to the logger."""
        return self._client

    @property
    def project(self):
        """Project bound to the logger."""
        return self._client.project

    @property
    def full_name(self):
        """Fully-qualified name used in metric APIs"""
        return 'projects/%s/metrics/%s' % (self.project, self.name)

    @property
    def path(self):
        """URL path for the metric's APIs"""
        return '/%s' % (self.full_name,)

    @classmethod
    def from_api_repr(cls, resource, client):
        """Factory:  construct a metric given its API representation

        :type resource: dict
        :param resource: metric resource representation returned from the API

        :type client: :class:`gcloud.logging.client.Client`
        :param client: Client which holds credentials and project
                       configuration for the metric.

        :rtype: :class:`gcloud.logging.metric.Metric`
        :returns: Metric parsed from ``resource``.
        """
        metric_name = resource['name']
        filter_ = resource['filter']
        description = resource.get('description', '')
        return cls(metric_name, filter_, client=client,
                   description=description)

    def _require_client(self, client):
        """Check client or verify over-ride.

        :type client: :class:`gcloud.logging.client.Client` or ``NoneType``
        :param client: the client to use.  If not passed, falls back to the
                       ``client`` stored on the current metric.

        :rtype: :class:`gcloud.logging.client.Client`
        :returns: The client passed in or the currently bound client.
        """
        if client is None:
            client = self._client
        return client

    def create(self, client=None):
        """API call:  create the metric via a PUT request

        See:
        https://cloud.google.com/logging/docs/api/ref_v2beta1/rest/v2beta1/projects.metrics/create

        :type client: :class:`gcloud.logging.client.Client` or ``NoneType``
        :param client: the client to use.  If not passed, falls back to the
                       ``client`` stored on the current metric.
        """
        client = self._require_client(client)
        client.metrics_api.metric_create(
            self.project, self.name, self.filter_, self.description)

    def exists(self, client=None):
        """API call:  test for the existence of the metric via a GET request

        See
        https://cloud.google.com/logging/docs/api/ref_v2beta1/rest/v2beta1/projects.metrics/get

        :type client: :class:`gcloud.logging.client.Client` or ``NoneType``
        :param client: the client to use.  If not passed, falls back to the
                       ``client`` stored on the current metric.

        :rtype: bool
        :returns: Boolean indicating existence of the metric.
        """
        client = self._require_client(client)

        try:
            client.metrics_api.metric_get(self.project, self.name)
        except NotFound:
            return False
        else:
            return True

    def reload(self, client=None):
        """API call:  sync local metric configuration via a GET request

        See
        https://cloud.google.com/logging/docs/api/ref_v2beta1/rest/v2beta1/projects.metrics/get

        :type client: :class:`gcloud.logging.client.Client` or ``NoneType``
        :param client: the client to use.  If not passed, falls back to the
                       ``client`` stored on the current metric.
        """
        client = self._require_client(client)
        data = client.metrics_api.metric_get(self.project, self.name)
        self.description = data.get('description', '')
        self.filter_ = data['filter']

    def update(self, client=None):
        """API call:  update metric configuration via a PUT request

        See
        https://cloud.google.com/logging/docs/api/ref_v2beta1/rest/v2beta1/projects.metrics/update

        :type client: :class:`gcloud.logging.client.Client` or ``NoneType``
        :param client: the client to use.  If not passed, falls back to the
                       ``client`` stored on the current metric.
        """
        client = self._require_client(client)
        client.metrics_api.metric_update(
            self.project, self.name, self.filter_, self.description)

    def delete(self, client=None):
        """API call:  delete a metric via a DELETE request

        See
        https://cloud.google.com/logging/docs/api/ref_v2beta1/rest/v2beta1/projects.metrics/delete

        :type client: :class:`gcloud.logging.client.Client` or ``NoneType``
        :param client: the client to use.  If not passed, falls back to the
                       ``client`` stored on the current metric.
        """
        client = self._require_client(client)
        client.metrics_api.metric_delete(self.project, self.name)

# Copyright 2014,  Doug Wiegley,  A10 Networks.
#
#    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.
from __future__ import absolute_import
from __future__ import unicode_literals

from acos_client import errors as acos_errors
from acos_client.v21 import base


class VirtualPort(base.BaseV21):

    # Protocols
    TCP = 2
    UDP = 3
    HTTP = 11
    HTTPS = 12
    OTHERS = 4
    RTSP = 5
    FTP = 6
    MMS = 7
    SIP = 8
    FAST_HTTP = 9
    GENERIC_PROXY = 10
    SSL_PROXY = 13
    SMTP = 14
    SIP_TCP = 15
    SIPS = 16
    DIAMETER = 17
    DNS_UDP = 18
    TFTP = 19
    DNS_TCP = 20
    RADIUS = 21
    MYSQL = 22
    MSSQL = 23
    FIX = 24
    SMPP_TCP = 25
    SPDY = 26
    SPDYS = 27
    FTP_PROXY = 28

    # The keys as specified in the ACOS JSON message.
    CLIENT_SSL_TMPL_KEY = "client_ssl_template"
    SERVER_SSL_TMPL_KEY = "server_ssl_template"

    # The keys as sent from a10-neutron-lbaas
    # They match what we use in v4 so we transform here
    CLIENT_SSL_ANL_KEY = "template_client_ssl"
    SERVER_SSL_ANL_KEY = "template_server_ssl"

    def _set(
        self,
        action,
        virtual_server_name,
        name,
        protocol,
        port,
        service_group_name,
        s_pers_name=None,
        c_pers_name=None,
        status=1,
        autosnat=False,
        ipinip=False,
        source_nat=None,
        ha_conn_mirror=None,
        no_dest_nat=None,
        conn_limit=None,
        tcp_template=None,
        udp_template=None,
        **kwargs
    ):
        params = {
            "name": virtual_server_name,
            "vport": self.minimal_dict({
                "name": name,
                "service_group": service_group_name,
                "protocol": int(protocol),
                "port": int(port),
                "source_ip_persistence_template": s_pers_name,
                "cookie_persistence_template": c_pers_name,
                "status": status
            })
        }
        client_ssl_template = kwargs.get(self.CLIENT_SSL_TMPL_KEY)
        server_ssl_template = kwargs.get(self.SERVER_SSL_TMPL_KEY)

        if client_ssl_template:
            params['vport'][self.CLIENT_SSL_ANL_KEY] = client_ssl_template

        if server_ssl_template:
            params['vport'][self.SERVER_SSL_ANL_KEY] = server_ssl_template

        if autosnat:
            params['vport']['source_nat_auto'] = int(autosnat)
        if ipinip:
            params['vport']['ip_in_ip'] = int(ipinip)
        if source_nat and len(source_nat) > 0:
            params['vport']['source_nat'] = source_nat
        if tcp_template:
            params['vport']['tcp_template'] = tcp_template
        if udp_template:
            params['vport']['udp_template'] = udp_template
        if no_dest_nat is not None:
            params['vport']['no-dest-nat'] = 1 if no_dest_nat else 0
        if ha_conn_mirror is not None:
            params['vport']['ha-conn-mirror'] = 1 if ha_conn_mirror else 0
        if conn_limit is not None:
            conn_limit = int(conn_limit)
            if conn_limit > 0 and conn_limit <= 8000000:
                params['vport']['conn-limit'] = conn_limit

        return self._post(action, params, **kwargs)

    def get(self, virtual_server_name, name, protocol, port, **kwargs):
        # There is no slb.virtual_server.vport.search.
        # Instead, we get the virtual server and get the desired vport.
        results = self._post('slb.virtual_server.search', {'name': virtual_server_name}, **kwargs)

        vport_list = results.get("virtual_server", []).get("vport_list", [])
        vport = None
        for vport_dict in vport_list:
            if (
                vport_dict.get("name", None) == name and
                vport_dict.get("protocol", None) == int(protocol) and
                vport_dict.get("port", None) == int(port)
            ):
                vport = vport_dict
        if vport is not None:
            return vport
        else:
            raise acos_errors.NotFound()

    def create(
        self,
        virtual_server_name,
        name,
        protocol,
        port,
        service_group_name,
        s_pers_name=None,
        c_pers_name=None,
        status=1,
        autosnat=False,
        ipinip=False,
        source_nat_pool=None,
        ha_conn_mirror=None,
        no_dest_nat=None,
        conn_limit=None,
        tcp_template=None,
        udp_template=None,
        **kwargs
    ):
        return self._set(
            'slb.virtual_server.vport.create',
            virtual_server_name,
            name,
            protocol,
            port,
            service_group_name,
            s_pers_name,
            c_pers_name,
            status,
            autosnat=autosnat,
            ipinip=ipinip,
            source_nat=source_nat_pool,
            ha_conn_mirror=ha_conn_mirror,
            no_dest_nat=no_dest_nat,
            conn_limit=conn_limit,
            tcp_template=tcp_template,
            udp_template=udp_template,
            **kwargs
        )

    def update(
        self,
        virtual_server_name,
        name,
        protocol,
        port,
        service_group_name,
        s_pers_name=None,
        c_pers_name=None,
        status=1,
        autosnat=False,
        ipinip=False,
        source_nat_pool=None,
        ha_conn_mirror=None,
        no_dest_nat=None,
        conn_limit=None,
        tcp_template=None,
        udp_template=None,
        **kwargs
    ):
            return self._set(
                'slb.virtual_server.vport.update',
                virtual_server_name,
                name,
                protocol,
                port,
                service_group_name,
                s_pers_name,
                c_pers_name,
                status,
                autosnat=autosnat,
                ipinip=ipinip,
                source_nat=source_nat_pool,
                ha_conn_mirror=ha_conn_mirror,
                no_dest_nat=no_dest_nat,
                conn_limit=conn_limit,
                tcp_template=tcp_template,
                udp_template=udp_template,
                **kwargs
            )

    def delete(self, virtual_server_name, name, protocol, port, **kwargs):
        params = {
            "name": virtual_server_name,
            "vport": {
                "name": name,
                "protocol": protocol,
                "port": int(port)
            }
        }
        return self._post("slb.virtual_server.vport.delete", params, **kwargs)

# vim: set encoding=utf-8
import re

from lxml import etree
import logging
from regparser import content
from regparser.tree.depth import heuristics, rules, markers as mtypes
from regparser.tree.depth.derive import derive_depths
from regparser.tree.struct import Node
from regparser.tree.paragraph import p_level_of
from regparser.tree.xml_parser.appendices import build_non_reg_text
from regparser.tree import reg_text
from regparser.tree.xml_parser import tree_utils
from settings import PARAGRAPH_HIERARCHY


def get_reg_part(reg_doc):
    """
    Depending on source, the CFR part number exists in different places. Fetch
    it, wherever it is.
    """

    potential_parts = []
    potential_parts.extend(
        # FR notice
        node.attrib['PART'] for node in reg_doc.xpath('//REGTEXT'))
    potential_parts.extend(
        # e-CFR XML, under PART/EAR
        node.text.replace('Pt.', '').strip()
        for node in reg_doc.xpath('//PART/EAR')
        if 'Pt.' in node.text)
    potential_parts.extend(
        # e-CFR XML, under FDSYS/HEADING
        node.text.replace('PART', '').strip()
        for node in reg_doc.xpath('//FDSYS/HEADING')
        if 'PART' in node.text)
    potential_parts.extend(
        # e-CFR XML, under FDSYS/GRANULENUM
        node.text.strip() for node in reg_doc.xpath('//FDSYS/GRANULENUM'))
    potential_parts = [p for p in potential_parts if p.strip()]

    if potential_parts:
        return potential_parts[0]


def get_title(reg_doc):
    """ Extract the title of the regulation. """
    parent = reg_doc.xpath('//PART/HD')[0]
    title = parent.text
    return title


def preprocess_xml(xml):
    """This transforms the read XML through macros. Each macro consists of
    an xpath and a replacement xml string"""
    for path, replacement in content.Macros():
        replacement = etree.fromstring('<ROOT>' + replacement + '</ROOT>')
        for node in xml.xpath(path):
            parent = node.getparent()
            idx = parent.index(node)
            parent.remove(node)
            for repl in replacement:
                parent.insert(idx, repl)
                idx += 1


def build_tree(reg_xml):
    if isinstance(reg_xml, str) or isinstance(reg_xml, unicode):
        doc = etree.fromstring(reg_xml)
    else:
        doc = reg_xml
    preprocess_xml(doc)

    reg_part = get_reg_part(doc)
    title = get_title(doc)

    tree = Node("", [], [reg_part], title)

    part = doc.xpath('//PART')[0]

    subpart_xmls = [c for c in part.getchildren() if c.tag == 'SUBPART']
    if len(subpart_xmls) > 0:
        subparts = [build_subpart(reg_part, s) for s in subpart_xmls]
        tree.children = subparts
    else:
        section_xmls = [c for c in part.getchildren() if c.tag == 'SECTION']
        sections = []
        for section_xml in section_xmls:
            sections.extend(build_from_section(reg_part, section_xml))
        empty_part = reg_text.build_empty_part(reg_part)
        empty_part.children = sections
        tree.children = [empty_part]

    non_reg_sections = build_non_reg_text(doc, reg_part)
    tree.children += non_reg_sections

    return tree


def get_subpart_title(subpart_xml):
    hds = subpart_xml.xpath('./HD|./RESERVED')
    return [hd.text for hd in hds][0]


def build_subpart(reg_part, subpart_xml):
    subpart_title = get_subpart_title(subpart_xml)
    subpart = reg_text.build_subpart(subpart_title, reg_part)

    sections = []
    for ch in subpart_xml.getchildren():
        if ch.tag == 'SECTION':
            sections.extend(build_from_section(reg_part, ch))

    subpart.children = sections
    return subpart


# @profile
def get_markers(text):
    """ Extract all the paragraph markers from text. Do some checks on the
    collapsed markers."""
    markers = tree_utils.get_paragraph_markers(text)
    collapsed_markers = tree_utils.get_collapsed_markers(text)

    #   Check that the collapsed markers make sense (i.e. are at least one
    #   level below the initial marker)
    if markers and collapsed_markers:
        initial_marker_levels = p_level_of(markers[-1])
        final_collapsed_markers = []
        for collapsed_marker in collapsed_markers:
            collapsed_marker_levels = p_level_of(collapsed_marker)
            if any(c > f for f in initial_marker_levels
                    for c in collapsed_marker_levels):
                final_collapsed_markers.append(collapsed_marker)
        collapsed_markers = final_collapsed_markers
    markers_list = [m for m in markers] + [m for m in collapsed_markers]

    return markers_list


def get_markers_and_text(node, markers_list):
    node_text = tree_utils.get_node_text(node, add_spaces=True)
    text_with_tags = tree_utils.get_node_text_tags_preserved(node)

    if len(markers_list) > 1:
        actual_markers = ['(%s)' % m for m in markers_list]
        plain_markers = [m.replace('<E T="03">', '').replace('</E>', '')
                         for m in actual_markers]
        node_texts = tree_utils.split_text(node_text, plain_markers)
        tagged_texts = tree_utils.split_text(text_with_tags, actual_markers)
        node_text_list = zip(node_texts, tagged_texts)
    elif markers_list:
        node_text_list = [(node_text, text_with_tags)]
    else:
        node_text_list = [('', '')]

    return zip(markers_list, node_text_list)


def next_marker(xml_node, remaining_markers):
    """Try to determine the marker following the current xml_node. Remaining
    markers is a list of other marks *within* the xml_node. May return
    None"""
    #   More markers in this xml node
    if remaining_markers:
        return remaining_markers[0][0]

    #   Check the next xml node; skip over stars
    sib = xml_node.getnext()
    while sib is not None and sib.tag in ('STARS', 'PRTPAGE'):
        sib = sib.getnext()
    if sib is not None:
        next_text = tree_utils.get_node_text(sib)
        next_markers = get_markers(next_text)
        if next_markers:
            return next_markers[0]


def build_from_section(reg_part, section_xml):
    section_texts = []
    nodes = []

    section_no = section_xml.xpath('SECTNO')[0].text
    section_no_without_marker = re.search('[0-9]+\.[0-9]+',
                                          section_no).group(0)
    subject_xml = section_xml.xpath('SUBJECT')
    if not subject_xml:
        subject_xml = section_xml.xpath('RESERVED')
    subject_text = subject_xml[0].text

    manual_hierarchy = []
    if (reg_part in PARAGRAPH_HIERARCHY
            and section_no_without_marker in PARAGRAPH_HIERARCHY[reg_part]):
        manual_hierarchy = PARAGRAPH_HIERARCHY[reg_part][
            section_no_without_marker]

    # Collect paragraph markers and section text (intro text for the
    # section)
    i = 0
    children = [ch for ch in section_xml.getchildren()
                if ch.tag in ['P', 'STARS']]
    for ch in children:
        text = tree_utils.get_node_text(ch, add_spaces=True)
        tagged_text = tree_utils.get_node_text_tags_preserved(ch)
        markers_list = get_markers(tagged_text.strip())

        # If the child has a 'DEPTH' attribute, we're in manual
        # hierarchy mode, just constructed from the XML instead of
        # specified in configuration.
        # This presumes that every child in the section has DEPTH
        # specified, if not, things will break in and around
        # derive_depths below.
        if ch.get("depth") is not None:
            manual_hierarchy.append(int(ch.get("depth")))

        if ch.tag == 'STARS':
            nodes.append(Node(label=[mtypes.STARS_TAG]))
        elif not markers_list and manual_hierarchy:
            # is this a bunch of definitions that don't have numbers next to
            # them?
            if len(nodes) > 0:
                if (subject_text.find('Definitions.') > -1
                        or nodes[-1].text.find(
                            'For the purposes of this section')):
                    # TODO: create a grammar for definitions
                    if text.find('means') > -1:
                        def_marker = text.split('means')[0].strip().split()
                        def_marker = ''.join([word[0].upper() + word[1:]
                                              for word in def_marker])
                    elif text.find('shall have the same meaning') > -1:
                        def_marker = text.split('shall')[0].strip().split()
                        def_marker = ''.join([word[0].upper() + word[1:]
                                              for word in def_marker])
                    else:
                        def_marker = 'def{0}'.format(i)
                        i += 1
                    n = Node(text, label=[def_marker], source_xml=ch)
                    n.tagged_text = tagged_text
                    nodes.append(n)
                else:
                    section_texts.append((text, tagged_text))
            else:
                if len(children) > 1:
                    def_marker = 'def{0}'.format(i)
                    n = Node(text, [], [def_marker], source_xml=ch)
                    n.tagged_text = tagged_text
                    i += 1
                    nodes.append(n)
                else:
                    # this is the only node around
                    section_texts.append((text, tagged_text))

        elif not markers_list and not manual_hierarchy:
            # No manual heirarchy specified, append to the section.
            section_texts.append((text, tagged_text))
        else:
            for m, node_text in get_markers_and_text(ch, markers_list):
                n = Node(node_text[0], [], [m], source_xml=ch)
                n.tagged_text = unicode(node_text[1])
                nodes.append(n)

            if node_text[0].endswith('* * *'):
                nodes.append(Node(label=[mtypes.INLINE_STARS]))

    # Trailing stars don't matter; slightly more efficient to ignore them
    while nodes and nodes[-1].label[0] in mtypes.stars:
        nodes = nodes[:-1]

    m_stack = tree_utils.NodeStack()

    # Use constraint programming to figure out possible depth assignments
    if not manual_hierarchy:
        depths = derive_depths(
            [node.label[0] for node in nodes],
            [rules.depth_type_order([mtypes.lower, mtypes.ints, mtypes.roman,
                                     mtypes.upper, mtypes.em_ints,
                                     mtypes.em_roman])])

    if not manual_hierarchy and depths:
        # Find the assignment which violates the least of our heuristics
        depths = heuristics.prefer_multiple_children(depths, 0.5)
        depths = sorted(depths, key=lambda d: d.weight, reverse=True)
        depths = depths[0]

        for node, par in zip(nodes, depths):
            if par.typ != mtypes.stars:
                last = m_stack.peek()
                node.label = [l.replace('<E T="03">', '').replace('</E>', '')
                              for l in node.label]
                if len(last) == 0:
                    m_stack.push_last((1 + par.depth, node))
                else:
                    m_stack.add(1 + par.depth, node)

    elif nodes and manual_hierarchy:
        logging.warning('Using manual depth hierarchy.')
        depths = manual_hierarchy
        if len(nodes) == len(depths):
            for node, spec in zip(nodes, depths):
                if isinstance(spec, int):
                    depth = spec
                elif isinstance(spec, tuple):
                    depth, marker = spec
                    node.marker = marker
                last = m_stack.peek()
                node.label = [l.replace('<E T="03">', '').replace('</E>', '')
                              for l in node.label]
                if len(last) == 0:
                    m_stack.push_last((1 + depth, node))
                else:
                    m_stack.add(1 + depth, node)
        else:
            logging.error('Manual hierarchy length does not match node '
                          'list length! ({0} nodes but {1} provided, '
                          '{2})'.format(
                              len(nodes),
                              len(depths),
                              [x.label[0] for x in nodes]))

    elif nodes and not manual_hierarchy:
        logging.warning(
            'Could not determine depth when parsing {0}:\n{1}'.format(
                section_no_without_marker, [node.label[0] for node in nodes]))
        for node in nodes:
            last = m_stack.peek()
            node.label = [l.replace('<E T="03">', '').replace('</E>', '')
                          for l in node.label]
            if len(last) == 0:
                m_stack.push_last((3, node))
            else:
                m_stack.add(3, node)

    nodes = []
    section_nums = []
    for match in re.finditer(r'%s\.(\d+)' % reg_part, section_no):
        section_nums.append(int(match.group(1)))

    #  Span of section numbers
    if u'§§' == section_no[:2] and '-' in section_no:
        first, last = section_nums
        section_nums = []
        for i in range(first, last + 1):
            section_nums.append(i)

    for section_number in section_nums:
        section_number = str(section_number)
        plain_sect_texts = [s[0] for s in section_texts]
        tagged_sect_texts = [s[1] for s in section_texts]

        section_title = u"§ " + reg_part + "." + section_number
        if subject_text:
            section_title += " " + subject_text

        section_text = ' '.join([section_xml.text] + plain_sect_texts)
        tagged_section_text = ' '.join([section_xml.text] + tagged_sect_texts)

        sect_node = Node(section_text, label=[reg_part, section_number],
                         title=section_title)
        sect_node.tagged_text = tagged_section_text

        m_stack.add_to_bottom((1, sect_node))

        while m_stack.size() > 1:
            m_stack.unwind()

        nodes.append(m_stack.pop()[0][1])

    return nodes

"""
Helper classes and methods for running modulestore tests without Django.
"""
from importlib import import_module
from opaque_keys.edx.keys import UsageKey
from unittest import TestCase
from xblock.fields import XBlockMixin
from xmodule.modulestore import ModuleStoreEnum
from xmodule.modulestore.draft_and_published import ModuleStoreDraftAndPublished
from xmodule.modulestore.edit_info import EditInfoMixin
from xmodule.modulestore.inheritance import InheritanceMixin
from xmodule.modulestore.mixed import MixedModuleStore
from xmodule.modulestore.tests.factories import ItemFactory
from xmodule.modulestore.tests.mongo_connection import MONGO_PORT_NUM, MONGO_HOST
from xmodule.tests import DATA_DIR


def load_function(path):
    """
    Load a function by name.

    path is a string of the form "path.to.module.function"
    returns the imported python object `function` from `path.to.module`
    """
    module_path, _, name = path.rpartition('.')
    return getattr(import_module(module_path), name)


# pylint: disable=unused-argument
def create_modulestore_instance(
        engine,
        contentstore,
        doc_store_config,
        options,
        i18n_service=None,
        fs_service=None,
        user_service=None
):
    """
    This will return a new instance of a modulestore given an engine and options
    """
    class_ = load_function(engine)

    if issubclass(class_, ModuleStoreDraftAndPublished):
        options['branch_setting_func'] = lambda: ModuleStoreEnum.Branch.draft_preferred

    return class_(
        doc_store_config=doc_store_config,
        contentstore=contentstore,
        **options
    )


class LocationMixin(XBlockMixin):
    """
    Adds a `location` property to an :class:`XBlock` so it is more compatible
    with old-style :class:`XModule` API. This is a simplified version of
    :class:`XModuleMixin`.
    """
    @property
    def location(self):
        """ Get the UsageKey of this block. """
        return self.scope_ids.usage_id

    @location.setter
    def location(self, value):
        """ Set the UsageKey of this block. """
        assert isinstance(value, UsageKey)
        self.scope_ids = self.scope_ids._replace(  # pylint: disable=attribute-defined-outside-init,protected-access
            def_id=value,
            usage_id=value,
        )


class MixedSplitTestCase(TestCase):
    """
    Stripped-down version of ModuleStoreTestCase that can be used without Django
    (i.e. for testing in common/lib/ ). Sets up MixedModuleStore and Split.
    """
    RENDER_TEMPLATE = lambda t_n, d, ctx=None, nsp='main': u'{}: {}, {}'.format(t_n, repr(d), repr(ctx))
    modulestore_options = {
        'default_class': 'xmodule.raw_module.RawDescriptor',
        'fs_root': DATA_DIR,
        'render_template': RENDER_TEMPLATE,
        'xblock_mixins': (EditInfoMixin, InheritanceMixin, LocationMixin),
    }
    DOC_STORE_CONFIG = {
        'host': MONGO_HOST,
        'port': MONGO_PORT_NUM,
        'db': 'test_mongo_libs',
        'collection': 'modulestore',
        'asset_collection': 'assetstore',
    }
    MIXED_OPTIONS = {
        'stores': [
            {
                'NAME': 'split',
                'ENGINE': 'xmodule.modulestore.split_mongo.split_draft.DraftVersioningModuleStore',
                'DOC_STORE_CONFIG': DOC_STORE_CONFIG,
                'OPTIONS': modulestore_options
            },
        ]
    }

    def setUp(self):
        """
        Set up requirements for testing: a user ID and a modulestore
        """
        super(MixedSplitTestCase, self).setUp()
        self.user_id = ModuleStoreEnum.UserID.test

        self.store = MixedModuleStore(
            None,
            create_modulestore_instance=create_modulestore_instance,
            mappings={},
            **self.MIXED_OPTIONS
        )
        self.addCleanup(self.store.close_all_connections)
        self.addCleanup(self.store._drop_database)  # pylint: disable=protected-access

    def make_block(self, category, parent_block, **kwargs):
        """
        Create a block of type `category` as a child of `parent_block`, in any
        course or library. You can pass any field values as kwargs.
        """
        extra = {"publish_item": False, "user_id": self.user_id}
        extra.update(kwargs)
        return ItemFactory.create(
            category=category,
            parent=parent_block,
            parent_location=parent_block.location,
            modulestore=self.store,
            **extra
        )

# -*- coding: utf-8 -*-
##############################################################################
#
#     This file is part of mozaik_retrocession, an Odoo module.
#
#     Copyright (c) 2015 ACSONE SA/NV (<http://acsone.eu>)
#
#     mozaik_retrocession is free software:
#     you can redistribute it and/or
#     modify it under the terms of the GNU Affero General Public License
#     as published by the Free Software Foundation, either version 3 of
#     the License, or (at your option) any later version.
#
#     mozaik_retrocession is distributed in the hope that it will
#     be useful but WITHOUT ANY WARRANTY; without even the implied warranty of
#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#     GNU Affero General Public License for more details.
#
#     You should have received a copy of the
#     GNU Affero General Public License
#     along with mozaik_retrocession.
#     If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

import datetime

from openerp.osv import orm, fields
from openerp.addons.connector.queue.job import job
from openerp.addons.connector.session import ConnectorSession


MANDATE_M2O = {
    'sta.mandate': 'sta_mandate_id',
    'ext.mandate': 'ext_mandate_id',
}


class retrocession_factory_wizard(orm.TransientModel):
    _name = "retrocession.factory.wizard"
    _description = 'Retrocessions Generator'

    _columns = {
        'model': fields.char('Model', size=128, required=True),
        'mandate_ids': fields.text('IDS', required=True),
        'month': fields.selection(fields.date.MONTHS, 'Month'),
        'year': fields.char('Year', size=128, required=True),
        'mandate_selected': fields.integer('Selected Mandates'),
        'yearly_count': fields.integer('Yearly Retrocessions to Create'),
        'yearly_duplicates': fields.integer(
            'Yearly Retrocessions Already Existing'),
        'monthly_count': fields.integer('Monthly Retrocessions to Create'),
        'monthly_duplicates': fields.integer(
            'Monthly Retrocessions Already Existing'),
        'total_retrocession': fields.integer(
            'Number of Retrocessions to Create'),
    }

    def default_get(self, cr, uid, flds, context=None):
        """
        To get default values for the object.
        """
        context = context or {}

        today = datetime.date.today()
        first = datetime.date(day=1, month=today.month, year=today.year)
        lastMonth = first - datetime.timedelta(days=1)
        model = context.get('active_model', False)
        if context.get('active_domain'):
            active_domain = context.get('active_domain')
            ids = self.pool.get(model).search(
                cr, uid, active_domain, context=context)
        elif context.get('active_ids'):
            ids = context.get('active_ids') or (
                context.get('active_id') and [
                    context.get('active_id')]) or []

        res = {
            'model': model,
            'mandate_ids': str(ids),
            'month': lastMonth.strftime("%m"),
            'year': lastMonth.strftime("%Y"),
            'mandate_selected': len(ids),
        }

        return res

    def mandate_selection_analysis(
            self,
            cr,
            uid,
            month,
            year,
            model,
            ids,
            mode='onchange',
            context=None):
        """
        ===============
        mandate_selection_analysis
        ==============)
        Analyse mandate selection and give an overview of expected results
        """
        mandate_key = MANDATE_M2O.get(model, False)
        rejected_ids = []
        yearly_count = 0
        yearly_duplicates = 0
        monthly_count = 0
        monthly_duplicates = 0
        for mandate_data in self.pool[model].read(cr,
                                                  uid,
                                                  ids,
                                                  ['retrocession_mode',
                                                   'end_date',
                                                   'deadline_date',
                                                   'calculation_method_id'],
                                                  context=context):
            if mandate_data['end_date'] or \
                    mandate_data['deadline_date'] <= fields.date.today() or \
                    mandate_data['retrocession_mode'] not in [
                        'month', 'year'] or\
                    not mandate_data['calculation_method_id']:
                rejected_ids.append(mandate_data['id'])
                continue

            if mandate_data['retrocession_mode'] == 'month':
                duplicate_ids = self.pool.get('retrocession').search(
                    cr,
                    uid,
                    [
                        (mandate_key,
                         '=',
                         mandate_data['id']),
                        ('month',
                         '=',
                         month),
                        ('year',
                         '=',
                         year),
                        ('is_regulation',
                         '=',
                         False)],
                    context=context)

                if not duplicate_ids:
                    monthly_count += 1
                else:
                    monthly_duplicates += 1

            elif mandate_data['retrocession_mode'] == 'year':
                duplicate_ids = self.pool.get('retrocession').search(
                    cr, uid, [
                        (mandate_key, '=', mandate_data['id']),
                        ('year', '=', year)],
                    context=context)
                if not duplicate_ids:
                    yearly_count += 1
                else:
                    yearly_duplicates += 1

        if mode == 'ids':
            res = list(set(ids) - set(rejected_ids))
        else:
            res = {
                'total_retrocession': yearly_count + monthly_count,
                'yearly_count': yearly_count,
                'yearly_duplicates': yearly_duplicates,
                'monthly_count': monthly_count,
                'monthly_duplicates': monthly_duplicates,
            }

        return res

    def onchange_month_year(
            self,
            cr,
            uid,
            ids,
            month,
            year,
            model,
            mandate_ids,
            context=None):
        return {
            'value': self.mandate_selection_analysis(
                cr,
                uid,
                month,
                year,
                model,
                eval(mandate_ids),
                context=context)}

    def generate_retrocessions(self, cr, uid, ids, context=None):
        """
        =======================
        generate_retrocessions
        =======================
        Generate retrocessions for valid selected mandates
        """
        wizard = self.browse(cr, uid, ids, context=context)[0]
        mandate_key = MANDATE_M2O.get(wizard.model, False)
        mandate_ids = self.mandate_selection_analysis(
            cr,
            uid,
            wizard.month,
            wizard.year,
            wizard.model,
            eval(
                wizard.mandate_ids),
            mode='ids',
            context=context)

        monthly_mandate_ids = [
            mandate['id'] for mandate in self.pool.get(
                wizard.model).read(
                cr,
                uid,
                mandate_ids,
                ['retrocession_mode']) if
            mandate['retrocession_mode'] == 'month']
        yearly_mandate_ids = list(set(mandate_ids) - set(monthly_mandate_ids))

        worker_pivot = int(
            self.pool.get('ir.config_parameter').get_param(
                cr,
                uid,
                'worker_pivot',
                10))

        vals = dict(month=wizard.month,
                    year=wizard.year)

        session = ConnectorSession(cr, uid, context=context)
        if len(monthly_mandate_ids) > worker_pivot:
            create_retrocessions.delay(
                session,
                self._name,
                monthly_mandate_ids,
                vals,
                mandate_key,
                context)
        else:
            create_retrocessions(
                session,
                self._name,
                monthly_mandate_ids,
                vals,
                mandate_key,
                context)

        vals.pop('month')

        if len(yearly_mandate_ids) > worker_pivot:
            create_retrocessions.delay(
                session,
                self._name,
                yearly_mandate_ids,
                vals,
                mandate_key,
                context)
        else:
            create_retrocessions(
                session,
                self._name,
                yearly_mandate_ids,
                vals,
                mandate_key,
                context)


@job
def create_retrocessions(
        session,
        model_name,
        ids,
        vals,
        mandate_key,
        context=None):
    """
    =======================
    create_retrocessions
    =======================
    Create retrocessions for given mandates
    """
    for mandate_id in ids:
        vals[mandate_key] = mandate_id
        session.pool['retrocession'].create(
            session.cr,
            session.uid,
            vals,
            context=context)

#!/usr/bin/env python

# Copyright (c) 2012 Google Inc. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""
Verifies that dependent Xcode settings are processed correctly.
"""

import TestGyp

import sys

if sys.platform == 'darwin':
  test = TestGyp.TestGyp(formats=['ninja', 'make', 'xcode'])

  CHDIR = 'xcode-env-order'
  INFO_PLIST_PATH = 'Test.app/Contents/Info.plist'

  test.run_gyp('test.gyp', chdir=CHDIR)
  test.build('test.gyp', test.ALL, chdir=CHDIR)

  # Env vars in 'copies' filenames.
  test.built_file_must_exist('Test-copy-brace/main.c', chdir=CHDIR)
  test.built_file_must_exist('Test-copy-paren/main.c', chdir=CHDIR)
  test.built_file_must_exist('Test-copy-bare/main.c', chdir=CHDIR)

  # Env vars in 'actions' filenames and inline actions
  test.built_file_must_exist('action-copy-brace.txt', chdir=CHDIR)
  test.built_file_must_exist('action-copy-paren.txt', chdir=CHDIR)
  test.built_file_must_exist('action-copy-bare.txt', chdir=CHDIR)

  # Env vars in 'rules' filenames and inline actions
  test.built_file_must_exist('rule-copy-brace.txt', chdir=CHDIR)
  test.built_file_must_exist('rule-copy-paren.txt', chdir=CHDIR)
  # TODO: see comment in test.gyp for this file.
  #test.built_file_must_exist('rule-copy-bare.txt', chdir=CHDIR)

  # Env vars in Info.plist.
  info_plist = test.built_file_path(INFO_PLIST_PATH, chdir=CHDIR)
  test.must_exist(info_plist)

  test.must_contain(info_plist, '''\
\t<key>BraceProcessedKey1</key>
\t<string>D:/Source/Project/Test</string>''')
  test.must_contain(info_plist, '''\
\t<key>BraceProcessedKey2</key>
\t<string>/Source/Project/Test</string>''')
  test.must_contain(info_plist, '''\
\t<key>BraceProcessedKey3</key>
\t<string>com.apple.product-type.application:D:/Source/Project/Test</string>''')

  test.must_contain(info_plist, '''\
\t<key>ParenProcessedKey1</key>
\t<string>D:/Source/Project/Test</string>''')
  test.must_contain(info_plist, '''\
\t<key>ParenProcessedKey2</key>
\t<string>/Source/Project/Test</string>''')
  test.must_contain(info_plist, '''\
\t<key>ParenProcessedKey3</key>
\t<string>com.apple.product-type.application:D:/Source/Project/Test</string>''')

  test.must_contain(info_plist, '''\
\t<key>BareProcessedKey1</key>
\t<string>D:/Source/Project/Test</string>''')
  test.must_contain(info_plist, '''\
\t<key>BareProcessedKey2</key>
\t<string>/Source/Project/Test</string>''')
  # NOTE: For bare variables, $PRODUCT_TYPE is not replaced! It _is_ replaced
  # if it's not right at the start of the string (e.g. ':$PRODUCT_TYPE'), so
  # this looks like an Xcode bug. This bug isn't emulated (yet?), so check this
  # only for Xcode.
  if test.format == 'xcode':
    test.must_contain(info_plist, '''\
\t<key>BareProcessedKey3</key>
\t<string>$PRODUCT_TYPE:D:/Source/Project/Test</string>''')

  test.must_contain(info_plist, '''\
\t<key>MixedProcessedKey</key>
\t<string>/Source/Project:Test:mh_execute</string>''')

  test.pass_test()

# (c) 2012, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os

from ansible.errors import AnsibleError
from ansible.module_utils._text import to_native
from ansible.plugins.action import ActionBase


class ActionModule(ActionBase):
    TRANSFERS_FILES = True

    def run(self, tmp=None, task_vars=None):
        ''' handler for file transfer operations '''
        if task_vars is None:
            task_vars = dict()

        result = super(ActionModule, self).run(tmp, task_vars)

        if not tmp:
            tmp = self._make_tmp_path()

        creates = self._task.args.get('creates')
        if creates:
            # do not run the command if the line contains creates=filename
            # and the filename already exists. This allows idempotence
            # of command executions.
            if self._remote_file_exists(creates):
                self._remove_tmp_path(tmp)
                return dict(skipped=True, msg=("skipped, since %s exists" % creates))

        removes = self._task.args.get('removes')
        if removes:
            # do not run the command if the line contains removes=filename
            # and the filename does not exist. This allows idempotence
            # of command executions.
            if not self._remote_file_exists(removes):
                self._remove_tmp_path(tmp)
                return dict(skipped=True, msg=("skipped, since %s does not exist" % removes))

        # the script name is the first item in the raw params, so we split it
        # out now so we know the file name we need to transfer to the remote,
        # and everything else is an argument to the script which we need later
        # to append to the remote command
        parts = self._task.args.get('_raw_params', '').strip().split()
        source = parts[0]
        args = ' '.join(parts[1:])

        try:
            source = self._loader.get_real_file(self._find_needle('files', source), decrypt=self._task.args.get('decrypt', True))
        except AnsibleError as e:
            return dict(failed=True, msg=to_native(e))

        # transfer the file to a remote tmp location
        tmp_src = self._connection._shell.join_path(tmp, os.path.basename(source))
        self._transfer_file(source, tmp_src)

        # set file permissions, more permissive when the copy is done as a different user
        self._fixup_perms2((tmp, tmp_src), execute=True)

        # add preparation steps to one ssh roundtrip executing the script
        env_dict = dict()
        env_string = self._compute_environment_string(env_dict)
        script_cmd = ' '.join([env_string, tmp_src, args])
        script_cmd = self._connection._shell.wrap_for_exec(script_cmd)

        exec_data = None
        # HACK: come up with a sane way to pass around env outside the command
        if self._connection.transport == "winrm":
            exec_data = self._connection._create_raw_wrapper_payload(script_cmd, env_dict)

        result.update(self._low_level_execute_command(cmd=script_cmd, in_data=exec_data, sudoable=True))

        # clean up after
        self._remove_tmp_path(tmp)

        result['changed'] = True

        if 'rc' in result and result['rc'] != 0:
            result['failed'] = True
            result['msg'] = 'non-zero return code'

        return result

from PIL import Image
from xml.dom import minidom
import os
import atlas
import process

def as_int(attr, df = 0):
    if not attr:
        return df
    return int(attr)

def as_bool(attr):
    if not attr:
        return False
    lw = attr.lower()
    return lw == "true" or lw == "1"


def fixImage(image):
    if image.mode != "RGBA":
        return image

    data = image.load()
    for y in xrange(image.size[1]):
        for x in xrange(image.size[0]):
            a = data[x,y][3]
            #if a == 0 or a == 1:
            if a == 0:
                data[x, y] = (0,0,0,0)
    return image

def premultipliedAlpha(image):
    if image.mode != "RGBA":
        return image    
    data = image.load()
    for y in xrange(image.size[1]):
        for x in xrange(image.size[0]):
            dt = data[x,y]
            a = dt[3]
            data[x, y] = ((dt[0] * a) / 255, (dt[1] * a) / 255, (dt[2] * a) / 255, a)

    return image    

class frame:
    def __init__(self, image, bbox, image_element, rs):
        self.image = image
        self.image_element = image_element

        self.node = None
        self.resanim = rs
        self.border_top = self.border_left = 0
        self.border_right = self.border_bottom = 1

        if not bbox:
            bbox = (0,0,1,1)

        self.bbox = bbox

class ResAnim:
    def __init__(self):
        self.frames = []
        self.name = ""
        self.frame_size = (1, 1)
        self.frame_scale = 1.0
        self.columns = 0
        self.rows = 0
        self.walker = None


def frame_cmp_sort(f1, f2):
    return f2.image.size[0] - f1.image.size[0]

def applyScale(intVal, scale):
    return int(intVal * scale + 0.5)


def applyScale2(x, scale):
    initialX = x
    best = None
    while 1:
        X = x * scale        
        d = abs(X - int(X))

        if not best:
            best = (d, X)        

        if best[0] > d:
            best = (d, X)        

        eps = 0.00000001
        if d < eps:
            return int(X)        


        if x > initialX * 2:
            return int(best[1])

        x += 1
        
def nextPOT(v):
    v = v - 1;
    v = v | (v >> 1);
    v = v | (v >> 2);
    v = v | (v >> 4);
    v = v | (v >> 8);
    v = v | (v >>16);
    return v + 1

class settings:
    def __init__(self):
        self.get_size = None
        self.set_node = None
        self.padding = 1
        self.max_w = 2048
        self.max_h = 2048
        self.atlasses = []
        self.square = False

def pack(st, frames, sw, sh):                       
                
    atl = atlas.Atlas(st.padding, sw, sh)            
            
    not_packed = []    
    for fr in frames:
        ns = st.get_size(fr)
        node = atl.add(ns[0], ns[1], fr)
        if not node:
            not_packed.append(fr)
        else:
            st.set_node(fr, node)   
        
    #atl.add(250, 250)
    #atl.save()
        
    return not_packed, atl


def get_pow2list(mn, mx):
    ls = []
    mn = nextPOT(mn)
    mx = nextPOT(mx)
    while 1:
        ls.append(mn)
        mn *= 2
        if mn > mx:
            break
    return ls

def pck(st, frames):        
    if 0:
        st = settings()
    while frames:
        sq = 0
        min_w = 64
        min_h = 64
        for f in frames:
            size = st.get_size(f)
            sq += size[0] * size[1]
            min_w = max(min_w, size[0])
            min_h = max(min_h, size[1])
            
        sizes_w = get_pow2list(min_w, st.max_w)
        sizes_h = get_pow2list(min_h, st.max_h)
                               
        
        for sw in sizes_w:
            for sh in sizes_h:
                end = sh == sizes_h[-1] and sw == sizes_w[-1]
                
                if st.square and sw != sh:
                    continue
                
                if sw * sh < sq and not end:
                    continue                
                
                not_packed, bn = pack(st, frames, sw, sh)
                st.atlasses.append(bn)
                if not not_packed:
                    return
                
                if end:                    
                    frames = not_packed   
                else:
                    st.atlasses.pop()

class atlas_Processor(process.Process):
    node_id = "atlas"

    def __init__(self):
        self.atlas_group_id = 0

    def process(self, context, walker):
        self.atlas_group_id += 1

        #meta = context.add_meta()

        anims = []

        frames = []
        
        while True:
            next = walker.next()
            if not next:
                break

            image_el = next.root
            

            image_name = image_el.getAttribute("file")
            if not image_name:
                continue
            
            file_path = next.getPath("file")


            #print image_path

            image = None

            #fn = self._getExistsFile(image_path)

            #virtual_width = 1        
            #virtual_height = 1
            path = context.src_data + file_path
            try:
                image = Image.open(path)
            except IOError:      
                pass


            if image:
                #   virtual_width = int(image.size[0] * scale + 0.001)
                #   virtual_height= int(image.size[1] * scale + 0.001)    
                pass
            else:
                context.error("can't find image:\n%s\n" % (path, ))
                image = Image.new("RGBA", (0, 0))



            resAnim = ResAnim()            
            resAnim.walker = next
            resAnim.image = image
            resAnim.name = image_name                        

            anims.append(resAnim)

            columns = as_int(image_el.getAttribute("cols"))
            frame_width = as_int(image_el.getAttribute("frame_width"))
            rows = as_int(image_el.getAttribute("rows"))
            frame_height = as_int(image_el.getAttribute("frame_height"))
            border = as_int(image_el.getAttribute("border"))
            
            if not columns:
                columns = 1
            if not rows:
                rows = 1


            if frame_width:
                columns = image.size[0] / frame_width
            else:
                frame_width = image.size[0] / columns

            if frame_height:
                rows = image.size[1] / frame_height
            else:
                frame_height = image.size[1] / rows

            size_warning = False
            if frame_width * columns != image.size[0]:
                size_warning = True
                context.warning("image has width %d and %d columns:" % (image.size[0], columns))
            if frame_height * rows != image.size[1]:
                size_warning = True
                context.warning("<image has height %d and %d rows:" % (image.size[1], rows))

            if size_warning:
                context.warnings += 1

            finalScale = context.get_apply_scale(True, walker)
            upscale = False            
            if finalScale > 1:
                if not context.args.upscale:
                    finalScale = 1
                else:
                    upscale = True

            resAnim.frame_scale = context.get_apply_scale(False, walker)
            #todo, fix bug when frame_scale > 1 and finalScale = 1

            resAnim.frame_size = (applyScale(frame_width, finalScale),
                                  applyScale(frame_height, finalScale))

            resAnim.columns = columns
            resAnim.rows = rows


            for row in xrange(rows):
                for col in xrange(columns):
                    rect = (col * frame_width, row * frame_height, (col + 1) * frame_width, (row + 1)* frame_height, )

                    frame_image = image.crop(rect)      


                    def resize():
                        ax = applyScale2(frame_width, finalScale);
                        ay = applyScale2(frame_height, finalScale);
                        bx = int(ax / finalScale)
                        by = int(ay / finalScale)
                        im = Image.new("RGBA", (bx, by))
                        im.paste(frame_image, (0, 0, frame_image.size[0], frame_image.size[1]))
                        frame_image = im.resize((ax, ay), Image.ANTIALIAS)
                        frame_image = frame_image.crop((0, 0, resAnim.frame_size[0], resAnim.frame_size[1]))                        

                    if context.args.resize:
                        if as_bool(image_el.getAttribute("trueds")):
                            frame_image = frame_image.resize((resAnim.frame_size[0], resAnim.frame_size[1]), Image.ANTIALIAS)
                        else:
                            ax = applyScale2(frame_width, finalScale);
                            ay = applyScale2(frame_height, finalScale);
                            bx = int(ax / finalScale)
                            by = int(ay / finalScale)
                            im = Image.new("RGBA", (bx, by))
                            im.paste(frame_image, (0, 0, frame_image.size[0], frame_image.size[1]))
                            frame_image = im.resize((ax, ay), Image.ANTIALIAS)
                            frame_image = frame_image.crop((0,0,resAnim.frame_size[0], resAnim.frame_size[1]))

                    trim = True
                    if image_el.getAttribute("trim") == "0":
                        trim = False
                    if image.mode == "RGBA" and trim:
                        r,g,b,a = frame_image.split()
                        frame_bbox = a.getbbox()
                    else:
                        frame_bbox = frame_image.getbbox()

                    if not frame_bbox:
                        frame_bbox = (0,0,0,0)

                    w = frame_bbox[2] - frame_bbox[0]
                    h = frame_bbox[3] - frame_bbox[1]                    


                    frame_image = frame_image.crop(frame_bbox)

                    fr = frame(frame_image, frame_bbox, image_el, resAnim)
                    if border:
                        fr.border_left = fr.border_right = fr.border_top = fr.border_bottom = border
                    

                    frames.append(fr)
                    resAnim.frames.append(fr)
        
        #sort frames by size
        #frames = sorted(frames, key = lambda fr: -fr.image.size[1])
        #frames = sorted(frames, key = lambda fr: -fr.image.size[0])
        frames = sorted(frames, key = lambda fr: -1 * max(fr.image.size[0], fr.image.size[1]) * max(fr.image.size[0], fr.image.size[1]))

        sq = 0
        for f in frames:
            sq += f.image.size[0] * f.image.size[1]


        compression = context.compression

        def get_aligned_frame_size(frame):            
            def align_pixel(p):
                if not context.compression:
                    return p + 1
                align = 4
                v = p % align
                if v == 0:
                    p += align
                else:
                    p += 8 - v
                return p
            sz = frame.image.size
            return align_pixel(sz[0] + frame.border_left + frame.border_right), align_pixel(sz[1] + frame.border_top + frame.border_bottom)
        
        def get_original_frame_size(frame):
            sz = frame.image.size
            return sz
        
        
        def set_node(frame, node):
            frame.node = node
        
        st = settings()
        st.get_size = get_aligned_frame_size
        st.set_node = set_node
        st.max_w = context.args.max_width
        st.max_h = context.args.max_height
        st.square = context.compression == "pvrtc"
        
        if len(frames) == 1:
            st.get_size = get_original_frame_size
            st.padding = 0
        
        pck(st, frames) 

        #print "done"
        
        for atlas_id, atl in enumerate(st.atlasses):
            image = Image.new("RGBA", (atl.w, atl.h))
            
            for node in atl.nodes:
                fr = node.data
                x = node.rect.x + fr.border_left
                y = node.rect.y + fr.border_top
                sz = fr.image.size
                rect = (x, y, x + sz[0], y + sz[1])
                image.paste(fr.image, rect)
                fr.atlas_id = atlas_id

            image_atlas_el = walker.root_meta.ownerDocument.createElement("atlas")                
            walker.root_meta.insertBefore(image_atlas_el,  anims[0].walker.root_meta)
            #meta.appendChild(image_atlas_el)            


            base_name = "%d_%d" % (self.atlas_group_id, atlas_id)
            ox_fmt = "r8g8b8a8"

            def compress(src, dest, fmt):
                cmd = context.helper.path_pvrtextool + " -i %s -f %s,UBN,lRGB -o %s" % (src, fmt, dest)
                cmd += " -l" #alpha bleed
                                
                if context.args.quality == "best":
                    cmd += " -q pvrtcbest"
                else:
                    cmd += " -q pvrtcfast"
                    
                if upscale or context.args.dither:
                    cmd += " -dither"                            
                cmd += " -shh" #silent
                os.system(cmd)

            if compression == "etc1":
                #premultipliedAlpha(v)
                r, g, b, a = image.split()
                rgb = Image.merge("RGB", (r, g, b))
                alpha = Image.merge("RGB", (a,a,a))
                base_alpha_name = base_name + "_alpha"
                alpha_path = context.get_inner_dest(base_alpha_name + ".png")
                alpha.save(alpha_path)
                image_atlas_el.setAttribute("alpha", base_alpha_name + ".png")

                path_base = base_name + ".png"

                rs = ".pvr"

                rgb_path = context.get_inner_dest(path_base)
                path = context.get_inner_dest(path_base)                
                rgb.save(path)
                pkm_rgb = base_name + rs
                pkm_alpha = base_alpha_name + rs

                def compress_etc1(src, dest):
                    compress(src, dest, "etc1")
                    #os.system(context.etc1tool + "%s -o %s -f etc1" %(src, dest))


                ox_fmt = "ETC1"

                compress_etc1(rgb_path, context.get_inner_dest() + pkm_rgb)                    
                os.remove(rgb_path)
                image_atlas_el.setAttribute("file", pkm_rgb)                

                compress_etc1(alpha_path, context.get_inner_dest() + pkm_alpha)
                os.remove(alpha_path)
                image_atlas_el.setAttribute("alpha", pkm_alpha)            
            else:
                if context.args.nopng:
                    path_base = base_name + ".tga"
                else:
                    path_base = base_name + ".png"
                    
                path = context.get_inner_dest(path_base)
                image_atlas_el.setAttribute("file", path_base)
                image.save(path)            

                if context.compression == "pvrtc":
                    ox_fmt = "PVRTC_4RGBA"

                    compress(path, context.get_inner_dest(base_name + ".pvr"), "PVRTC1_4")
                    image_atlas_el.setAttribute("file", base_name + ".pvr")
                    os.remove(path)             
                    
                    


            image_atlas_el.setAttribute("format", ox_fmt)

            image_atlas_el.setAttribute("w", str(image.size[0]))
            image_atlas_el.setAttribute("h", str(image.size[1]))  


        for anim in anims:                
            if 0:
                anim = ResAnim()

            image_frames_el = anim.walker.root_meta

            image_frames_el.setAttribute("fs", "%d,%d,%d,%d,%f" % (anim.columns, anim.rows, 
                                                                   anim.frame_size[0], anim.frame_size[1], 
                                                                   anim.frame_scale))
            #meta.appendChild(image_frames_el)

            if context.debug:
                image_frames_el.setAttribute("debug_image", anim.name)


            data = ""
            for fr in anim.frames:
                data += "%d,%d,%d,%d,%d,%d,%d;" %(fr.atlas_id, 
                                                  fr.node.rect.x + fr.border_left, fr.node.rect.y + fr.border_top, 
                                                  fr.bbox[0], fr.bbox[1],
                                                  fr.bbox[2] - fr.bbox[0], fr.bbox[3] - fr.bbox[1])

            text = image_frames_el.ownerDocument.createTextNode(data)
            image_frames_el.appendChild(text)
from unittest import TestCase
from datetime import datetime
from dateutil.relativedelta import relativedelta
try:
    # Python 3 >
    from unittest.mock import patch  # noqa: F401
except ImportError:
    from mock import patch  # noqa: F401
try:
    # Python 3.3 >
    from unittest.mock import MagicMock  # noqa: F401
except ImportError:
    from mock import MagicMock  # noqa: F401

from reviewrot.basereview import BaseReview, BaseService, Age

PATH = 'reviewrot.basereview.'


class BaseServiceTest(TestCase):
    """
    This class represents the BaseService test cases
    """

    def test_check_request_state_newer(self):
        base_service = BaseService()
        # created four hours ago
        now = datetime.now()
        created_at = now - relativedelta(hours=4)

        # include pull request that have been added in the past day
        date = now - relativedelta(days=1)
        age = Age(date=date, state="newer")
        actual = base_service.check_request_state(created_at, age)
        self.assertTrue(actual)

        # include pull request that bave been added in the past 3 hours
        date = now - relativedelta(hours=3)
        age = Age(date=date, state="newer")
        actual = base_service.check_request_state(created_at, age)
        self.assertFalse(actual)

    def test_check_request_state_older(self):
        base_service = BaseService()
        now = datetime.now()
        # created four hours ago
        created_at = now - relativedelta(hours=4)

        # include pull request that are older than 1 day
        date = now - relativedelta(days=1)
        age = Age(date=date, state="older")
        actual = base_service.check_request_state(created_at, age)
        self.assertFalse(actual)

        # include pull request that ale older than 3 hours
        date = now - relativedelta(hours=3)
        age = Age(date=date, state="older")
        actual = base_service.check_request_state(created_at, age)
        self.assertTrue(actual)

    def test_check_request_state_age_is_none(self):
        base_service = BaseService()
        now = datetime.now()
        # created four hours ago
        created_at = now - relativedelta(hours=4)

        # No filtering
        actual = base_service.check_request_state(created_at, None)
        self.assertTrue(actual)

    def test_has_new_comments_none(self):
        """
        Tests 'has_new_comments' function where last_activity and days
        are none
        """
        # Call the function
        response = BaseService().has_new_comments(
            last_activity=None,
            days=None)

        # Assert values were called correctly
        self.assertFalse(response)

    def test_has_new_comments(self):
        """
        Tests 'has_new_comments' function where last_activity and days
        are NOT none
        """
        # Set up mock return values and side effects
        mock_last_activity = datetime.now() - relativedelta(days=599)

        # Call the function
        response = BaseService().has_new_comments(
            last_activity=mock_last_activity,
            days=600)

        # Validate function calls and response
        self.assertTrue(response)

    @patch(PATH + 'json')
    def test_decode_response(self,
                             mock_json):
        """
        Tests '_decode_response' function
        """
        # Set up mock return values and side effects
        mock_response = MagicMock()
        mock_response.encoding = True
        mock_content = MagicMock()
        mock_content.decode.return_value = mock_content
        mock_content.startswith.return_value = True
        mock_response.content.strip.return_value = mock_content
        mock_json.loads.return_value = 'mock_content'

        # Call the function
        response = BaseService()._decode_response(
            mock_response)

        # Validate function calls and response
        self.assertEqual(response, 'mock_content')
        mock_content.decode.assert_called_with(True)
        mock_content.startswith.assert_called_with(")]}\'\n")
        mock_json.loads.assert_called_with(mock_content.__getitem__())

    @patch(PATH + 'json')
    def test_decode_response_valueerror(self,
                                        mock_json):
        """
        Tests '_decode_response' where we have a ValueError
        """
        # Set up mock return values and side effects
        mock_response = MagicMock()
        mock_response.encoding = True
        mock_content = MagicMock()
        mock_content.decode.side_effect = ValueError
        mock_response.content.strip.return_value = mock_content

        # Call the function
        with self.assertRaises(ValueError):
            BaseService()._decode_response(
                mock_response)

        # Validate function calls and response
        mock_content.decode.assert_called_with(True)
        mock_content.startswith.assert_not_called()
        mock_json.loads.assert_not_called()

    @patch(PATH + 'BaseService.get_response')
    @patch(PATH + 'BaseService._decode_response')
    @patch(PATH + 'json')
    def test_call_api(self,
                      mock_json,
                      mock_decode_response,
                      mock_get_response):
        """
        Tests '_call_api'
        """
        # Set up mock return values and side effects
        mock_response = MagicMock()
        mock_response.json.return_value = 'mock_decoded_response'
        mock_get_response.return_value = mock_response

        # Call the function
        response = BaseService()._call_api(
            url='mock_url')

        # Validate function calls and response
        self.assertEqual(response, 'mock_decoded_response')
        mock_response.json.assert_called()
        mock_get_response.assert_called_with(
            'GET', 'mock_url', True)
        mock_decode_response.assert_not_called()

    @patch(PATH + 'BaseService.get_response')
    @patch(PATH + 'BaseService._decode_response')
    @patch(PATH + 'json')
    def test_call_api_valueerror(self,
                                 mock_json,
                                 mock_decode_response,
                                 mock_get_response):
        """
        Tests '_call_api' where we have a ValueError
        """
        # Set up mock return values and side effects
        mock_response = MagicMock()
        mock_response.json.side_effect = ValueError
        mock_decode_response.return_value = 'mock_decoded_response'
        mock_get_response.return_value = mock_response

        # Call the function
        response = BaseService()._call_api(
            url='mock_url')

        # Validate function calls and response
        self.assertEqual(response, 'mock_decoded_response')
        mock_response.json.assert_called()
        mock_get_response.assert_called_with(
            'GET', 'mock_url', True)
        mock_decode_response.assert_called_with(mock_response)

    def test_get_response(self):
        """
        Tests 'get_response' function
        """
        # Set up mock return values and side effects
        mock_response = MagicMock()
        mock_session = MagicMock()
        mock_session.request.return_value = mock_response
        service = BaseService()
        service.header = 'mock_header'
        service.session = mock_session

        # Call the function
        response = service.get_response(
            method='mock_method',
            url='mock_url',
            ssl_verify=True
        )

        # Validate function calls and response
        self.assertEqual(response, mock_response)
        mock_response.raise_for_status.assert_any_call()
        mock_session.request.assert_called_with(
            method='mock_method',
            url='mock_url',
            headers='mock_header',
            verify=True
        )


class BaseReviewTest(TestCase):
    """
    This class represents the BaseReview test cases
    """
    def setUp(self):
        self.mock_base_review = BaseReview()
        self.mock_base_review.user = 'mock_user'
        self.mock_base_review.title = 'mock_title'
        self.mock_base_review.url = 'mock_url'
        self.mock_base_review.time = 'mock_time'

    @patch(PATH + 'datetime')
    def test_format_duration_no_result(self,
                                       mock_datetime):
        """
        Tests 'format_duration' function where we have no result
        """
        # Set up mock return values and side effects
        mock_datetime.datetime.utcnow.return_value = datetime(2018, 2, 2)
        mock_created_at = datetime(2018, 3, 2)

        # Call the function
        response = BaseReview().format_duration(mock_created_at)

        # Validate function calls and response
        self.assertEqual('less than 1 minute', response)

    @patch(PATH + 'datetime')
    def test_format_duration_(self,
                              mock_datetime):
        """
        Tests 'format_duration' function
        """
        # Set up mock return values and side effects
        mock_datetime.datetime.utcnow.return_value = datetime(2018, 2, 2)
        mock_created_at = datetime(2018, 1, 2)

        # Call the function
        response = BaseReview().format_duration(mock_created_at)

        # Validate function calls and response
        self.assertEqual('1 month', response)

    @patch(PATH + 'BaseReview.format_duration')
    def test_format_oneline_one_comment(self,
                                        mock_format_duration):
        """
        Tests '_format_oneline' function with one comment and no last comments
        """
        # Set up mock return values and side effects
        service = self.mock_base_review
        self.mock_base_review.comments = 1
        mock_format_duration.return_value = 'mock_duration'

        # Call the function
        response = service._format_oneline(
            1, 1
        )

        # Validate function calls and response
        self.assertEqual("mock_user filed 'mock_title' "
                         "mock_url mock_duration ago, 1 comment",
                         response)

    @patch(PATH + 'BaseReview.format_duration')
    def test_format_oneline_last_comment(self,
                                         mock_format_duration):
        """
        Tests '_format_oneline' function with more than one
        comment and last comments
        """
        # Set up mock return values and side effects
        service = self.mock_base_review
        self.mock_base_review.comments = 10
        mock_last_comment = MagicMock()
        mock_last_comment.author = 'mock_author'
        mock_last_comment.last_comment.created_at = 'mock_created_at'
        mock_format_duration.return_value = 'mock_duration'
        self.mock_base_review.last_comment = mock_last_comment

        # Call the function
        response = service._format_oneline(
            1, 1
        )

        # Validate function calls and response
        self.assertEqual("mock_user filed 'mock_title' mock_url"
                         " mock_duration ago, 10 comments, "
                         "last comment by mock_author mock_duration ago",
                         response)

    @patch(PATH + 'BaseReview.format_duration')
    def test_format_indented_one_comment(self,
                                         mock_format_duration):
        """
        Tests '_format_indented' function with one comment and no last comments
        """
        # Set up mock return values and side effects
        service = self.mock_base_review
        self.mock_base_review.comments = 1
        mock_format_duration.return_value = 'mock_duration'

        # Call the function
        response = service._format_indented(
            1, 1, False
        )

        # Validate function calls and response
        self.assertEqual("mock_user filed 'mock_title'\n"
                         "\tmock_url\n\tmock_duration ago\n"
                         "\t1 comment",
                         response)

    @patch(PATH + 'BaseReview.format_duration')
    def test_format_indented_last_comment(self,
                                          mock_format_duration):
        """
        Tests '_format_indented' function with more than one
        comment and last comments
        """
        # Set up mock return values and side effects
        service = self.mock_base_review
        self.mock_base_review.comments = 10
        mock_last_comment = MagicMock()
        mock_last_comment.author = 'mock_author'
        mock_last_comment.last_comment.created_at = 'mock_created_at'
        mock_format_duration.return_value = 'mock_duration'
        self.mock_base_review.last_comment = mock_last_comment

        # Call the function
        response = service._format_indented(
            1, 1, True
        )

        # Validate function calls and response
        self.assertEqual("mock_user filed 'mock_title'"
                         "\n\tmock_url\n\tmock_duration"
                         " ago\n\t10 comments, last "
                         "comment by mock_author mock_"
                         "duration ago\n",
                         response)

    @patch(PATH + 'json')
    @patch(PATH + 'BaseReview.__json__')
    def test_format_json(self,
                         mock__json__,
                         mock_json):
        """
        Tests '_format_json' function
        """
        # Set up mock return values and side effects
        mock_json.dumps.return_value = 'mock_format_json'
        mock__json__.return_value = 'mock__json__'

        # Call the function
        response = BaseReview()._format_json(
            1, 2, 3
        )

        # Validate function calls and response
        self.assertEqual(response, 'mock_format_json')
        mock_json.dumps.assert_called_with('mock__json__', indent=2)
        mock__json__.assert_called_with(3)

    @patch(PATH + 'BaseReview.format_duration')
    def test_format_irc_one_comment(self,
                                    mock_format_duration):
        """
        Tests '_format_irc' function with one comment and no last comments
        """
        # Set up mock return values and side effects
        service = self.mock_base_review
        self.mock_base_review.comments = 1
        mock_format_duration.return_value = 'mock_duration'

        # Call the function
        response = service._format_irc()

        # Validate function calls and response
        self.assertEqual("\x02mock_user\x02 filed"
                         " \x02'mock_title'\x02"
                         " \x0312mock_url\x03 mock_duration ago, "
                         "1 comment",
                         response)

    @patch(PATH + 'BaseReview.format_duration')
    def test_format_irc_last_comment(self,
                                     mock_format_duration):
        """
        Tests '_format_irc' function with more than one
        comment and last comments
        """
        # Set up mock return values and side effects
        service = self.mock_base_review
        self.mock_base_review.comments = 10
        mock_last_comment = MagicMock()
        mock_last_comment.author = 'mock_author'
        mock_last_comment.last_comment.created_at = 'mock_created_at'
        mock_format_duration.return_value = 'mock_duration'
        self.mock_base_review.last_comment = mock_last_comment

        # Call the function
        response = service._format_irc()

        # Validate function calls and response
        self.assertEqual("\x02mock_user\x02 filed \x02'mock_title'\x02"
                         " \x0312mock_url\x03 mock_duration ago, 10 comments, "
                         "last comment by \x02mock_author\x02 mock_duration ago",
                         response)

import math
import torch
import torch.nn as nn
import torch.nn.functional as F


class BasicBlock(nn.Module):
    def __init__(self, in_planes, out_planes, dropRate=0.0):
        super(BasicBlock, self).__init__()
        self.bn1 = nn.BatchNorm2d(in_planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=1,
                               padding=1, bias=False)
        self.droprate = dropRate
    def forward(self, x):
        out = self.conv1(self.relu(self.bn1(x)))
        if self.droprate > 0:
            out = F.dropout(out, p=self.droprate, training=self.training)
        return torch.cat([x, out], 1)

class BottleneckBlock(nn.Module):
    def __init__(self, in_planes, out_planes, dropRate=0.0):
        super(BottleneckBlock, self).__init__()
        inter_planes = out_planes * 4
        self.bn1 = nn.BatchNorm2d(in_planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv1 = nn.Conv2d(in_planes, inter_planes, kernel_size=1, stride=1,
                               padding=0, bias=False)
        self.bn2 = nn.BatchNorm2d(inter_planes)
        self.conv2 = nn.Conv2d(inter_planes, out_planes, kernel_size=3, stride=1,
                               padding=1, bias=False)
        self.droprate = dropRate
    def forward(self, x):
        out = self.conv1(self.relu(self.bn1(x)))
        if self.droprate > 0:
            out = F.dropout(out, p=self.droprate, inplace=False, training=self.training)
        out = self.conv2(self.relu(self.bn2(out)))
        if self.droprate > 0:
            out = F.dropout(out, p=self.droprate, inplace=False, training=self.training)
        return torch.cat([x, out], 1)

class TransitionBlock(nn.Module):
    def __init__(self, in_planes, out_planes, dropRate=0.0):
        super(TransitionBlock, self).__init__()
        self.bn1 = nn.BatchNorm2d(in_planes)
        self.relu = nn.ReLU(inplace=True)
        self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=1,
                               padding=0, bias=False)
        self.droprate = dropRate
    def forward(self, x):
        out = self.conv1(self.relu(self.bn1(x)))
        if self.droprate > 0:
            out = F.dropout(out, p=self.droprate, inplace=False, training=self.training)
        return F.avg_pool2d(out, 2)

class DenseBlock(nn.Module):
    def __init__(self, nb_layers, in_planes, growth_rate, block, dropRate=0.0):
        super(DenseBlock, self).__init__()
        self.layer = self._make_layer(block, in_planes, growth_rate, nb_layers, dropRate)
    def _make_layer(self, block, in_planes, growth_rate, nb_layers, dropRate):
        layers = []
        for i in range(nb_layers):
            layers.append(block(in_planes+i*growth_rate, growth_rate, dropRate))
        return nn.Sequential(*layers)
    def forward(self, x):
        return self.layer(x)

class DenseNet3(nn.Module):
    def __init__(self, depth, num_classes, growth_rate=12,
                 reduction=0.5, bottleneck=True, dropRate=0.0):
        super(DenseNet3, self).__init__()
        in_planes = 2 * growth_rate
        n = (depth - 4) / 3
        if bottleneck == True:
            n = n/2
            block = BottleneckBlock
        else:
            block = BasicBlock
        n = int(n)
        # 1st conv before any dense block
        self.conv1 = nn.Conv2d(3, in_planes, kernel_size=3, stride=1,
                               padding=1, bias=False)
        # 1st block
        self.block1 = DenseBlock(n, in_planes, growth_rate, block, dropRate)
        in_planes = int(in_planes+n*growth_rate)
        self.trans1 = TransitionBlock(in_planes, int(math.floor(in_planes*reduction)), dropRate=dropRate)
        in_planes = int(math.floor(in_planes*reduction))
        # 2nd block
        self.block2 = DenseBlock(n, in_planes, growth_rate, block, dropRate)
        in_planes = int(in_planes+n*growth_rate)
        self.trans2 = TransitionBlock(in_planes, int(math.floor(in_planes*reduction)), dropRate=dropRate)
        in_planes = int(math.floor(in_planes*reduction))
        # 3rd block
        self.block3 = DenseBlock(n, in_planes, growth_rate, block, dropRate)
        in_planes = int(in_planes+n*growth_rate)
        # global average pooling and classifier
        self.bn1 = nn.BatchNorm2d(in_planes)
        self.relu = nn.ReLU(inplace=True)
        self.fc = nn.Linear(in_planes, num_classes)
        self.in_planes = in_planes

        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.data.normal_(0, math.sqrt(2. / n))
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                m.bias.data.zero_()
    def forward(self, x):
        out = self.conv1(x)
        out = self.trans1(self.block1(out))
        out = self.trans2(self.block2(out))
        out = self.block3(out)
        out = self.relu(self.bn1(out))
        out = F.avg_pool2d(out, 8)
        out = out.view(-1, self.in_planes)
        return self.fc(out)

import pytz

import logging
import requests
from dateutil.parser import parse
from datetime import datetime, timedelta
from django.utils import timezone

from website.app import init_app
from scripts.analytics.base import SummaryAnalytics

logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)

LOG_THRESHOLD = 11


class PreprintSummary(SummaryAnalytics):

    @property
    def collection_name(self):
        return 'preprint_summary'

    def get_events(self, date):
        super(PreprintSummary, self).get_events(date)
        from osf.models import PreprintProvider

        # Convert to a datetime at midnight for queries and the timestamp
        timestamp_datetime = datetime(date.year, date.month, date.day).replace(tzinfo=pytz.UTC)
        query_datetime = timestamp_datetime + timedelta(days=1)

        elastic_query = {
            'query': {
                'bool': {
                    'must': [
                        {
                            'match': {
                                'type': 'preprint'
                            }
                        },
                        {
                            'match': {
                                'sources': None
                            }
                        }
                    ],
                    'filter': [
                        {
                            'range': {
                                'date': {
                                    'lte': '{}||/d'.format(query_datetime.strftime('%Y-%m-%d'))
                                }
                            }
                        }
                    ]
                }
            }
        }

        counts = []
        for preprint_provider in PreprintProvider.objects.all():
            name = preprint_provider.name if preprint_provider.name != 'Open Science Framework' else 'OSF'
            elastic_query['query']['bool']['must'][1]['match']['sources'] = name
            resp = requests.post('https://share.osf.io/api/v2/search/creativeworks/_search', json=elastic_query).json()
            counts.append({
                'keen': {
                    'timestamp': timestamp_datetime.isoformat()
                },
                'provider': {
                    'name': preprint_provider.name,
                    'total': resp['hits']['total'],
                },
            })
            logger.info('{} Preprints counted for the provider {}'.format(resp['hits']['total'], preprint_provider.name))

        return counts


def get_class():
    return PreprintSummary


if __name__ == '__main__':
    init_app()

    preprint_summary = PreprintSummary()
    args = preprint_summary.parse_args()
    yesterday = args.yesterday
    if yesterday:
        date = (timezone.now() - timedelta(days=1)).date()
    else:
        date = parse(args.date).date() if args.date else None
    events = preprint_summary.get_events(date)
    preprint_summary.send_events(events)

# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for debugger functionalities in tf.Session with grpc:// URLs.

This test focus on grpc:// debugging of distributed (gRPC) sessions.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import json
import subprocess
import sys
import time

import portpicker
from six.moves import xrange  # pylint: disable=redefined-builtin

from tensorflow.core.protobuf import config_pb2
from tensorflow.python.client import session
from tensorflow.python.debug.lib import debug_utils
from tensorflow.python.debug.lib import grpc_debug_test_server
from tensorflow.python.debug.wrappers import framework
from tensorflow.python.debug.wrappers import grpc_wrapper
from tensorflow.python.framework import ops
from tensorflow.python.framework import test_util
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import state_ops
from tensorflow.python.ops import variables
from tensorflow.python.platform import googletest
from tensorflow.python.platform import test
from tensorflow.python.platform import tf_logging


class DistributedSessionDebugTest(test_util.TensorFlowTestCase):
  """Test the debugging of distributed sessions."""

  PER_PROC_GPU_MEMORY_FRACTION = 0.1
  POLLING_INTERVAL_SEC = 0.025

  @classmethod
  def setUpClass(cls):
    gpu_memory_fraction_opt = (
        "--gpu_memory_fraction=%f" % cls.PER_PROC_GPU_MEMORY_FRACTION)

    worker_port = portpicker.pick_unused_port()
    cluster_spec = "worker|localhost:%d" % worker_port
    tf_logging.info("cluster_spec: %s", cluster_spec)

    server_bin = test.test_src_dir_path(
        "tools/dist_test/server/grpc_tensorflow_server")

    cls.server_target = "grpc://localhost:%d" % worker_port

    cls.server_procs = {}
    cls.server_procs["worker"] = subprocess.Popen(
        [
            server_bin,
            "--cluster_spec=%s" % cluster_spec,
            "--job_name=worker",
            "--task_id=0",
            gpu_memory_fraction_opt,
        ],
        stdout=sys.stdout,
        stderr=sys.stderr)

    # Start debug server in-process, on separate thread.
    (cls.debug_server_port, cls.debug_server_url, _, cls.debug_server_thread,
     cls.debug_server
    ) = grpc_debug_test_server.start_server_on_separate_thread(
        dump_to_filesystem=False)
    tf_logging.info("debug server url: %s", cls.debug_server_url)

    cls.session_config = config_pb2.ConfigProto(
        gpu_options=config_pb2.GPUOptions(
            per_process_gpu_memory_fraction=cls.PER_PROC_GPU_MEMORY_FRACTION))

  @classmethod
  def tearDownClass(cls):
    for key in cls.server_procs:
      cls.server_procs[key].terminate()
    cls.debug_server.stop_server().wait()
    cls.debug_server_thread.join()

  def setUp(self):
    pass

  def tearDown(self):
    self.debug_server.clear_data()

  def _pollingAssertDebugTensorValuesAllClose(self, expected_values,
                                              debug_tensor_name):
    """Poll debug_server till tensor appears and matches expected values."""
    while (debug_tensor_name not in self.debug_server.debug_tensor_values or
           len(self.debug_server.debug_tensor_values) < len(expected_values)):
      time.sleep(self.POLLING_INTERVAL_SEC)
    self.assertAllClose(
        expected_values,
        self.debug_server.debug_tensor_values[debug_tensor_name])

  def _createGraph(self):
    """Create graph for testing.

    Returns:
      Python Graph object.
    """
    with ops.Graph().as_default() as graph:
      with ops.device("/job:worker/task:0/cpu:0"):
        self.a = variables.Variable(10.0, name="a")
        self.b = variables.Variable(100.0, name="b")
        self.inc_a = state_ops.assign_add(self.a, 2.0, name="inc_a")
        self.dec_b = state_ops.assign_add(self.b, -5.0, name="dec_b")
        self.p = math_ops.multiply(self.inc_a, self.dec_b, name="p")
        self.q = math_ops.negative(self.p, name="q")
    return graph

  def testDistributedRunWithGatedGrpcCommunicatesWithDebugServerCorrectly(self):
    graph = self._createGraph()
    with session.Session(
        config=self.session_config, graph=graph,
        target=self.server_target) as sess:
      sess.run(self.a.initializer)
      sess.run(self.b.initializer)

      run_options = config_pb2.RunOptions()
      debug_utils.watch_graph(
          run_options,
          sess.graph,
          node_name_regex_whitelist=r"a",
          debug_ops=["DebugIdentity"],
          debug_urls=[self.debug_server_url])

      # Test gated_grpc for an op located on the worker, i.e., on the same
      # host as where MasterSession is.
      # TODO(cais): gRPC gating of debug ops does not work on partition graphs
      # not located on MasterSession hosts (e.g., parameter servers) yet. Make
      # it work.
      debug_utils.watch_graph(
          run_options,
          sess.graph,
          node_name_regex_whitelist=r"p",
          debug_ops=["DebugIdentity(gated_grpc=True)"],
          debug_urls=[self.debug_server_url])

      for i in xrange(4):
        # N.B.: These requests will be fulfilled not in this debugged
        # Session.run() invocation, but in the next one.
        if i % 2 == 0:
          self.debug_server.request_watch("p", 0, "DebugIdentity")
        else:
          self.debug_server.request_unwatch("p", 0, "DebugIdentity")

        expected_p = (10.0 + 2.0 * (i + 1)) * (100.0 - 5.0 * (i + 1))
        self.assertAllClose(-expected_p, sess.run(self.q, options=run_options))

        self.assertEqual(1, len(self.debug_server.core_metadata_json_strings))
        core_metadata = json.loads(
            self.debug_server.core_metadata_json_strings[0])
        self.assertEqual([], core_metadata["input_names"])
        self.assertEqual(["q:0"], core_metadata["output_names"])
        self.assertEqual(i, core_metadata["executor_step_index"])

        if i == 0:
          self.assertEqual(1, len(self.debug_server.partition_graph_defs))

        # Tensor "a" is from a PS. It may take longer to arrive due to the fact
        # that the stream connection between the PS and the debug server is
        # persistent and not torn down at the end of each Session.run()
        self._pollingAssertDebugTensorValuesAllClose([10.0 + 2.0 * i],
                                                     "a:0:DebugIdentity")

        # Due to the gRPC gating of the debug op for "p", the debug tensor
        # should be available on odd-indexed runs.
        if i % 2 == 0:
          self.assertNotIn("p:0:DebugIdentity",
                           self.debug_server.debug_tensor_values)
        else:
          self.assertAllClose(
              [expected_p],
              self.debug_server.debug_tensor_values["p:0:DebugIdentity"])

        self.assertNotIn("b:0:DebugIdentity",
                         self.debug_server.debug_tensor_values)
        self.debug_server.clear_data()

  def testDistributedRunWithGrpcDebugWrapperWorks(self):
    graph = self._createGraph()
    with session.Session(
        config=self.session_config, graph=graph,
        target=self.server_target) as sess:
      sess.run(self.a.initializer)
      sess.run(self.b.initializer)

      def watch_fn(feeds, fetch_keys):
        del feeds, fetch_keys
        return framework.WatchOptions(
            debug_ops=["DebugIdentity"],
            node_name_regex_whitelist=r"p")
      sess = grpc_wrapper.GrpcDebugWrapperSession(
          sess, "localhost:%d" % self.debug_server_port, watch_fn=watch_fn)

      for i in xrange(4):
        expected_p = (10.0 + 2.0 * (i + 1)) * (100.0 - 5.0 * (i + 1))
        self.assertAllClose(-expected_p, sess.run(self.q))

        if i == 0:
          self.assertEqual(1, len(self.debug_server.partition_graph_defs))

        self.assertAllClose(
            [expected_p],
            self.debug_server.debug_tensor_values["p:0:DebugIdentity"])
        self.assertNotIn("b:0:DebugIdentity",
                         self.debug_server.debug_tensor_values)
        self.debug_server.clear_data()


if __name__ == "__main__":
  googletest.main()

# -*- coding: utf-8 -*-
##############################################################################
#
#    Copyright (C) 2004-2012 Pexego Sistemas Informáticos All Rights Reserved
#    $Marta Vázquez Rodríguez$ <marta@pexego.es>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as published
#    by the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################
from osv import osv, fields
import decimal_precision as dp

class weighted_average_price(osv.osv):
    _name = 'weighted.average.price'
    _description = 'Records, for each product, the PMP and the stock in a date.'

    def _product_qty_available(self, cr, uid, ids, field_names, arg, context=None):
        if context is None:
            context = {}
        c = context.copy()
        res = {}
        
        for line in self.browse(cr, uid, ids, context=context):
            c.update({'to_date': line.date})
            if line.move_id.state != 'done':
                res[line.id] = self.pool.get('product.product').browse(cr, uid, line.product_id.id, context=c).qty_available + self.pool.get('product.uom')._compute_qty(cr, uid, line.move_id.product_uom.id, line.move_id.product_qty, line.product_id.uom_id.id)
            else:
                res[line.id] = self.pool.get('product.product').browse(cr, uid, line.product_id.id, context=c).qty_available
        return res

    _columns = {
        'name': fields.char('Name', size=20, required=True, readonly=True),
        'product_id': fields.many2one('product.product', 'Product', required=True,readonly=True),
        'date': fields.datetime('Date', required=True,readonly=True),
        'pmp': fields.float('PMP', digits_compute=dp.get_precision('Purchase Price'), required=True,readonly=True),
        'move_id': fields.many2one('stock.move', 'Stock move', required=True,readonly=True),
        'company_id': fields.many2one('res.company', 'Company', readonly=True),
        'stock_qty': fields.function(_product_qty_available, type='float', string='Stock qty.'),
        'pmp_old': fields.float('PMP Old', digits_compute=dp.get_precision('Purchase Price'), readonly=True),
        
    }
    _defaults = {
        'name': "_CODE AUTOGENERATE"
    }
    def create(self, cr, uid, vals, context=None):
        if vals.get('name', "_CODE AUTOGENERATE") == '_CODE AUTOGENERATE':
            sequence = self.pool.get('ir.sequence').get(cr, uid, 'weighted.average.price')
            vals['name'] = sequence

        return super(weighted_average_price, self).create(cr, uid, vals, context)
    
weighted_average_price()

# Copyright 2017 Capital One Services, LLC
#
# 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.
from __future__ import absolute_import, division, print_function, unicode_literals

from .common import BaseTest, functional

# datapipeline is not available in us-east-2 where we run our functional tests
# so we do a forced override here.
REGION = 'us-west-2'


class DataPipelineTest(BaseTest):

    def test_reporting(self):
        factory = self.replay_flight_data('test_datapipeline_reporting')

        session = factory()
        client = session.client('datapipeline')
        pipeline = client.create_pipeline(
            name='PipelinesFTW', uniqueId='PipelinesFTW')
        pipe_id = pipeline['pipelineId']
        client.put_pipeline_definition(
            pipelineId=pipe_id,
            pipelineObjects=
                [{"id": "Default", "name": "Default", "fields": [
                    {"key": "workerGroup", "stringValue": "workerGroup"}]},
                 {"id": "Schedule", "name": "Schedule", "fields": [
                    {"key": "startDateTime",
                     "stringValue": "2012-12-12T00:00:00"},
                    {"key": "type", "stringValue": "Schedule"},
                    {"key": "period", "stringValue": "1 hour"},
                    {"key": "endDateTime",
                     "stringValue": "2012-12-21T18:00:00"}]},
                 {"id": "SayHello", "name": "SayHello", "fields": [
                    {"key": "type", "stringValue": "ShellCommandActivity"},
                    {"key": "command", "stringValue": "echo hello"},
                    {"key": "parent", "refValue": "Default"},
                    {"key": "schedule", "refValue": "Schedule"}]}
                  ])
        client.add_tags(
            pipelineId=pipe_id,
            tags=[{'key': 'foo', 'value': 'bar'}]
        )
        client.activate_pipeline(pipelineId=pipe_id)
        self.addCleanup(client.delete_pipeline, pipelineId=pipe_id)

        p = self.load_policy({
            'name': 'datapipeline-report',
            'resource': 'datapipeline',
            'filters': [
                {'tag:foo': 'bar'}],
            },
            config={'region': REGION},
            session_factory=factory)
        resources = p.run()
        self.assertEqual(len(resources), 1)
        resource = resources[0]
        self.assertEqual(resource['name'], 'PipelinesFTW')
        self.assertEqual(resource['Tags'], [{'Key': 'foo', 'Value': 'bar'}])
        self.assertEqual(resource['lastActivationTime'], '2017-03-13T11:37:36')
        self.assertEqual(resource['creationTime'], '2017-03-13T11:37:34')
        self.assertEqual(resource['sphere'], 'PIPELINE')
        self.assertEqual(resource['version'], '1')
        self.assertEqual(resource['id'], 'df-0993359USAD6HT96D2W')
        self.assertEqual(resource['pipelineState'], 'SCHEDULING')
        self.assertEqual(resource['accountId'], '644160558196')
        self.assertEqual(resource['userId'], 'AIDAIXI7ULG2SDYI3RBNM')
        self.assertEqual(resource['firstActivationTime'], '2017-03-13T11:37:36')


    def test_delete_datapipeline(self):
        factory = self.replay_flight_data('test_datapipeline_delete')
        p = self.load_policy({
            'name': 'delete-datapipeline',
            'resource': 'datapipeline',
            'filters': [{'name': 'test-delete-pipeline'}],
            'actions': ['delete']
        }, session_factory=factory)
        resources = p.run()
        self.assertEqual(len(resources), 1)
        self.assertEqual(resources[0]['name'], 'test-delete-pipeline')
        client = factory().client('datapipeline')
        removed = client.describe_pipelines(pipelineIds=[resources[0]['id']])
        self.assertEqual(removed['pipelineDescriptionList'][0]['fields'][12]['stringValue'], 'DELETING')


    @functional
    def test_tag_datapipeline(self):
        factory = self.replay_flight_data('test_datapipeline_tag', region=REGION)

        session = factory()
        client = session.client('datapipeline')
        pipeline = client.create_pipeline(
            name='PipelineTagTest', uniqueId='PipelineTagTest1')
        pipe_id = pipeline['pipelineId']
        self.addCleanup(client.delete_pipeline, pipelineId=pipe_id)
        p = self.load_policy({
            'name': 'datapipeline-tag-test',
            'resource': 'datapipeline',
            'filters': [
                {'name': 'PipelineTagTest'}],
            'actions': [
                {'type': 'tag',
                 'key': 'key1',
                 'value': 'value1'
                }]
            },
            session_factory=factory)
        resources = p.run()
        response = client.describe_pipelines(
            pipelineIds=[pipe_id])
        self.assertEqual(response['pipelineDescriptionList'][0]['tags'], [{'key': 'key1', 'value': 'value1'}])

    @functional
    def test_mark_datapipeline(self):
        factory = self.replay_flight_data('test_datapipeline_mark', region=REGION)

        session = factory()
        client = session.client('datapipeline')
        pipeline = client.create_pipeline(
            name='PipelineMarkTest', uniqueId='PipelineMarkTest1')
        pipe_id = pipeline['pipelineId']
        self.addCleanup(client.delete_pipeline, pipelineId=pipe_id)
        p = self.load_policy({
            'name': 'datapipeline-mark-test',
            'resource': 'datapipeline',
            'filters': [
                {'name': 'PipelineMarkTest'}],
            'actions': [
                {'type': 'mark-for-op',
                 'tag': 'custodian_mark',
                 'op': 'delete',
                 'msg': 'marked for op with no date',
                 'days': 7
                }]
            },
            session_factory=factory)
        resources = p.run()
        response = client.describe_pipelines(
            pipelineIds=[pipe_id])
        self.assertEqual(response['pipelineDescriptionList'][0]['tags'], [{'key': 'custodian_mark', 'value': 'marked for op with no date'}])


    @functional
    def test_remove_tag_datapipeline(self):
        factory = self.replay_flight_data('test_datapipeline_remove_tag', region=REGION)

        session = factory()
        client = session.client('datapipeline')
        pipeline = client.create_pipeline(
            name='PipelineRemoveTagTest', uniqueId='PipelineRemoveTagTest1')
        pipe_id = pipeline['pipelineId']

        self.addCleanup(client.delete_pipeline, pipelineId=pipe_id)

        client.add_tags(pipelineId=pipe_id, tags=[{'key':'tag_to_remove','value':'value of tag to remove'}])
        response1 = client.describe_pipelines(
            pipelineIds=[pipe_id])
        num_tags = len(response1['pipelineDescriptionList'][0]['tags'])
        
        p = self.load_policy({
            'name': 'datapipeline-remove-tag-test',
            'resource': 'datapipeline',
            'filters': [
                {'name': 'PipelineRemoveTagTest'}],
            'actions': [
                {'type': 'remove-tag',
                 'tags': ['tag_to_remove']
                }]
            },
            session_factory=factory)
        resources = p.run()
        response2 = client.describe_pipelines(
            pipelineIds=[pipe_id])
        self.assertEqual(len(response2['pipelineDescriptionList'][0]['tags']), num_tags-1)

    @functional
    def test_marked_for_op_datapipeline(self):
        factory = self.replay_flight_data('test_datapipeline_marked_for_op', region=REGION)

        session = factory()
        client = session.client('datapipeline')
        pipeline = client.create_pipeline(
            name='PipelineMarkedForOpTest', uniqueId='PipelineMarkedForOpTest1')
        pipe_id = pipeline['pipelineId']

        self.addCleanup(client.delete_pipeline, pipelineId=pipe_id)

        client.add_tags(pipelineId=pipe_id, tags=[{'key':'pipeline_marked_for_op','value':'Pipeline marked for op: delete@2017-12-01'}])
        
        p = self.load_policy({
            'name': 'datapipeline-marked-for-op-test',
            'resource': 'datapipeline',
            'filters': [
                {'type': 'marked-for-op',
                 'tag': 'pipeline_marked_for_op',
                 'op': 'delete'
                }]
            },
            session_factory=factory)
        resources = p.run()
        self.assertEqual(len(resources), 1)

# -*- coding: utf-8 -*-
#
# NESTClient_script.py
#
# This file is part of NEST.
#
# Copyright (C) 2004 The NEST Initiative
#
# NEST is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# NEST is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with NEST.  If not, see <http://www.gnu.org/licenses/>.

import nest


# Reset kernel
nest.ResetKernel()

# Create nodes
pg = nest.Create("poisson_generator", params={"rate": 6500.})
neurons = nest.Create("iaf_psc_alpha", 100)
sr = nest.Create("spike_recorder")

# Connect nodes
nest.Connect(pg, neurons, syn_spec={"weight": 10.})
nest.Connect(neurons, sr)

# Simulate
nest.Simulate(1000.)

# Get events
n_events = sr.get("n_events")

import pytest
import numpy as np
import tensorflow as tf
from mock import Mock

from tfsnippet import StochasticTensor, FlowDistributionDerivedTensor
from tfsnippet.distributions import Normal, Categorical, FlowDistribution
from tfsnippet.layers import ReshapeFlow
from tfsnippet.utils import get_static_shape
from tests.layers.flows.helper import QuadraticFlow


class FlowDistributionTestCase(tf.test.TestCase):

    def test_errors(self):
        # errors in constructor
        normal = Normal(mean=tf.zeros([3]), std=1.)
        with pytest.raises(TypeError, match='`flow` is not an instance of '
                                            '`BaseFlow`: 123'):
            _ = FlowDistribution(normal, 123)

        flow = QuadraticFlow(2., 5., value_ndims=1)
        with pytest.raises(ValueError,
                           match='cannot be transformed by a flow, because '
                                 'it is not continuous'):
            _ = FlowDistribution(Categorical(logits=[0., 1., 2.]), flow)

        with pytest.raises(ValueError,
                           match='cannot be transformed by a flow, because '
                                 'its data type is not float'):
            _ = FlowDistribution(Mock(normal, dtype=tf.int32), flow)

        with pytest.raises(ValueError,
                           match='cannot be transformed by flow .*, because '
                                 'distribution.value_ndims is larger than '
                                 'flow.x_value_ndims'):
            _ = FlowDistribution(Mock(normal, value_ndims=2), flow)

        # errors in sample
        distrib = FlowDistribution(normal, flow)
        with pytest.raises(RuntimeError,
                           match='`FlowDistribution` requires `compute_prob` '
                                 'not to be False'):
            _ = distrib.sample(compute_density=False)

    def test_property(self):
        normal = Normal(mean=tf.constant([0., 1., 2.], dtype=tf.float64),
                        std=tf.constant(1., dtype=tf.float64))
        flow = QuadraticFlow(2., 5., value_ndims=1)
        distrib = FlowDistribution(normal, flow)

        self.assertIs(distrib.flow, flow)
        self.assertIs(distrib.base_distribution, normal)
        self.assertEqual(distrib.dtype, tf.float64)
        self.assertTrue(distrib.is_continuous)
        self.assertTrue(distrib.is_reparameterized)
        self.assertEqual(distrib.value_ndims, 1)

        # self.assertEqual(distrib.get_value_shape(), normal.get_value_shape())
        # self.assertEqual(distrib.get_batch_shape(), normal.get_batch_shape())
        # with self.test_session() as sess:
        #     np.testing.assert_equal(
        #         *sess.run([distrib.value_shape, normal.value_shape]))
        #     np.testing.assert_equal(
        #         *sess.run([distrib.batch_shape, normal.batch_shape]))

        # test is_reparameterized = False
        normal = Normal(mean=[0., 1., 2.], std=1., is_reparameterized=False)
        distrib = FlowDistribution(normal, flow)
        self.assertFalse(distrib.is_reparameterized)

        # test y_value_ndims = 2
        distrib = FlowDistribution(normal, ReshapeFlow(1, [-1, 1]))
        self.assertEqual(distrib.value_ndims, 2)

    def test_sample(self):
        tf.set_random_seed(123456)

        mean = tf.constant([0., 1., 2.], dtype=tf.float64)
        normal = Normal(mean=mean, std=tf.constant(1., dtype=tf.float64))
        flow = QuadraticFlow(2., 5.)
        distrib = FlowDistribution(normal, flow)

        # test ordinary sample, is_reparameterized = None
        y = distrib.sample(n_samples=5)
        self.assertTrue(y.is_reparameterized)
        self.assertIsInstance(y.flow_origin, StochasticTensor)
        self.assertIs(y.flow_origin.distribution, normal)

        grad = tf.gradients(y * 1., mean)[0]
        self.assertIsNotNone(grad)
        self.assertEqual(get_static_shape(y), (5, 3))
        self.assertIsNotNone(y._self_log_prob)

        log_prob = y.log_prob()
        self.assertIsInstance(log_prob, FlowDistributionDerivedTensor)
        self.assertIs(log_prob.flow_origin, y.flow_origin)

        prob = y.prob()
        self.assertIsInstance(prob, FlowDistributionDerivedTensor)
        self.assertIs(prob.flow_origin, y.flow_origin)

        x, log_det = flow.inverse_transform(y)
        log_py = normal.log_prob(x) + log_det
        py = tf.exp(log_py)

        with self.test_session() as sess:
            np.testing.assert_allclose(
                *sess.run([y.flow_origin, x]), rtol=1e-5)
            np.testing.assert_allclose(
                *sess.run([log_py, log_prob]), rtol=1e-5)
            np.testing.assert_allclose(
                *sess.run([py, prob]), rtol=1e-5)

        # test stop gradient sample, is_reparameterized = False
        y = distrib.sample(n_samples=5, is_reparameterized=False)
        self.assertFalse(y.is_reparameterized)
        grad = tf.gradients(y * 1., mean)[0]
        self.assertIsNone(grad)

    def test_sample_value_and_group_ndims(self):
        tf.set_random_seed(123456)

        mean = tf.constant([0., 1., 2.], dtype=tf.float64)
        normal = Normal(mean=mean, std=tf.constant(1., dtype=tf.float64))

        with self.test_session() as sess:
            # test value_ndims = 0, group_ndims = 1
            flow = QuadraticFlow(2., 5.)
            distrib = FlowDistribution(normal, flow)
            self.assertEqual(distrib.value_ndims, 0)

            y = distrib.sample(n_samples=5, group_ndims=1)
            self.assertTupleEqual(get_static_shape(y), (5, 3))
            x, log_det = flow.inverse_transform(y)
            self.assertTupleEqual(get_static_shape(x), (5, 3))
            self.assertTupleEqual(get_static_shape(log_det), (5, 3))
            log_py = tf.reduce_sum(normal.log_prob(x) + log_det, axis=-1)

            np.testing.assert_allclose(*sess.run([y.log_prob(), log_py]),
                                       rtol=1e-5)

            # test value_ndims = 1, group_ndims = 0
            flow = QuadraticFlow(2., 5., value_ndims=1)
            distrib = FlowDistribution(normal, flow)
            self.assertEqual(distrib.value_ndims, 1)

            y = distrib.sample(n_samples=5, group_ndims=0)
            self.assertTupleEqual(get_static_shape(y), (5, 3))
            x, log_det = flow.inverse_transform(y)
            self.assertTupleEqual(get_static_shape(x), (5, 3))
            self.assertTupleEqual(get_static_shape(log_det), (5,))
            log_py = log_det + tf.reduce_sum(normal.log_prob(x), axis=-1)

            np.testing.assert_allclose(*sess.run([y.log_prob(), log_py]),
                                       rtol=1e-5)

            # test value_ndims = 1, group_ndims = 1
            flow = QuadraticFlow(2., 5., value_ndims=1)
            distrib = FlowDistribution(normal, flow)
            self.assertEqual(distrib.value_ndims, 1)

            y = distrib.sample(n_samples=5, group_ndims=1)
            self.assertTupleEqual(get_static_shape(y), (5, 3))
            x, log_det = flow.inverse_transform(y)
            self.assertTupleEqual(get_static_shape(x), (5, 3))
            self.assertTupleEqual(get_static_shape(log_det), (5,))
            log_py = tf.reduce_sum(
                log_det + tf.reduce_sum(normal.log_prob(x), axis=-1))

            np.testing.assert_allclose(*sess.run([y.log_prob(), log_py]),
                                       rtol=1e-5)

    def test_log_prob(self):
        mean = tf.constant([0., 1., 2.], dtype=tf.float64)
        normal = Normal(mean=mean, std=tf.constant(1., dtype=tf.float64))
        flow = QuadraticFlow(2., 5.)
        flow.build(tf.constant(0., dtype=tf.float64))
        distrib = FlowDistribution(normal, flow)

        y = tf.constant([1., -1., 2.], dtype=tf.float64)
        x, log_det = flow.inverse_transform(y)
        log_py = normal.log_prob(x) + log_det
        py = tf.exp(log_py)

        log_prob = distrib.log_prob(y)
        self.assertIsInstance(log_prob, FlowDistributionDerivedTensor)
        self.assertIsInstance(log_prob.flow_origin, StochasticTensor)
        self.assertIs(log_prob.flow_origin.distribution, normal)

        prob = distrib.prob(y)
        self.assertIsInstance(prob, FlowDistributionDerivedTensor)
        self.assertIsInstance(prob.flow_origin, StochasticTensor)
        self.assertIs(prob.flow_origin.distribution, normal)

        with self.test_session() as sess:
            np.testing.assert_allclose(
                *sess.run([log_prob.flow_origin, x]), rtol=1e-5)
            np.testing.assert_allclose(
                *sess.run([log_py, log_prob]), rtol=1e-5)
            np.testing.assert_allclose(
                *sess.run([py, prob]), rtol=1e-5)

    def test_log_prob_value_and_group_ndims(self):
        tf.set_random_seed(123456)

        mean = tf.constant([0., 1., 2.], dtype=tf.float64)
        normal = Normal(mean=mean, std=tf.constant(1., dtype=tf.float64))
        y = tf.random_normal(shape=[2, 5, 3], dtype=tf.float64)

        with self.test_session() as sess:
            # test value_ndims = 0, group_ndims = 1
            flow = QuadraticFlow(2., 5.)
            flow.build(tf.zeros([2, 5, 3], dtype=tf.float64))
            distrib = FlowDistribution(normal, flow)
            self.assertEqual(distrib.value_ndims, 0)

            x, log_det = flow.inverse_transform(y)
            self.assertTupleEqual(get_static_shape(x), (2, 5, 3))
            self.assertTupleEqual(get_static_shape(log_det), (2, 5, 3))
            log_py = tf.reduce_sum(normal.log_prob(x) + log_det, axis=-1)

            np.testing.assert_allclose(
                *sess.run([distrib.log_prob(y, group_ndims=1), log_py]),
                rtol=1e-5
            )

            # test value_ndims = 1, group_ndims = 0
            flow = QuadraticFlow(2., 5., value_ndims=1)
            flow.build(tf.zeros([2, 5, 3], dtype=tf.float64))
            distrib = FlowDistribution(normal, flow)
            self.assertEqual(distrib.value_ndims, 1)

            x, log_det = flow.inverse_transform(y)
            self.assertTupleEqual(get_static_shape(x), (2, 5, 3))
            self.assertTupleEqual(get_static_shape(log_det), (2, 5))
            log_py = normal.log_prob(x, group_ndims=1) + log_det

            np.testing.assert_allclose(
                *sess.run([distrib.log_prob(y, group_ndims=0), log_py]),
                rtol=1e-5
            )

            # test value_ndims = 1, group_ndims = 2
            flow = QuadraticFlow(2., 5., value_ndims=1)
            flow.build(tf.zeros([2, 5, 3], dtype=tf.float64))
            distrib = FlowDistribution(normal, flow)
            self.assertEqual(distrib.value_ndims, 1)

            x, log_det = flow.inverse_transform(y)
            self.assertTupleEqual(get_static_shape(x), (2, 5, 3))
            self.assertTupleEqual(get_static_shape(log_det), (2, 5))
            log_py = tf.reduce_sum(
                log_det + tf.reduce_sum(normal.log_prob(x), axis=-1))

            np.testing.assert_allclose(
                *sess.run([distrib.log_prob(y, group_ndims=2), log_py]),
                rtol=1e-5
            )


__all__ = ['average', 'histogram', 'standardDeviation', 'variance']

import numpy.oldnumeric as Numeric

def average(data):
    data = Numeric.array(data)
    return Numeric.add.reduce(data)/len(data)

def variance(data):
    data = Numeric.array(data)
    return Numeric.add.reduce((data-average(data,axis=0))**2)/(len(data)-1)

def standardDeviation(data):
    data = Numeric.array(data)
    return Numeric.sqrt(variance(data))

def histogram(data, nbins, range = None):
    data = Numeric.array(data, Numeric.Float)
    if range is None:
        min = Numeric.minimum.reduce(data)
        max = Numeric.maximum.reduce(data)
    else:
        min, max = range
        data = Numeric.repeat(data,
                              Numeric.logical_and(Numeric.less_equal(data, max),
                                                  Numeric.greater_equal(data,
                                                                        min)),axis=0)
    bin_width = (max-min)/nbins
    data = Numeric.floor((data - min)/bin_width).astype(Numeric.Int)
    histo = Numeric.add.reduce(Numeric.equal(
        Numeric.arange(nbins)[:,Numeric.NewAxis], data), -1)
    histo[-1] = histo[-1] + Numeric.add.reduce(Numeric.equal(nbins, data))
    bins = min + bin_width*(Numeric.arange(nbins)+0.5)
    return Numeric.transpose(Numeric.array([bins, histo]))

import argparse

from django.contrib.gis import gdal
from django.core.management.base import BaseCommand, CommandError
from django.utils.inspect import get_func_args


class LayerOptionAction(argparse.Action):
    """
    Custom argparse action for the `ogrinspect` `layer_key` keyword option
    which may be an integer or a string.
    """
    def __call__(self, parser, namespace, value, option_string=None):
        try:
            setattr(namespace, self.dest, int(value))
        except ValueError:
            setattr(namespace, self.dest, value)


class ListOptionAction(argparse.Action):
    """
    Custom argparse action for `ogrinspect` keywords that require
    a string list. If the string is 'True'/'true' then the option
    value will be a boolean instead.
    """
    def __call__(self, parser, namespace, value, option_string=None):
        if value.lower() == 'true':
            setattr(namespace, self.dest, True)
        else:
            setattr(namespace, self.dest, value.split(','))


class Command(BaseCommand):
    help = (
        'Inspects the given OGR-compatible data source (e.g., a shapefile) and outputs\n'
        'a GeoDjango model with the given model name. For example:\n'
        ' ./manage.py ogrinspect zipcode.shp Zipcode'
    )

    requires_system_checks = False

    def add_arguments(self, parser):
        parser.add_argument('data_source', help='Path to the data source.')
        parser.add_argument('model_name', help='Name of the model to create.')
        parser.add_argument(
            '--blank', dest='blank',
            action=ListOptionAction, default=False,
            help='Use a comma separated list of OGR field names to add '
                 'the `blank=True` option to the field definition. Set to `true` '
                 'to apply to all applicable fields.',
        )
        parser.add_argument(
            '--decimal', dest='decimal',
            action=ListOptionAction, default=False,
            help='Use a comma separated list of OGR float fields to '
                 'generate `DecimalField` instead of the default '
                 '`FloatField`. Set to `true` to apply to all OGR float fields.',
        )
        parser.add_argument(
            '--geom-name', dest='geom_name', default='geom',
            help='Specifies the model name for the Geometry Field (defaults to `geom`)'
        )
        parser.add_argument(
            '--layer', dest='layer_key',
            action=LayerOptionAction, default=0,
            help='The key for specifying which layer in the OGR data '
                 'source to use. Defaults to 0 (the first layer). May be '
                 'an integer or a string identifier for the layer.',
        )
        parser.add_argument(
            '--multi-geom', action='store_true',
            dest='multi_geom', default=False,
            help='Treat the geometry in the data source as a geometry collection.',
        )
        parser.add_argument(
            '--name-field', dest='name_field',
            help='Specifies a field name to return for the `__unicode__`/`__str__` function.',
        )
        parser.add_argument(
            '--no-imports', action='store_false', dest='imports', default=True,
            help='Do not include `from django.contrib.gis.db import models` statement.',
        )
        parser.add_argument(
            '--null', dest='null', action=ListOptionAction, default=False,
            help='Use a comma separated list of OGR field names to add '
                 'the `null=True` option to the field definition. Set to `true` '
                 'to apply to all applicable fields.',
        )
        parser.add_argument(
            '--srid', dest='srid',
            help='The SRID to use for the Geometry Field. If it can be '
                 'determined, the SRID of the data source is used.',
        )
        parser.add_argument(
            '--mapping', action='store_true', dest='mapping',
            help='Generate mapping dictionary for use with `LayerMapping`.',
        )

    def handle(self, *args, **options):
        data_source, model_name = options.pop('data_source'), options.pop('model_name')
        if not gdal.HAS_GDAL:
            raise CommandError('GDAL is required to inspect geospatial data sources.')

        # Getting the OGR DataSource from the string parameter.
        try:
            ds = gdal.DataSource(data_source)
        except gdal.GDALException as msg:
            raise CommandError(msg)

        # Returning the output of ogrinspect with the given arguments
        # and options.
        from django.contrib.gis.utils.ogrinspect import _ogrinspect, mapping
        # Filter options to params accepted by `_ogrinspect`
        ogr_options = {k: v for k, v in options.items()
                       if k in get_func_args(_ogrinspect) and v is not None}
        output = [s for s in _ogrinspect(ds, model_name, **ogr_options)]

        if options['mapping']:
            # Constructing the keyword arguments for `mapping`, and
            # calling it on the data source.
            kwargs = {
                'geom_name': options['geom_name'],
                'layer_key': options['layer_key'],
                'multi_geom': options['multi_geom'],
            }
            mapping_dict = mapping(ds, **kwargs)
            # This extra legwork is so that the dictionary definition comes
            # out in the same order as the fields in the model definition.
            rev_mapping = {v: k for k, v in mapping_dict.items()}
            output.extend(['', '# Auto-generated `LayerMapping` dictionary for %s model' % model_name,
                           '%s_mapping = {' % model_name.lower()])
            output.extend("    '%s' : '%s'," % (
                rev_mapping[ogr_fld], ogr_fld) for ogr_fld in ds[options['layer_key']].fields
            )
            output.extend(["    '%s' : '%s'," % (options['geom_name'], mapping_dict[options['geom_name']]), '}'])
        return '\n'.join(output) + '\n'

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models, migrations


class Migration(migrations.Migration):

    dependencies = [
        ('contenttypes', '0001_initial'),
        ('inheritance', '0001_initial'),
    ]

    operations = [
        migrations.CreateModel(
            name='BasePlugin',
            fields=[
                ('modelwithinheritance_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='inheritance.ModelWithInheritance')),
                ('container_pk', models.TextField(verbose_name='object ID')),
                ('title', models.CharField(max_length=64)),
                ('views', models.CharField(blank=True, max_length=255)),
            ],
            options={
                'abstract': False,
            },
            bases=('inheritance.modelwithinheritance',),
        ),
        migrations.CreateModel(
            name='BaseTab',
            fields=[
                ('modelwithinheritance_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='inheritance.ModelWithInheritance')),
                ('container_pk', models.TextField(verbose_name='object ID')),
                ('label', models.CharField(max_length=12)),
                ('title', models.CharField(max_length=64)),
                ('order', models.IntegerField(default=100)),
                ('opening_method', models.CharField(blank=True, max_length=32)),
            ],
            options={
                'ordering': ['order', 'id'],
            },
            bases=('inheritance.modelwithinheritance',),
        ),
        migrations.CreateModel(
            name='EmbeddedTab',
            fields=[
                ('basetab_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='apps.BaseTab')),
                ('content_url', models.URLField(max_length=128)),
                ('element_id', models.CharField(blank=True, max_length=32)),
            ],
            options={
                'abstract': False,
            },
            bases=('apps.basetab',),
        ),
        migrations.CreateModel(
            name='ExternalIFramePlugin',
            fields=[
                ('baseplugin_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='apps.BasePlugin')),
                ('service_url', models.URLField(max_length=255)),
                ('width', models.IntegerField()),
                ('height', models.IntegerField()),
            ],
            options={
                'abstract': False,
            },
            bases=('apps.baseplugin',),
        ),
        migrations.CreateModel(
            name='ExternalIFrameTab',
            fields=[
                ('basetab_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='apps.BaseTab')),
                ('content_url', models.URLField(max_length=255)),
                ('width', models.IntegerField()),
                ('height', models.IntegerField()),
            ],
            options={
                'abstract': False,
            },
            bases=('apps.basetab',),
        ),
        migrations.CreateModel(
            name='HTMLPlugin',
            fields=[
                ('baseplugin_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='apps.BasePlugin')),
                ('content', models.TextField()),
            ],
            options={
                'abstract': False,
            },
            bases=('apps.baseplugin',),
        ),
        migrations.CreateModel(
            name='HTMLTab',
            fields=[
                ('basetab_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='apps.BaseTab')),
                ('content', models.TextField()),
            ],
            options={
                'abstract': False,
            },
            bases=('apps.basetab',),
        ),
        migrations.CreateModel(
            name='RSSPlugin',
            fields=[
                ('baseplugin_ptr', models.OneToOneField(parent_link=True, auto_created=True, primary_key=True, serialize=False, to='apps.BasePlugin')),
                ('feed_url', models.URLField(max_length=256)),
            ],
            options={
                'abstract': False,
            },
            bases=('apps.baseplugin',),
        ),
        migrations.AddField(
            model_name='basetab',
            name='container_type',
            field=models.ForeignKey(to='contenttypes.ContentType'),
            preserve_default=True,
        ),
        migrations.AddField(
            model_name='baseplugin',
            name='container_type',
            field=models.ForeignKey(to='contenttypes.ContentType'),
            preserve_default=True,
        ),
    ]

#!/usr/bin/env python
#
# test_codecmaps_cn.py
#   Codec mapping tests for PRC encodings
#

from test import test_support
from test import test_multibytecodec_support
import unittest

class TestGB2312Map(test_multibytecodec_support.TestBase_Mapping,
                   unittest.TestCase):
    encoding = 'gb2312'
    mapfileurl = 'http://people.freebsd.org/~perky/i18n/EUC-CN.TXT'

class TestGBKMap(test_multibytecodec_support.TestBase_Mapping,
                   unittest.TestCase):
    encoding = 'gbk'
    mapfileurl = 'http://www.unicode.org/Public/MAPPINGS/VENDORS/' \
                 'MICSFT/WINDOWS/CP936.TXT'

class TestGB18030Map(test_multibytecodec_support.TestBase_Mapping,
                     unittest.TestCase):
    encoding = 'gb18030'
    mapfileurl = 'http://source.icu-project.org/repos/icu/data/' \
                 'trunk/charset/data/xml/gb-18030-2000.xml'


def test_main():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(TestGB2312Map))
    suite.addTest(unittest.makeSuite(TestGBKMap))
    suite.addTest(unittest.makeSuite(TestGB18030Map))
    test_support.run_suite(suite)

if __name__ == "__main__":
    test_main()

import argparse
from gailtf.baselines.common import set_global_seeds, tf_util as U
import gym, logging, sys
from gailtf.baselines import bench
import os.path as osp
from gailtf.baselines import logger
from gailtf.dataset.mujoco import Mujoco_Dset
import numpy as np
import ipdb

def argsparser():
    parser = argparse.ArgumentParser("Tensorflow Implementation of GAIL")
    parser.add_argument('--env_id', help='environment ID', default='Hopper-v1')
    parser.add_argument('--seed', help='RNG seed', type=int, default=0)
    parser.add_argument('--num_cpu', help='number of cpu to used', type=int, default=1)
    parser.add_argument('--expert_path', type=str, default='baselines/ppo1/deterministic.ppo.Hopper.0.00.pkl')
    parser.add_argument('--checkpoint_dir', help='the directory to save model', default='checkpoint')
    parser.add_argument('--log_dir', help='the directory to save log file', default='log')
    parser.add_argument('--load_model_path', help='if provided, load the model', type=str, default=None)
    # Task
    parser.add_argument('--task', type=str, choices=['train', 'evaluate'], default='train')
    # for evaluatation
    parser.add_argument('--stochastic_policy', type=bool, default=False)
    #  Mujoco Dataset Configuration
    parser.add_argument('--ret_threshold', help='the return threshold for the expert trajectories', type=int, default=0)
    parser.add_argument('--traj_limitation', type=int, default=np.inf)
    # Optimization Configuration
    parser.add_argument('--g_step', help='number of steps to train policy in each epoch', type=int, default=3)
    parser.add_argument('--d_step', help='number of steps to train discriminator in each epoch', type=int, default=1)
    # Network Configuration (Using MLP Policy)
    parser.add_argument('--policy_hidden_size', type=int, default=100)
    parser.add_argument('--adversary_hidden_size', type=int, default=100)
    # Algorithms Configuration
    parser.add_argument('--algo', type=str, choices=['bc', 'trpo', 'ppo'], default='trpo')
    parser.add_argument('--max_kl', type=float, default=0.01)
    parser.add_argument('--policy_entcoeff', help='entropy coefficiency of policy', type=float, default=0)
    parser.add_argument('--adversary_entcoeff', help='entropy coefficiency of discriminator', type=float, default=1e-3)
    # Traing Configuration
    parser.add_argument('--save_per_iter', help='save model every xx iterations', type=int, default=100)
    parser.add_argument('--num_timesteps', help='number of timesteps per episode', type=int, default=5e6)
    # Behavior Cloning
    parser.add_argument('--pretrained', help='Use BC to pretrain', type=bool, default=False)
    parser.add_argument('--BC_max_iter', help='Max iteration for training BC', type=int, default=1e4)
    return parser.parse_args()

def get_task_name(args):
    if args.algo == 'bc':
        task_name = 'behavior_cloning.'
        if args.traj_limitation != np.inf: task_name += "traj_limitation_%d."%args.traj_limitation
        task_name += args.env_id.split("-")[0]
    else:
        task_name = args.algo + "_gail."
        if args.pretrained: task_name += "with_pretrained."
        if args.traj_limitation != np.inf: task_name += "traj_limitation_%d."%args.traj_limitation
        task_name += args.env_id.split("-")[0]
        if args.ret_threshold > 0: task_name += ".return_threshold_%d" % args.ret_threshold
        task_name = task_name + ".g_step_" + str(args.g_step) + ".d_step_" + str(args.d_step) + \
                ".policy_entcoeff_" + str(args.policy_entcoeff) + ".adversary_entcoeff_" + str(args.adversary_entcoeff)
    return task_name

def main(args):
    from gailtf.baselines.ppo1 import mlp_policy
    U.make_session(num_cpu=args.num_cpu).__enter__()
    set_global_seeds(args.seed)
    env = gym.make(args.env_id)
    def policy_fn(name, ob_space, ac_space, reuse=False):
        return mlp_policy.MlpPolicy(name=name, ob_space=ob_space, ac_space=ac_space,
            reuse=reuse, hid_size=64, num_hid_layers=2)
    env = bench.Monitor(env, logger.get_dir() and
        osp.join(logger.get_dir(), "monitor.json"))
    env.seed(args.seed)
    gym.logger.setLevel(logging.WARN)
    task_name = get_task_name(args)
    args.checkpoint_dir = osp.join(args.checkpoint_dir, task_name)
    args.log_dir = osp.join(args.log_dir, task_name)
    dataset = Mujoco_Dset(expert_path=args.expert_path, ret_threshold=args.ret_threshold, traj_limitation=args.traj_limitation)
    pretrained_weight = None
    if (args.pretrained and args.task == 'train') or args.algo == 'bc':
        # Pretrain with behavior cloning
        from gailtf.algo import behavior_clone
        if args.algo == 'bc' and args.task == 'evaluate':
            behavior_clone.evaluate(env, policy_fn, args.load_model_path, stochastic_policy=args.stochastic_policy)
            sys.exit()
        pretrained_weight = behavior_clone.learn(env, policy_fn, dataset,
            max_iters=args.BC_max_iter, pretrained=args.pretrained, 
            ckpt_dir=args.checkpoint_dir, log_dir=args.log_dir, task_name=task_name)
        if args.algo == 'bc':
            sys.exit()

    from gailtf.network.adversary import TransitionClassifier
    # discriminator
    discriminator = TransitionClassifier(env, args.adversary_hidden_size, entcoeff=args.adversary_entcoeff)
    if args.algo == 'trpo':
        # Set up for MPI seed
        from mpi4py import MPI
        rank = MPI.COMM_WORLD.Get_rank()
        if rank != 0:
            logger.set_level(logger.DISABLED)
        workerseed = args.seed + 10000 * MPI.COMM_WORLD.Get_rank()
        set_global_seeds(workerseed)
        env.seed(workerseed)
        from gailtf.algo import trpo_mpi
        if args.task == 'train':
            trpo_mpi.learn(env, policy_fn, discriminator, dataset,
                pretrained=args.pretrained, pretrained_weight=pretrained_weight,
                g_step=args.g_step, d_step=args.d_step,
                timesteps_per_batch=1024, 
                max_kl=args.max_kl, cg_iters=10, cg_damping=0.1,
                max_timesteps=args.num_timesteps, 
                entcoeff=args.policy_entcoeff, gamma=0.995, lam=0.97, 
                vf_iters=5, vf_stepsize=1e-3,
                ckpt_dir=args.checkpoint_dir, log_dir=args.log_dir,
                save_per_iter=args.save_per_iter, load_model_path=args.load_model_path,
                task_name=task_name)
        elif args.task == 'evaluate':
            trpo_mpi.evaluate(env, policy_fn, args.load_model_path, timesteps_per_batch=1024,
                number_trajs=10, stochastic_policy=args.stochastic_policy)
        else: raise NotImplementedError
    else: raise NotImplementedError

    env.close()

if __name__ == '__main__':
    args = argsparser()
    main(args)

#
# ElementTree
# $Id: ElementInclude.py 3375 2008-02-13 08:05:08Z fredrik $
#
# limited xinclude support for element trees
#
# history:
# 2003-08-15 fl   created
# 2003-11-14 fl   fixed default loader
#
# Copyright (c) 2003-2004 by Fredrik Lundh.  All rights reserved.
#
# fredrik@pythonware.com
# http://www.pythonware.com
#
# --------------------------------------------------------------------
# The ElementTree toolkit is
#
# Copyright (c) 1999-2008 by Fredrik Lundh
#
# By obtaining, using, and/or copying this software and/or its
# associated documentation, you agree that you have read, understood,
# and will comply with the following terms and conditions:
#
# Permission to use, copy, modify, and distribute this software and
# its associated documentation for any purpose and without fee is
# hereby granted, provided that the above copyright notice appears in
# all copies, and that both that copyright notice and this permission
# notice appear in supporting documentation, and that the name of
# Secret Labs AB or the author not be used in advertising or publicity
# pertaining to distribution of the software without specific, written
# prior permission.
#
# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
# OF THIS SOFTWARE.
# --------------------------------------------------------------------

# Licensed to PSF under a Contributor Agreement.
# See http://www.python.org/psf/license for licensing details.

##
# Limited XInclude support for the ElementTree package.
##

import copy
from . import ElementTree

XINCLUDE = "{http://www.w3.org/2001/XInclude}"

XINCLUDE_INCLUDE = XINCLUDE + "include"
XINCLUDE_FALLBACK = XINCLUDE + "fallback"

##
# Fatal include error.

class FatalIncludeError(SyntaxError):
    pass

##
# Default loader.  This loader reads an included resource from disk.
#
# @param href Resource reference.
# @param parse Parse mode.  Either "xml" or "text".
# @param encoding Optional text encoding (UTF-8 by default for "text").
# @return The expanded resource.  If the parse mode is "xml", this
#    is an ElementTree instance.  If the parse mode is "text", this
#    is a Unicode string.  If the loader fails, it can return None
#    or raise an OSError exception.
# @throws OSError If the loader fails to load the resource.

def default_loader(href, parse, encoding=None):
    if parse == "xml":
        with open(href, 'rb') as file:
            data = ElementTree.parse(file).getroot()
    else:
        if not encoding:
            encoding = 'UTF-8'
        with open(href, 'r', encoding=encoding) as file:
            data = file.read()
    return data

##
# Expand XInclude directives.
#
# @param elem Root element.
# @param loader Optional resource loader.  If omitted, it defaults
#     to {@link default_loader}.  If given, it should be a callable
#     that implements the same interface as <b>default_loader</b>.
# @throws FatalIncludeError If the function fails to include a given
#     resource, or if the tree contains malformed XInclude elements.
# @throws OSError If the function fails to load a given resource.

def include(elem, loader=None):
    if loader is None:
        loader = default_loader
    # look for xinclude elements
    i = 0
    while i < len(elem):
        e = elem[i]
        if e.tag == XINCLUDE_INCLUDE:
            # process xinclude directive
            href = e.get("href")
            parse = e.get("parse", "xml")
            if parse == "xml":
                node = loader(href, parse)
                if node is None:
                    raise FatalIncludeError(
                        "cannot load %r as %r" % (href, parse)
                        )
                node = copy.copy(node)
                if e.tail:
                    node.tail = (node.tail or "") + e.tail
                elem[i] = node
            elif parse == "text":
                text = loader(href, parse, e.get("encoding"))
                if text is None:
                    raise FatalIncludeError(
                        "cannot load %r as %r" % (href, parse)
                        )
                if i:
                    node = elem[i-1]
                    node.tail = (node.tail or "") + text + (e.tail or "")
                else:
                    elem.text = (elem.text or "") + text + (e.tail or "")
                del elem[i]
                continue
            else:
                raise FatalIncludeError(
                    "unknown parse type in xi:include tag (%r)" % parse
                )
        elif e.tag == XINCLUDE_FALLBACK:
            raise FatalIncludeError(
                "xi:fallback tag must be child of xi:include (%r)" % e.tag
                )
        else:
            include(e, loader)
        i = i + 1

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for scalar strictness and scalar leniency."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import numpy as np

from tensorflow.python.framework import ops
from tensorflow.python.framework import test_util
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import gen_io_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import random_ops
from tensorflow.python.ops import sparse_ops
import tensorflow.python.ops.nn_grad  # pylint: disable=unused-import
from tensorflow.python.platform import test


class ScalarTest(test.TestCase):

  def check(self, op, args, error, correct=None):
    # Within Google, the switch to scalar strict occurred at version 6.
    lenient = []
    strict = [5, 6]

    # Use placeholders to bypass shape inference, since only the C++
    # GraphDef level is ever scalar lenient.
    def placeholders(args, feed):
      if isinstance(args, tuple):
        return [placeholders(x, feed) for x in args]
      else:
        x = ops.convert_to_tensor(args).eval()
        fake = array_ops.placeholder(np.asarray(x).dtype)
        feed[fake] = x
        return fake

    # Test various GraphDef versions
    for version in strict + lenient:
      with ops.Graph().as_default() as g:
        test_util.set_producer_version(g, version)
        with self.test_session(graph=g) as sess:
          feed = {}
          xs = placeholders(args, feed)
          x = op(*xs)
          if version in strict:
            with self.assertRaisesOpError(error):
              sess.run(x, feed_dict=feed)
          else:
            r = sess.run(x, feed_dict=feed)
            if correct is not None:
              self.assertAllEqual(r, correct)

  def testConcat(self):
    self.check(array_ops.concat, (([2], [3], [7]), [0]),
               'axis tensor should be a scalar integer', [2, 3, 7])
    for data in (2, 3, 7), (2, [3], 7), (2, 3, [7]):
      self.check(array_ops.concat, (data, 0),
                 r'Expected \w+ dimensions in the range \[0, 0\)', [2, 3, 7])
    for data in ([2], 3, 7), ([2], [3], 7):
      self.check(array_ops.concat, (data, 0),
                 r'Ranks of all input tensors should match', [2, 3, 7])

  def testFill(self):
    self.check(array_ops.fill, (2, 3), 'dims must be a vector', [3, 3])
    self.check(array_ops.fill, ([2], [3]), 'value must be a scalar', [3, 3])

  def testPad(self):
    self.check(array_ops.pad, (7, [[1, 2]]),
               'The first dimension of paddings must be the rank of inputs',
               [0, 7, 0, 0])

  def testRandom(self):
    self.check(random_ops.random_uniform, (3,), 'shape must be a vector')

  def testReshape(self):
    self.check(array_ops.reshape, (7, 1), 'sizes input must be 1-D', [7])

  def testShardedFilename(self):
    self.check(gen_io_ops.sharded_filename, ('foo', 4, [100]),
               'must be a scalar', b'foo-00004-of-00100')

  def testShardedFilespec(self):
    self.check(gen_io_ops.sharded_filespec, ('foo', [100]), 'must be a scalar',
               b'foo-?????-of-00100')

  def testUnsortedSegmentSum(self):
    self.check(math_ops.unsorted_segment_sum, (7, 1, [4]),
               'num_segments should be a scalar', [0, 7, 0, 0])

  def testRange(self):
    self.check(math_ops.range, ([0], 3, 2), 'start must be a scalar', [0, 2])
    self.check(math_ops.range, (0, [3], 2), 'limit must be a scalar', [0, 2])
    self.check(math_ops.range, (0, 3, [2]), 'delta must be a scalar', [0, 2])

  def testSlice(self):
    data = np.arange(10)
    error = 'Expected begin and size arguments to be 1-D tensors'
    self.check(array_ops.slice, (data, 2, 3), error, [2, 3, 4])
    self.check(array_ops.slice, (data, [2], 3), error, [2, 3, 4])
    self.check(array_ops.slice, (data, 2, [3]), error, [2, 3, 4])

  def testSparseToDense(self):
    self.check(sparse_ops.sparse_to_dense, (1, 4, 7),
               'output_shape should be a vector', [0, 7, 0, 0])

  def testTile(self):
    self.check(array_ops.tile, ([7], 2), 'Expected multiples to be 1-D', [7, 7])


if __name__ == '__main__':
  test.main()

# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------

from typing import TYPE_CHECKING

from azure.core import PipelineClient
from msrest import Deserializer, Serializer

if TYPE_CHECKING:
    # pylint: disable=unused-import,ungrouped-imports
    from typing import Any

    from azure.core.pipeline.transport import HttpRequest, HttpResponse

from ._configuration import ConfidentialLedgerClientConfiguration
from .operations import ConfidentialLedgerOperations
from . import models


class ConfidentialLedgerClient(object):
    """The ConfidentialLedgerClient writes and retrieves ledger entries against the Confidential Ledger service.

    :ivar confidential_ledger: ConfidentialLedgerOperations operations
    :vartype confidential_ledger: azure.confidentialledger._generated/_generated_ledger.v0_1_preview.operations.ConfidentialLedgerOperations
    :param ledger_uri: The Confidential Ledger URL, for example https://contoso.confidentialledger.azure.com.
    :type ledger_uri: str
    """

    def __init__(
        self,
        ledger_uri,  # type: str
        **kwargs  # type: Any
    ):
        # type: (...) -> None
        base_url = '{ledgerUri}'
        self._config = ConfidentialLedgerClientConfiguration(ledger_uri, **kwargs)
        self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self._serialize = Serializer(client_models)
        self._serialize.client_side_validation = False
        self._deserialize = Deserializer(client_models)

        self.confidential_ledger = ConfidentialLedgerOperations(
            self._client, self._config, self._serialize, self._deserialize)

    def _send_request(self, http_request, **kwargs):
        # type: (HttpRequest, Any) -> HttpResponse
        """Runs the network request through the client's chained policies.

        :param http_request: The network request you want to make. Required.
        :type http_request: ~azure.core.pipeline.transport.HttpRequest
        :keyword bool stream: Whether the response payload will be streamed. Defaults to True.
        :return: The response of your network call. Does not do error handling on your response.
        :rtype: ~azure.core.pipeline.transport.HttpResponse
        """
        path_format_arguments = {
            'ledgerUri': self._serialize.url("self._config.ledger_uri", self._config.ledger_uri, 'str', skip_quote=True),
        }
        http_request.url = self._client.format_url(http_request.url, **path_format_arguments)
        stream = kwargs.pop("stream", True)
        pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs)
        return pipeline_response.http_response

    def close(self):
        # type: () -> None
        self._client.close()

    def __enter__(self):
        # type: () -> ConfidentialLedgerClient
        self._client.__enter__()
        return self

    def __exit__(self, *exc_details):
        # type: (Any) -> None
        self._client.__exit__(*exc_details)

# Copyright (c) 2013 Qubell Inc., http://qubell.com
#
# 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.

__author__ = "Vasyl Khomenko"
__copyright__ = "Copyright 2013, Qubell.com"
__license__ = "Apache"
__version__ = "1.0.1"
__email__ = "vkhomenko@qubell.com"

import requests
import simplejson as json
import logging as log
import qubellclient.tools as tools
from qubellclient.private.platform import QubellPlatform

class Organization(QubellPlatform):

    rawResponse = None

    def __init__(self, context, id=None, name=None):
        self.context = context
        if name:
            self.name = name
            orgz = [org for org in self.json() if org['name'] == name]
            # Org found by name
            if len(orgz):
                self.organizationId = orgz[0]['id']
            else:
                self.organizationId = self._create()['id']
        else:
            self.name = 'testsuite-run'
            if id:
                self.organizationId = id
            else:
                self.organizationId = self._create()['id']

        self.context.organizationId = self.organizationId

        self.zoneId = self.getZones()[0]['id'] #TODO
        self.context.zoneId = self.zoneId

    def _create(self):
        log.info("Creating organization: %s" % self.name)
        url = self.context.api+'/organizations.json'
        headers = {'Content-Type': 'application/json'}
        payload = json.dumps({'editable': 'true',
                              'name': self.name})
        resp = requests.post(url, cookies=self.context.cookies, data=payload, verify=False, headers=headers)
        log.debug(resp.text)
        self.rawResponse = resp
        if resp.status_code == 200:
            return resp.json()
        else:
            return False

    def json(self):
        url = self.context.api+'/organizations.json'
        resp = requests.get(url, cookies=self.context.cookies, verify=False)
        log.debug(resp.text)
        self.rawRespose = resp
        if resp.status_code == 200:
            return resp.json()
        else:
            return False

    def application(self, *args, **kwargs):
        from application import Application
        return Application(self.context, *args, **kwargs)

    def service(self, *args, **kwargs):
        from service import Service
        return Service(self.context, *args, **kwargs)

    def environment(self, *args, **kwargs):
        from environment import Environment
        return Environment(self.context, *args, **kwargs)

    def provider(self, *args, **kwargs):
        from provider import Provider
        return Provider(self.context, *args, **kwargs)

    def getZones(self):
        url = self.context.api+'/organizations/'+self.context.organizationId+'/zones.json'
        resp = requests.get(url, cookies=self.context.cookies, verify=False)
        log.debug(resp.text)
        self.rawRespose = resp
        if resp.status_code == 200:
            return resp.json()
        else:
            return False

from MySQLdb import connect, escape_string
from optparse import OptionParser
import sys
import pickle, os
from math import sqrt
from scipy.sparse import lil_matrix, spdiags, csr_matrix
from numpy import zeros, array, matrix

JNL_LEVEL_ABSTRACT_COUNT_TABLE = 'journal_abstract_MED_jid_word_count'
JNL_LEVEL_TITLE_COUNT_TABLE = 'journal_title_MED_jid_word_count'
CPID_LEVEL_ABSTRACT_COUNT_TABLE = 'cpid_abstract_MED_jid_word_count'
CPID_LEVEL_TITLE_COUNT_TABLE = 'cpid_title_MED_jid_word_count'
CORPUS_LEVEL_ABSTRACT_COUNT_TABLE = 'all_word_abstract_MED_word_count'
CORPUS_LEVEL_TITLE_COUNT_TABLE = 'all_word_title_MED_word_count'

def get_index_word_dicts(cursor, feature_type):
    if os.path.exists("word_index_dict.pkl"):
        word_index_dict = pickle.load(open("word_index_"+feature_type+"_dict.pkl", "rb"))
        index_word_dict = pickle.load(open("index_word_"+feature_type+"dict.pkl", "rb"))
    else:
        cursor.execute('select word from '+ eval("CORPUS_LEVEL_"+feature_type.upper()+"_COUNT_TABLE") +
                       ' where count > 50 order by count desc')
        words = map (lambda x : x[0].strip().lower(), cursor.fetchall())
        num_words = len(words)
        i = 0
        word_index_dict = {}
        index_word_dict = {}
        for word in words:
            word_index_dict[word] = i
            index_word_dict[i] = word
            i+=1
        pickle.dump(index_word_dict, open("index_word_"+feature_type+"_dict.pkl", "wb"))
        pickle.dump(word_index_dict, open("words_index_"+feature_type+"_dict.pkl", "wb"))
    return (index_word_dict, word_index_dict)

def get_level_index_dict(cursor, feature_type, level_type):
    if os.path.exists("level_index_"+feature_type+"_"+level_type+"_dict.pkl"):
        level_index_dict = pickle.load(open("level_index_"+feature_type+"_"+level_type+"_dict.pkl", "rb"))
    else:
        #count number of distinct level in cited_paper_words_count table
        cursor.execute('SELECT distinct '+level_type+' FROM MED_cpid_refjnl_rlev_ct where rlev!=0')
        levels = map (lambda x : x[0], cursor.fetchall())
        i = 0
        level_index_dict = {}
        for level in levels:
            level_index_dict[level] = i
            i+=1
        pickle.dump(level_index_dict, open("level_index_"+feature_type+"_"+level_type+"_dict.pkl", "wb"))
        print len(level_index_dict)
    return level_index_dict

def get_sparse_matrix(cursor, feature_type, level_type):
        #lil sparse matrix in scipy package:
        #http://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.lil_matrix.html
        #matrix is (num_level) * num_words+1 size (+1 for the last column)
    if os.path.exists("X_word_by_"+level_type+"_"+feature_type+".pkl"):
        X = pickle.load(open("X_word_by_"+level_type+"_"+feature_type+".pkl", "rb"))
    else:
        (index_word_dict, word_index_dict) = get_index_word_dicts(cursor, feature_type)
        level_index_dict = get_level_index_dict(cursor, feature_type, level_type)
        X = lil_matrix((len(level_index_dict),len(word_index_dict),))
        print X.get_shape()
        #dict for tracking sparse matrix index and actual cited id
        i = 0
        print "Reading level and words..."

        for level in level_index_dict:
            if i%10000 == 0:
                print i, "th insert"
            cursor.execute('SELECT word, count from '+ eval(level_type.upper() + '_LEVEL_'+feature_type.upper()+'_COUNT_TABLE')
                           +' where '+level_type+'=\'' + level +'\'')
            word_count_dict = dict(cursor.fetchall())
            vec = map(lambda x : word_count_dict[x] if x in word_count_dict else 0, word_index_dict.keys())
            i+=1
            X[[level_index_dict[level]], [word_count_dict.keys()]] = word_count_dict.values()

        pickle.dump(X, open("X_word_by_"+level_type+"_"+feature_type+".pkl", "wb"))
        print "finished inserting count into sparse matrix"
        #row standardize X as distribution
        return X

def get_label_vector(cursor, feature_type, level_type):
    if os.path.exists("Y_"+level_type+".pkl"):
        Y = pickle.load(open("Y_"+level_type+".pkl", "rb"))
    else:
        level_index_dict = get_level_index_dict(cursor, feature_type, level_type)
        Y = lil_matrix((len(level_index_dict),1,))
        i = 0
        for level in level_index_dict:
            cursor.execute('SELECT distinct rlev from MED_cpid_refjnl_rlev_ct where '
                           +level_type+'=\''+level+'\'')
            rlevl = cursor.fetchall()
            print rlevl
            print level
            assert len(rlevl) == 1
            Y[[level_index_dict[level]],[0]] = rlevl[0][0] 
        Y = pickle.dump(Y, open("Y_" + level_type + ".pkl", "wb"))
    return Y

if __name__ == "__main__":
    usage = ("usage: %prog [options] [word_group_name]")

    parser = OptionParser(usage)

    (options, args) = parser.parse_args()
    conn = connect(host = 'localhost', user = 'root',
                   db = 'shepard', passwd='shepard')

    cursor = conn.cursor()
    X1 = get_sparse_matrix(cursor, 'abstract', 'jnl')
    X2 = get_sparse_matrix(cursor, 'title', 'jnl')
    #X3 = get_sparse_matrix(cursor, 'title', 'cpid')
    #X4 = get_sparse_matrix(cursor, 'abstract', 'cpid')
    Y1 = get_label_vector(cursor, 'title', 'jnl')
    Y2 = get_label_vector(cursor, 'title', 'cpid')

import numpy as np

def apply_bovy_extinction(data):
	import mwdust
	from healpy import ang2pix	
	## This updates the Galaxia extinction to the bovy2015 extinction.
	## the resolution is given in the next line (healpix in factors of 2) 128 takes approximately 3hours 256 takes approximately 13hours
	## The extinction is averaged over healpix pixel to make use of arrays, otherwise each star needs to be calculated individually.
	## Still the distance information of the extinction map is used.
		
	healpix_resolution = 128
	print(len(data))	
	dust = mwdust.Combined15()
	phi = data['glon'] * np.pi/180.
	theta = (90.- data['glat']) * np.pi/180.
	number = ang2pix(healpix_resolution,theta,phi)
	index = np.arange(len(number))
	sorted_indices = np.argsort(number)
	number = number[sorted_indices]
	data = data[sorted_indices]
	index_list = [0]
	temp = min(number)
	for i in range(len(number)):
		if number[i] != temp:
			index_list.append(i)	
		temp = number[i]	
	index_list.append(len(number))
	for i in range(len(index_list)-1):
		if i%1000 == 0:		
			print i, len(index_list)
		data['exbv_schlegel'][index_list[i]:index_list[i+1]] = dust(np.median(data['glon'][index_list[i]:index_list[i+1]]),np.median(data['glat'][index_list[i]:index_list[i+1]]),data['rad'][index_list[i]:index_list[i+1]])

	print(np.median(data['exbv_schlegel']))
		
	return(data)




# -*- coding: utf-8 -*-
import re
import codecs
import logging
import sys, errno, os
logging.basicConfig(level=logging.INFO)

f = codecs.open(sys.argv[1], "r", "utf-8")
outdir = 'target/test'
if not os.path.exists(outdir):
    os.makedirs(outdir)
o = codecs.open(outdir + '/Language-utf8encoded.properties', "w", "UTF-8")

changed_lines = False
for line in f:
    # first the really screwed up bits: two unicode chars for what is definitely one:
    original_line = line
    line = line.replace('\\u00c3\\u00a4', u'ä')
    line = line.replace('\\u00c3\\u00bc', u'ü')
    line = line.replace('\\u00c3\\u00b6', u'ö')
    line = line.replace('\\u00c3\\u009f', u'ß')
    line = line.replace('\\u00c3\\u0084', u'Ä')
    line = line.replace('\\u00c3\\u009c', u'Ü')
    line = line.replace('\\u00c3\\u0096', u'Ö')
    line = re.sub(r'\\u([0-9a-fA-F]{4})', lambda m:unichr(int('0x' + m.group(1)[2:], 0)), line)
    if not line == original_line:
        logging.info('changed line: ' + original_line)
        changed_lines = True
    o.write(line)
if changed_lines:
    sys.exit(errno.EPROTO)
#! /usr/bin/env python3

import sys
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import re
from matplotlib.lines import Line2D

#
# First, use
#   ./postprocessing.py > postprocessing_output.txt
# to generate the .txt file
#

fig, ax = plt.subplots(figsize=(10,7))


ax.set_xscale("log", nonposx='clip')
ax.set_yscale("log", nonposy='clip')

#mode = 'simtime'
mode = 'dt'


with open('postprocessing_output_vort.txt') as f:
	lines = f.readlines()


colors = ['b', 'g', 'r', 'c', 'm', 'y', 'k']

markers = []
for m in Line2D.markers:
    try:
        if len(m) == 1 and m != ' ' and m != '':
            markers.append(m)

    except TypeError:
        pass



linestyles = ['-', '--', ':', '-.']



if len(sys.argv) > 1:
	output_filename = sys.argv[1]
else:
	output_filename = "./postprocessing_output_vort_err_vs_"+mode+".pdf"

if len(sys.argv) > 2:
	plot_set = sys.argv[2:]
else:
	plot_set = []



def plot(x, y, marker, linestyle, label):

	# plot values and prev_name
	print(label)
	#print(values_err)
	#print(values_time)
	#print("")

	if len(x) == 0:
		return


	if len(plot_set) != 0:
		if prev_name not in plot_set:
			return

	ax.plot(x, y, marker=marker, linestyle=linestyle, label=label)



prev_name = ''
values_err = []
values_time = []
c = 2
for l in lines:
	if l[-1] == '\n':
		l = l[0:-1]

	d = l.split("\t")

	if d[0] == 'Running tests for new group:':
		plot(values_time, values_err, markers[c % len(markers)], linestyles[c % len(linestyles)], prev_name)
		for i, txt in enumerate(values_time):
			ax.annotate("%.1f" % txt, (values_time[i]*1.03, values_err[i]*1.03))

		prev_name = d[0]
		values_err = []
		values_time = []
		c = c+1
		continue

	if len(d) != 5:
		continue

	if d[0] == 'SIMNAME':
		continue

	prev_name = d[0]
	prev_name = prev_name.replace('script_ln2_b100_g9.81_h10000_f7.2921e-05_p0_a6371220_u0.0_rob1_fsph0_tsm_', '')
	prev_name = prev_name.replace('_M0128_MPI_space01_time128', '')
	prev_name = prev_name.replace('_M0128_MPI_space01_time001', '')
	prev_name = prev_name.replace('_prcircle_nrm0_hlf0_pre1_ext00', '')
	prev_name = prev_name.replace('_tso2_tsob2_REXICI', '')
	prev_name = prev_name.replace('_C0040', '')
	prev_name = prev_name.replace('_C0080', '')
	prev_name = prev_name.replace('_C0160', '')
	prev_name = prev_name.replace('_C0320', '')
	prev_name = prev_name.replace('_C0640', '')
	prev_name = prev_name.replace('_C1280', '')
	prev_name = prev_name.replace('_C2560', '')
	prev_name = prev_name.replace('_mr10.0_mi30.0', '')
	prev_name = prev_name.replace('_n0064_sx50.0_sy50.0', '')
	prev_name = prev_name.replace('_n0064', '')
	prev_name = prev_name.replace('_sx50.0_sy50.0', '')

	prev_name = re.sub(r"_mu.*", "", prev_name)
	prev_name = re.sub(r"0000", "", prev_name)

	values_err.append(float(d[1]))



	if mode == 'simtime':
		#
		# SIMTIME
		#
		values_time.append(float(d[4]))
		plt.xlabel("simulation time")

	elif mode == 'dt':
		#
		# DT
		#
		m = re.search('_C([0-9]*)', d[0])
		dt = float(m.group(1))
		values_time.append(dt)
		plt.xlabel("Timestep size")

	plt.ylabel("Error")


plot(values_time, values_err, markers[c % len(markers)], linestyles[c % len(linestyles)], prev_name)

plt.legend()

plt.savefig(output_filename)
#plt.show()


# run_static_model.py
#
# Author: Daniel Clark, 2015

'''
'''

# Load config file and run static model
def load_and_run(config, av_zone, price_hr):
    '''
    '''

    # Import packages
    import os
    import numpy as np
    import pandas as pd
    import yaml

    # Relative imports
    from spot_price_model import calc_s3_model_costs
    import utils

    # Init variables
    df_rows = []
    cfg_dict = yaml.load(open(config, 'r'))

    # Model parameters
    down_rate = cfg_dict['down_rate']
    in_gb = cfg_dict['in_gb']
    instance_type = cfg_dict['instance_type']
    jobs_per = cfg_dict['jobs_per']
    num_jobs_arr = cfg_dict['num_jobs']
    out_gb = cfg_dict['out_gb']
    out_gb_dl = cfg_dict['out_gb_dl']
    proc_time = cfg_dict['proc_time']
    proc_time *= 60.0 # convert to seconds
    product = cfg_dict['product']
    up_rate = cfg_dict['up_rate']

    # Evaluate for each dataset size (number of jobs)
    for num_jobs in num_jobs_arr:
        print '%d datasets...' % num_jobs

        # Tune parameters for cost model
        num_nodes = min(np.ceil(float(num_jobs)/jobs_per), 20)
        num_iter = np.ceil(num_jobs/float((jobs_per*num_nodes)))

        # Runtime parameters
        run_time = num_iter*proc_time
        wait_time = 0
        pernode_cost = np.ceil(run_time/3600.0)*price_hr
        num_interruipts = 0
        first_iter_time = proc_time

        # Grab costs from s3 model
        print av_zone
        total_cost, instance_cost, ebs_storage_cost, s3_cost, \
        s3_storage_cost, s3_req_cost, s3_xfer_cost, \
        total_time, run_time, wait_time, \
        xfer_up_time, s3_upl_time, s3_download_time = \
            calc_s3_model_costs(run_time, wait_time, pernode_cost,
                                first_iter_time, num_jobs, num_nodes, jobs_per,
                                av_zone, in_gb, out_gb, up_rate, down_rate)

        # Populate dictionary
        row_dict = {'av_zone' : av_zone, 'down_rate' : down_rate,
                    'in_gb' : in_gb, 'instance_type' : instance_type,
                    'jobs_per' : jobs_per, 'num_datasets' : num_jobs,
                    'out_gb' : out_gb, 'out_gb_dl' : out_gb_dl,
                    'proc_time' : proc_time, 'product' : product,
                    'up_rate' : up_rate, 'price_hr' : price_hr,
                    'static_total_cost' : total_cost,
                    'static_instance_cost' : instance_cost,
                    'static_ebs_storage_cost' : ebs_storage_cost,
                    's3_total_cost' : s3_cost,
                    's3_storage_cost' : s3_storage_cost,
                    's3_req_cost' : s3_req_cost,
                    's3_xfer_cost' : s3_xfer_cost,
                    'static_total_time' : total_time,
                    'static_run_time' : run_time,
                    'static_wait_time' : wait_time,
                    'xfer_up_time' : xfer_up_time,
                    's3_upl_time' : s3_upl_time,
                    's3_dl_time' : s3_download_time}

        # Convert to pandas series and add to list
        row_series = pd.Series(row_dict)
        df_rows.append(row_series)

    # Create static model dataframe
    static_df = pd.DataFrame.from_records(df_rows)

    out_df_path = os.path.join(os.getcwd(), os.path.basename(config).split('.')[0], str(price_hr), av_zone, 'on_demand.csv')
    if not os.path.exists(os.path.dirname(out_df_path)):
        os.makedirs(os.path.dirname(out_df_path))
    static_df.to_csv(out_df_path)

    # Return dataframe
    return static_df


# Make executable
if __name__ == '__main__':

    # Import packages
    import argparse
    import os

    # Init argparser
    parser = argparse.ArgumentParser(description=__doc__)

    # Required arguments
    parser.add_argument('-c', '--config', nargs=1, required=True,
                        type=str, help='Filepath to the sim config file')
    parser.add_argument('-p', '--price_hr', nargs=1, required=True,
                        type=float, help='Price per compute hour to assume')
    parser.add_argument('-z', '--av_zone', nargs=1, required=False, type=str,
                        help='Specify availability zone of interest')

    # Parse arguments
    args = parser.parse_args()

    # Init variables
    config = args.config[0]
    price_hr = args.price_hr[0]
    av_zone = args.av_zone[0]

    # Call static model function
    static_df = load_and_run(config, av_zone, price_hr)

    # Write to disk
    out_df_path = os.path.join(os.getcwd(), os.path.basename(config).split('.')[0], str(price_hr), av_zone, 'on_demand.csv')
    static_df.to_csv(out_df_path)

import logging

import plugins


logger = logging.getLogger(__name__)


def _initialise(bot):
    plugins.register_admin_command(["attachsyncout", "detachsyncout"])


def attachsyncout(bot, event, *args):
    """attach conversations to a new/existing syncout group.
    supply list of conversation ids to attach. supplying an id that is not the current conversation
    will make the bot attempt to attach the current conversation to the specified id. if the id
    does not already exist in another syncout group, a new syncout will be created consisting of
    the current conversation and the specified id. if more than conversation id is supplied, the
    bot will attempt to attach all the conversation ids to an existing syncout provided at least
    one of the supplied ids is in an existing syncout. if all the conversation ids are new, then
    a new syncout will be created. append "quietly" to silently create/attach.
    """

    conversation_ids = list(args)

    quietly = False
    if "quietly" in conversation_ids:
        quietly = True
        conversation_ids.remove("quietly")

    if len(args) == 1:
        conversation_ids.append(event.conv_id)

    conversation_ids = list(set(conversation_ids))

    if len(conversation_ids) < 2:
        # need at least 2 ids, one has to be another room
        return

    if not bot.get_config_option('syncing_enabled'):
        return

    syncouts = bot.get_config_option('sync_rooms')

    if type(syncouts) is not list:
        syncouts = []

    affected_conversations = None

    found_existing = False
    for sync_room_list in syncouts:
        if any(x in conversation_ids for x in sync_room_list):
            missing_ids = list(set(conversation_ids) - set(sync_room_list))
            sync_room_list.extend(missing_ids)
            affected_conversations = list(sync_room_list) # clone
            found_existing = True
            break

    if not found_existing:
        syncouts.append(conversation_ids)
        affected_conversations = conversation_ids

    if affected_conversations:
        bot.config.set_by_path(["sync_rooms"], syncouts)
        bot.config.save()
        if found_existing:
            logger.info("syncrooms extended")
            html_message = _("<i>syncout updated: {} conversations</i>")
        else:
            logger.info("syncrooms created")
            html_message = _("<i>syncout created: {} conversations</i>")
    else:
        logger.info("syncrooms unchanged")
        html_message = _("<i>syncouts unchanged</i>")

    if not quietly:
        yield from bot.coro_send_message(event.conv, html_message.format(
            len(affected_conversations)))


def detachsyncout(bot, event, target_conversation_id=None, *args):
    """detach current conversation from a syncout if no parameters supplied. if a conversation id
    is supplied, the bot will attempt to detach that conversation from an existing syncout
    """

    if not bot.get_config_option('syncing_enabled'):
        return

    syncouts = bot.get_config_option('sync_rooms')

    if not syncouts:
        return

    if target_conversation_id is None:
        # detach myself if no target_conversation_id provided
        target_conversation_id = event.conv_id

    _detached = False
    for sync_room_list in syncouts:
        if target_conversation_id in sync_room_list:
            sync_room_list.remove(target_conversation_id)
            _detached = True
            break;

    # cleanup: remove empty or 1-item syncouts by rewriting variable
    _syncouts = []
    for sync_room_list in syncouts:
        if len(sync_room_list) > 1:
            _syncouts.append(sync_room_list)
    syncouts = _syncouts

    if _detached:
        bot.config.set_by_path(["sync_rooms"], syncouts)
        bot.config.save()
        yield from bot.coro_send_message(event.conv, _("<i>`{}` was detached</i>").format(target_conversation_id))

# Copyright (c) 2017-present, Facebook, Inc.
# All rights reserved.
#
# This source code is licensed under the license found in the LICENSE file in
# the root directory of this source tree. An additional grant of patent rights
# can be found in the PATENTS file in the same directory.

import math
import torch
import torch.optim

from . import FairseqOptimizer, register_optimizer
from apex.contrib.optimizers.fused_adam import FusedAdam
from apex.contrib.optimizers.distributed_fused_adam import DistributedFusedAdam
from apex.contrib.optimizers.distributed_fused_adam_v2 import DistributedFusedAdamV2
from apex.contrib.optimizers.distributed_fused_adam_v3 import DistributedFusedAdamV3

@register_optimizer('adam')
class FairseqAdam(FairseqOptimizer):
    def __init__(self, args, params):
        super().__init__(args, params)
        if self.args.distributed_weight_update == 2:
            dwu_args = self.distributed_weight_update_config
            print("DistributedFusedAdam",dwu_args)
            self._optimizer = DistributedFusedAdam(params, **dwu_args, **self.optimizer_config)
        elif self.args.distributed_weight_update == 3:
            dwu_args = self.distributed_weight_update_config
            print("DistributedFusedAdamV2",dwu_args)
            self._optimizer = DistributedFusedAdamV2(params, **dwu_args, **self.optimizer_config)
        elif self.args.distributed_weight_update == 4:
            dwu_args = self.distributed_weight_update_config
            print("DistributedFusedAdamV3",dwu_args)
            self._optimizer = DistributedFusedAdamV3(params, **dwu_args, **self.optimizer_config)
        else:
            assert (self.args.distributed_weight_update == 0), "Vanilla optimizer not supported anymore"
            self._optimizer = FusedAdam(params, **self.optimizer_config)

    @staticmethod
    def add_args(parser):
        """Add optimizer-specific arguments to the parser."""
        parser.add_argument('--adam-betas', default='(0.9, 0.999)', metavar='B',
                            help='betas for Adam optimizer')
        parser.add_argument('--adam-eps', type=float, default=1e-8, metavar='D',
                            help='epsilon for Adam optimizer')

    @property
    def optimizer_config(self):
        """
        Return a kwarg dictionary that will be used to override optimizer
        args stored in checkpoints. This allows us to load a checkpoint and
        resume training using a different set of optimizer args, e.g., with a
        different learning rate.
        """
        return {
            'lr': self.args.lr[0],
            'betas': eval(self.args.adam_betas),
            'eps': self.args.adam_eps,
            'weight_decay': self.args.weight_decay,
        }

    @property
    def distributed_weight_update_config(self):
        """
        Return a kwarg dictionary that provides arguments for the distributed
        weight update feature.
        """
        return {
            'distributed_weight_update': self.args.distributed_weight_update,
            'dwu_group_size': self.args.dwu_group_size,
            'dwu_num_blocks': self.args.dwu_num_blocks,
            'dwu_num_chunks': self.args.dwu_num_chunks,
            'dwu_num_rs_pg': self.args.dwu_num_rs_pg,
            'dwu_num_ar_pg': self.args.dwu_num_ar_pg,
            'dwu_num_ag_pg': self.args.dwu_num_ag_pg,
            'overlap_reductions': self.args.dwu_overlap_reductions,
            'full_pipeline': self.args.dwu_full_pipeline,
            'compute_L2_grad_norm': self.args.dwu_compute_L2_grad_norm,
            'flat_mt': self.args.dwu_flat_mt,
            'e5m2_allgather': self.args.dwu_e5m2_allgather,
            'do_not_flatten_model': self.args.dwu_do_not_flatten_model,
        }

class Adam(torch.optim.Optimizer):
    """Implements Adam algorithm.

    This implementation is modified from torch.optim.Adam based on:
    `Fixed Weight Decay Regularization in Adam`
    (see https://arxiv.org/abs/1711.05101)

    It has been proposed in `Adam: A Method for Stochastic Optimization`_.

    Arguments:
        params (iterable): iterable of parameters to optimize or dicts defining
            parameter groups
        lr (float, optional): learning rate (default: 1e-3)
        betas (Tuple[float, float], optional): coefficients used for computing
            running averages of gradient and its square (default: (0.9, 0.999))
        eps (float, optional): term added to the denominator to improve
            numerical stability (default: 1e-8)
        weight_decay (float, optional): weight decay (L2 penalty) (default: 0)
        amsgrad (boolean, optional): whether to use the AMSGrad variant of this
            algorithm from the paper `On the Convergence of Adam and Beyond`_

    .. _Adam\: A Method for Stochastic Optimization:
        https://arxiv.org/abs/1412.6980
    .. _On the Convergence of Adam and Beyond:
        https://openreview.net/forum?id=ryQu7f-RZ
    """

    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8,
                 weight_decay=0, amsgrad=False):
        defaults = dict(lr=lr, betas=betas, eps=eps,
                        weight_decay=weight_decay, amsgrad=amsgrad)
        super(Adam, self).__init__(params, defaults)

    def step(self, closure=None):
        """Performs a single optimization step.

        Arguments:
            closure (callable, optional): A closure that reevaluates the model
                and returns the loss.
        """
        loss = None
        if closure is not None:
            loss = closure()

        for group in self.param_groups:
            for p in group['params']:
                if p.grad is None:
                    continue
                grad = p.grad.data
                if grad.is_sparse:
                    raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')
                amsgrad = group['amsgrad']

                state = self.state[p]

                # State initialization
                if len(state) == 0:
                    state['step'] = 0
                    # Exponential moving average of gradient values
                    state['exp_avg'] = torch.zeros_like(p.data)
                    # Exponential moving average of squared gradient values
                    state['exp_avg_sq'] = torch.zeros_like(p.data)
                    if amsgrad:
                        # Maintains max of all exp. moving avg. of sq. grad. values
                        state['max_exp_avg_sq'] = torch.zeros_like(p.data)

                exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
                if amsgrad:
                    max_exp_avg_sq = state['max_exp_avg_sq']
                beta1, beta2 = group['betas']

                state['step'] += 1

                # Decay the first and second moment running average coefficient
                exp_avg.mul_(beta1).add_(1 - beta1, grad)
                exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)
                if amsgrad:
                    # Maintains the maximum of all 2nd moment running avg. till now
                    torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)
                    # Use the max. for normalizing running avg. of gradient
                    denom = max_exp_avg_sq.sqrt().add_(group['eps'])
                else:
                    denom = exp_avg_sq.sqrt().add_(group['eps'])

                bias_correction1 = 1 - beta1 ** state['step']
                bias_correction2 = 1 - beta2 ** state['step']
                step_size = group['lr'] * math.sqrt(bias_correction2) / bias_correction1

                if group['weight_decay'] != 0:
                    p.data.add_(-group['weight_decay'] * group['lr'], p.data)

                p.data.addcdiv_(-step_size, exp_avg, denom)
        return loss

#!/usr/bin/python
# -*- coding: utf-8 -*-

# (c) 2014, Ravi Bhure <ravibhure@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

ANSIBLE_METADATA = {'status': ['preview'],
                    'supported_by': 'community',
                    'version': '1.0'}

DOCUMENTATION = '''
---
module: haproxy
version_added: "1.9"
short_description: Enable, disable, and set weights for HAProxy backend servers using socket commands.
author: "Ravi Bhure (@ravibhure)"
description:
    - Enable, disable, and set weights for HAProxy backend servers using socket
      commands.
notes:
    - Enable and disable commands are restricted and can only be issued on
      sockets configured for level 'admin'. For example, you can add the line
      'stats socket /var/run/haproxy.sock level admin' to the general section of
      haproxy.cfg. See http://haproxy.1wt.eu/download/1.5/doc/configuration.txt.
options:
  backend:
    description:
      - Name of the HAProxy backend pool.
    required: false
    default: auto-detected
  host:
    description:
      - Name of the backend host to change.
    required: true
    default: null
  shutdown_sessions:
    description:
      - When disabling a server, immediately terminate all the sessions attached
        to the specified server. This can be used to terminate long-running
        sessions after a server is put into maintenance mode.
    required: false
    default: false
  socket:
    description:
      - Path to the HAProxy socket file.
    required: false
    default: /var/run/haproxy.sock
  state:
    description:
      - Desired state of the provided backend host.
    required: true
    default: null
    choices: [ "enabled", "disabled" ]
  fail_on_not_found:
    description:
      - Fail whenever trying to enable/disable a backend host that does not exist
    required: false
    default: false
    version_added: "2.2"
  wait:
    description:
      - Wait until the server reports a status of 'UP' when `state=enabled`, or
        status of 'MAINT' when `state=disabled`.
    required: false
    default: false
    version_added: "2.0"
  wait_interval:
    description:
      - Number of seconds to wait between retries.
    required: false
    default: 5
    version_added: "2.0"
  wait_retries:
    description:
      - Number of times to check for status after changing the state.
    required: false
    default: 25
    version_added: "2.0"
  weight:
    description:
      - The value passed in argument. If the value ends with the `%` sign, then
        the new weight will be relative to the initially configured weight.
        Relative weights are only permitted between 0 and 100% and absolute
        weights are permitted between 0 and 256.
    required: false
    default: null
'''

EXAMPLES = '''
# disable server in 'www' backend pool
- haproxy:
    state: disabled
    host: '{{ inventory_hostname }}'
    backend: www

# disable server without backend pool name (apply to all available backend pool)
- haproxy:
    state: disabled
    host: '{{ inventory_hostname }}'

# disable server, provide socket file
- haproxy:
    state: disabled
    host: '{{ inventory_hostname }}'
    socket: /var/run/haproxy.sock
    backend: www

# disable server, provide socket file, wait until status reports in maintenance
- haproxy:
    state: disabled
    host: '{{ inventory_hostname }}'
    socket: /var/run/haproxy.sock
    backend: www
    wait: yes

# disable backend server in 'www' backend pool and drop open sessions to it
- haproxy:
    state: disabled
    host: '{{ inventory_hostname }}'
    backend: www
    socket: /var/run/haproxy.sock
    shutdown_sessions: true

# disable server without backend pool name (apply to all available backend pool) but fail when the backend host is not found
- haproxy:
    state: disabled
    host: '{{ inventory_hostname }}'
    fail_on_not_found: yes

# enable server in 'www' backend pool
- haproxy:
    state: enabled
    host: '{{ inventory_hostname }}'
    backend: www

# enable server in 'www' backend pool wait until healthy
- haproxy:
    state: enabled
    host: '{{ inventory_hostname }}'
    backend: www
    wait: yes

# enable server in 'www' backend pool wait until healthy. Retry 10 times with intervals of 5 seconds to retrieve the health
- haproxy:
    state: enabled
    host: '{{ inventory_hostname }}'
    backend: www
    wait: yes
    wait_retries: 10
    wait_interval: 5

# enable server in 'www' backend pool with change server(s) weight
- haproxy:
    state: enabled
    host: '{{ inventory_hostname }}'
    socket: /var/run/haproxy.sock
    weight: 10
    backend: www
'''

import socket
import csv
import time
from string import Template


DEFAULT_SOCKET_LOCATION="/var/run/haproxy.sock"
RECV_SIZE = 1024
ACTION_CHOICES = ['enabled', 'disabled']
WAIT_RETRIES=25
WAIT_INTERVAL=5

######################################################################
class TimeoutException(Exception):
    pass

class HAProxy(object):
    """
    Used for communicating with HAProxy through its local UNIX socket interface.
    Perform common tasks in Haproxy related to enable server and
    disable server.

    The complete set of external commands Haproxy handles is documented
    on their website:

    http://haproxy.1wt.eu/download/1.5/doc/configuration.txt#Unix Socket commands
    """

    def __init__(self, module):
        self.module = module

        self.state = self.module.params['state']
        self.host = self.module.params['host']
        self.backend = self.module.params['backend']
        self.weight = self.module.params['weight']
        self.socket = self.module.params['socket']
        self.shutdown_sessions = self.module.params['shutdown_sessions']
        self.fail_on_not_found = self.module.params['fail_on_not_found']
        self.wait = self.module.params['wait']
        self.wait_retries = self.module.params['wait_retries']
        self.wait_interval = self.module.params['wait_interval']
        self.command_results = {}

    def execute(self, cmd, timeout=200, capture_output=True):
        """
        Executes a HAProxy command by sending a message to a HAProxy's local
        UNIX socket and waiting up to 'timeout' milliseconds for the response.
        """
        self.client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        self.client.connect(self.socket)
        self.client.sendall('%s\n' % cmd)
        result = ''
        buf = ''
        buf = self.client.recv(RECV_SIZE)
        while buf:
            result += buf
            buf = self.client.recv(RECV_SIZE)
        if capture_output:
            self.capture_command_output(cmd, result.strip())
        self.client.close()
        return result


    def capture_command_output(self, cmd, output):
        """
        Capture the output for a command
        """
        if 'command' not in self.command_results:
            self.command_results['command'] = []
        self.command_results['command'].append(cmd)
        if 'output' not in self.command_results:
            self.command_results['output'] = []
        self.command_results['output'].append(output)


    def discover_all_backends(self):
        """
        Discover all entries with svname = 'BACKEND' and return a list of their corresponding
        pxnames
        """
        data = self.execute('show stat', 200, False).lstrip('# ')
        r = csv.DictReader(data.splitlines())
        return tuple(map(lambda d: d['pxname'], filter(lambda d: d['svname'] == 'BACKEND', r)))


    def execute_for_backends(self, cmd, pxname, svname, wait_for_status = None):
        """
        Run some command on the specified backends. If no backends are provided they will
        be discovered automatically (all backends)
        """
        # Discover backends if none are given
        if pxname is None:
            backends = self.discover_all_backends()
        else:
            backends = [pxname]

        # Run the command for each requested backend
        for backend in backends:
            # Fail when backends were not found
            state = self.get_state_for(backend, svname)
            if (self.fail_on_not_found or self.wait) and state is None:
                self.module.fail_json(msg="The specified backend '%s/%s' was not found!" % (backend, svname))

            self.execute(Template(cmd).substitute(pxname = backend, svname = svname))
            if self.wait:
                self.wait_until_status(backend, svname, wait_for_status)


    def get_state_for(self, pxname, svname):
        """
        Find the state of specific services. When pxname is not set, get all backends for a specific host.
        Returns a list of dictionaries containing the status and weight for those services.
        """
        data = self.execute('show stat', 200, False).lstrip('# ')
        r = csv.DictReader(data.splitlines())
        state = tuple(map(lambda d: { 'status': d['status'], 'weight': d['weight'] }, filter(lambda d: (pxname is None or d['pxname'] == pxname) and d['svname'] == svname, r)))
        return state or None


    def wait_until_status(self, pxname, svname, status):
        """
        Wait for a service to reach the specified status. Try RETRIES times
        with INTERVAL seconds of sleep in between. If the service has not reached
        the expected status in that time, the module will fail. If the service was
        not found, the module will fail.
        """
        for i in range(1, self.wait_retries):
            state = self.get_state_for(pxname, svname)

            # We can assume there will only be 1 element in state because both svname and pxname are always set when we get here
            if state[0]['status'] == status:
                return True
            else:
                time.sleep(self.wait_interval)

        self.module.fail_json(msg="server %s/%s not status '%s' after %d retries. Aborting." % (pxname, svname, status, self.wait_retries))


    def enabled(self, host, backend, weight):
        """
        Enabled action, marks server to UP and checks are re-enabled,
        also supports to get current weight for server (default) and
        set the weight for haproxy backend server when provides.
        """
        cmd = "get weight $pxname/$svname; enable server $pxname/$svname"
        if weight:
            cmd += "; set weight $pxname/$svname %s" % weight
        self.execute_for_backends(cmd, backend, host, 'UP')


    def disabled(self, host, backend, shutdown_sessions):
        """
        Disabled action, marks server to DOWN for maintenance. In this mode, no more checks will be
        performed on the server until it leaves maintenance,
        also it shutdown sessions while disabling backend host server.
        """
        cmd = "get weight $pxname/$svname; disable server $pxname/$svname"
        if shutdown_sessions:
            cmd += "; shutdown sessions server $pxname/$svname"
        self.execute_for_backends(cmd, backend, host, 'MAINT')


    def act(self):
        """
        Figure out what you want to do from ansible, and then do it.
        """
        # Get the state before the run
        state_before = self.get_state_for(self.backend, self.host)
        self.command_results['state_before'] = state_before

        # toggle enable/disbale server
        if self.state == 'enabled':
            self.enabled(self.host, self.backend, self.weight)
        elif self.state == 'disabled':
            self.disabled(self.host, self.backend, self.shutdown_sessions)
        else:
            self.module.fail_json(msg="unknown state specified: '%s'" % self.state)

        # Get the state after the run
        state_after = self.get_state_for(self.backend, self.host)
        self.command_results['state_after'] = state_after

        # Report change status
        if state_before != state_after:
            self.command_results['changed'] = True
            self.module.exit_json(**self.command_results)
        else:
            self.command_results['changed'] = False
            self.module.exit_json(**self.command_results)


def main():

    # load ansible module object
    module = AnsibleModule(
        argument_spec = dict(
            state = dict(required=True, default=None, choices=ACTION_CHOICES),
            host=dict(required=True, default=None),
            backend=dict(required=False, default=None),
            weight=dict(required=False, default=None),
            socket = dict(required=False, default=DEFAULT_SOCKET_LOCATION),
            shutdown_sessions=dict(required=False, default=False, type='bool'),
            fail_on_not_found=dict(required=False, default=False, type='bool'),
            wait=dict(required=False, default=False, type='bool'),
            wait_retries=dict(required=False, default=WAIT_RETRIES, type='int'),
            wait_interval=dict(required=False, default=WAIT_INTERVAL, type='int'),
        ),
    )

    if not socket:
        module.fail_json(msg="unable to locate haproxy socket")

    ansible_haproxy = HAProxy(module)
    ansible_haproxy.act()

# import module snippets
from ansible.module_utils.basic import *

if __name__ == '__main__':
    main()

"""Python implementation of Z85 85-bit encoding

Z85 encoding is a plaintext encoding for a bytestring interpreted as 32bit integers.
Since the chunks are 32bit, a bytestring must be a multiple of 4 bytes.
See ZMQ RFC 32 for details.


"""

# Copyright (C) PyZMQ Developers
# Distributed under the terms of the Modified BSD License.

import sys
import struct

PY3 = sys.version_info[0] >= 3
# Z85CHARS is the base 85 symbol table
Z85CHARS = b"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#"
# Z85MAP maps integers in [0,84] to the appropriate character in Z85CHARS
Z85MAP = dict([(c, idx) for idx, c in enumerate(Z85CHARS)])

_85s = [ 85**i for i in range(5) ][::-1]

def encode(rawbytes):
    """encode raw bytes into Z85"""
    # Accepts only byte arrays bounded to 4 bytes
    if len(rawbytes) % 4:
        raise ValueError("length must be multiple of 4, not %i" % len(rawbytes))
    
    nvalues = len(rawbytes) / 4
    
    values = struct.unpack('>%dI' % nvalues, rawbytes)
    encoded = []
    for v in values:
        for offset in _85s:
            encoded.append(Z85CHARS[(v // offset) % 85])
    
    # In Python 3, encoded is a list of integers (obviously?!)
    if PY3:
        return bytes(encoded)
    else:
        return b''.join(encoded)

def decode(z85bytes):
    """decode Z85 bytes to raw bytes, accepts ASCII string"""
    if PY3 and isinstance(z85bytes, str):
        try:
            z85bytes = z85bytes.encode('ascii')
        except UnicodeEncodeError:
            raise ValueError('string argument should contain only ASCII characters')

    if len(z85bytes) % 5:
        raise ValueError("Z85 length must be multiple of 5, not %i" % len(z85bytes))
    
    nvalues = len(z85bytes) / 5
    values = []
    for i in range(0, len(z85bytes), 5):
        value = 0
        for j, offset in enumerate(_85s):
            value += Z85MAP[z85bytes[i+j]] * offset
        values.append(value)
    return struct.pack('>%dI' % nvalues, *values)

# Copyright 2019 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

from __future__ import print_function
from __future__ import division
from __future__ import absolute_import

from google.appengine.ext import ndb

from dashboard.api import api_request_handler
from dashboard.common import utils


class NudgeAlertHandler(api_request_handler.ApiRequestHandler):
  def _CheckUser(self):
    if not utils.IsValidSheriffUser():
      raise api_request_handler.ForbiddenError()

  def Post(self):
    keys = self.request.get_all('key')
    start = self.request.get('new_start_revision')
    end = self.request.get('new_end_revision')
    try:
      start = int(start)
      end = int(end)
    except ValueError:
      return {'error': 'Invalid revisions %s, %s' % (start, end)}
    alerts = ndb.get_multi([ndb.Key(urlsafe=k) for k in keys])
    for a in alerts:
      a.start_revision = start
      a.end_revision = end
    ndb.put_multi(alerts)
    return {}

"""
mbed SDK
Copyright (c) 2011-2013 ARM Limited

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.
"""
from host_test import Test
from mbedrpc import SerialRPC, DigitalOut, DigitalIn, pin


class RpcTest(Test):
    def test(self):
        self.notify("RPC Test")
        s = SerialRPC(self.mbed.port, debug=True)

        self.notify("Init remote objects")

        p_out = pin("p10")
        p_in  = pin("p11")

        if hasattr(self.mbed.options, 'micro'):
            if self.mbed.options.micro == 'M0+':
                print "Freedom Board: PTA12 <-> PTC4"
                p_out = pin("PTA12")
                p_in  = pin("PTC4")

        self.output = DigitalOut(s, p_out);
        self.input = DigitalIn(s, p_in);

        self.check = True
        self.write_read_test(1)
        self.write_read_test(0)
        return self.check

    def write_read_test(self, v):
        self.notify("Check %d" % v)
        self.output.write(v)
        if self.input.read() != v:
            self.notify("ERROR")
            self.check = False
        else:
            self.notify("OK")


if __name__ == '__main__':
    RpcTest().run()

#!/usr/bin/env python2
# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai

__license__   = 'GPL v3'
__copyright__ = '2010, Kovid Goyal <kovid@kovidgoyal.net>'
__docformat__ = 'restructuredtext en'

import os

from calibre.utils.config_base import Config, StringConfig, config_dir, tweaks


listen_on = tweaks['server_listen_on']


log_access_file = os.path.join(config_dir, 'server_access_log.txt')
log_error_file = os.path.join(config_dir, 'server_error_log.txt')


def server_config(defaults=None):
    desc=_('Settings to control the calibre content server')
    c = Config('server', desc) if defaults is None else StringConfig(defaults, desc)

    c.add_opt('port', ['-p', '--port'], default=8080,
              help=_('The port on which to listen. Default is %default'))
    c.add_opt('timeout', ['-t', '--timeout'], default=120,
              help=_('The server timeout in seconds. Default is %default'))
    c.add_opt('thread_pool', ['--thread-pool'], default=30,
              help=_('The max number of worker threads to use. Default is %default'))
    c.add_opt('password', ['--password'], default=None,
              help=_('Set a password to restrict access. By default access is unrestricted.'))
    c.add_opt('username', ['--username'], default='calibre',
              help=_('Username for access. By default, it is: %default'))
    c.add_opt('develop', ['--develop'], default=False,
              help=_('Development mode. Server automatically restarts on file changes and serves code files (html, css, js) from the file system instead of calibre\'s resource system.'))
    c.add_opt('max_cover', ['--max-cover'], default='600x800',
              help=_('The maximum size for displayed covers. Default is %default.'))
    c.add_opt('max_opds_items', ['--max-opds-items'], default=30,
            help=_('The maximum number of matches to return per OPDS query. '
            'This affects Stanza, WordPlayer, etc. integration.'))
    c.add_opt('max_opds_ungrouped_items', ['--max-opds-ungrouped-items'],
            default=100,
            help=_('Group items in categories such as author/tags '
                'by first letter when there are more than this number '
                'of items. Default: %default. Set to a large number '
                'to disable grouping.'))
    c.add_opt('url_prefix', ['--url-prefix'], default='',
              help=_('Prefix to prepend to all URLs. Useful for reverse'
                  'proxying to this server from Apache/nginx/etc.'))

    return c

def custom_fields_to_display(db):
    ckeys = set(db.field_metadata.ignorable_field_keys())
    yes_fields = set(tweaks['content_server_will_display'])
    no_fields = set(tweaks['content_server_wont_display'])
    if '*' in yes_fields:
        yes_fields = ckeys
    if '*' in no_fields:
        no_fields = ckeys
    return frozenset(ckeys & (yes_fields - no_fields))

def main():
    from calibre.library.server.main import main
    return main()

"""Forest covertype dataset.

A classic dataset for classification benchmarks, featuring categorical and
real-valued features.

The dataset page is available from UCI Machine Learning Repository

    http://archive.ics.uci.edu/ml/datasets/Covertype

Courtesy of Jock A. Blackard and Colorado State University.
"""

# Author: Lars Buitinck <L.J.Buitinck@uva.nl>
#         Peter Prettenhofer <peter.prettenhofer@gmail.com>
# License: BSD 3 clause

import sys
from gzip import GzipFile
from io import BytesIO
import logging
from os.path import exists, join
try:
    from urllib2 import urlopen
except ImportError:
    from urllib.request import urlopen

import numpy as np

from .base import get_data_home
from .base import Bunch
from ..utils.fixes import makedirs
from ..externals import joblib
from ..utils import check_random_state


URL = ('http://archive.ics.uci.edu/ml/'
       'machine-learning-databases/covtype/covtype.data.gz')


logger = logging.getLogger()


def fetch_covtype(data_home=None, download_if_missing=True,
                  random_state=None, shuffle=False):
    """Load the covertype dataset, downloading it if necessary.

    Read more in the :ref:`User Guide <datasets>`.

    Parameters
    ----------
    data_home : string, optional
        Specify another download and cache folder for the datasets. By default
        all scikit learn data is stored in '~/scikit_learn_data' subfolders.

    download_if_missing : boolean, default=True
        If False, raise a IOError if the data is not locally available
        instead of trying to download the data from the source site.

    random_state : int, RandomState instance or None, optional (default=None)
        Random state for shuffling the dataset.
        If int, random_state is the seed used by the random number generator;
        If RandomState instance, random_state is the random number generator;
        If None, the random number generator is the RandomState instance used
        by `np.random`.

    shuffle : bool, default=False
        Whether to shuffle dataset.

    Returns
    -------
    dataset : dict-like object with the following attributes:

    dataset.data : numpy array of shape (581012, 54)
        Each row corresponds to the 54 features in the dataset.

    dataset.target : numpy array of shape (581012,)
        Each value corresponds to one of the 7 forest covertypes with values
        ranging between 1 to 7.

    dataset.DESCR : string
        Description of the forest covertype dataset.

    """

    data_home = get_data_home(data_home=data_home)
    if sys.version_info[0] == 3:
        # The zlib compression format use by joblib is not compatible when
        # switching from Python 2 to Python 3, let us use a separate folder
        # under Python 3:
        dir_suffix = "-py3"
    else:
        # Backward compat for Python 2 users
        dir_suffix = ""
    covtype_dir = join(data_home, "covertype" + dir_suffix)
    samples_path = join(covtype_dir, "samples")
    targets_path = join(covtype_dir, "targets")
    available = exists(samples_path)

    if download_if_missing and not available:
        makedirs(covtype_dir, exist_ok=True)
        logger.warning("Downloading %s" % URL)
        f = BytesIO(urlopen(URL).read())
        Xy = np.genfromtxt(GzipFile(fileobj=f), delimiter=',')

        X = Xy[:, :-1]
        y = Xy[:, -1].astype(np.int32)

        joblib.dump(X, samples_path, compress=9)
        joblib.dump(y, targets_path, compress=9)

    try:
        X, y
    except NameError:
        X = joblib.load(samples_path)
        y = joblib.load(targets_path)

    if shuffle:
        ind = np.arange(X.shape[0])
        rng = check_random_state(random_state)
        rng.shuffle(ind)
        X = X[ind]
        y = y[ind]

    return Bunch(data=X, target=y, DESCR=__doc__)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Copyright (C) 2011 Adriano Monteiro Marques
#
# Author: Piotrek Wasilewski <wasilewski.piotrek@gmail.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
"""
This is the core module of the Network Administrator web API. Its main
purpose is to receive notifications and give access to hosts, networks
and reports data. It is based on RESTful web services and uses JSON to
serialize data.

The API has its private and public sections. The private section's task
is to receive notifications (events) from servers and save them into the
database. The public part is supposed to be the interface that will give
external applications access to informations about hosts, networks and
reports.

Our next goal for this API is to provide authentication with OAuth.
So far we are using system which simply sends user login and password
encoded with the base64 library.
"""

try:
    import simplejson as json
except ImportError:
    import json
import datetime

from django.utils.translation import ugettext as _
from piston.handler import BaseHandler

from netadmin.networks.models import Host, Network
from netadmin import notifier
from netadmin.events.models import Event
from netadmin.events.utils import get_event_data, EventParseError

from views import api_error, api_ok, api_response


class HostHandler(BaseHandler):
    """
    Host handler is a part of the public API. It gives access to hosts data.
    """
    allowed_methods = ('GET', )
    
    def read(self, request, host_id=None):
        """
        Returns host details if host_id is specified, otherwise returns
        list of hosts.
        
        Method: GET
        
        Request parameters:
            * host_id (optional) - if specified, host details are returned
            * order_by (optional) - if host_id is not specified, order
              hosts list according to this parameter; allowed values are:
                ** name - order by name
                ** last_event - order by occurance of last event
            * limit - maximum number of hosts on a list
                
        Host details response:
            * host_id
            * host_name
            * host_description
            * ipv4 - IPv4 address of the host
            * ipv6 - IPv6 address of the host
            * events (optional) - list of events for the host
                ** id - event identifier
                ** message - event message
                
        Hosts list response:
            * hosts
                ** id - host identifier
                ** name - host name
        """
        
        if not host_id:
            hosts = Host.objects.filter(user=request.user)
            if not hosts:
                return api_error(_('The hosts list is empty'))
            
            order_by = request.GET.get('order_by', 'name')
            if order_by == 'name':
                hosts = hosts.order_by('name')
            elif order_by == 'latest_event':
                hosts = sorted(hosts, key=lambda host: host.latest_event())
                
            limit = request.GET.get('limit')
            if limit:
                hosts = hosts[:limit]
            
            response = {
                'hosts': [host.api_list() for host in hosts]
            }
            return api_response(response)
        
        try:
            host = Host.objects.get(pk=host_id, user=request.user)
        except Host.DoesNotExist:
            return api_error(_('Host does not exist'))
        
        return api_response(host.api_detail())
    
class NetworkHandler(BaseHandler):
    """
    This handler gives access to all informations about networks, like
    networks list or details of the specified network. This is a part
    of the public API.
    """
    allowed_methods = ('GET', )
    
    def read(self, request, network_id=None):
        """
        If the network_id is specified returns network details,
        otherwise returns networks list.
        
        Method: GET
        
        Request parematers:
            * network_id (optional) - network which details we want
            * get_hosts (optional) - if 'true' and network_id is
              specified, then list of hosts in the network is returned
            * order_by (optional) - if network_id is not specified
              then networks list will be sorted according to this
              parameter; the allowed values are:
                ** name - order by name
                ** last_event - order by occurance of last event
        
        Network details response:
            * network_id
            * network_name - name of the network
            * network_description - description of the network
            * hosts (optional)
                ** id - host identifier
                ** name - host name
            
        Networks list reponse:
            * networks
                ** id - network identifier
                ** name - network name
        """ 
        
        if not network_id:
            networks = Network.objects.filter(user=request.user)
            if not networks:
                return api_error(_('The networks list is empty'))
            
            order_by = request.GET.get('order_by', 'name')
            if order_by == 'name':
                networks = networks.order_by('name')
            elif order_by == 'latest_event':
                networks = sorted(networks, key=lambda net: net.latest_event())
            
            response = {
                'networks': [net.api_list() for net in networks]
            }
            return api_response(response)
        
        try:
            network = Network.objects.get(pk=network_id, user=request.user)
        except Network.DoesNotExist:
            return api_error(_('Network does not exist'))
        
        response = network.api_detail()
        
        get_hosts = request.GET.get('get_hosts', 'true')
        if get_hosts.lower() == 'true':
            response['hosts'] = [host.api_list() for host in network.hosts()]
            
        return api_response(response)
    
class EventHandler(BaseHandler):
    """
    Event handler is responsible for receiving notifications (events)
    and saving them to the Network Administrator database. Its second
    task is to return events list or details of event.
    
    Every event has its source host which is the host from where it
    comes. In the notification the source host is identified by pair
    of IPv4 and IPv6 addresses, where the second one is optional so far.
    So to relate the upcoming event with the corresponding host in
    database we have to search for the host which has the same
    addresses like the source host in the notification. 
    """
    allowed_methods = ('POST', 'GET')
    
    def create(self, request):
        """
        Receives one or more notifications and saves them to the database.
        This method is a part of private API.
        
        Method: POST
        URL: /api/event/report/
        
        Case 1: Reporting single event (notification)
        ---------------------------------------------
        
        Request parameters:
            * description - message describing the event
            * short_description - shorter message, e.g. to use in list
            * timestamp - when the event occurred
            * event_type - type of the event which should also describe
              its importance
            * protocol - network protocol related to the event
            * hostname - name of the source host
            * source_host_ipv4, source_host_ipv6 - IPv4 and IPv6
              addresses of the source host
            * fields_class - monitoring module identifier
        
        Any additional data provided with the event will be serialized and
        saved together with fields described above.
              
        Response:
            * status - **ok** or **error**
            * message - details of the result
            
        Case 2: Reporting multiple events at once
        -----------------------------------------
        
        Request parameters:
            * events - list of events serialized with JSON
            
        Response:
            * status - **ok** or **error**
            * message - details of the result
        
        """
        if request.POST.get('events'):
            try:
                events = json.loads(request.POST.get('events', ''))
            except ValueError:
                return api_error(_('No events could be read'))
            
            for event_dict in events:
                try:
                    event_data = get_event_data(request, event_dict)
                except EventParseError, e:
                    message = str(e)
                    return api_error(_(message))
                event = Event(**event_data)
                event.save()
                
                if event.event_type.notify:
                    notifier.manager.add(event.short_message, event.message,
                                         event.user(), event)
            
            return api_ok(_('Events reported successfully'))
        
        try:
            event_data = get_event_data(request, request.POST)
        except EventParseError, e:
            message = str(e)
            return api_error(_(message))
        event = Event(**event_data)
        event.save()
        
        if event.event_type.notify:
            notifier.manager.add(event.short_message, event.message,
                                 event.user(), event)
        
        return api_ok(_('Event reported successfully'))
    
    def read(self, request, event_id=None):
        """
        The part of the public API. If the event_id parameter is specified,
        returns event details, otherwise returns events list ordered by timestamp.
        In the second case, events may be filtered by source host or
        timestamp and their number may be limited. 
        
        Method: GET
        
        Request parameters:
            * source_host - identifier of a source host
            * time_from - include only those events which timestamp is greater
              or equal than this value
            * time_to - include only those events which timestamp if less than
              this value
            * limit - maximal number of events on a list
        
        Response for events list:
            * events - list of events
                ** id - event identifier
                ** message - event message
                
        Response for event details:
            * event_id
            * description - event message
            * description - event short message
            * timestamp - event timestamp
            * event_type - type of event 
            * source_host_id - identifier of source host
            * module_id - identifier of monitoring module
            * module_fields - fields defined by monitoring module
        """
        if not event_id:
            events = Event.objects.all().order_by('-timestamp')
            if not events:
                return api_error(_('The events list is empty'))
            
            source_host = request.GET.get('source_host')
            if source_host:
                events = events.filter(source_host__pk=source_host)
                
            time_from = request.GET.get('time_from')
            time_to = request.GET.get('time_to')
            if time_from:
                time_from = datetime.datetime.fromtimestamp(float(time_from))
                events = events.filter(timestamp__gte=time_from)
            if time_to:
                time_to = datetime.datetime.fromtimestamp(float(time_to))
                events = events.filter(timestamp__lt=time_to)
                
            # because of limited JOINs, we cannot use events.filter(source_host__user=request.user)
            events = filter(lambda event: event.user == request.user, events)
            
            limit = request.GET.get('limit')
            if limit and limit > 0:
                events = events[:limit]
            
            response = {
                'events': [event.api_list() for event in events]
            }
            return api_response(response)
        
        try:
            event = Event.objects.get(pk=event_id)
        except Event.DoesNotExist:
            return api_error(_('Event does not exist'))
        
        if event.source_host.user != request.user:
            return api_error(_('Event does not exist'))
        
        return api_response(event.api_detail())

#    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.

from openstack_dashboard.test.integration_tests import helpers

NEW_PASSWORD = "123"


class TestPasswordChange(helpers.TestCase):

    def _reset_password(self):
        passwordchange_page = self.home_pg.go_to_settings_changepasswordpage()
        passwordchange_page.reset_to_default_password(NEW_PASSWORD)

    def _login(self):
        self.login_pg.login()
        self.assertTrue(self.home_pg.is_logged_in,
                        "Failed to login with default password")

    def test_password_change(self):
        """Changes the password, verifies it was indeed changed and resets to
        default password.
        """
        passwordchange_page = self.home_pg.go_to_settings_changepasswordpage()

        try:
            passwordchange_page.change_password(self.TEST_PASSWORD,
                                                NEW_PASSWORD)

            self.home_pg = self.login_pg.login(user=self.TEST_USER_NAME,
                                               password=NEW_PASSWORD)
            self.assertTrue(self.home_pg.is_logged_in,
                            "Failed to login with new password")
        finally:
            self._reset_password()
            self._login()

    def test_show_message_after_logout(self):
        """Ensure an informational message is shown on the login page after the
        user is logged out.
        """
        passwordchange_page = self.home_pg.go_to_settings_changepasswordpage()

        try:
            passwordchange_page.change_password(self.TEST_PASSWORD,
                                                NEW_PASSWORD)
            self.assertTrue(
                self.login_pg.is_logout_reason_displayed(),
                "The logout reason message was not found on the login page")
        finally:
            self.login_pg.login(user=self.TEST_USER_NAME,
                                password=NEW_PASSWORD)
            self._reset_password()
            self._login()

import os

# toolchains options
ARCH='arm'
CPU='cortex-m3'
CROSS_TOOL='iar'

if os.getenv('RTT_CC'):
	CROSS_TOOL = os.getenv('RTT_CC')

# cross_tool provides the cross compiler
# EXEC_PATH is the compiler execute path, for example, CodeSourcery, Keil MDK, IAR

if  CROSS_TOOL == 'gcc':
	PLATFORM 	= 'gcc'
	EXEC_PATH 	= 'C:/Program Files/CodeSourcery/Sourcery G++ Lite/bin'
elif CROSS_TOOL == 'keil':
	PLATFORM 	= 'armcc'
	EXEC_PATH 	= 'C:/Keil'
elif CROSS_TOOL == 'iar':
	PLATFORM 	= 'iar'
	EXEC_PATH 	= 'C:/Program Files/IAR Systems/Embedded Workbench 6.0 Evaluation'

if os.getenv('RTT_EXEC_PATH'):
	EXEC_PATH = os.getenv('RTT_EXEC_PATH')

BUILD = 'debug'

if PLATFORM == 'gcc':
    # toolchains
    PREFIX = 'arm-none-eabi-'
    CC = PREFIX + 'gcc'
    AS = PREFIX + 'gcc'
    AR = PREFIX + 'ar'
    LINK = PREFIX + 'gcc'
    TARGET_EXT = 'elf'
    SIZE = PREFIX + 'size'
    OBJDUMP = PREFIX + 'objdump'
    OBJCPY = PREFIX + 'objcopy'

    DEVICE = ' -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections'
    CFLAGS = DEVICE
    AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp'
    LFLAGS = DEVICE + ' -Wl,--gc-sections,-Map=rtthread-fm3.map,-cref,-u,Reset_Handler -T rtthread-mb9bf506.ld -nostartfiles'

    CPATH = ''
    LPATH = ''

    if BUILD == 'debug':
        CFLAGS += ' -O0 -gdwarf-2'
        AFLAGS += ' -gdwarf-2'
    else:
        CFLAGS += ' -O2'

    POST_ACTION = OBJCPY + ' -O binary $TARGET rtthread.bin\n' + SIZE + ' $TARGET \n'
elif PLATFORM == 'armcc':
    # toolchains
    CC = 'armcc'
    AS = 'armasm'
    AR = 'armar'
    LINK = 'armlink'
    TARGET_EXT = 'axf'

    DEVICE = ' --device DARMSTM'
    CFLAGS = DEVICE + ' --apcs=interwork'
    AFLAGS = DEVICE
    LFLAGS = DEVICE + ' --info sizes --info totals --info unused --info veneers --list rtthread-fm3.map --scatter rtthread-mb9bf506.sct'

    CFLAGS += ' -I' + EXEC_PATH + '/ARM/RV31/INC'
    LFLAGS += ' --libpath ' + EXEC_PATH + '/ARM/RV31/LIB'

    EXEC_PATH += '/arm/bin40/'

    if BUILD == 'debug':
        CFLAGS += ' -g -O0'
        AFLAGS += ' -g'
    else:
        CFLAGS += ' -O2'

    POST_ACTION = 'fromelf --bin $TARGET --output rtthread.bin \nfromelf -z $TARGET'

elif PLATFORM == 'iar':
    # toolchains
    CC = 'iccarm'
    AS = 'iasmarm'
    AR = 'iarchive'
    LINK = 'ilinkarm'
    TARGET_EXT = 'out'

    CFLAGS = ''
    CFLAGS += ' --diag_suppress Pa050'
    CFLAGS += ' --no_cse' 
    CFLAGS += ' --no_unroll' 
    CFLAGS += ' --no_inline' 
    CFLAGS += ' --no_code_motion' 
    CFLAGS += ' --no_tbaa' 
    CFLAGS += ' --no_clustering' 
    CFLAGS += ' --no_scheduling' 
    CFLAGS += ' --debug' 
    CFLAGS += ' --endian=little' 
    CFLAGS += ' --cpu=Cortex-M3' 
    CFLAGS += ' -e' 
    CFLAGS += ' --fpu=None'
    CFLAGS += ' --dlib_config "' + EXEC_PATH + '/arm/INC/c/DLib_Config_Normal.h"'    
    CFLAGS += ' -Ol'    
    CFLAGS += ' --use_c++_inline'    
        
    AFLAGS = ''
    AFLAGS += ' -s+' 
    AFLAGS += ' -w+' 
    AFLAGS += ' -r' 
    AFLAGS += ' --cpu Cortex-M3' 
    AFLAGS += ' --fpu None' 
    AFLAGS += ' -I"' + EXEC_PATH + '/arm/INC"'

    LFLAGS = ' --config rtthread-mb9bf506.icf'
    LFLAGS += ' --semihosting' 
    LFLAGS += ' --entry __iar_program_start'    

    EXEC_PATH = EXEC_PATH + '/arm/bin/'
    POST_ACTION = 'ielftool.exe --srec --verbose $TARGET rtthread.srec' 

#!/usr/bin/env python
"""
This is the project main settings file. (Source controlled).
If you need to override a setting locally, use local_settings.py.
"""
GENERATOR_DJANGO_POLYMER_VERSION = "0.0.1"
import os
import sys
import logging

from project.utils import logger


# Django settings for project.
DEBUG = True  # As of Django 1.5 all logging messages reaching the django logger are sent to Console if (DEBUG=True)
DEV_SETTINGS = os.environ.get('DJ_DEV_SETTINGS')
LOG_LEVEL = os.environ.get('DJ_LOG_LEVEL')

# General Directory Structure
# +++ apps
#   ++ someApp
#       ++ templatetags
#           -- someAppTags.py
#       - models.py
#       - urls.py
#       - views.py
#       - utils.py
#   ++ someOtherApp
#       ++ templatetags
#           -- someOtherAppTags.py
#       - models.py
#       - urls.py
#       - views.py
#       - utils.py
# +++ project
#   ++ settings
#       - base.py (THIS FILE)
#       - dev.py
#       - global.py* (optional)
#   ++ templates
#       # someApp
#           - someTemplate.html
#   ++ test_factories
#       - usefulFactoryScript.py
#   ++ utils
#       - usefulFunctions.py
#   ++ views
#       - mixins.py
#   ++ static
#       - staticFile.html/css/png
#   ++ media
#   - urls.py
#   - views.py

DATABASES = {
    'default': {
        'ENGINE':   'django.db.backends.postgresql_psycopg2',                # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
        'NAME':     os.environ.get('DB_NAME'),                  # Or path to database file if using sqlite3.
        'USER':     os.environ.get('DB_USER'),                  # Not used with sqlite3.
        'PASSWORD': os.environ.get('DB_PASSWORD'),              # Not used with sqlite3.
        'HOST':     os.environ.get('DB_HOST'),                  # Set to empty string for localhost. Not used with sqlite3.
        'PORT':     os.environ.get('DB_PORT'),                  # Set to empty string for default. Not used with sqlite3.
    }
}

# ============================================================================ #
# Main Paths
# ============================================================================ #
# Make filepaths relative to settings. This dynamically discovers the path to the project
PROJECT_ROOT = os.path.dirname(os.path.realpath(os.path.dirname(__file__)))
SITE_ROOT = os.path.dirname(PROJECT_ROOT)
APP_ROOT = os.path.join(SITE_ROOT, 'apps')
# Add App/Library Path
sys.path.append(APP_ROOT)

# ---------------------------------------------------------------------------- #
# General
# ---------------------------------------------------------------------------- #
# Make this unique, and don't share it with anybody.
# (This should be unique if this page was used created using generator-django-polymer)
SECRET_KEY = '5XUFDmBgx8gTVPpx998Iiosm9zmmgwD/gHG4XWHIs2zQWs352dY='

ADMINS = ((os.environ.get('ADMIN_NAME'), os.environ.get('ADMIN_EMAIL')),)

MANAGERS = ADMINS

MIDDLEWARE_CLASSES = (
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
)

import django.conf.global_settings as DEFAULT_SETTINGS

#TEMPLATE_CONTEXT_PROCESSORS = DEFAULT_SETTINGS.TEMPLATE_CONTEXT_PROCESSORS + (
#          'django.core.context_processors.request',
#)


ROOT_URLCONF = 'project.urls'

# Local time zone for this installation. Choices can be found here:
# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
# although not all choices may be available on all operating systems.
# On Unix systems, a value of None will cause Django to use the same
# timezone as the operating system.
# If running in a Windows environment this must be set to the same as your
# system time zone.
TIME_ZONE = 'Europe/London'

# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-GB'
SITE_ID = 1

# If you set this to False, Django will make some optimizations so as not
# to load the internationalization machinery.
USE_I18N = True

# If you set this to False, Django will not format dates, numbers and
# calendars according to the current locale
USE_L10N = True

# ---------------------------------------------------------------------------- #
# Media / Static
# ---------------------------------------------------------------------------- #
# Absolute filesystem path to the directory that will hold user-uploaded files.
# Example: "/home/media/media.lawrence.com/media/"
MEDIA_ROOT = os.path.join(PROJECT_ROOT, 'media')

# URL that handles the media served from MEDIA_ROOT. Make sure to use a trailing slash.
# Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
MEDIA_URL = '/media/'

# URL prefix for admin static files -- CSS, JavaScript and images.
# Make sure to use a trailing slash.
# Examples: "http://foo.com/static/admin/", "/static/admin/".
ADMIN_MEDIA_PREFIX = '/static/admin/'

# Absolute path to the directory static files should be collected to.
# Don't put anything in this directory yourself; store your static files
# in apps' "static/" subdirectories and in STATICFILES_DIRS.
# Example: "/home/media/media.lawrence.com/static/"
# use "manage.py collectstatic"    collects to STATIC_ROOT
STATIC_ROOT = os.path.join(PROJECT_ROOT, '_auto_static')

# URL prefix for static files. Example: "http://media.lawrence.com/static/"
STATIC_URL = '/static/'

# Additional locations of static files (absolute)
STATICFILES_DIRS = (os.path.join(PROJECT_ROOT, 'static'),)
# Other ways
#STATICFILES_DIRS = (
    # Put strings here, like "/home/html/static" or "C:/www/django/static".
    # Always use forward slashes, even on Windows.
    # Don't forget to use absolute paths, not relative paths.
#)

# List of finder classes that know how to find static files in various locations.
STATICFILES_FINDERS = (
    'django.contrib.staticfiles.finders.FileSystemFinder',
    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
    'django.contrib.staticfiles.finders.DefaultStorageFinder',
)

# ---------------------------------------------------------------------------- #
# Templating
# ---------------------------------------------------------------------------- #
# List of callables that know how to import templates from various sources.
# TEMPLATE_LOADERS = (
#     'django.template.loaders.filesystem.Loader',
#     'django.template.loaders.app_directories.Loader',
#     'django.template.loaders.eggs.Loader',
# )

# NOTE: It makes sense to keep all templates under /templates/<app> for easier use.
#       The applications in this project dont need to portable so this decision makes sense.
# For the sake of keeping the ability to add templates under an application we add the
# following code: (but it is not technically needed)
# Dir Structure
# + someApplication
#       + templates
#           + someApplication
#               - someTemplate.html
#TEMPLATE_DIRS = (os.path.join(PROJECT_ROOT, 'templates'), )

# ---------------------------------------------------------------------------- #
# Fixtures
# ---------------------------------------------------------------------------- #
# The list of directories to search for fixtures
# Note: It's bad practice to use fixtures so uncomment this.
#       Use test factories or migrations for data instead
#FIXTURE_DIRS = (os.path.join(PROJECT_ROOT, 'fixtures'))

# ---------------------------------------------------------------------------- #
# Installed Applications
# ---------------------------------------------------------------------------- #
DJANGO_APPS = (
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.sites',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.admin',
    'django.contrib.admindocs',
)

THIRD_PATH_APPS = (
    'django_extensions',
    'mptt',
    'taggit',
    'corsheaders',
    'rest_framework',
    'rest_framework.authtoken',
    'rest_framework_swagger',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'allauth.socialaccount.providers.google',
)

# HACK BEFORE DJANGO.CONTRIB.AUTH
LOCAL_APPS = (
    'accounts',
    'stats',
    # 'accounts.rest_auth',
    # 'accounts.profiles',
    'blog',
    # 'content',
    # 'mailbot',
    # 'search',
    # 'shop',
    # 'cms',
    # 'admin',
)

INSTALLED_APPS = DJANGO_APPS + THIRD_PATH_APPS + LOCAL_APPS
print INSTALLED_APPS
# ---------------------------------------------------------------------------- #
# Third Party App Dependencies
# ---------------------------------------------------------------------------- #
##############################################################################
# Accounts / Regisratiorn App
AUTH_USER_MODEL = 'accounts.AccountsUser'
REGISTRATION_OPEN = True

ACCOUNT_AUTHENTICATION_METHOD = 'username'

AUTHENTICATION_BACKENDS = (

    # Needed to login by username in Django admin, regardless of `allauth`
    'django.contrib.auth.backends.ModelBackend',

    # `allauth` specific authentication methods, such as login by e-mail
    'allauth.account.auth_backends.AuthenticationBackend',
    
)

# REST_FRAMEWORK = {
#     'DEFAULT_AUTHENTICATION_CLASSES': (
#         'rest_framework.authentication.BasicAuthentication',
#         'rest_framework.authentication.SessionAuthentication',
#         'rest_framework.authentication.TokenAuthentication',
#     )
# }

REST_FRAMEWORK = {
   'DEFAULT_AUTHENTICATION_CLASSES': (
       'rest_framework.authentication.TokenAuthentication',
   ),
   'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAdminUser',
   ),
   'PAGINATE_BY': 10,
}

# If you are running Django 1.8+, specify the context processors
# as follows:
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                # Already defined Django-related contexts here
            'django.contrib.auth.context_processors.auth',
                'django.template.context_processors.debug',
                'django.template.context_processors.i18n',
                'django.template.context_processors.media',
                'django.template.context_processors.static',
                'django.template.context_processors.tz',
                'django.contrib.messages.context_processors.messages',
                 'django.core.context_processors.request',
                # `allauth` needs this from django
                'django.template.context_processors.request',

            ],
            'debug': True,    
        },
    },
]


ACCOUNTS_PASSWORD_RESET_NOTIFY_EMAIL_NOT_IN_SYSTEM = True
#PASSWORD_RESET_NOTIFY_EMAIL_NOT_IN_SYSTEM













# Search App
REDIS_HOST = '192.168.99.100'

# Search App
REDIS_HOST = 'redis'








##############################################################################
# Reg App
# Actually from django.contrib.auth  (AUTHENTICATION)
#LOGIN_URL = '/accounts/auth/login/'
#LOGIN_REDIRECT_URL = '/accounts/auth/login/'  # (global_settings.py)  '/users/profile/' - - default
# One-week activation window; you may, of course, use a different value.
ACCOUNT_ACTIVATION_DAYS = 7

#REGISTRATION_OPEN = True


# http://django-allauth.readthedocs.org/en/latest/configuration.html









##############################################################################
# Django Shop
SHOP_SHIPPING_FLAT_RATE = '-30'
#SHOP_SHIPPING_BACKENDS = [
#    'shop.shipping.backends.flat_rate.FlatRateShipping',
#]
SHOP_PAYMENT_BACKENDS = [
     'payment.shipping.SkipShippingBackend',
  #  'shop.payment.backends.pay_on_delivery.PayOnDeliveryBackend'
]
SHOP_CART_MODIFIERS = [
    'shop_simplevariations.cart_modifier.ProductOptionsModifier',
    'payment.modifiers.FixedShippingCosts',
    'payment.modifiers.FixedTaxRate',
]

##############################################################################
# CORS Django App
CORS_ORIGIN_ALLOW_ALL = True
CORS_ALLOW_CREDENTIALS = True
#CORS_ALLOW_ALL_ORIGIN = True
#CORS_ORIGIN_REGEX_WHITELIST = ('^(https?://)?$', )

##############################################################################
# Django Dynamic Fixture
DDF_DEFAULT_DATA_FIXTURE = 'sequential'  # or 'static_sequential' or 'random' or 'path.to.yout.DataFixtureClass'
IMPORT_DDF_MODELS = ''
DDF_FILL_NULLABLE_FIELDS = True

##############################################################################
# Django Nose
# overrides global settings for default test runner
# (we dont want to use default django testing as it has many limitations )
TEST_RUNNER = 'django_nose.NoseTestSuiteRunner'

# ---------------------------------------------------------------------------- #
# LOGGING - logging configuration
# ---------------------------------------------------------------------------- #
# A sample logging configuration. The only tangible logging
# performed by this configuration is to send an email to
# the site admins on every HTTP 500 error.
# See http://docs.djangoproject.com/en/dev/topics/logging for
# more details on how to customize your logging configuration.
LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(created)f %(filename)s %(funcName)s %(levelname)s %(module)s %(pathname)s %(process)d %(processName)s  %(lineno)s %(levelno)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s',
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
        'custom': {
            '()':  logger.DjangoProjectLogFormatter,
        },

    },
    # special filter: e.g. only log when debug=False (Django only provides two filters) (make a custom if needed)
    'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse',
         }
    },
    'handlers': {
        'file': {
        'level': 'DEBUG',
        'class': 'logging.handlers.TimedRotatingFileHandler',
        'when': 'midnight',
        'interval': 1,
        'backupCount': 30,
        'filename': SITE_ROOT + '/log/' + 'project' + '.log',
                'formatter': 'verbose',
        },
        'null': {
            'level': 'DEBUG',
            'class': 'django.utils.log.NullHandler',
        },
        'console': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'custom'
        },
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'filters': ['require_debug_false']
        }
    },
    # This is the logger you use e.g. logging.getLogger(django)
    'loggers': {
        'django': {
            'handlers': ['console'],
            'propagate': True,
            'level': 'DEBUG',
        },
        'django.request': {
            'handlers': ['console', 'file'],
            'level': 'INFO',
            'propagate': False,
        },
        'project_logger': {
        'handlers': ['console', 'file'],
        'level': 'DEBUG',
        'propagate': True,


        },
    }
}

# ---------------------------------------------------------------------------- #
# Finally, Import any other settings
# ---------------------------------------------------------------------------- #
if DEV_SETTINGS:
        from .local import *


"""
=========================================================
Multi-dimensional image processing (:mod:`scipy.ndimage`)
=========================================================

.. currentmodule:: scipy.ndimage

This package contains various functions for multi-dimensional image
processing.


Filters :mod:`scipy.ndimage.filters`
====================================

.. module:: scipy.ndimage.filters

.. autosummary::
   :toctree: generated/

   convolve - Multi-dimensional convolution
   convolve1d - 1-D convolution along the given axis
   correlate - Multi-dimensional correlation
   correlate1d - 1-D correlation along the given axis
   gaussian_filter
   gaussian_filter1d
   gaussian_gradient_magnitude
   gaussian_laplace
   generic_filter - Multi-dimensional filter using a given function
   generic_filter1d - 1-D generic filter along the given axis
   generic_gradient_magnitude
   generic_laplace
   laplace - n-D Laplace filter based on approximate second derivatives
   maximum_filter
   maximum_filter1d
   median_filter - Calculates a multi-dimensional median filter
   minimum_filter
   minimum_filter1d
   percentile_filter - Calculates a multi-dimensional percentile filter
   prewitt
   rank_filter - Calculates a multi-dimensional rank filter
   sobel
   uniform_filter - Multi-dimensional uniform filter
   uniform_filter1d - 1-D uniform filter along the given axis

Fourier filters :mod:`scipy.ndimage.fourier`
============================================

.. module:: scipy.ndimage.fourier

.. autosummary::
   :toctree: generated/

   fourier_ellipsoid
   fourier_gaussian
   fourier_shift
   fourier_uniform

Interpolation :mod:`scipy.ndimage.interpolation`
================================================

.. module:: scipy.ndimage.interpolation

.. autosummary::
   :toctree: generated/

   affine_transform - Apply an affine transformation
   geometric_transform - Apply an arbritrary geometric transform
   map_coordinates - Map input array to new coordinates by interpolation
   rotate - Rotate an array
   shift - Shift an array
   spline_filter
   spline_filter1d
   zoom - Zoom an array

Measurements :mod:`scipy.ndimage.measurements`
==============================================

.. module:: scipy.ndimage.measurements

.. autosummary::
   :toctree: generated/

   center_of_mass - The center of mass of the values of an array at labels
   extrema - Min's and max's of an array at labels, with their positions
   find_objects - Find objects in a labeled array
   histogram - Histogram of the values of an array, optionally at labels
   label - Label features in an array
   maximum
   maximum_position
   mean - Mean of the values of an array at labels
   minimum
   minimum_position
   standard_deviation - Standard deviation of an n-D image array
   sum - Sum of the values of the array
   variance - Variance of the values of an n-D image array
   watershed_ift

Morphology :mod:`scipy.ndimage.morphology`
==========================================

.. module:: scipy.ndimage.morphology

.. autosummary::
   :toctree: generated/

   binary_closing
   binary_dilation
   binary_erosion
   binary_fill_holes
   binary_hit_or_miss
   binary_opening
   binary_propagation
   black_tophat
   distance_transform_bf
   distance_transform_cdt
   distance_transform_edt
   generate_binary_structure
   grey_closing
   grey_dilation
   grey_erosion
   grey_opening
   iterate_structure
   morphological_gradient
   morphological_laplace
   white_tophat

Utility
=======

.. currentmodule:: scipy.ndimage

.. autosummary::
   :toctree: generated/

   imread - Load an image from a file

"""

# Copyright (C) 2003-2005 Peter J. Verveer
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above
#    copyright notice, this list of conditions and the following
#    disclaimer in the documentation and/or other materials provided
#    with the distribution.
#
# 3. The name of the author may not be used to endorse or promote
#    products derived from this software without specific prior
#    written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

from __future__ import division, print_function, absolute_import

from .filters import *
from .fourier import *
from .interpolation import *
from .measurements import *
from .morphology import *
from .io import *

__version__ = '2.0'

__all__ = [s for s in dir() if not s.startswith('_')]
from numpy.testing import Tester
test = Tester().test

# -*- coding: utf-8 -*-
##############################################################################
#
#    Copyright (C) 2014-2018 Compassion CH (http://www.compassion.ch)
#    Releasing children from poverty in Jesus' name
#    @author: Emanuel Cino <ecino@compassion.ch>
#
#    The licence is in the file __manifest__.py
#
##############################################################################

from odoo import models, exceptions, _


class MoveLine(models.Model):
    """ Adds a method to split a payment into several move_lines
    in order to reconcile only a partial amount, avoiding doing
    partial reconciliation. """
    _inherit = 'account.move.line'

    def split_payment_and_reconcile(self):
        move = False
        move_line = False
        sum_credit = sum(self.mapped('credit'))
        sum_debit = sum(self.mapped('debit'))
        if sum_credit == sum_debit:
            # Nothing to do here
            return self.reconcile()

        # Check in which direction we are reconciling
        split_column = 'credit' if sum_credit > sum_debit else 'debit'
        difference = abs(sum_credit - sum_debit)

        for line in self:
            if getattr(line, split_column) > difference:
                # We will split this line
                move = line.move_id
                move_line = line
                break
        else:
            raise exceptions.UserError(
                _('This can only be done if one move line can be split '
                  'to cover the reconcile difference'))

        # Edit move in order to split payment into two move lines
        move.button_cancel()
        move.write({
            'line_ids': [
                (1, move_line.id, {
                    split_column: move_line.credit - difference}),
                (0, 0, {
                    split_column: difference,
                    'name': self.env.context.get('residual_comment',
                                                 move_line.name),
                    'account_id': move_line.account_id.id,
                    'date': move_line.date,
                    'date_maturity': move_line.date_maturity,
                    'journal_id': move_line.journal_id.id,
                    'partner_id': move_line.partner_id.id,
                }),
            ]
        })
        move.post()

        # Perform the reconciliation
        self.reconcile()

        return True

from Products.ZenModel.DeviceComponent import DeviceComponent
from Products.ZenModel.ManagedEntity import ManagedEntity
from Products.ZenModel.ZenossSecurity import ZEN_CHANGE_DEVICE
from Products.ZenRelations.RelSchema import ToManyCont, ToOne


class ExampleComponent(DeviceComponent, ManagedEntity):
    meta_type = portal_type = "ExampleComponent"

    attributeOne = None
    attributeTwo = None

    _properties = ManagedEntity._properties + (
        {'id': 'attributeOne', 'type': 'int', 'mode': ''},
        {'id': 'attributeTwo', 'type': 'string', 'mode': ''},
    )

    _relations = ManagedEntity._relations + (
        ('exampleDevice', ToOne(ToManyCont,
            'ZenPacks.NAMESPACE.PACKNAME.ExampleDevice.ExampleDevice',
            'exampleComponents',
            ),
        ),
    )

    # Defining the "perfConf" action here causes the "Graphs" display to be
    # available for components of this type.
    factory_type_information = ({
        'actions': ({
            'id': 'perfConf',
            'name': 'Template',
            'action': 'objTemplates',
            'permissions': (ZEN_CHANGE_DEVICE,),
        },),
    },)

    # Custom components must always implement the device method. The method
    # should return the device object that contains the component.
    def device(self):
        return self.exampleDevice()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# author: lintao

class HelperReadOnly(object):
  def __init__(self, val):
    self.val = val

  def __get__(self, obj, objtype):
    return self.val

  def __set__(self, obj, val):
    raise AttributeError("can't modify attribute")

class AbsFileSystem(object):
  fs_name = HelperReadOnly("AbsFileSystem")
  seq = HelperReadOnly("/")

  def list_dir(self, path):
    raise NotImplementedError

  def is_dir(self, path):
    raise NotImplementedError


import os
import os.path
class UnixLikeFileSystem(AbsFileSystem):
  fs_name = HelperReadOnly("UnixLikeFileSystem")
  seq = HelperReadOnly("/")

  def list_dir(self, path):
    if not self.is_dir(path):
      raise StopIteration
    for entry in os.listdir(path):
      if self.is_dir( os.path.join(path, entry) ):
        entry += self.seq
      yield entry
  def is_dir(self, path):
    return os.path.isdir(path)
  pass

class DFCFileSystem(AbsFileSystem):
  fs_name = HelperReadOnly("DFCFileSystem")
  seq = HelperReadOnly("/")

  def __init__(self, fc):
    self.fc = fc

  def list_dir(self, path):
    if path.endswith('/'):
      path = path.replace('//', '/')
      path = os.path.normpath(path)
    if not self.is_dir(path):
      print "It is not Directory"
      raise StopIteration

    result = self.fc.listDirectory(path, False)
    if not result['OK']:
      print "some errors."
      raise StopIteration

    content = result['Value']['Successful'].get(path, False)
    if not content:
      raise StopIteration

    if content['Files']:
      for fn in content['Files']:
        yield self.gen_no_prefix_content(fn, path)
    if content['SubDirs']:
      for dn in content['SubDirs']:
        yield self.gen_no_prefix_content(dn, path) + "/"

  def gen_no_prefix_content(self, dn, parent_dn):
    subdn = dn
    if dn.startswith(parent_dn):
      # remove the prefix
      subdn = dn[ len(parent_dn): ]
      if subdn.startswith("/"):
        subdn = subdn[1:]
    return subdn 


  def is_dir(self, path):
    if path.endswith('/'):
      path = path.replace('//', '/')
      path = os.path.normpath(path)
    result = self.fc.isDirectory(path)
    if not result['OK']:
      return False
    return result['Value']['Successful'].get(path, False)

if __name__ == "__main__":
  ulfs = UnixLikeFileSystem()
  print "FS", ulfs.fs_name
  print "SEQ", ulfs.seq

  print list(ulfs.list_dir("/"))
  print list(ulfs.list_dir("/bad"))

  

# vim: sw=4:expandtab:foldmethod=marker
#
# Copyright (c) 2003, Mathieu Fenniak
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright notice,
# this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * The name of the author may not be used to endorse or promote products
# derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

"""
A simple library that implements a pingback client.  The library supports
version 1.0 of the pingback library, based upon the specification published
at http://www.hixie.ch/specs/pingback/pingback.

Implementing a pingback server is beyond the scope of this library simply
because of the very application-specific nature of a server.  However, it is
also trivially easy to create a pingback server by using Python's
SimpleXMLRPCServer module.  The following simple framework could be used
by a CGI script to implement a pingback server::

    def pingback(sourceURI, targetURI):
        '''Do something interesting!'''
        return "arbitrary string return value."

    import SimpleXMLRPCServer
    handler = SimpleXMLRPCServer.CGIXMLRPCRequestHandler()
    handler.register_function(pingback, "pingback.ping")
    handler.handle_request()

It would still be necessary to provide an X-Pingback HTTP header which pointed
at the given CGI script.
"""
__author__ = "Mathieu Fenniak <laotzu@pobox.com>"
__date__ = "2003-01-26"
__version__ = "2003.01.26.01"
__changed__ = "2010.10.03@SkyCloud <admin@tangblog.info>"
__website__ = "www.tangblog.info"

import re
from base import util
from HTMLParser import HTMLParser

def reSTLinks(txt):
    reSTLink = re.compile("\n\\.\\.\\s+[^\n:]+:\s+(http://[^\n]+)", re.I)
    linkMatches = reSTLink.findall(txt)
    return linkMatches


class _LinkExtractor(HTMLParser, object):
    def __init__(self, links):
        super(_LinkExtractor, self).__init__()
        self.links = links

    def handle_starttag(self, tag, attrs):
        if tag == "a":
            for key, value in attrs:
                if key == "href" and value.startswith("http://"):
                    self.links.append(value)

class _HrefExtractor(HTMLParser,object):
    def __init__(self, links):
        super(_HrefExtractor, self).__init__()
        self.links = links
        self.currentLink=None

    def handle_starttag(self, tag, attrs):
        if tag == "a":
            self.currentLink=None
            self.buffer=""
            for key, value in attrs:
                if key == "href" and value.startswith("http://"):
                    self.currentLink=value
            
    def handle_endtag(self,tag):
        if tag == "a":
            if self.currentLink:
                self.links.append((self.currentLink,self.buffer))
                self.currentLink=None
                self.buffer=""
    def handle_data(self,data):
        if self.currentLink:
            self.buffer += data
            
def htmlLinks(txt):
    links = []
    le = _LinkExtractor(links)
    le.feed(txt)
    le.close()
    return links

def hrefExtractor(txt):
    links=[]
    le = _HrefExtractor(links)
    le.feed(txt)
    le.close()
    return links

def autoPingback(sourceURI, reST = None, HTML = None):
    """Scans the input text, which can be in either reStructuredText or HTML
    format, pings every linked website for auto-discovery-capable pingback
    servers, and does an appropriate pingback.

    The following specification details how this code should work:
        http://www.hixie.ch/specs/pingback/pingback"""
    assert reST != None or HTML != None


    if reST != None:
        links = reSTLinks(reST)
    else:
        links = htmlLinks(HTML)

    for link in links:
        util.do_pingback(sourceURI,link)

#!/usr/bin/python
# Copyright: Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}


DOCUMENTATION = '''
---
module: ec2_vpc_vgw_facts
short_description: Gather facts about virtual gateways in AWS
description:
    - Gather facts about virtual gateways in AWS.
version_added: "2.3"
requirements: [ boto3 ]
options:
  filters:
    description:
      - A dict of filters to apply. Each dict item consists of a filter key and a filter value.
        See U(https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DescribeRouteTables.html) for possible filters.
  vpn_gateway_ids:
    description:
      - Get details of a specific Virtual Gateway ID. This value should be provided as a list.
author: "Nick Aslanidis (@naslanidis)"
extends_documentation_fragment:
    - aws
    - ec2
'''

EXAMPLES = '''
# # Note: These examples do not set authentication details, see the AWS Guide for details.

- name: Gather facts about all virtual gateways for an account or profile
  ec2_vpc_vgw_facts:
    region: ap-southeast-2
    profile: production
  register: vgw_facts

- name: Gather facts about a filtered list of Virtual Gateways
  ec2_vpc_vgw_facts:
    region: ap-southeast-2
    profile: production
    filters:
        "tag:Name": "main-virt-gateway"
  register: vgw_facts

- name: Gather facts about a specific virtual gateway by VpnGatewayIds
  ec2_vpc_vgw_facts:
    region: ap-southeast-2
    profile: production
    vpn_gateway_ids: vgw-c432f6a7
  register: vgw_facts
'''

RETURN = '''
virtual_gateways:
    description: The virtual gateways for the account.
    returned: always
    type: list
    sample: [
        {
            "state": "available",
            "tags": [
                {
                    "key": "Name",
                    "value": "TEST-VGW"
                }
            ],
            "type": "ipsec.1",
            "vpc_attachments": [
                {
                    "state": "attached",
                    "vpc_id": "vpc-22a93c74"
                }
            ],
            "vpn_gateway_id": "vgw-23e3d64e"
        }
    ]

changed:
    description: True if listing the virtual gateways succeeds.
    returned: always
    type: bool
    sample: "false"
'''
import traceback

try:
    import botocore
except ImportError:
    pass  # will be captured by imported HAS_BOTO3

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.ec2 import (ec2_argument_spec, get_aws_connection_info, boto3_conn,
                                      camel_dict_to_snake_dict, ansible_dict_to_boto3_filter_list, HAS_BOTO3)


def get_virtual_gateway_info(virtual_gateway):
    virtual_gateway_info = {'VpnGatewayId': virtual_gateway['VpnGatewayId'],
                            'State': virtual_gateway['State'],
                            'Type': virtual_gateway['Type'],
                            'VpcAttachments': virtual_gateway['VpcAttachments'],
                            'Tags': virtual_gateway.get('Tags', [])}
    return virtual_gateway_info


def list_virtual_gateways(client, module):
    params = dict()

    params['Filters'] = ansible_dict_to_boto3_filter_list(module.params.get('filters'))
    params['DryRun'] = module.check_mode

    if module.params.get("vpn_gateway_ids"):
        params['VpnGatewayIds'] = module.params.get("vpn_gateway_ids")

    try:
        all_virtual_gateways = client.describe_vpn_gateways(**params)
    except botocore.exceptions.ClientError as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())

    return [camel_dict_to_snake_dict(get_virtual_gateway_info(vgw))
            for vgw in all_virtual_gateways['VpnGateways']]


def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(
            filters=dict(type='dict', default=dict()),
            vpn_gateway_ids=dict(type='list', default=None)
        )
    )

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)

    # Validate Requirements
    if not HAS_BOTO3:
        module.fail_json(msg='json and boto3 is required.')

    try:
        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
        connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_kwargs)
    except botocore.exceptions.NoCredentialsError as e:
        module.fail_json(msg="Can't authorize connection - " + str(e))

    # call your function here
    results = list_virtual_gateways(connection, module)

    module.exit_json(virtual_gateways=results)


if __name__ == '__main__':
    main()

"""
Files Pipeline

See documentation in topics/media-pipeline.rst
"""

import hashlib
import os
import os.path
import time
import logging
from email.utils import parsedate_tz, mktime_tz
from six.moves.urllib.parse import urlparse
from collections import defaultdict
import six

try:
    from cStringIO import StringIO as BytesIO
except ImportError:
    from io import BytesIO

from twisted.internet import defer, threads

from scrapy.pipelines.media import MediaPipeline
from scrapy.exceptions import NotConfigured, IgnoreRequest
from scrapy.http import Request
from scrapy.utils.misc import md5sum
from scrapy.utils.log import failure_to_exc_info
from scrapy.utils.python import to_bytes
from scrapy.utils.request import referer_str

logger = logging.getLogger(__name__)


class FileException(Exception):
    """General media error exception"""


class FSFilesStore(object):

    def __init__(self, basedir):
        if '://' in basedir:
            basedir = basedir.split('://', 1)[1]
        self.basedir = basedir
        self._mkdir(self.basedir)
        self.created_directories = defaultdict(set)

    def persist_file(self, path, buf, info, meta=None, headers=None):
        absolute_path = self._get_filesystem_path(path)
        self._mkdir(os.path.dirname(absolute_path), info)
        with open(absolute_path, 'wb') as f:
            f.write(buf.getvalue())

    def stat_file(self, path, info):
        absolute_path = self._get_filesystem_path(path)
        try:
            last_modified = os.path.getmtime(absolute_path)
        except:  # FIXME: catching everything!
            return {}

        with open(absolute_path, 'rb') as f:
            checksum = md5sum(f)

        return {'last_modified': last_modified, 'checksum': checksum}

    def _get_filesystem_path(self, path):
        path_comps = path.split('/')
        return os.path.join(self.basedir, *path_comps)

    def _mkdir(self, dirname, domain=None):
        seen = self.created_directories[domain] if domain else set()
        if dirname not in seen:
            if not os.path.exists(dirname):
                os.makedirs(dirname)
            seen.add(dirname)


class S3FilesStore(object):

    AWS_ACCESS_KEY_ID = None
    AWS_SECRET_ACCESS_KEY = None

    POLICY = 'public-read'
    HEADERS = {
        'Cache-Control': 'max-age=172800',
    }

    def __init__(self, uri):
        try:
            from boto.s3.connection import S3Connection
            self.S3Connection = S3Connection
        except ImportError:
            raise NotConfigured("missing boto library")
        assert uri.startswith('s3://')
        self.bucket, self.prefix = uri[5:].split('/', 1)

    def stat_file(self, path, info):
        def _onsuccess(boto_key):
            checksum = boto_key.etag.strip('"')
            last_modified = boto_key.last_modified
            modified_tuple = parsedate_tz(last_modified)
            modified_stamp = int(mktime_tz(modified_tuple))
            return {'checksum': checksum, 'last_modified': modified_stamp}

        return self._get_boto_key(path).addCallback(_onsuccess)

    def _get_boto_bucket(self):
        # disable ssl (is_secure=False) because of this python bug:
        # http://bugs.python.org/issue5103
        c = self.S3Connection(self.AWS_ACCESS_KEY_ID, self.AWS_SECRET_ACCESS_KEY, is_secure=False)
        return c.get_bucket(self.bucket, validate=False)

    def _get_boto_key(self, path):
        b = self._get_boto_bucket()
        key_name = '%s%s' % (self.prefix, path)
        return threads.deferToThread(b.get_key, key_name)

    def persist_file(self, path, buf, info, meta=None, headers=None):
        """Upload file to S3 storage"""
        b = self._get_boto_bucket()
        key_name = '%s%s' % (self.prefix, path)
        k = b.new_key(key_name)
        if meta:
            for metakey, metavalue in six.iteritems(meta):
                k.set_metadata(metakey, str(metavalue))
        h = self.HEADERS.copy()
        if headers:
            h.update(headers)
        buf.seek(0)
        return threads.deferToThread(k.set_contents_from_string, buf.getvalue(),
                                     headers=h, policy=self.POLICY)


class FilesPipeline(MediaPipeline):
    """Abstract pipeline that implement the file downloading

    This pipeline tries to minimize network transfers and file processing,
    doing stat of the files and determining if file is new, uptodate or
    expired.

    `new` files are those that pipeline never processed and needs to be
        downloaded from supplier site the first time.

    `uptodate` files are the ones that the pipeline processed and are still
        valid files.

    `expired` files are those that pipeline already processed but the last
        modification was made long time ago, so a reprocessing is recommended to
        refresh it in case of change.

    """

    MEDIA_NAME = "file"
    EXPIRES = 90
    STORE_SCHEMES = {
        '': FSFilesStore,
        'file': FSFilesStore,
        's3': S3FilesStore,
    }
    DEFAULT_FILES_URLS_FIELD = 'file_urls'
    DEFAULT_FILES_RESULT_FIELD = 'files'

    def __init__(self, store_uri, download_func=None):
        if not store_uri:
            raise NotConfigured
        self.store = self._get_store(store_uri)
        super(FilesPipeline, self).__init__(download_func=download_func)

    @classmethod
    def from_settings(cls, settings):
        s3store = cls.STORE_SCHEMES['s3']
        s3store.AWS_ACCESS_KEY_ID = settings['AWS_ACCESS_KEY_ID']
        s3store.AWS_SECRET_ACCESS_KEY = settings['AWS_SECRET_ACCESS_KEY']

        cls.FILES_URLS_FIELD = settings.get('FILES_URLS_FIELD', cls.DEFAULT_FILES_URLS_FIELD)
        cls.FILES_RESULT_FIELD = settings.get('FILES_RESULT_FIELD', cls.DEFAULT_FILES_RESULT_FIELD)
        cls.EXPIRES = settings.getint('FILES_EXPIRES', 90)
        store_uri = settings['FILES_STORE']
        return cls(store_uri)

    def _get_store(self, uri):
        if os.path.isabs(uri):  # to support win32 paths like: C:\\some\dir
            scheme = 'file'
        else:
            scheme = urlparse(uri).scheme
        store_cls = self.STORE_SCHEMES[scheme]
        return store_cls(uri)

    def media_to_download(self, request, info):
        def _onsuccess(result):
            if not result:
                return  # returning None force download

            last_modified = result.get('last_modified', None)
            if not last_modified:
                return  # returning None force download

            age_seconds = time.time() - last_modified
            age_days = age_seconds / 60 / 60 / 24
            if age_days > self.EXPIRES:
                return  # returning None force download

            referer = referer_str(request)
            logger.debug(
                'File (uptodate): Downloaded %(medianame)s from %(request)s '
                'referred in <%(referer)s>',
                {'medianame': self.MEDIA_NAME, 'request': request,
                 'referer': referer},
                extra={'spider': info.spider}
            )
            self.inc_stats(info.spider, 'uptodate')

            checksum = result.get('checksum', None)
            return {'url': request.url, 'path': path, 'checksum': checksum}

        path = self.file_path(request, info=info)
        dfd = defer.maybeDeferred(self.store.stat_file, path, info)
        dfd.addCallbacks(_onsuccess, lambda _: None)
        dfd.addErrback(
            lambda f:
            logger.error(self.__class__.__name__ + '.store.stat_file',
                         exc_info=failure_to_exc_info(f),
                         extra={'spider': info.spider})
        )
        return dfd

    def media_failed(self, failure, request, info):
        if not isinstance(failure.value, IgnoreRequest):
            referer = referer_str(request)
            logger.warning(
                'File (unknown-error): Error downloading %(medianame)s from '
                '%(request)s referred in <%(referer)s>: %(exception)s',
                {'medianame': self.MEDIA_NAME, 'request': request,
                 'referer': referer, 'exception': failure.value},
                extra={'spider': info.spider}
            )

        raise FileException

    def media_downloaded(self, response, request, info):
        referer = referer_str(request)

        if response.status != 200:
            logger.warning(
                'File (code: %(status)s): Error downloading file from '
                '%(request)s referred in <%(referer)s>',
                {'status': response.status,
                 'request': request, 'referer': referer},
                extra={'spider': info.spider}
            )
            raise FileException('download-error')

        if not response.body:
            logger.warning(
                'File (empty-content): Empty file from %(request)s referred '
                'in <%(referer)s>: no-content',
                {'request': request, 'referer': referer},
                extra={'spider': info.spider}
            )
            raise FileException('empty-content')

        status = 'cached' if 'cached' in response.flags else 'downloaded'
        logger.debug(
            'File (%(status)s): Downloaded file from %(request)s referred in '
            '<%(referer)s>',
            {'status': status, 'request': request, 'referer': referer},
            extra={'spider': info.spider}
        )
        self.inc_stats(info.spider, status)

        try:
            path = self.file_path(request, response=response, info=info)
            checksum = self.file_downloaded(response, request, info)
        except FileException as exc:
            logger.warning(
                'File (error): Error processing file from %(request)s '
                'referred in <%(referer)s>: %(errormsg)s',
                {'request': request, 'referer': referer, 'errormsg': str(exc)},
                extra={'spider': info.spider}, exc_info=True
            )
            raise
        except Exception as exc:
            logger.error(
                'File (unknown-error): Error processing file from %(request)s '
                'referred in <%(referer)s>',
                {'request': request, 'referer': referer},
                exc_info=True, extra={'spider': info.spider}
            )
            raise FileException(str(exc))

        return {'url': request.url, 'path': path, 'checksum': checksum}

    def inc_stats(self, spider, status):
        spider.crawler.stats.inc_value('file_count', spider=spider)
        spider.crawler.stats.inc_value('file_status_count/%s' % status, spider=spider)

    ### Overridable Interface
    def get_media_requests(self, item, info):
        return [Request(x) for x in item.get(self.FILES_URLS_FIELD, [])]

    def file_downloaded(self, response, request, info):
        path = self.file_path(request, response=response, info=info)
        buf = BytesIO(response.body)
        self.store.persist_file(path, buf, info)
        checksum = md5sum(buf)
        return checksum

    def item_completed(self, results, item, info):
        if isinstance(item, dict) or self.FILES_RESULT_FIELD in item.fields:
            item[self.FILES_RESULT_FIELD] = [x for ok, x in results if ok]
        return item

    def file_path(self, request, response=None, info=None):
        ## start of deprecation warning block (can be removed in the future)
        def _warn():
            from scrapy.exceptions import ScrapyDeprecationWarning
            import warnings
            warnings.warn('FilesPipeline.file_key(url) method is deprecated, please use '
                          'file_path(request, response=None, info=None) instead',
                          category=ScrapyDeprecationWarning, stacklevel=1)

        # check if called from file_key with url as first argument
        if not isinstance(request, Request):
            _warn()
            url = request
        else:
            url = request.url

        # detect if file_key() method has been overridden
        if not hasattr(self.file_key, '_base'):
            _warn()
            return self.file_key(url)
        ## end of deprecation warning block

        media_guid = hashlib.sha1(to_bytes(url)).hexdigest()  # change to request.url after deprecation
        media_ext = os.path.splitext(url)[1]  # change to request.url after deprecation
        return 'full/%s%s' % (media_guid, media_ext)

    # deprecated
    def file_key(self, url):
        return self.file_path(url)
    file_key._base = True

#! /usr/bin/env python

# Copyright 2011, 2013-2014 OpenStack Foundation
# Copyright 2012 Hewlett-Packard Development Company, L.P.
#
# 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.

import argparse
import irc.client
import logging
import random
import string
import ssl
import sys
import time
import yaml


logging.basicConfig(level=logging.INFO)


class CheckAccess(irc.client.SimpleIRCClient):
    log = logging.getLogger("checkaccess")

    def __init__(self, channels, nick, flags):
        irc.client.SimpleIRCClient.__init__(self)
        self.identify_msg_cap = False
        self.channels = channels
        self.nick = nick
        self.flags = flags
        self.current_channel = None
        self.current_list = []
        self.failed = None

    def on_disconnect(self, connection, event):
        if self.failed is not False:
            sys.exit(1)
        else:
            sys.exit(0)

    def on_welcome(self, c, e):
        self.identify_msg_cap = False
        self.log.debug("Requesting identify-msg capability")
        c.cap('REQ', 'identify-msg')
        c.cap('END')

    def on_cap(self, c, e):
        self.log.debug("Received cap response %s" % repr(e.arguments))
        if e.arguments[0] == 'ACK' and 'identify-msg' in e.arguments[1]:
            self.log.debug("identify-msg cap acked")
            self.identify_msg_cap = True
            self.advance()

    def on_privnotice(self, c, e):
        if not self.identify_msg_cap:
            self.log.debug("Ignoring message because identify-msg "
                           "cap not enabled")
            return
        nick = e.source.split('!')[0]
        auth = e.arguments[0][0]
        msg = e.arguments[0][1:]
        if auth != '+' or nick != 'ChanServ':
            self.log.debug("Ignoring message from unauthenticated "
                           "user %s" % nick)
            return
        self.advance(msg)

    def advance(self, msg=None):
        if not self.current_channel:
            if not self.channels:
                self.connection.quit()
                return
            self.current_channel = self.channels.pop()
            self.current_list = []
            self.connection.privmsg('chanserv', 'access list %s' %
                                    self.current_channel)
            time.sleep(1)
            return
        if msg.endswith('is not registered.'):
            self.failed = True
            print ("%s is not registered with ChanServ." %
                   self.current_channel)
            self.current_channel = None
            self.advance()
            return
        if msg.startswith('End of'):
            found = False
            for nick, flags, msg in self.current_list:
                if nick == self.nick and flags == self.flags:
                    self.log.info('%s access ok on %s' %
                                  (self.nick, self.current_channel))
                    found = True
                    break
            if not found:
                self.failed = True
                print ("%s does not have permissions on %s:" %
                       (self.nick, self.current_channel))
                for nick, flags, msg in self.current_list:
                    print msg
                print
            # If this is the first channel checked, set the failure
            # flag to false because we know that the system is
            # operating well enough to check at least one channel.
            if self.failed is None:
                self.failed = False
            self.current_channel = None
            self.advance()
            return
        parts = msg.split()
        self.current_list.append((parts[1], parts[2], msg))


def main():
    parser = argparse.ArgumentParser(description='IRC channel access check')
    parser.add_argument('-l', dest='config',
                        default='/etc/accessbot/channels.yaml',
                        help='path to the config file')
    parser.add_argument('-s', dest='server',
                        default='chat.freenode.net',
                        help='IRC server')
    parser.add_argument('-p', dest='port',
                        default=6697,
                        help='IRC port')
    parser.add_argument('nick',
                        help='the nick for which access should be validated')
    args = parser.parse_args()

    config = yaml.load(open(args.config))
    channels = []
    for channel in config['channels']:
        channels.append('#' + channel['name'])

    access_level = None
    for level, names in config['global'].items():
        if args.nick in names:
            access_level = level
    if access_level is None:
        raise Exception("Unable to determine global access level for %s" %
                        args.nick)
    flags = config['access'][access_level]

    a = CheckAccess(channels, args.nick, flags)
    mynick = ''.join(random.choice(string.ascii_uppercase)
                     for x in range(16))
    port = int(args.port)
    if port == 6697:
        factory = irc.connection.Factory(wrapper=ssl.wrap_socket)
        a.connect(args.server, int(args.port), mynick,
                  connect_factory=factory)
    else:
        a.connect(args.server, int(args.port), mynick)
    a.start()

if __name__ == "__main__":
    main()

# coding: utf-8
from __future__ import unicode_literals

from .common import InfoExtractor
from ..utils import (
    clean_html,
    qualities,
)


class ClubicIE(InfoExtractor):
    _VALID_URL = r'https?://(?:www\.)?clubic\.com/video/(?:[^/]+/)*video.*-(?P<id>[0-9]+)\.html'

    _TESTS = [{
        'url': 'http://www.clubic.com/video/clubic-week/video-clubic-week-2-0-le-fbi-se-lance-dans-la-photo-d-identite-448474.html',
        'md5': '1592b694ba586036efac1776b0b43cd3',
        'info_dict': {
            'id': '448474',
            'ext': 'mp4',
            'title': 'Clubic Week 2.0 : le FBI se lance dans la photo d\u0092identité',
            'description': 're:Gueule de bois chez Nokia. Le constructeur a indiqué cette.*',
            'thumbnail': r're:^http://img\.clubic\.com/.*\.jpg$',
        }
    }, {
        'url': 'http://www.clubic.com/video/video-clubic-week-2-0-apple-iphone-6s-et-plus-mais-surtout-le-pencil-469792.html',
        'only_matching': True,
    }]

    def _real_extract(self, url):
        video_id = self._match_id(url)

        player_url = 'http://player.m6web.fr/v1/player/clubic/%s.html' % video_id
        player_page = self._download_webpage(player_url, video_id)

        config = self._parse_json(self._search_regex(
            r'(?m)M6\.Player\.config\s*=\s*(\{.+?\});$', player_page,
            'configuration'), video_id)

        video_info = config['videoInfo']
        sources = config['sources']
        quality_order = qualities(['sd', 'hq'])

        formats = [{
            'format_id': src['streamQuality'],
            'url': src['src'],
            'quality': quality_order(src['streamQuality']),
        } for src in sources]
        self._sort_formats(formats)

        return {
            'id': video_id,
            'title': video_info['title'],
            'formats': formats,
            'description': clean_html(video_info.get('description')),
            'thumbnail': config.get('poster'),
        }

#!/usr/bin/env python

#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.
#

# This script is a modified version of the one created by the Spark 
# project (https://github.com/apache/spark/blob/master/dev/merge_spark_pr.py).

# Utility for creating well-formed pull request merges and pushing them to Apache.
#   usage: ./merge_rocketmq_pr.py    (see config env vars below)
#
# This utility assumes you already have local a RocketMQ git folder and that you
# have added remotes corresponding to both (i) the github apache RocketMQ
# mirror and (ii) the apache git repo.

import json
import os
import re
import subprocess
import sys
import urllib2

try:
    import jira.client
    JIRA_IMPORTED = True
except ImportError:
    JIRA_IMPORTED = False

# Location of your RocketMQ git development area
ROCKETMQ_HOME = os.environ.get("ROCKETMQ_HOME", os.getcwd())
# Remote name which points to the Gihub site
PR_REMOTE_NAME = os.environ.get("PR_REMOTE_NAME", "apache-github")
# Remote name which points to Apache git
PUSH_REMOTE_NAME = os.environ.get("PUSH_REMOTE_NAME", "origin")
# ASF JIRA username
JIRA_USERNAME = os.environ.get("JIRA_USERNAME", "")
# ASF JIRA password
JIRA_PASSWORD = os.environ.get("JIRA_PASSWORD", "")
# OAuth key used for issuing requests against the GitHub API. If this is not defined, then requests
# will be unauthenticated. You should only need to configure this if you find yourself regularly
# exceeding your IP's unauthenticated request rate limit. You can create an OAuth key at
# https://github.com/settings/tokens. This script only requires the "public_repo" scope.
GITHUB_OAUTH_KEY = os.environ.get("GITHUB_OAUTH_KEY")


GITHUB_BASE = "https://github.com/apache/rocketmq/pull"
GITHUB_API_BASE = "https://api.github.com/repos/apache/rocketmq"
JIRA_BASE = "https://issues.apache.org/jira/browse"
JIRA_API_BASE = "https://issues.apache.org/jira"
# Prefix added to temporary branches
BRANCH_PREFIX = "PR_TOOL"
DEVELOP_BRANCH = "develop"


def get_json(url):
    try:
        request = urllib2.Request(url)
        if GITHUB_OAUTH_KEY:
            request.add_header('Authorization', 'token %s' % GITHUB_OAUTH_KEY)
        return json.load(urllib2.urlopen(request))
    except urllib2.HTTPError as e:
        if "X-RateLimit-Remaining" in e.headers and e.headers["X-RateLimit-Remaining"] == '0':
            print("Exceeded the GitHub API rate limit; see the instructions in " +
                  "dev/merge_rocketmq_pr.py to configure an OAuth token for making authenticated " +
                  "GitHub requests.")
        else:
            print("Unable to fetch URL, exiting: %s" % url)
        sys.exit(-1)


def fail(msg):
    print(msg)
    clean_up()
    sys.exit(-1)


def run_cmd(cmd):
    print(cmd)
    if isinstance(cmd, list):
        return subprocess.check_output(cmd)
    else:
        return subprocess.check_output(cmd.split(" "))


def continue_maybe(prompt):
    result = raw_input("\n%s (y/n): " % prompt)
    if result.lower() != "y":
        fail("Okay, exiting")


def clean_up():
    print("Restoring head pointer to %s" % original_head)
    run_cmd("git checkout %s" % original_head)

    branches = run_cmd("git branch").replace(" ", "").split("\n")

    for branch in filter(lambda x: x.startswith(BRANCH_PREFIX), branches):
        print("Deleting local branch %s" % branch)
        run_cmd("git branch -D %s" % branch)


# merge the requested PR and return the merge hash
def merge_pr(pr_num, target_ref, title, body, pr_repo_desc):
    pr_branch_name = "%s_MERGE_PR_%s" % (BRANCH_PREFIX, pr_num)
    target_branch_name = "%s_MERGE_PR_%s_%s" % (BRANCH_PREFIX, pr_num, target_ref.upper())
    run_cmd("git fetch %s pull/%s/head:%s" % (PR_REMOTE_NAME, pr_num, pr_branch_name))
    run_cmd("git fetch %s %s:%s" % (PUSH_REMOTE_NAME, target_ref, target_branch_name))
    run_cmd("git checkout %s" % target_branch_name)

    had_conflicts = False
    try:
        run_cmd(['git', 'merge', pr_branch_name, '--squash'])
    except Exception as e:
        msg = "Error merging: %s\nWould you like to manually fix-up this merge?" % e
        continue_maybe(msg)
        msg = "Okay, please fix any conflicts and 'git add' conflicting files... Finished?"
        continue_maybe(msg)
        had_conflicts = True

    commit_authors = run_cmd(['git', 'log', 'HEAD..%s' % pr_branch_name,
                             '--pretty=format:%an <%ae>']).split("\n")
    distinct_authors = sorted(set(commit_authors),
                              key=lambda x: commit_authors.count(x), reverse=True)
    primary_author = raw_input(
        "Enter primary author in the format of \"name <email>\" [%s]: " %
        distinct_authors[0])
    if primary_author == "":
        primary_author = distinct_authors[0]

    commits = run_cmd(['git', 'log', 'HEAD..%s' % pr_branch_name,
                      '--pretty=format:%h [%an] %s']).split("\n\n")

    merge_message_flags = []

    modified_title = raw_input("Modify commit log [%s]: " % title)
    if modified_title == "":
        modified_title = title
    merge_message_flags += ["-m", modified_title]

    authors = "\n".join(["Author: %s" % a for a in distinct_authors])

    merge_message_flags += ["-m", authors]

    if had_conflicts:
        committer_name = run_cmd("git config --get user.name").strip()
        committer_email = run_cmd("git config --get user.email").strip()
        message = "This patch had conflicts when merged, resolved by\nCommitter: %s <%s>" % (
            committer_name, committer_email)
        merge_message_flags += ["-m", message]

    # The string "Closes #%s" string is required for GitHub to correctly close the PR
    merge_message_flags += ["-m", "Closes #%s from %s." % (pr_num, pr_repo_desc)]

    run_cmd(['git', 'commit', '--author="%s"' % primary_author] + merge_message_flags)

    continue_maybe("Merge complete (local ref %s). Push to %s?" % (
        target_branch_name, PUSH_REMOTE_NAME))

    try:
        run_cmd('git push %s %s:%s' % (PUSH_REMOTE_NAME, target_branch_name, target_ref))
    except Exception as e:
        clean_up()
        fail("Exception while pushing: %s" % e)

    merge_hash = run_cmd("git rev-parse %s" % target_branch_name)[:8]
    clean_up()
    print("Pull request #%s merged!" % pr_num)
    print("Merge hash: %s" % merge_hash)
    return merge_hash


def cherry_pick(pr_num, merge_hash, default_branch):
    pick_ref = raw_input("Enter a branch name [%s]: " % default_branch)
    if pick_ref == "":
        pick_ref = default_branch

    pick_branch_name = "%s_PICK_PR_%s_%s" % (BRANCH_PREFIX, pr_num, pick_ref.upper())

    run_cmd("git fetch %s %s:%s" % (PUSH_REMOTE_NAME, pick_ref, pick_branch_name))
    run_cmd("git checkout %s" % pick_branch_name)

    try:
        run_cmd("git cherry-pick -sx %s" % merge_hash)
    except Exception as e:
        msg = "Error cherry-picking: %s\nWould you like to manually fix-up this merge?" % e
        continue_maybe(msg)
        msg = "Okay, please fix any conflicts and finish the cherry-pick. Finished?"
        continue_maybe(msg)

    continue_maybe("Pick complete (local ref %s). Push to %s?" % (
        pick_branch_name, PUSH_REMOTE_NAME))

    try:
        run_cmd('git push %s %s:%s' % (PUSH_REMOTE_NAME, pick_branch_name, pick_ref))
    except Exception as e:
        clean_up()
        fail("Exception while pushing: %s" % e)

    pick_hash = run_cmd("git rev-parse %s" % pick_branch_name)[:8]
    clean_up()

    print("Pull request #%s picked into %s!" % (pr_num, pick_ref))
    print("Pick hash: %s" % pick_hash)
    return pick_ref


def fix_version_from_branch(branch, versions):
    # Note: Assumes this is a sorted (newest->oldest) list of un-released versions
    if branch == "master":
        return versions[0]
    else:
        branch_ver = branch.replace("branch-", "")
        return filter(lambda x: x.name.startswith(branch_ver), versions)[-1]


def resolve_jira_issue(merge_branches, comment, default_jira_id=""):
    asf_jira = jira.client.JIRA({'server': JIRA_API_BASE},
                                basic_auth=(JIRA_USERNAME, JIRA_PASSWORD))

    jira_id = raw_input("Enter a JIRA id [%s]: " % default_jira_id)
    if jira_id == "":
        jira_id = default_jira_id

    try:
        issue = asf_jira.issue(jira_id)
    except Exception as e:
        fail("ASF JIRA could not find %s\n%s" % (jira_id, e))

    cur_status = issue.fields.status.name
    cur_summary = issue.fields.summary
    cur_assignee = issue.fields.assignee
    if cur_assignee is None:
        cur_assignee = "NOT ASSIGNED!!!"
    else:
        cur_assignee = cur_assignee.displayName

    if cur_status == "Resolved" or cur_status == "Closed":
        fail("JIRA issue %s already has status '%s'" % (jira_id, cur_status))
    print("=== JIRA %s ===" % jira_id)
    print("summary\t\t%s\nassignee\t%s\nstatus\t\t%s\nurl\t\t%s/%s\n" %
          (cur_summary, cur_assignee, cur_status, JIRA_BASE, jira_id))

    versions = asf_jira.project_versions("ROCKETMQ")
    versions = sorted(versions, key=lambda x: x.name, reverse=True)
    versions = filter(lambda x: x.raw['released'] is False, versions)
    # Consider only x.y.z versions
    versions = filter(lambda x: re.match('\d+\.\d+\.\d+', x.name), versions)

    default_fix_versions = map(lambda x: fix_version_from_branch(x, versions).name, merge_branches)
    for v in default_fix_versions:
        # Handles the case where we have forked a release branch but not yet made the release.
        # In this case, if the PR is committed to the master branch and the release branch, we
        # only consider the release branch to be the fix version. E.g. it is not valid to have
        # both 1.1.0 and 1.0.0 as fix versions.
        (major, minor, patch) = v.split(".")
        if patch == "0":
            previous = "%s.%s.%s" % (major, int(minor) - 1, 0)
            if previous in default_fix_versions:
                default_fix_versions = filter(lambda x: x != v, default_fix_versions)
    default_fix_versions = ",".join(default_fix_versions)

    fix_versions = raw_input("Enter comma-separated fix version(s) [%s]: " % default_fix_versions)
    if fix_versions == "":
        fix_versions = default_fix_versions
    fix_versions = fix_versions.replace(" ", "").split(",")

    def get_version_json(version_str):
        return filter(lambda v: v.name == version_str, versions)[0].raw

    jira_fix_versions = map(lambda v: get_version_json(v), fix_versions)

    resolve = filter(lambda a: a['name'] == "Resolve Issue", asf_jira.transitions(jira_id))[0]
    resolution = filter(lambda r: r.raw['name'] == "Fixed", asf_jira.resolutions())[0]
    asf_jira.transition_issue(
        jira_id, resolve["id"], fixVersions=jira_fix_versions,
        comment=comment, resolution={'id': resolution.raw['id']})

    print("Successfully resolved %s with fixVersions=%s!" % (jira_id, fix_versions))


def resolve_jira_issues(title, merge_branches, comment):
    jira_ids = re.findall("ROCKETMQ-[0-9]{4,5}", title)

    if len(jira_ids) == 0:
        resolve_jira_issue(merge_branches, comment)
    for jira_id in jira_ids:
        resolve_jira_issue(merge_branches, comment, jira_id)


def standardize_jira_ref(text):
    """
    Standardize the [ROCKETMQ-XXXXX] [MODULE] prefix
    Converts "[ROCKETMQ-XXX][mllib] Issue", "[MLLib] ROCKETMQ-XXX. Issue" or "ROCKETMQ XXX [MLLIB]: Issue" to
    "[ROCKETMQ-XXX][MLLIB] Issue"
    """
    jira_refs = []
    components = []

    # If the string is compliant, no need to process any further
    if (re.search(r'^\[ROCKETMQ-[0-9]{3,6}\](\[[A-Z0-9_\s,]+\] )+\S+', text)):
        return text

    # Extract JIRA ref(s):
    pattern = re.compile(r'(ROCKETMQ[-\s]*[0-9]{3,6})+', re.IGNORECASE)
    for ref in pattern.findall(text):
        # Add brackets, replace spaces with a dash, & convert to uppercase
        jira_refs.append('[' + re.sub(r'\s+', '-', ref.upper()) + ']')
        text = text.replace(ref, '')

    # Extract rocketmq component(s):
    # Look for alphanumeric chars, spaces, dashes, periods, and/or commas
    pattern = re.compile(r'(\[[\w\s,-\.]+\])', re.IGNORECASE)
    for component in pattern.findall(text):
        components.append(component.upper())
        text = text.replace(component, '')

    # Cleanup any remaining symbols:
    pattern = re.compile(r'^\W+(.*)', re.IGNORECASE)
    if (pattern.search(text) is not None):
        text = pattern.search(text).groups()[0]

    # Assemble full text (JIRA ref(s), module(s), remaining text)
    clean_text = ''.join(jira_refs).strip() + ''.join(components).strip() + " " + text.strip()

    # Replace multiple spaces with a single space, e.g. if no jira refs and/or components were
    # included
    clean_text = re.sub(r'\s+', ' ', clean_text.strip())

    return clean_text


def get_current_ref():
    ref = run_cmd("git rev-parse --abbrev-ref HEAD").strip()
    if ref == 'HEAD':
        # The current ref is a detached HEAD, so grab its SHA.
        return run_cmd("git rev-parse HEAD").strip()
    else:
        return ref


def main():
    global original_head

    os.chdir(ROCKETMQ_HOME)
    original_head = get_current_ref()

    latest_branch = DEVELOP_BRANCH

    pr_num = raw_input("Which pull request would you like to merge? (e.g. 34): ")
    pr = get_json("%s/pulls/%s" % (GITHUB_API_BASE, pr_num))
    pr_events = get_json("%s/issues/%s/events" % (GITHUB_API_BASE, pr_num))

    url = pr["url"]

    # Decide whether to use the modified title or not
    modified_title = standardize_jira_ref(pr["title"])
    if modified_title != pr["title"]:
        print("I've re-written the title as follows to match the standard format:")
        print("Original: %s" % pr["title"])
        print("Modified: %s" % modified_title)
        result = raw_input("Would you like to use the modified title? (y/n): ")
        if result.lower() == "y":
            title = modified_title
            print("Using modified title:")
        else:
            title = pr["title"]
            print("Using original title:")
        print(title)
    else:
        title = pr["title"]

    body = pr["body"]
    target_ref = pr["base"]["ref"]
    user_login = pr["user"]["login"]
    base_ref = pr["head"]["ref"]
    pr_repo_desc = "%s/%s" % (user_login, base_ref)

    # Merged pull requests don't appear as merged in the GitHub API;
    # Instead, they're closed by asfgit.
    merge_commits = \
        [e for e in pr_events if e["actor"]["login"] == "asfgit" and e["event"] == "closed"]

    if merge_commits:
        merge_hash = merge_commits[0]["commit_id"]
        message = get_json("%s/commits/%s" % (GITHUB_API_BASE, merge_hash))["commit"]["message"]

        print("Pull request %s has already been merged, assuming you want to backport" % pr_num)
        commit_is_downloaded = run_cmd(['git', 'rev-parse', '--quiet', '--verify',
                                        "%s^{commit}" % merge_hash]).strip() != ""
        if not commit_is_downloaded:
            fail("Couldn't find any merge commit for #%s, you may need to update HEAD." % pr_num)

        print("Found commit %s:\n%s" % (merge_hash, message))
        cherry_pick(pr_num, merge_hash, latest_branch)
        sys.exit(0)

    if not bool(pr["mergeable"]):
        msg = "Pull request %s is not mergeable in its current form.\n" % pr_num + \
            "Continue? (experts only!)"
        continue_maybe(msg)

    print("\n=== Pull Request #%s ===" % pr_num)
    print("title\t%s\nsource\t%s\ntarget\t%s\nurl\t%s" %
          (title, pr_repo_desc, target_ref, url))
    continue_maybe("Proceed with merging pull request #%s?" % pr_num)

    merged_refs = [target_ref]

    merge_hash = merge_pr(pr_num, target_ref, title, body, pr_repo_desc)

    pick_prompt = "Would you like to pick %s into another branch?" % merge_hash
    while raw_input("\n%s (y/n): " % pick_prompt).lower() == "y":
        merged_refs = merged_refs + [cherry_pick(pr_num, merge_hash, latest_branch)]

    if JIRA_IMPORTED:
        if JIRA_USERNAME and JIRA_PASSWORD:
            continue_maybe("Would you like to update an associated JIRA?")
            jira_comment = "Issue resolved by pull request %s\n[%s/%s]" % \
                           (pr_num, GITHUB_BASE, pr_num)
            resolve_jira_issues(title, merged_refs, jira_comment)
        else:
            print("JIRA_USERNAME and JIRA_PASSWORD not set")
            print("Exiting without trying to close the associated JIRA.")
    else:
        print("Could not find jira-python library. Run 'sudo pip install jira' to install.")
        print("Exiting without trying to close the associated JIRA.")

if __name__ == "__main__":
    import doctest
    (failure_count, test_count) = doctest.testmod()
    if failure_count:
        exit(-1)
    try:
        main()
    except:
        clean_up()
        raise
#!/usr/bin/python3
# -*- coding: utf-8 -*-
################################################################################
#    DChars-FE Copyright (C) 2012 Suizokukan
#    Contact: suizokukan _A.T._ orange dot fr
#
#    This file is part of DChars-FE.
#    DChars-FE is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    DChars-FE is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with DChars-FE.  If not, see <http://www.gnu.org/licenses/>.
################################################################################
"""
    ❏DChars-FE❏ : errors/errors.py
"""

#///////////////////////////////////////////////////////////////////////////////
def display_error( context, message ):
    """
        function display_error
    """

    print("="*80)
    print( "({0}) {1}".format(context, message))
    print("="*80)

################################################################################
class DCharsFEError(BaseException):
    """
        class DCharsFEError

        All purpose class.
    """

    #///////////////////////////////////////////////////////////////////////////
    def __init__(self, context, message):
        """
                DCharsFEError.__init__
        """
        BaseException.__init__(self, message)

        display_error("[DCharsFEError] "+context,
                      message)


# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# MIT License. See license.txt
from __future__ import unicode_literals

import frappe, unittest

class TestDynamicLinks(unittest.TestCase):
	def setUp(self):
		frappe.db.sql('delete from `tabEmail Unsubscribe`')

	def test_delete_normal(self):
		event = frappe.get_doc({
			'doctype': 'Event',
			'subject':'test-for-delete',
			'starts_on': '2014-01-01',
			'event_type': 'Public'
		}).insert()

		unsub = frappe.get_doc({
			'doctype': 'Email Unsubscribe',
			'email': 'test@example.com',
			'reference_doctype': event.doctype,
			'reference_name': event.name
		}).insert()

		event.delete()

		self.assertFalse(frappe.db.exists('Email Unsubscribe', unsub.name))

	def test_delete_with_comment(self):
		event = frappe.get_doc({
			'doctype': 'Event',
			'subject':'test-for-delete-1',
			'starts_on': '2014-01-01',
			'event_type': 'Public'
		}).insert()
		event.add_comment('Comment', 'test')

		self.assertTrue(frappe.get_all('Communication',
			filters={'reference_doctype':'Event', 'reference_name':event.name}))
		event.delete()
		self.assertFalse(frappe.get_all('Communication',
			filters={'reference_doctype':'Event', 'reference_name':event.name}))

	def test_custom_fields(self):
		from frappe.utils.testutils import add_custom_field, clear_custom_fields
		add_custom_field('Event', 'test_ref_doc', 'Link', 'DocType')
		add_custom_field('Event', 'test_ref_name', 'Dynamic Link', 'test_ref_doc')

		unsub = frappe.get_doc({
			'doctype': 'Email Unsubscribe',
			'email': 'test@example.com',
			'global_unsubscribe': 1
		}).insert()

		event = frappe.get_doc({
			'doctype': 'Event',
			'subject':'test-for-delete-2',
			'starts_on': '2014-01-01',
			'event_type': 'Public',
			'test_ref_doc': unsub.doctype,
			'test_ref_name': unsub.name
		}).insert()

		self.assertRaises(frappe.LinkExistsError, unsub.delete)

		event.test_ref_doc = None
		event.test_ref_name = None
		event.save()

		unsub.delete()

		clear_custom_fields('Event')

# coding=utf-8
# Copyright 2015 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).

from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
                        unicode_literals, with_statement)

import mock

from pants.pantsd.subsystem.watchman_launcher import WatchmanLauncher
from pants.pantsd.watchman import Watchman
from pants_test.base_test import BaseTest
from pants_test.subsystem.subsystem_util import create_subsystem


class TestWatchmanLauncher(BaseTest):
  def setUp(self):
    BaseTest.setUp(self)
    self.watchman_launcher = create_subsystem(WatchmanLauncher,
                                              pants_workdir='/pants_workdir',
                                              level='info')

  def test_options_defaults(self):
    self.assertIsNone(self.watchman_launcher._watchman_path)
    self.assertEquals(self.watchman_launcher._watchman_log_level, '1')

  def create_mock_watchman(self, is_alive):
    mock_watchman = mock.create_autospec(Watchman, spec_set=False)
    mock_watchman.watchman_path = None
    mock_watchman.ExecutionError = Watchman.ExecutionError
    mock_watchman.is_alive.return_value = is_alive
    return mock_watchman

  def test_maybe_launch(self):
    mock_watchman = self.create_mock_watchman(False)

    self.watchman_launcher._watchman = mock_watchman
    self.assertTrue(self.watchman_launcher.maybe_launch())

    mock_watchman.is_alive.assert_called_once_with()
    mock_watchman.launch.assert_called_once_with()

  def test_maybe_launch_already_alive(self):
    mock_watchman = self.create_mock_watchman(True)

    self.watchman_launcher._watchman = mock_watchman
    self.assertTrue(self.watchman_launcher.maybe_launch())

    mock_watchman.is_alive.assert_called_once_with()
    assert not mock_watchman.launch.called

  def test_maybe_launch_error(self):
    mock_watchman = self.create_mock_watchman(False)
    mock_watchman.launch.side_effect = Watchman.ExecutionError('oops!')

    self.watchman_launcher._watchman = mock_watchman
    self.assertFalse(self.watchman_launcher.maybe_launch())

    mock_watchman.is_alive.assert_called_once_with()
    mock_watchman.launch.assert_called_once_with()

  def test_watchman_property(self):
    with mock.patch.object(Watchman, '_resolve_watchman_path'):
      self.assertIsInstance(self.watchman_launcher.watchman, Watchman)


# Copyright 2016 Battelle Energy Alliance, LLC
#
# 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.

from __future__ import unicode_literals, absolute_import
from django.test import TestCase, Client
from django.test.client import RequestFactory
from py_w3c.validators.html.validator import HTMLValidator
from django.urls import reverse
import json
from ci.tests import utils
from ci import models
import unittest, os

@unittest.skipIf(os.environ.get("VALIDATE_HTML") != "1", "run tests with VALIDATE_HTML=1")
class Tests(TestCase):
    def setUp(self):
        self.client = Client()
        self.factory = RequestFactory()
        for i in range(5):
            repo = utils.create_repo(name="repo%s" % i)
            repo.active = True
            repo.status = models.JobStatus.SUCCESS
            repo.save()
            for j in range(2):
                b = utils.create_branch(name="branch%s" % j, repo=repo)
                b.status = models.JobStatus.SUCCESS
                b.save()
            for j in range(3):
                b = repo.branches.first()
                pr = utils.create_pr(title="pr%s" % j, number=j+1, repo=repo)
                pr.closed = False
                pr.status = models.JobStatus.SUCCESS
                pr.save()
                ev = utils.create_event(user=repo.user, branch1=b, branch2=b, commit1="%s" % j)
                ev.pull_request = pr
                ev.save()
                for k in range(3):
                    r = utils.create_recipe(name="%s%s" % (repo.name, k), repo=repo, branch=b)
                    r.private = False
                    r.save()
                    job = utils.create_job(recipe=r, event=ev)
                    job.status = models.JobStatus.SUCCESS
                    job.client = utils.create_client(name="client%s/%s" % (repo.name, k))
                    job.save()
                    utils.create_step_result(job=job)
        utils.create_osversion()
        utils.create_loadedmodule()

    def check_url(self, url):
        response = self.client.get(url)
        vld = HTMLValidator()
        vld.validate_fragment(response.content)
        if vld.errors or vld.warnings:
            print(response.content)
        if vld.errors:
            print("ERRORS: %s" % json.dumps(vld.errors, indent=4))
        if vld.warnings:
            print("WARNINGS: %s" % json.dumps(vld.warnings, indent=4))
        self.assertEqual(vld.errors, [])
        self.assertEqual(vld.warnings, [])

    def test_main(self):
        self.check_url(reverse("ci:main"))

    def test_view_branch(self):
        self.check_url(reverse("ci:view_branch", args=[models.Branch.objects.first().pk]))

    def test_view_repo(self):
        self.check_url(reverse("ci:view_repo", args=[models.Repository.objects.first().pk]))

    def test_view_event(self):
        self.check_url(reverse("ci:view_event", args=[models.Event.objects.first().pk]))

    def test_view_pr(self):
        self.check_url(reverse("ci:view_pr", args=[models.PullRequest.objects.latest().pk]))

    def test_view_job(self):
        self.check_url(reverse("ci:view_job", args=[models.Job.objects.first().pk]))

    def test_view_client(self):
        self.check_url(reverse("ci:view_client", args=[models.Client.objects.first().pk]))

    def test_recipe_events(self):
        self.check_url(reverse("ci:recipe_events", args=[models.Recipe.objects.first().pk]))

    def test_view_profile(self):
        self.check_url(reverse("ci:view_profile", args=[models.Recipe.objects.first().build_user.pk]))

    def test_job_info_search(self):
        self.check_url(reverse("ci:job_info_search", args=[]))

    def test_user_repo_settings(self):
        user = utils.get_test_user()
        utils.simulate_login(self.client.session, user)
        self.check_url(reverse("ci:user_repo_settings"))

    def test_event_list(self):
        self.check_url(reverse("ci:event_list"))

    def test_pullrequest_list(self):
        self.check_url(reverse("ci:pullrequest_list"))

    def test_branch_list(self):
        self.check_url(reverse("ci:branch_list"))

    def test_client_list(self):
        self.check_url(reverse("ci:client_list"))

    def test_scheduled(self):
        self.check_url(reverse("ci:scheduled"))

# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from telemetry.page import page as page_module
from telemetry import story


class ToughFiltersCasesPage(page_module.Page):

  def RunPageInteractions(self, action_runner):
    with action_runner.CreateInteraction('Filter'):
      action_runner.Wait(10)


class PirateMarkPage(page_module.Page):

  def RunPageInteractions(self, action_runner):
    with action_runner.CreateInteraction('Filter'):
      action_runner.EvaluateJavaScript(
          'document.getElementById("benchmarkButtonText").click()')
      action_runner.Wait(10)

class ToughFiltersCasesPageSet(story.StorySet):

  """
  Description: Self-driven filters animation examples
  """

  def __init__(self):
    super(ToughFiltersCasesPageSet, self).__init__(
      archive_data_file='data/tough_filters_cases.json',
      cloud_storage_bucket=story.PARTNER_BUCKET)

    urls_list = [
      'http://letmespellitoutforyou.com/samples/svg/filter_terrain.svg',
      'http://static.bobdo.net/Analog_Clock.svg',
    ]

    for url in urls_list:
      self.AddStory(ToughFiltersCasesPage(url, self))

    self.AddStory(PirateMarkPage(
        'http://ie.microsoft.com/testdrive/Performance/Pirates/', self))


#    Copyright 2010 OpenStack Foundation
#
#    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.

import glob
import os


from cinder import exception
from cinder.i18n import _
from cinder import test


class ExceptionTestCase(test.TestCase):
    @staticmethod
    def _raise_exc(exc):
        raise exc()

    def test_exceptions_raise(self):
        # NOTE(dprince): disable format errors since we are not passing kwargs
        self.flags(fatal_exception_format_errors=False)
        for name in dir(exception):
            exc = getattr(exception, name)
            if isinstance(exc, type):
                self.assertRaises(exc, self._raise_exc, exc)


class ProjectTestCase(test.TestCase):
    def test_all_migrations_have_downgrade(self):
        topdir = os.path.normpath(os.path.dirname(__file__) + '/../../')
        py_glob = os.path.join(topdir, "cinder", "db", "sqlalchemy",
                               "migrate_repo", "versions", "*.py")
        missing_downgrade = []
        for path in glob.iglob(py_glob):
            has_upgrade = False
            has_downgrade = False
            with open(path, "r") as f:
                for line in f:
                    if 'def upgrade(' in line:
                        has_upgrade = True
                    if 'def downgrade(' in line:
                        has_downgrade = True

                if has_upgrade and not has_downgrade:
                    fname = os.path.basename(path)
                    missing_downgrade.append(fname)

        helpful_msg = (_("The following migrations are missing a downgrade:"
                         "\n\t%s") % '\n\t'.join(sorted(missing_downgrade)))
        self.assertFalse(missing_downgrade, msg=helpful_msg)

"""
Fixture to create a Content Library
"""

from opaque_keys.edx.keys import CourseKey

from . import STUDIO_BASE_URL
from .base import XBlockContainerFixture, FixtureError


class LibraryFixture(XBlockContainerFixture):
    """
    Fixture for ensuring that a library exists.

    WARNING: This fixture is NOT idempotent.  To avoid conflicts
    between tests, you should use unique library identifiers for each fixture.
    """

    def __init__(self, org, number, display_name):
        """
        Configure the library fixture to create a library with
        """
        super(LibraryFixture, self).__init__()
        self.library_info = {
            'org': org,
            'number': number,
            'display_name': display_name
        }

        self.display_name = display_name
        self._library_key = None
        super(LibraryFixture, self).__init__()

    def __str__(self):
        """
        String representation of the library fixture, useful for debugging.
        """
        return "<LibraryFixture: org='{org}', number='{number}'>".format(**self.library_info)

    def install(self):
        """
        Create the library and XBlocks within the library.
        This is NOT an idempotent method; if the library already exists, this will
        raise a `FixtureError`.  You should use unique library identifiers to avoid
        conflicts between tests.
        """
        self._create_library()
        self._create_xblock_children(self.library_location, self.children)

        return self

    @property
    def library_key(self):
        """
        Get the LibraryLocator for this library, as a string.
        """
        return self._library_key

    @property
    def library_location(self):
        """
        Return the locator string for the LibraryRoot XBlock that is the root of the library hierarchy.
        """
        lib_key = CourseKey.from_string(self._library_key)
        return unicode(lib_key.make_usage_key('library', 'library'))

    def _create_library(self):
        """
        Create the library described in the fixture.
        Will fail if the library already exists.
        """
        response = self.session.post(
            STUDIO_BASE_URL + '/library/',
            data=self._encode_post_dict(self.library_info),
            headers=self.headers
        )

        if response.ok:
            self._library_key = response.json()['library_key']
        else:
            try:
                err_msg = response.json().get('ErrMsg')
            except ValueError:
                err_msg = "Unknown Error"
            raise FixtureError("Could not create library {}. Status was {}, error was: {}".format(
                self.library_info, response.status_code, err_msg
            ))

    def create_xblock(self, parent_loc, xblock_desc):
        # Disable publishing for library XBlocks:
        xblock_desc.publish = "not-applicable"

        return super(LibraryFixture, self).create_xblock(parent_loc, xblock_desc)

from wagtaillinkchecker.celery import app


__all__ = ['app']

__version__ = '0.1.0'

default_app_config = 'wagtaillinkchecker.apps.WagtailLinkchekerAppConfig'

HTTP_STATUS_CODES = {
    100: ('Continue', 'Request received, please continue'),
    101: ('Switching Protocols',
          'Switching to new protocol; obey Upgrade header'),
    102: ('Processing', 'WebDAV; RFC 2518'),

    200: ('OK', 'Request fulfilled, document follows'),
    201: ('Created', 'Document created, URL follows'),
    202: ('Accepted',
          'Request accepted, processing continues off-line'),
    203: ('Non-Authoritative Information', 'Request fulfilled from cache'),
    204: ('No Content', 'Request fulfilled, nothing follows'),
    205: ('Reset Content', 'Clear input form for further input.'),
    206: ('Partial Content', 'Partial content follows.'),
    207: ('Multi-Status', 'WebDAV; RFC 4918'),
    208: ('Already Reported', 'WebDAV; RFC 5842'),
    226: ('IM Used', 'RFC 3229'),

    300: ('Multiple Choices',
          'Object has several resources -- see URI list'),
    301: ('Moved Permanently', 'Object moved permanently -- see URI list'),
    302: ('Found', 'Object moved temporarily -- see URI list'),
    303: ('See Other', 'Object moved -- see Method and URL list'),
    304: ('Not Modified',
          'Document has not changed since given time'),
    305: ('Use Proxy',
          'You must use proxy specified in Location to access this '
          'resource.'),
    306: ('Switch Proxy', 'Subsequent requests should use the specified proxy'),
    307: ('Temporary Redirect',
          'Object moved temporarily -- see URI list'),
    308: ('Permanent Redirect', 'Object moved permanently'),

    400: ('Bad Request',
          'Bad request syntax or unsupported method'),
    401: ('Unauthorized',
          'No permission -- see authorization schemes'),
    402: ('Payment Required',
          'No payment -- see charging schemes'),
    403: ('Forbidden',
          'Request forbidden -- authorization will not help'),
    404: ('Not Found', 'Nothing matches the given URI'),
    405: ('Method Not Allowed',
          'Specified method is invalid for this resource.'),
    406: ('Not Acceptable', 'URI not available in preferred format.'),
    407: ('Proxy Authentication Required', 'You must authenticate with '
          'this proxy before proceeding.'),
    408: ('Request Timeout', 'Request timed out; try again later.'),
    409: ('Conflict', 'Request conflict.'),
    410: ('Gone',
          'URI no longer exists and has been permanently removed.'),
    411: ('Length Required', 'Client must specify Content-Length.'),
    412: ('Precondition Failed', 'Precondition in headers is false.'),
    413: ('Payload Too Large', 'Payload is too large.'),
    414: ('Request-URI Too Long', 'URI is too long.'),
    415: ('Unsupported Media Type', 'Entity body in unsupported format.'),
    416: ('Requested Range Not Satisfiable',
          'Cannot satisfy request range.'),
    417: ('Expectation Failed',
          'Expect condition could not be satisfied.'),
    418: ("I'm a teapot", 'The HTCPCP server is a teapot'),
    419: ('Authentication Timeout', 'previously valid authentication has expired'),
    420: ('Method Failure / Enhance Your Calm', 'Spring Framework / Twitter'),
    422: ('Unprocessable Entity', 'WebDAV; RFC 4918'),
    423: ('Locked', 'WebDAV; RFC 4918'),
    424: ('Failed Dependency / Method Failure', 'WebDAV; RFC 4918'),
    425: ('Unordered Collection', 'Internet draft'),
    426: ('Upgrade Required', 'client should switch to a different protocol'),
    428: ('Precondition Required', 'RFC 6585'),
    429: ('Too Many Requests', 'RFC 6585'),
    431: ('Request Header Fields Too Large', 'RFC 6585'),
    440: ('Login Timeout', 'Microsoft'),
    444: ('No Response', 'Nginx'),
    449: ('Retry With', 'Microsoft'),
    450: ('Blocked by Windows Parental Controls', 'Microsoft'),
    451: ('Unavailable For Legal Reasons', 'RFC 7725'),
    494: ('Request Header Too Large', 'Nginx'),
    495: ('Cert Error', 'Nginx'),
    496: ('No Cert', 'Nginx'),
    497: ('HTTP to HTTPS', 'Nginx'),
    498: ('Token expired/invalid', 'Esri'),
    499: ('Client Closed Request', 'Nginx'),

    500: ('Internal Server Error', 'Server got itself in trouble'),
    501: ('Not Implemented',
          'Server does not support this operation'),
    502: ('Bad Gateway', 'Invalid responses from another server/proxy.'),
    503: ('Service Unavailable',
          'The server cannot process the request due to a high load'),
    504: ('Gateway Timeout',
          'The gateway server did not receive a timely response'),
    505: ('HTTP Version Not Supported', 'Cannot fulfill request.'),
    506: ('Variant Also Negotiates', 'RFC 2295'),
    507: ('Insufficient Storage', 'WebDAV; RFC 4918'),
    508: ('Loop Detected', 'WebDAV; RFC 5842'),
    509: ('Bandwidth Limit Exceeded', 'Apache bw/limited extension'),
    510: ('Not Extended', 'RFC 2774'),
    511: ('Network Authentication Required', 'RFC 6585'),
    598: ('Network read timeout error', 'Unknown'),
    599: ('Network connect timeout error', 'Unknown'),
}

# 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.

import logging

from django.conf import settings
from django.utils.translation import ugettext_lazy as _

from horizon import exceptions

from openstack_dashboard import api

LOG = logging.getLogger(__name__)


def flavor_list(request):
    """Utility method to retrieve a list of flavors."""
    try:
        return api.nova.flavor_list(request)
    except Exception:
        exceptions.handle(request,
                          _('Unable to retrieve instance flavors.'))
        return []


def sort_flavor_list(request, flavors):
    """Utility method to sort a list of flavors.
        By default, returns the available flavors, sorted by RAM
        usage (ascending). Override these behaviours with a
        CREATE_INSTANCE_FLAVOR_SORT dict
        in local_settings.py.
    """
    def get_key(flavor, sort_key):
        try:
            return getattr(flavor, sort_key)
        except AttributeError:
            LOG.warning('Could not find sort key "%s". Using the default '
                        '"ram" instead.', sort_key)
            return getattr(flavor, 'ram')
    try:
        flavor_sort = getattr(settings, 'CREATE_INSTANCE_FLAVOR_SORT', {})
        sort_key = flavor_sort.get('key', 'ram')
        rev = flavor_sort.get('reverse', False)
        if not callable(sort_key):
            key = lambda flavor: get_key(flavor, sort_key)
        else:
            key = sort_key
        flavor_list = [(flavor.id, '%s' % flavor.name)
                   for flavor in sorted(flavors, key=key, reverse=rev)]
        return flavor_list
    except Exception:
        exceptions.handle(request,
                          _('Unable to sort instance flavors.'))
        return []

# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import logging
import os
import re
import subprocess

from telemetry.core import util
from telemetry.internal.platform import device
from telemetry.internal.platform.profiler import monsoon

from devil.android import device_blacklist
from devil.android import device_errors
from devil.android import device_utils
from pylib import constants


class AndroidDevice(device.Device):
  """ Class represents information for connecting to an android device.

  Attributes:
    device_id: the device's serial string created by adb to uniquely
      identify an emulator/device instance. This string can be found by running
      'adb devices' command
    enable_performance_mode: when this is set to True, android platform will be
    set to high performance mode after browser is started.
  """
  def __init__(self, device_id, enable_performance_mode=True):
    super(AndroidDevice, self).__init__(
        name='Android device %s' % device_id, guid=device_id)
    self._device_id = device_id
    self._enable_performance_mode = enable_performance_mode

  @classmethod
  def GetAllConnectedDevices(cls, blacklist):
    device_serials = GetDeviceSerials(blacklist)
    return [cls(s) for s in device_serials]

  @property
  def device_id(self):
    return self._device_id

  @property
  def enable_performance_mode(self):
    return self._enable_performance_mode


def _ListSerialsOfHealthyOnlineDevices(blacklist):
  return [d.adb.GetDeviceSerial()
          for d in device_utils.DeviceUtils.HealthyDevices(blacklist)
          if d.IsOnline()]


def GetDeviceSerials(blacklist):
  """Return the list of device serials of healthy devices.

  If a preferred device has been set with ANDROID_SERIAL, it will be first in
  the returned list. The arguments specify what devices to include in the list.
  """

  device_serials = _ListSerialsOfHealthyOnlineDevices(blacklist)

  # The monsoon provides power for the device, so for devices with no
  # real battery, we need to turn them on after the monsoon enables voltage
  # output to the device.
  if not device_serials:
    try:
      m = monsoon.Monsoon(wait=False)
      m.SetUsbPassthrough(1)
      m.SetVoltage(3.8)
      m.SetMaxCurrent(8)
      logging.warn("""
Monsoon power monitor detected, but no Android devices.

The Monsoon's power output has been enabled. Please now ensure that:

  1. The Monsoon's front and back USB are connected to the host.
  2. The device is connected to the Monsoon's main and USB channels.
  3. The device is turned on.

Waiting for device...
""")
      util.WaitFor(_ListSerialsOfHealthyOnlineDevices(blacklist), 600)
      device_serials = _ListSerialsOfHealthyOnlineDevices(blacklist)
    except IOError:
      return []

  preferred_device = os.environ.get('ANDROID_SERIAL')
  if preferred_device in device_serials:
    logging.warn(
        'ANDROID_SERIAL is defined. Put %s in the first of the'
        'discovered devices list.' % preferred_device)
    device_serials.remove(preferred_device)
    device_serials.insert(0, preferred_device)
  return device_serials


def GetDevice(finder_options):
  """Return a Platform instance for the device specified by |finder_options|."""
  if not CanDiscoverDevices():
    logging.info(
        'No adb command found. Will not try searching for Android browsers.')
    return None

  if (finder_options.device
      and finder_options.device in GetDeviceSerials(finder_options)):
    return AndroidDevice(
        finder_options.device,
        enable_performance_mode=not finder_options.no_performance_mode)

  if finder_options.android_blacklist_file:
    blacklist = device_blacklist.Blacklist(
        finder_options.android_blacklist_file)
  else:
    blacklist = None

  devices = AndroidDevice.GetAllConnectedDevices(blacklist)
  if len(devices) == 0:
    logging.info('No android devices found.')
    return None
  if len(devices) > 1:
    logging.warn(
        'Multiple devices attached. Please specify one of the following:\n' +
        '\n'.join(['  --device=%s' % d.device_id for d in devices]))
    return None
  return devices[0]


def CanDiscoverDevices():
  """Returns true if devices are discoverable via adb."""
  adb_path = constants.GetAdbPath()
  if os.path.isabs(adb_path) and not os.path.exists(adb_path):
    return False
  try:
    with open(os.devnull, 'w') as devnull:
      adb_process = subprocess.Popen(
          ['adb', 'devices'], stdout=subprocess.PIPE, stderr=subprocess.PIPE,
          stdin=devnull)
      stdout = adb_process.communicate()[0]
    if re.search(re.escape('????????????\tno permissions'), stdout) != None:
      logging.warn('adb devices gave a permissions error. '
                   'Consider running adb as root:')
      logging.warn('  adb kill-server')
      logging.warn('  sudo `which adb` devices\n\n')
    return True
  except OSError:
    pass
  try:
    os.environ['PATH'] = os.pathsep.join(
        [os.path.dirname(adb_path), os.environ['PATH']])
    device_utils.DeviceUtils.HealthyDevices(None)
    return True
  except (device_errors.CommandFailedError, device_errors.CommandTimeoutError,
          OSError):
    return False


def FindAllAvailableDevices(options):
  """Returns a list of available devices.
  """
  if options.android_blacklist_file:
    blacklist = device_blacklist.Blacklist(options.android_blacklist_file)
  else:
    blacklist = None

  if not CanDiscoverDevices():
    return []
  else:
    return AndroidDevice.GetAllConnectedDevices(blacklist)

##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""DEPRECATED"""

import zope.deferredimport

zope.deferredimport.deprecated(
    "Local registration is now much simpler.  The old baroque APIs "
    "will go away in Zope 3.5.  See the new component-registration APIs "
    "defined in zope.component, especially IComponentRegistry.",
    LocalAdapterRegistry = 'zope.app.component.site:_LocalAdapterRegistry',
    AdapterRegistration = 'zope.app.component.back35:AdapterRegistration2',
    )


# -*- coding: utf-8 -*-

from __future__ import absolute_import as _init

__all__ = ['Level2ApiStruct', 'Level2Api']

if 0: from . import Level2ApiStruct
Level2ApiStruct = __import__(__name__.rsplit('.',1)[0]+'.Level2ApiStruct', None, None, 'x')

class Level2Api(object):
    def Create(self, pszFlowPath='', bIsUsingUdp=False):
        """创建UserApi
        @param pszFlowPath 存贮订阅信息文件的目录，默认为当前目录
        @return 创建出的UserApi
        modify for udp marketdata
        """

    def Release(self):
        """删除接口对象本身
        @remark 不再使用本接口对象时,调用该函数删除接口对象
        """

    def Init(self):
        """初始化
        @remark 初始化运行环境,只有调用后,接口才开始工作
        """

    def Join(self):
        """等待接口线程结束运行
        @return 线程退出代码
        """
        return 0

    def GetTradingDay(self):
        """获取当前交易日
        @retrun 获取到的交易日
        @remark 只有登录成功后,才能得到正确的交易日
        """
        return ''

    def RegisterFront(self, pszFrontAddress):
        """注册前置机网络地址
        @param pszFrontAddress：前置机网络地址。
        @remark 网络地址的格式为：“protocol:
        ipaddress:port”，如：”tcp:
        127.0.0.1:17001”。
        @remark “tcp”代表传输协议，“127.0.0.1”代表服务器地址。”17001”代表服务器端口号。
        """

    def SubscribeLevel2MarketData(self, pSecurityList, nCount):
        return 0

    def UnSubscribeLevel2MarketData(self, pSecurityList, nCount):
        return 0

    def SubscribeNGTSIndex(self, pSecurityList, nCount):
        return 0

    def UnSubscribeNGTSIndex(self, pSecurityList, nCount):
        return 0

    def SubscribePublicTopic(self, nResumeType):
        """订阅公共流。
        @param nResumeType 公共流重传方式
                THOST_TERT_RESTART:从本交易日开始重传
                THOST_TERT_RESUME:从上次收到的续传
                THOST_TERT_QUICK:只传送登录后公共流的内容
        @remark 该方法要在Init方法前调用。若不调用则不会收到公共流的数据。
        """

    def ReqUserLogin(self, pReqUserLogin, nRequestID):
        """用户登录请求"""
        return 0

    def ReqUserLogout(self, pUserLogout, nRequestID):
        """登出请求"""
        return 0

    def OnFrontConnected(self):
        """当客户端与交易后台建立起通信连接时（还未登录前），该方法被调用。"""

    def OnFrontDisconnected(self, nReason):
        """当客户端与交易后台通信连接断开时，该方法被调用。当发生这个情况后，API会自动重新连接，客户端可不做处理。
        @param nReason 错误原因
                0x1001 网络读失败
                0x1002 网络写失败
                0x2001 接收心跳超时
                0x2002 发送心跳失败
                0x2003 收到错误报文
        """

    def OnHeartBeatWarning(self, nTimeLapse):
        """心跳超时警告。当长时间未收到报文时，该方法被调用。
        @param nTimeLapse 距离上次接收报文的时间
        """

    def OnRspUserLogin(self, pRspUserLogin, pRspInfo, nRequestID, bIsLast):
        """登录请求响应"""

    def OnRspUserLogout(self, pUserLogout, pRspInfo, nRequestID, bIsLast):
        """登出请求响应"""

    def OnRspError(self, pRspInfo, nRequestID, bIsLast):
        """错误应答"""

    def OnRspSubLevel2MarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        """订阅Level2行情应答"""

    def OnRspUnSubLevel2MarketData(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        """取消订阅Level2行情应答"""

    def OnRspSubNGTSIndex(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        """订阅Level2指数行情应答"""

    def OnRspUnSubNGTSIndex(self, pSpecificSecurity, pRspInfo, nRequestID, bIsLast):
        """取消订阅Level2指数行情应答"""

    def OnRtnLevel2MarketData(self, pLevel2MarketData):
        """Level2行情通知"""

    def OnRtnNGTSIndex(self, pNGTSIndex):
        """Level2指数行情通知"""

def _init(Level2Spi=Level2Api):
    G = globals(); del G['_init']
    Level2Spi = dict((k,v) for k,v in Level2Spi.__dict__.items() if k.startswith('On'))
    from ._Level2Api import _init, Level2Api; _init(Level2ApiStruct)
    G['Level2Api'] = type('Level2Api', (Level2Api,), Level2Spi)
_init()

#!/usr/bin/env python2.6
# -*- cpy-indent-level: 4; indent-tabs-mode: nil -*-
# ex: set expandtab softtabstop=4 shiftwidth=4:
#
# Copyright (C) 2011,2012,2013  Contributor
#
# 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.
"""Module for testing the add reboot_schedule command."""

import unittest
import os.path

if __name__ == "__main__":
    import utils
    utils.import_depends()

from brokertest import TestBrokerCommand


class TestAddRebootSchedule(TestBrokerCommand):

    def test_100_nonexistent(self):
        command = ["show_reboot_schedule",
                   "--hostname=server1.aqd-unittest.ms.com"]
        out = self.notfoundtest(command)

    def test_110_add_schedule(self):
        # devaq add_reboot_schedule --hostname aquilon07.one-nyp.ms.com
        # --week 1,2,3,4,5 --day Sun --time 06:00
        command = ["add_reboot_schedule",
                   "--week=all", "--day=Sun", "--time=08:00",
                   "--hostname=server1.aqd-unittest.ms.com"]
        self.successtest(command)

    def test_115_make(self):
        command = ["make", "--hostname=server1.aqd-unittest.ms.com"]
        self.successtest(command)

    def test_120_show_reboot_schedule(self):
        command = ["show_reboot_schedule",
                   "--hostname=server1.aqd-unittest.ms.com"]
        out = self.commandtest(command)
        self.matchoutput(out, "RebootSchedule: reboot_schedule",
                         command)
        self.matchoutput(out, "Bound to: Host server1.aqd-unittest.ms.com",
                         command)
        self.matchoutput(out, "Week: All", command)
        self.matchoutput(out, "Day: Sun", command)
        self.matchoutput(out, "Time: 08:00", command)

    def test_120_cat_resource(self):
        command = ["cat", "--reboot_schedule=reboot_schedule",
                   "--hostname=server1.aqd-unittest.ms.com"]
        out = self.commandtest(command)
        self.matchoutput(out,
                         "structure template resource"
                         "/host/server1.aqd-unittest.ms.com"
                         "/reboot_schedule/reboot_schedule/config;",
                         command)
        self.matchoutput(out, "\"name\" = \"reboot_schedule\";", command)
        self.matchoutput(out, "\"time\" = \"08:00\";", command)
        self.matchoutput(out, "\"week\" = \"All\"", command)
        self.matchoutput(out, "\"day\" = \"Sun\"", command)

        command = ["cat", "--reboot_schedule=reboot_schedule",
                   "--hostname=server1.aqd-unittest.ms.com",
                   "--generate"]
        newout = self.commandtest(command)
        self.assertEqual(out, newout)

    def test_120_cat_host(self):
        command = ["cat", "--hostname", "server1.aqd-unittest.ms.com", "--data"]
        out = self.commandtest(command)
        self.matchoutput(out,
                         '"system/resources/reboot_schedule" = '
                         'append(create("resource/host/server1.aqd-unittest.ms.com/reboot_schedule/reboot_schedule/config"))',
                         command)

    def test_120_show_all(self):
        command = ["show_reboot_schedule", "--all"]
        out = self.commandtest(command)
        self.matchoutput(out, "RebootSchedule: reboot_schedule", command)

    def test_120_show_host(self):
        command = ["show_host", "--host=server1.aqd-unittest.ms.com"]
        out = self.commandtest(command)
        self.matchoutput(out,
                         "RebootSchedule: reboot_schedule", command)

    def test_120_show_host_proto(self):
        command = ["show_host", "--hostname=server1.aqd-unittest.ms.com",
                   "--format=proto"]
        out = self.commandtest(command)
        hostlist = self.parse_hostlist_msg(out, expect=1)
        host = hostlist.hosts[0]
        found = False
        for resource in host.resources:
            if resource.name == "reboot_schedule" and \
               resource.type == "reboot_schedule":
                found = True
                self.failUnlessEqual(resource.reboot_schedule.week, "All")
                self.failUnlessEqual(resource.reboot_schedule.day, "Sun")
                self.failUnlessEqual(resource.reboot_schedule.time, "08:00")
        self.assertTrue(found,
                        "Reboot schedule not found in the resources. "
                        "Existing resources: %s" %
                        ", ".join(["%s %s" % (res.type, res.name) for res in
                                              host.resources]))

    def test_200_add_existing(self):
        command = ["add_reboot_schedule",
                   "--week=all", "--day=Sun", "--time=08:00",
                   "--hostname=server1.aqd-unittest.ms.com"]
        out = self.badrequesttest(command)
        self.matchoutput(out, "already exists", command)

    def test_200_cat_notfound(self):
        command = ["cat", "--reboot_schedule=schedule-does-not-exist",
                   "--hostname=server1.aqd-unittest.ms.com"]
        self.notfoundtest(command)

    def test_300_del_reboot_schedule(self):
        plenary = self.plenary_name("resource", "host",
                                    "server1.aqd-unittest.ms.com",
                                    "reboot_schedule", "reboot_schedule",
                                    "config")
        self.failUnless(os.path.exists(plenary),
                        "Pleanry '%s' does not exist" % plenary)

        command = ["del_reboot_schedule",
                   "--hostname=server1.aqd-unittest.ms.com"]
        self.successtest(command)

        dir = os.path.dirname(plenary)
        self.failIf(os.path.exists(dir),
                    "Plenary directory '%s' still exists" % dir)

    def test_310_verify_del(self):
        command = ["show_host", "--hostname", "server1.aqd-unittest.ms.com"]
        out = self.commandtest(command)
        self.matchclean(out, "reboot_schedule", command)


if __name__ == '__main__':
    suite = unittest.TestLoader().loadTestsFromTestCase(TestAddRebootSchedule)
    unittest.TextTestRunner(verbosity=2).run(suite)

# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2011 Nebula, Inc.
#
#    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.

import os

from django.views import generic


class ModalFormView(generic.TemplateView):
    form_class = None
    initial = {}
    context_form_name = "form"
    context_object_name = "object"

    def get_template_names(self):
        if self.request.is_ajax():
            if not hasattr(self, "ajax_template_name"):
                # Transform standard template name to ajax name (leading "_")
                bits = list(os.path.split(self.template_name))
                bits[1] = "".join(("_", bits[1]))
                self.ajax_template_name = os.path.join(*bits)
            template = self.ajax_template_name
        else:
            template = self.template_name
        return template

    def get_object(self, *args, **kwargs):
        return None

    def get_initial(self):
        return self.initial

    def get_form_kwargs(self):
        kwargs = {'initial': self.get_initial()}
        return kwargs

    def maybe_handle(self):
        if not self.form_class:
            raise AttributeError('You must specify a SelfHandlingForm class '
                                 'for the "form_class" attribute on %s.'
                                 % self.__class__.__name__)
        if not hasattr(self, "form"):
            form = self.form_class
            kwargs = self.get_form_kwargs()
            self.form, self.handled = form.maybe_handle(self.request, **kwargs)
        return self.form, self.handled

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(*args, **kwargs)
        form, handled = self.maybe_handle()
        if handled:
            return handled
        context = self.get_context_data(**kwargs)
        context[self.context_form_name] = form
        context[self.context_object_name] = self.object
        if self.request.is_ajax():
            context['hide'] = True
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        """ Placeholder to allow POST; handled the same as GET. """
        return self.get(self, request, *args, **kwargs)

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for fft operations.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import numpy as np
import tensorflow as tf
from six.moves import xrange  # pylint: disable=redefined-builtin


VALID_FFT_RANKS = (1, 2, 3)


class FFTOpsTest(tf.test.TestCase):

  def _Compare(self, x, rank):
    if tf.test.is_gpu_available():
      # GPU/Forward
      self.assertAllClose(
          self._npFFT(x, rank),
          self._tfFFT(x, rank, use_gpu=True),
          rtol=1e-4,
          atol=1e-4)
      # GPU/Backward
      self.assertAllClose(
          self._npIFFT(x, rank),
          self._tfIFFT(x, rank, use_gpu=True),
          rtol=1e-4,
          atol=1e-4)

  def _checkGrad(self, func, x, y, use_gpu=False):
    with self.test_session(use_gpu=use_gpu):
      inx = tf.convert_to_tensor(x)
      iny = tf.convert_to_tensor(y)
      # func is a forward or inverse FFT function (batched or unbatched)
      z = func(tf.complex(inx, iny))
      # loss = sum(|z|^2)
      loss = tf.reduce_sum(tf.real(z * tf.conj(z)))
      ((x_jacob_t, x_jacob_n),
       (y_jacob_t, y_jacob_n)) = tf.test.compute_gradient(
           [inx, iny],
           [list(x.shape), list(y.shape)],
           loss,
           [1],
           x_init_value=[x, y],
           delta=1e-2)
    self.assertAllClose(x_jacob_t, x_jacob_n, rtol=1e-2, atol=1e-2)
    self.assertAllClose(y_jacob_t, y_jacob_n, rtol=1e-2, atol=1e-2)

  def _npFFT(self, x, rank):
    if rank == 1:
      return np.fft.fft2(x, axes=(-1,))
    elif rank == 2:
      return np.fft.fft2(x, axes=(-2, -1))
    elif rank == 3:
      return np.fft.fft2(x, axes=(-3, -2, -1))
    else:
      raise ValueError("invalid rank")

  def _npIFFT(self, x, rank):
    if rank == 1:
      return np.fft.ifft2(x, axes=(-1,))
    elif rank == 2:
      return np.fft.ifft2(x, axes=(-2, -1))
    elif rank == 3:
      return np.fft.ifft2(x, axes=(-3, -2, -1))
    else:
      raise ValueError("invalid rank")

  def _tfFFT(self, x, rank, use_gpu=False):
    with self.test_session(use_gpu=use_gpu):
      return self._tfFFTForRank(rank)(x).eval()

  def _tfIFFT(self, x, rank, use_gpu=False):
    with self.test_session(use_gpu=use_gpu):
      return self._tfIFFTForRank(rank)(x).eval()

  def _tfFFTForRank(self, rank):
    if rank == 1:
      return tf.fft
    elif rank == 2:
      return tf.fft2d
    elif rank == 3:
      return tf.fft3d
    else:
      raise ValueError("invalid rank")

  def _tfIFFTForRank(self, rank):
    if rank == 1:
      return tf.ifft
    elif rank == 2:
      return tf.ifft2d
    elif rank == 3:
      return tf.ifft3d
    else:
      raise ValueError("invalid rank")

  def testEmpty(self):
    if tf.test.is_gpu_available():
      for rank in VALID_FFT_RANKS:
        for dims in xrange(rank, rank + 3):
          x = np.zeros((0,) * dims).astype(np.complex64)
          self.assertEqual(x.shape, self._tfFFT(x, rank).shape)
          self.assertEqual(x.shape, self._tfIFFT(x, rank).shape)

  def testBasic(self):
    for rank in VALID_FFT_RANKS:
      for dims in xrange(rank, rank + 3):
        self._Compare(
            np.mod(
                np.arange(np.power(4, dims)), 10).reshape((4,) * dims), rank)

  def testRandom(self):
    np.random.seed(12345)

    def gen(shape):
      n = np.prod(shape)
      re = np.random.uniform(size=n)
      im = np.random.uniform(size=n)
      return (re + im * 1j).reshape(shape)

    for rank in VALID_FFT_RANKS:
      for dims in xrange(rank, rank + 3):
        self._Compare(gen((4,) * dims), rank)

  def testError(self):
    if tf.test.is_gpu_available():
      for rank in VALID_FFT_RANKS:
        for dims in xrange(0, rank):
          x = np.zeros((1,) * dims).astype(np.complex64)
          with self.assertRaisesWithPredicateMatch(
              ValueError,
              "Shape must be .*rank {}.*".format(rank)):
            self._tfFFT(x, rank)
          with self.assertRaisesWithPredicateMatch(
              ValueError,
              "Shape must be .*rank {}.*".format(rank)):
            self._tfIFFT(x, rank)

  def testGrad_Simple(self):
    if tf.test.is_gpu_available():
      for rank in VALID_FFT_RANKS:
        for dims in xrange(rank, rank + 2):
          re = np.ones(shape=(4,) * dims, dtype=np.float32) / 10.0
          im = np.zeros(shape=(4,) * dims, dtype=np.float32)
          self._checkGrad(self._tfFFTForRank(rank), re, im, use_gpu=True)
          self._checkGrad(self._tfIFFTForRank(rank), re, im, use_gpu=True)

  def testGrad_Random(self):
    if tf.test.is_gpu_available():
      np.random.seed(54321)
      for rank in VALID_FFT_RANKS:
        for dims in xrange(rank, rank + 2):
          re = np.random.rand(*((3,) * dims)).astype(np.float32) * 2 - 1
          im = np.random.rand(*((3,) * dims)).astype(np.float32) * 2 - 1
          self._checkGrad(self._tfFFTForRank(rank), re, im, use_gpu=True)
          self._checkGrad(self._tfIFFTForRank(rank), re, im, use_gpu=True)


if __name__ == "__main__":
  tf.test.main()

#_*_coding:utf-8_*_
__author__ = 'jieli'

import threading,time
import random
def light():
    if not event.isSet():
        event.set() #wait就不阻塞 #绿灯状态
    count = 0
    while True:
        if count < 10:
            print '\033[42;1m--green light on---\033[0m'
        elif count <13:
            print '\033[43;1m--yellow light on---\033[0m'
        elif count <20:
            if event.isSet():
                event.clear()
            print '\033[41;1m--red light on---\033[0m'
        else:
            count = 0
            event.set() #打开绿灯
        time.sleep(1)
        count +=1
def car(n):
    while 1:
        time.sleep(random.randrange(10))
        if  event.isSet(): #绿灯
            print "car [%s] is running.." % n
        else:
            print "car [%s] is waiting for the red light.." %n
if __name__ == '__main__':
    event = threading.Event()
    Light = threading.Thread(target=light)
    Light.start()
    for i in range(3):
        t = threading.Thread(target=car,args=(i,))
        t.start()
'''
Events #

An event is a simple synchronization object;
the event represents an internal flag, and threads
can wait for the flag to be set, or set or clear the flag themselves.

event = threading.Event()

# a client thread can wait for the flag to be set
event.wait()

# a server thread can set or reset it
event.set()
event.clear()
If the flag is set, the wait method doesn’t do anything.
If the flag is cleared, wait will block until it becomes set again.
Any number of threads may wait for the same event.
'''
# -*- coding: utf-8 -*-
# Copyright 2011-2012 Antoine Bertin <diaoulael@gmail.com>
#
# This file is part of subliminal.
#
# subliminal is free software; you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# subliminal is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with subliminal.  If not, see <http://www.gnu.org/licenses/>.
from .core import (SERVICES, LANGUAGE_INDEX, SERVICE_INDEX, SERVICE_CONFIDENCE,
    MATCHING_CONFIDENCE, create_list_tasks, consume_task, create_download_tasks,
    group_by_video, key_subtitles)
from .language import language_set, language_list, LANGUAGES
import logging


__all__ = ['list_subtitles', 'download_subtitles']
logger = logging.getLogger("subliminal")


def list_subtitles(paths, languages=None, services=None, force=True, multi=False, cache_dir=None, max_depth=3, scan_filter=None):
    """List subtitles in given paths according to the criteria

    :param paths: path(s) to video file or folder
    :type paths: string or list
    :param languages: languages to search for, in preferred order
    :type languages: list of :class:`~subliminal.language.Language` or string
    :param list services: services to use for the search, in preferred order
    :param bool force: force searching for subtitles even if some are detected
    :param bool multi: search multiple languages for the same video
    :param string cache_dir: path to the cache directory to use
    :param int max_depth: maximum depth for scanning entries
    :param function scan_filter: filter function that takes a path as argument and returns a boolean indicating whether it has to be filtered out (``True``) or not (``False``)
    :return: found subtitles
    :rtype: dict of :class:`~subliminal.videos.Video` => [:class:`~subliminal.subtitles.ResultSubtitle`]

    """
    services = services or SERVICES
    languages = language_set(languages) if languages is not None else language_set(LANGUAGES)
    if isinstance(paths, basestring):
        paths = [paths]
    if any([not isinstance(p, unicode) for p in paths]):
        logger.warning(u'Not all entries are unicode')
    results = []
    service_instances = {}
    tasks = create_list_tasks(paths, languages, services, force, multi, cache_dir, max_depth, scan_filter)
    for task in tasks:
        try:
            result = consume_task(task, service_instances)
            results.append((task.video, result))
        except:
            logger.error(u'Error consuming task %r' % task, exc_info=True)
    for service_instance in service_instances.itervalues():
        service_instance.terminate()
    return group_by_video(results)


def download_subtitles(paths, languages=None, services=None, force=True, multi=False, cache_dir=None, max_depth=3, scan_filter=None, order=None):
    """Download subtitles in given paths according to the criteria

    :param paths: path(s) to video file or folder
    :type paths: string or list
    :param languages: languages to search for, in preferred order
    :type languages: list of :class:`~subliminal.language.Language` or string
    :param list services: services to use for the search, in preferred order
    :param bool force: force searching for subtitles even if some are detected
    :param bool multi: search multiple languages for the same video
    :param string cache_dir: path to the cache directory to use
    :param int max_depth: maximum depth for scanning entries
    :param function scan_filter: filter function that takes a path as argument and returns a boolean indicating whether it has to be filtered out (``True``) or not (``False``)
    :param order: preferred order for subtitles sorting
    :type list: list of :data:`~subliminal.core.LANGUAGE_INDEX`, :data:`~subliminal.core.SERVICE_INDEX`, :data:`~subliminal.core.SERVICE_CONFIDENCE`, :data:`~subliminal.core.MATCHING_CONFIDENCE`
    :return: downloaded subtitles
    :rtype: dict of :class:`~subliminal.videos.Video` => [:class:`~subliminal.subtitles.ResultSubtitle`]

    .. note::

        If you use ``multi=True``, :data:`~subliminal.core.LANGUAGE_INDEX` has to be the first item of the ``order`` list
        or you might get unexpected results.

    """
    services = services or SERVICES
    languages = language_list(languages) if languages is not None else language_list(LANGUAGES)
    if isinstance(paths, basestring):
        paths = [paths]
    order = order or [LANGUAGE_INDEX, SERVICE_INDEX, SERVICE_CONFIDENCE, MATCHING_CONFIDENCE]
    subtitles_by_video = list_subtitles(paths, languages, services, force, multi, cache_dir, max_depth, scan_filter)
    for video, subtitles in subtitles_by_video.iteritems():
        subtitles.sort(key=lambda s: key_subtitles(s, video, languages, services, order), reverse=True)
    results = []
    service_instances = {}
    tasks = create_download_tasks(subtitles_by_video, languages, multi)
    for task in tasks:
        try:
            result = consume_task(task, service_instances)
            results.append((task.video, result))
        except:
            logger.error(u'Error consuming task %r' % task, exc_info=True)
    for service_instance in service_instances.itervalues():
        service_instance.terminate()
    return group_by_video(results)

from __future__ import unicode_literals

from django.apps import apps
from django.conf import settings
from django.contrib.redirects.models import Redirect
from django.contrib.sites.shortcuts import get_current_site
from django.core.exceptions import ImproperlyConfigured
from django import http


class RedirectFallbackMiddleware(object):

    # Defined as class-level attributes to be subclassing-friendly.
    response_gone_class = http.HttpResponseGone
    response_redirect_class = http.HttpResponsePermanentRedirect

    def __init__(self):
        if not apps.is_installed('django.contrib.sites'):
            raise ImproperlyConfigured(
                "You cannot use RedirectFallbackMiddleware when "
                "django.contrib.sites is not installed."
            )

    def process_response(self, request, response):
        # No need to check for a redirect for non-404 responses.
        if response.status_code != 404:
            return response

        full_path = request.get_full_path()
        current_site = get_current_site(request)

        r = None
        try:
            r = Redirect.objects.get(site=current_site, old_path=full_path)
        except Redirect.DoesNotExist:
            pass
        if settings.APPEND_SLASH and not request.path.endswith('/'):
            # Try appending a trailing slash.
            path_len = len(request.path)
            full_path = full_path[:path_len] + '/' + full_path[path_len:]
            try:
                r = Redirect.objects.get(site=current_site, old_path=full_path)
            except Redirect.DoesNotExist:
                pass
        if r is not None:
            if r.new_path == '':
                return self.response_gone_class()
            return self.response_redirect_class(r.new_path)

        # No redirect was found. Return the response.
        return response

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
#

from thrift.Thrift import *

class TProtocolException(TException):

  """Custom Protocol Exception class"""

  UNKNOWN = 0
  INVALID_DATA = 1
  NEGATIVE_SIZE = 2
  SIZE_LIMIT = 3
  BAD_VERSION = 4

  def __init__(self, type=UNKNOWN, message=None):
    TException.__init__(self, message)
    self.type = type

class TProtocolBase:

  """Base class for Thrift protocol driver."""

  def __init__(self, trans):
    self.trans = trans

  def writeMessageBegin(self, name, type, seqid):
    pass

  def writeMessageEnd(self):
    pass

  def writeStructBegin(self, name):
    pass

  def writeStructEnd(self):
    pass

  def writeFieldBegin(self, name, type, id):
    pass

  def writeFieldEnd(self):
    pass

  def writeFieldStop(self):
    pass

  def writeMapBegin(self, ktype, vtype, size):
    pass

  def writeMapEnd(self):
    pass

  def writeListBegin(self, etype, size):
    pass

  def writeListEnd(self):
    pass

  def writeSetBegin(self, etype, size):
    pass

  def writeSetEnd(self):
    pass

  def writeBool(self, bool):
    pass

  def writeByte(self, byte):
    pass

  def writeI16(self, i16):
    pass

  def writeI32(self, i32):
    pass

  def writeI64(self, i64):
    pass

  def writeDouble(self, dub):
    pass

  def writeString(self, str):
    pass

  def readMessageBegin(self):
    pass

  def readMessageEnd(self):
    pass

  def readStructBegin(self):
    pass

  def readStructEnd(self):
    pass

  def readFieldBegin(self):
    pass

  def readFieldEnd(self):
    pass

  def readMapBegin(self):
    pass

  def readMapEnd(self):
    pass

  def readListBegin(self):
    pass

  def readListEnd(self):
    pass

  def readSetBegin(self):
    pass

  def readSetEnd(self):
    pass

  def readBool(self):
    pass

  def readByte(self):
    pass

  def readI16(self):
    pass

  def readI32(self):
    pass

  def readI64(self):
    pass

  def readDouble(self):
    pass

  def readString(self):
    pass

  def skip(self, type):
    if type == TType.STOP:
      return
    elif type == TType.BOOL:
      self.readBool()
    elif type == TType.BYTE:
      self.readByte()
    elif type == TType.I16:
      self.readI16()
    elif type == TType.I32:
      self.readI32()
    elif type == TType.I64:
      self.readI64()
    elif type == TType.DOUBLE:
      self.readDouble()
    elif type == TType.STRING:
      self.readString()
    elif type == TType.STRUCT:
      name = self.readStructBegin()
      while True:
        (name, type, id) = self.readFieldBegin()
        if type == TType.STOP:
          break
        self.skip(type)
        self.readFieldEnd()
      self.readStructEnd()
    elif type == TType.MAP:
      (ktype, vtype, size) = self.readMapBegin()
      for i in range(size):
        self.skip(ktype)
        self.skip(vtype)
      self.readMapEnd()
    elif type == TType.SET:
      (etype, size) = self.readSetBegin()
      for i in range(size):
        self.skip(etype)
      self.readSetEnd()
    elif type == TType.LIST:
      (etype, size) = self.readListBegin()
      for i in range(size):
        self.skip(etype)
      self.readListEnd()

class TProtocolFactory:
  def getProtocol(self, trans):
    pass

# -*- coding: utf-8 -*-
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.
#

import unittest
import shutil
import tempfile

from airflow import configuration
from airflow import models, DAG
from airflow.exceptions import AirflowSensorTimeout
from airflow.contrib.sensors.file_sensor import FileSensor
from airflow.settings import Session
from airflow.utils.timezone import datetime

TEST_DAG_ID = 'unit_tests'
DEFAULT_DATE = datetime(2015, 1, 1)
configuration.load_test_config()


def reset(dag_id=TEST_DAG_ID):
    session = Session()
    tis = session.query(models.TaskInstance).filter_by(dag_id=dag_id)
    tis.delete()
    session.commit()
    session.close()


reset()


class FileSensorTest(unittest.TestCase):
    def setUp(self):
        configuration.load_test_config()
        from airflow.contrib.hooks.fs_hook import FSHook
        hook = FSHook()
        args = {
            'owner': 'airflow',
            'start_date': DEFAULT_DATE,
            'provide_context': True
        }
        dag = DAG(TEST_DAG_ID + 'test_schedule_dag_once', default_args=args)
        dag.schedule_interval = '@once'
        self.hook = hook
        self.dag = dag

    def test_simple(self):
        with tempfile.NamedTemporaryFile() as tmp:
            task = FileSensor(
                task_id="test",
                filepath=tmp.name[1:],
                fs_conn_id='fs_default',
                dag=self.dag,
                timeout=0,
            )
            task._hook = self.hook
            task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,
                     ignore_ti_state=True)

    def test_file_in_nonexistent_dir(self):
        dir = tempfile.mkdtemp()
        task = FileSensor(
            task_id="test",
            filepath=dir[1:] + "/file",
            fs_conn_id='fs_default',
            dag=self.dag,
            timeout=0,
        )
        task._hook = self.hook
        try:
            with self.assertRaises(AirflowSensorTimeout):
                task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,
                         ignore_ti_state=True)
        finally:
            shutil.rmtree(dir)

    def test_empty_dir(self):
        dir = tempfile.mkdtemp()
        task = FileSensor(
            task_id="test",
            filepath=dir[1:],
            fs_conn_id='fs_default',
            dag=self.dag,
            timeout=0,
        )
        task._hook = self.hook
        try:
            with self.assertRaises(AirflowSensorTimeout):
                task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,
                         ignore_ti_state=True)
        finally:
            shutil.rmtree(dir)

    def test_file_in_dir(self):
        dir = tempfile.mkdtemp()
        task = FileSensor(
            task_id="test",
            filepath=dir[1:],
            fs_conn_id='fs_default',
            dag=self.dag,
            timeout=0,
        )
        task._hook = self.hook
        try:
            # `touch` the dir
            open(dir + "/file", "a").close()
            task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,
                     ignore_ti_state=True)
        finally:
            shutil.rmtree(dir)

    def test_default_fs_conn_id(self):
        with tempfile.NamedTemporaryFile() as tmp:
            task = FileSensor(
                task_id="test",
                filepath=tmp.name[1:],
                dag=self.dag,
                timeout=0,
            )
            task._hook = self.hook
            task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,
                     ignore_ti_state=True)


if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
This module defines filters for Container instances.
"""
from __future__ import print_function

from tunacell.filters.main import FilterGeneral


class FilterContainer(FilterGeneral):
    """General class to filter containers"""

    _type = 'CONTAINER'


class FilterContainerAny(FilterContainer):
    """True for any container"""

    def __init__(self):
        label = 'True for any container'
        self.label = label
        return

    def func(self, container):
        return True


class FilterContainerMetadataEquals(FilterContainer):
    """Test a given metadata value

    Parameters
    ----------
    key : str
    value : requested type (str, float, int)

    Raises
    ------
    KeyError : when requested key is not present in container metadata
    """

    def __init__(self, key, value):
        self.key = key
        self.value = value
        label = '{}={}'.format(key, value)
        self.label = label
        return

    def func(self, container):
        if not hasattr(container.metadata, self.key):
            raise KeyError
        svalue = getattr(container.metadata, self.key)
        if type(self.value) == str:
            if self.value == svalue:
                return True
            else:
                return False
        elif type(self.value) == int:
            if int(svalue) == self.value:
                return True
            else:
                return False
        elif type(self.value) == float:
            if float(svalue) == self.value:
                return True
            else:
                return False
        else:
            raise TypeError('type not understood')

import json
from os import path
from types import *
import getopt
import sys

def get_input_output_bytes_from_files(
        json_files,
        show_output=False
):
    assert type(json_files) is ListType, "json_files is not a list: %r" % json_files

    browser_tx = 0
    browser_rx = 0

    file_index = 0
    for json_file in json_files:
        analysis_output = get_input_output_bytes_from_file(json_file)
        browser_tx += analysis_output['browser_tx']
        browser_rx += analysis_output['browser_rx']
        file_index += 1

        if show_output:
            print 'get_input_output_bytes_from_files[%i] -- Rx: %i Tx: %i' % (file_index, analysis_output['browser_rx'], analysis_output['browser_tx'])

    if show_output:
        print 'get_input_output_bytes_from_files[SUM] -- Rx: %i Tx: %i' % (browser_rx, browser_tx)

    return {
        'browser_tx': browser_tx,
        'browser_rx': browser_rx
    }

def get_input_output_bytes_from_file(
        json_file
):
    assert type(json_file) is StringType, "json_file is not a string: %r" % json_file
    assert path.isfile(json_file) or path.islink(json_file), "json_file is not a path to a file or link: %r" % json_file

    return get_input_output_bytes(
        json.loads(
            open(json_file, "rb").read()
        )
    )

def get_input_output_bytes(
        json_obj
):
    assert not type(json_obj) is NoneType, "No json_obj provided"
    assert type(json_obj) is DictType, "json_obj was type '%s' instead of dict: %r" % (type(json_obj), json_obj)

    browser_rx = 0
    browser_tx = 0

    for page_req in json_obj['log']['entries']:
        if type(page_req['response']['bodySize']) == IntType:
            browser_rx += page_req['response']['bodySize']

        if type(page_req['request']['headersSize']) == IntType:
            browser_tx += page_req['request']['headersSize']

    return {
        'browser_tx': browser_tx,
        'browser_rx': browser_rx
    }

if __name__ == '__main__':
    ###
    # Use getopt to parse the command line options
    ###
    args_parsed, args_remain = getopt.getopt(
        sys.argv[1:],
        'f:TP',
        [
            'file=',
            'get-transfer',
            'no-pretty-print'
        ]
    )

    target_files = []
    target_operation = None
    output_pretty_print = True

    ###
    # Validate and retain the command line arguments
    ###
    for opt, arg in args_parsed:
        if opt in ('-f', '--file'):
            target_files.append(arg)
        elif opt in ('-T', '--get-transfer'):
            target_operation = 'get_input_output_bytes_from_files'
        elif opt in ('-P', '--no-pretty-print'):
            output_pretty_print = False

    ###
    # Validate the target_operation variable
    ###
    if not target_operation:
        target_operation = 'get_input_output_bytes_from_files'

    try:
        if not locals()[target_operation]:
            pass
    except KeyError:
        raise Exception('target_operation "%s" does not exist' % target_operation)

    ###
    # Ensure we have at least one file to operate on
    ###
    if len(target_files) == 0:
        raise Exception('No target_files specified')

    ###
    # Call the target_operation and output the results
    ###
    output = locals()[target_operation](target_files)

    if output_pretty_print:
        print json.dumps(
            output,
            sort_keys=True,
            indent=4,
            separators=(',', ': ')
        )
    else:
        print output

from coalib.bearlib.abstractions.Linter import linter
from dependency_management.requirements.PipRequirement import PipRequirement
from coalib.results.RESULT_SEVERITY import RESULT_SEVERITY


@linter(executable='rstcheck',
        use_stdout=False,
        use_stderr=True,
        output_format='regex',
        output_regex=r'.+\s?:(?P<line>\d+):\s'
                     r'(?P<message>\((?P<severity>\w+).+)',
        severity_map={'INFO': RESULT_SEVERITY.INFO,
                      'WARNING': RESULT_SEVERITY.NORMAL,
                      'ERROR': RESULT_SEVERITY.MAJOR,
                      'SEVERE': RESULT_SEVERITY.MAJOR})
class RSTcheckBear:

    """
    Check syntax of ``reStructuredText`` and code blocks
    nested within it.

    Check <https://pypi.python.org/pypi/rstcheck> for more information.
    """

    LANGUAGES = {'reStructuredText'}
    REQUIREMENTS = {PipRequirement('rstcheck', '3.1')}
    AUTHORS = {'The coala developers'}
    AUTHORS_EMAILS = {'coala-devel@googlegroups.com'}
    LICENSE = 'AGPL-3.0'
    CAN_DETECT = {'Formatting', 'Syntax'}
    ASCIINEMA_URL = 'https://asciinema.org/a/8ntlaqubk2qkrn9mm0dh07rlk?speed=2'

    @staticmethod
    def create_arguments(filename, file, config_file,
                         code_block_language_ignore: list=()):
        """
        :param code_block_language_ignore:
            Comma seperated list for languages of which code blocks
            should be ignored. Code block of following languages
            can be detected: ``bash``, ``c``, ``cpp``, ``json``,
            ``python``, ``rst``.
        """
        args = ()
        if code_block_language_ignore:
            args = ('--ignore-language=' +
                    ','.join(code_block_language_ignore),)
        return args + (filename,)

#
# (C) Copyright 2008 Jelmer Vernooij <jelmer@samba.org>
# (C) Copyright 2011 Jacek Konieczny <jajcus@jajcus.net>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License Version
# 2.1 as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#
"""GSSAPI authentication mechanism for PyXMPP SASL implementation.

Normative reference:
  - `RFC 4752 <http://www.ietf.org/rfc/rfc4752.txt>`__
"""



__docformat__ = "restructuredtext en"

import base64
import kerberos

import logging

from .core import ClientAuthenticator, Response, Success
from .core import sasl_mechanism
        
logger = logging.getLogger("pyxmpp2.sasl.gssapi")

@sasl_mechanism("GSSAPI", 75)
class GSSAPIClientAuthenticator(ClientAuthenticator):
    """Provides client-side GSSAPI SASL (Kerberos 5) authentication."""

    def __init__(self, password_manager):
        ClientAuthenticator.__init__(self, password_manager)
        self.password_manager = password_manager
        self.username = None
        self._gss = None
        self.step = None
        self.authzid = None

    def start(self, username, authzid):
        self.username = username
        self.authzid = authzid
        _unused, self._gss = kerberos.authGSSClientInit(authzid or 
                        "{0}@{1}".format("xmpp", 
                                    self.password_manager.get_serv_host()))
        self.step = 0
        return self.challenge("")

    def challenge(self, challenge):
        if self.step == 0:
            ret = kerberos.authGSSClientStep(self._gss,
                                                base64.b64encode(challenge))
            if ret != kerberos.AUTH_GSS_CONTINUE:
                self.step = 1
        elif self.step == 1:
            ret = kerberos.authGSSClientUnwrap(self._gss,
                                                base64.b64encode(challenge))
            response = kerberos.authGSSClientResponse(self._gss)
            ret = kerberos.authGSSClientWrap(self._gss, response, self.username)
        response = kerberos.authGSSClientResponse(self._gss)
        if response is None:
            return Response("")
        else:
            return Response(base64.b64decode(response))

    def finish(self, data):
        self.username = kerberos.authGSSClientUserName(self._gss)
        logger.debug("Authenticated as {0!r}".format(
                                    kerberos.authGSSClientUserName(self._gss)))
        return Success(self.username, None, self.authzid)


# vi: sts=4 et sw=4

from keras import backend as K
from keras.callbacks import Callback, TensorBoard
from keras.models import Model, Sequential, load_model
from keras import layers
import numpy as np
import glob
import audio_utilities
import wandb
from wandb.keras import WandbCallback
from keras import optimizers
import os
wandb.init()

sample_rate = 8000
audio_utilities.ensure_audio()
if not os.path.exists("cache"):
    raise ValueError("You must run python preprocess before training")


def load_data():
    print("Loading data...")
    data = {}
    X_train, y_train = [], []
    clean = np.load('cache/clean.npy')
    data['clean'] = clean[:, 1]
    data['dirty'] = []
    for f in glob.glob("cache/*"):
        spects = np.load(f)
        key = f.split("/")[-1]
        data['dirty'].extend(spects[:, 1])
        if key == "clean":
            continue
        else:
            X_train.extend(spects[:, 0])
            y_train.extend(clean[:, 0])
    return np.expand_dims(np.array(X_train), -1), np.expand_dims(np.array(y_train), -1), data


class Audio(Callback):
    def on_epoch_end(self, *args):
        validation_X = self.validation_data[0]
        validation_y = self.validation_data[1]
        val_scales = scales["dirty"][:20]
        validation_length = len(validation_X)
        indices = np.random.choice(
            validation_length, 1, replace=False)
        predictions = self.model.predict(validation_X[indices])
        print("Min: ", predictions.min(), "Max: ", predictions.max())
        predictions = predictions.clip(0, 1)  # np.max(abs(predictions))
        norm_pred = []
        norm_in = []
        clean_in = []
        for i, idx in enumerate(indices):
            scale = val_scales[idx]
            pred = np.squeeze(predictions[i])
            norm = np.squeeze(validation_X[idx])
            clean = np.squeeze(validation_y[idx])
            norm_pred.append(audio_utilities.griffin_lim(pred, scale))
            norm_in.append(audio_utilities.griffin_lim(norm, scale))
            clean_in.append(audio_utilities.griffin_lim(clean, scale))

        wandb.log({
            "clean_audio": [wandb.Audio(audio, sample_rate=sample_rate) for audio in clean_in],
            "noisy_audio": [wandb.Audio(audio, sample_rate=sample_rate) for audio in norm_in],
            "audio": [wandb.Audio(audio, sample_rate=sample_rate)
                      for audio in norm_pred]}, commit=False)


X_train, y_train, scales = load_data()

model = Sequential()
model.add(layers.Conv2D(64, 3, padding="same",
                        activation="relu", use_bias=False, input_shape=(X_train[0].shape)))
model.add(layers.Conv2D(32, 3, strides=(2, 2),
                        padding="same", activation="relu", use_bias=False))
model.add(layers.Conv2D(2, 3, strides=(2, 2),
                        padding="same", activation="relu", use_bias=False))
model.add(layers.UpSampling2D(2))
model.add(layers.Conv2D(32, 3, padding="same",
                        activation="relu", use_bias=False))
model.add(layers.UpSampling2D(2))
model.add(layers.Conv2D(64, 3, padding="same",
                        activation="relu", use_bias=False))
model.add(layers.Conv2D(1, 3, padding="same", use_bias=False))
model.add(layers.Cropping2D(cropping=((0, 0), (0, 3))))
model.summary()

model.compile(optimizer="adagrad", loss="mse")

model.fit(X_train[20:], y_train[20:], epochs=60, batch_size=64,
          validation_data=(X_train[:20], y_train[:20]), callbacks=[Audio(), WandbCallback(data_type="image")])

#
#    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.

from django import shortcuts

from horizon import forms
from horizon.test import helpers as test


class FormMixinTests(test.TestCase):

    def _prepare_view(self, cls, request_headers, *args, **kwargs):
        req = self.factory.get('/my_url/', **request_headers)
        req.user = self.user
        view = cls()
        view.request = req
        view.args = args
        view.kwargs = kwargs
        view.template_name = 'test_template'
        return view

    def test_modal_form_mixin_hide_true_if_ajax(self):
        view = self._prepare_view(
            forms.views.ModalFormView,
            dict(HTTP_X_REQUESTED_WITH='XMLHttpRequest'))
        context = view.get_context_data()
        self.assertTrue(context['hide'])

    def test_modal_form_mixin_add_to_field_header_set(self):
        return self._test_form_mixin_add_to_field_header(add_field=True)

    def test_modal_form_mixin_add_to_field_header_not_set(self):
        return self._test_form_mixin_add_to_field_header(add_field=False)

    def _test_form_mixin_add_to_field_header(self, add_field=False):
        options = dict(HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        if add_field:
            options[forms.views.ADD_TO_FIELD_HEADER] = "keepme"

        view = self._prepare_view(forms.views.ModalFormView, options)
        context = view.get_context_data()

        if add_field:
            self.assertEqual("keepme", context['add_to_field'])
        else:
            self.assertNotIn('add_to_field', context)

    def test_template_name_change_based_on_ajax_request(self):
            view = self._prepare_view(
                forms.views.ModalFormView,
                dict(HTTP_X_REQUESTED_WITH='XMLHttpRequest'))
            self.assertEqual('_' + view.template_name,
                             view.get_template_names())

            view = self._prepare_view(forms.views.ModalFormView, {})
            self.assertEqual(view.template_name, view.get_template_names())


class TestForm(forms.SelfHandlingForm):

    name = forms.CharField(max_length=255)

    def handle(self, request, data):
        return True


class FormErrorTests(test.TestCase):

    template = 'horizon/common/_form_fields.html'

    def setUp(self):
        super(FormErrorTests, self).setUp()
        self.form = TestForm(self.request)

    def _render_form(self):
        return shortcuts.render(self.request, self.template,
                                {'form': self.form})

    def test_set_warning(self):
        warning_text = 'WARNING 29380'
        self.form.set_warning(warning_text)
        self.assertEqual([warning_text], self.form.warnings)
        resp = self._render_form()
        self.assertIn(warning_text, resp.content)

    def test_api_error(self):
        error_text = 'ERROR 12938'
        self.form.full_clean()
        self.form.api_error(error_text)
        self.assertEqual([error_text], self.form.non_field_errors())
        resp = self._render_form()
        self.assertIn(error_text, resp.content)


class TestChoiceFieldForm(forms.SelfHandlingForm):
    title_dic = {"label1": {"title": "This is choice 1"},
                 "label2": {"title": "This is choice 2"},
                 "label3": {"title": "This is choice 3"}}
    name = forms.CharField(max_length=255,
                           label="Test Name",
                           help_text="Please enter a name")
    test_choices = forms.ChoiceField(label="Test Choices",
                                     required=False,
                                     help_text="Testing drop down choices",
                                     widget=forms.fields.SelectWidget(
                                         attrs={
                                             'class': 'switchable',
                                             'data-slug': 'source'},
                                         transform_html_attrs=title_dic.get))

    def __init__(self, request, *args, **kwargs):
        super(TestChoiceFieldForm, self).__init__(request, *args, **kwargs)
        choices = ([('choice1', 'label1'),
                    ('choice2', 'label2')])
        self.fields['test_choices'].choices = choices

    def handle(self, request, data):
        return True


class ChoiceFieldTests(test.TestCase):

    template = 'horizon/common/_form_fields.html'

    def setUp(self):
        super(ChoiceFieldTests, self).setUp()
        self.form = TestChoiceFieldForm(self.request)

    def _render_form(self):
        return shortcuts.render(self.request, self.template,
                                {'form': self.form})

    def test_choicefield_title(self):
        resp = self._render_form()
        self.assertContains(
            resp,
            '<option value="choice1" title="This is choice 1">label1</option>',
            count=1, html=True)
        self.assertContains(
            resp,
            '<option value="choice2" title="This is choice 2">label2</option>',
            count=1, html=True)

from django import forms
from django.test import TestCase

from contact.forms import ContactForm


class ContactFormTest(TestCase):
    def test_contact_form_should_have_first_name_and_last_name_fields(self):
        expected_fields = ['first_name','last_name', 'email']

        form = ContactForm()
        for each in expected_fields:
            self.assertTrue(each in form.fields)

        self.assertEqual(len(form.fields), 3)

    def test_contact_form_with_valid_data_should_be_valid_and_have_no_errors(
        self
    ):
        valid_data = {
            'first_name': 'N',
            'last_name': 'P',
            'email': 'oy@prontomarketing.com'
        }

        form = ContactForm(data=valid_data)

        self.assertTrue(form.is_valid())
        self.assertFalse(form.errors)

    def test_contact_form_with_invalid_data_should_be_invalid_and_have_errors(
        self
    ):
        invalid_data = [
            {
                'first_name': '',
                'last_name': 'P',
                'email': 'oy@prontomarketing.com'
            },
            {
                'first_name': 'N',
                'last_name': '',
                'email': 'oy@prontomarketing.com'
            },
            {
                'first_name': '',
                'last_name': '',
                'email': 'oy@prontomarketing.com'
            },
            {
                'first_name': '',
                'last_name': '',
                'email': ''
            }
        ]

        for each in invalid_data:
            form = ContactForm(data=each)

            self.assertFalse(form.is_valid())
            self.assertTrue(form.errors)

    def test_email_field_should_use_email_widget(self):
        form = ContactForm()

        self.assertIsInstance(form.fields['email'].widget, forms.EmailInput)

# Copyright Iris contributors
#
# This file is part of Iris and is released under the LGPL license.
# See COPYING and COPYING.LESSER in the root of the repository for full
# licensing details.

import iris.tests as tests
import iris

import numpy as np
import PIL.Image


@tests.skip_gdal
@tests.skip_data
class TestGeoTiffExport(tests.IrisTest):
    def check_tiff_header(self, tiff_filename, expect_keys, expect_entries):
        """
        Checks the given tiff file's metadata contains the expected keys,
        and some matching values (not all).

        """
        with open(tiff_filename, "rb") as fh:
            im = PIL.Image.open(fh)
            file_keys = im.tag.keys()

            missing_keys = sorted(set(expect_keys) - set(file_keys))
            msg_nokeys = "Tiff header has missing keys : {}."
            self.assertEqual(missing_keys, [], msg_nokeys.format(missing_keys))

            extra_keys = sorted(set(file_keys) - set(expect_keys))
            msg_extrakeys = "Tiff header has extra unexpected keys : {}."
            self.assertEqual(extra_keys, [], msg_extrakeys.format(extra_keys))

            msg_badval = "Tiff header entry {} has value {} != {}."
            for key, value in expect_entries.items():
                content = im.tag[key]
                self.assertEqual(
                    content, value, msg_badval.format(key, content, value)
                )

    def check_tiff(self, cube, header_keys, header_items):
        # Check that the cube saves correctly to TIFF :
        #   * the header contains expected keys and (some) values
        #   * the data array retrives correctly
        import iris.experimental.raster

        with self.temp_filename(".tif") as temp_filename:
            iris.experimental.raster.export_geotiff(cube, temp_filename)

            # Check the metadata is correct.
            self.check_tiff_header(temp_filename, header_keys, header_items)

            # Ensure that north is at the top then check the data is correct.
            coord_y = cube.coord(axis="Y", dim_coords=True)
            data = cube.data
            if np.diff(coord_y.bounds[0]) > 0:
                data = cube.data[::-1, :]
            im = PIL.Image.open(temp_filename)
            im_data = np.array(im)
            # Currently we only support writing 32-bit tiff, when comparing
            # the data ensure that it is also 32-bit
            np.testing.assert_array_equal(im_data, data.astype(np.float32))

    def _check_tiff_export(self, masked, inverted=False):
        tif_header_keys = [
            256,
            257,
            258,
            259,
            262,
            273,
            277,
            278,
            279,
            284,
            339,
            33550,
            33922,
        ]
        tif_header_entries = {
            256: (160,),
            257: (159,),
            258: (32,),
            259: (1,),
            262: (1,),
            # Skip this one: behaviour is not consistent across gdal versions.
            # 273: (354, 8034, 15714, 23394, 31074, 38754, 46434,
            #       54114, 61794, 69474, 77154, 84834, 92514, 100194),
            277: (1,),
            278: (12,),
            279: (
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                7680,
                1920,
            ),
            284: (1,),
            339: (3,),
            33550: (1.125, 1.125, 0.0),
            33922: (0.0, 0.0, 0.0, -0.5625, 89.4375, 0.0),
        }
        fin = tests.get_data_path(
            ("NetCDF", "global", "xyt", "SMALL_total_column_co2.nc")
        )
        cube = iris.load_cube(fin)[0]
        # PIL doesn't support float64
        cube.data = cube.data.astype("f4")

        # Ensure longitude values are continuous and monotonically increasing,
        # and discard the 'half cells' at the top and bottom of the UM output
        # by extracting a subset.
        east = iris.Constraint(longitude=lambda cell: cell < 180)
        non_edge = iris.Constraint(latitude=lambda cell: -90 < cell < 90)
        cube = cube.extract(east & non_edge)
        cube.coord("longitude").guess_bounds()
        cube.coord("latitude").guess_bounds()

        if masked:
            # Mask some of the data + expect a slightly different header...
            cube.data = np.ma.masked_where(cube.data <= 380, cube.data)

            # There is an additional key..
            tif_header_keys += [42113]
            # Don't add a check entry for this, as coding changed between gdal
            # version 1 and 2, *and* between Python2 and Python3.
            # tif_header_entries[42113] = (u'1e+20',)

        if inverted:
            # Check with the latitude coordinate (and the corresponding
            # cube.data) inverted.
            # The output should be exactly the same.
            coord = cube.coord("latitude")
            coord.points = coord.points[::-1]
            coord.bounds = None
            coord.guess_bounds()
            cube.data = cube.data[::-1, :]

        self.check_tiff(cube, tif_header_keys, tif_header_entries)

    def test_unmasked(self):
        self._check_tiff_export(masked=False)

    def test_masked(self):
        self._check_tiff_export(masked=True)

    def test_inverted(self):
        self._check_tiff_export(masked=False, inverted=True)


if __name__ == "__main__":
    tests.main()

import sys
from services.spawn import MobileTemplate
from services.spawn import WeaponTemplate
from resources.datatables import WeaponType
from resources.datatables import Difficulty
from resources.datatables import Options
from java.util import Vector


def addTemplate(core):
	mobileTemplate = MobileTemplate()
	
	mobileTemplate.setCreatureName('panshee_cub')
	mobileTemplate.setLevel(69)
	mobileTemplate.setDifficulty(Difficulty.NORMAL)

	mobileTemplate.setMinSpawnDistance(3)
	mobileTemplate.setMaxSpawnDistance(5)
	mobileTemplate.setDeathblow(False)
	mobileTemplate.setScale(.5)
	mobileTemplate.setSocialGroup('panshee tribe')
	mobileTemplate.setAssistRange(1)
	mobileTemplate.setOptionsBitmask(128)
	mobileTemplate.setStalker(True)
	
	
	templates = Vector()
	templates.add('object/mobile/shared_dressed_ewok_f_01.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_02.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_03.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_04.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_05.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_06.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_07.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_08.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_09.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_10.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_11.iff')
	templates.add('object/mobile/shared_dressed_ewok_f_12.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_01.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_02.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_03.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_04.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_05.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_06.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_07.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_08.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_09.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_10.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_11.iff')
	templates.add('object/mobile/shared_dressed_ewok_m_12.iff')
	
	mobileTemplate.setTemplates(templates)
	
	weaponTemplates = Vector()
	weapontemplate = WeaponTemplate('object/weapon/melee/unarmed/shared_unarmed_default.iff', WeaponType.UNARMED, 1.0, 6, 'kinetic')
	weaponTemplates.add(weapontemplate)
	mobileTemplate.setWeaponTemplateVector(weaponTemplates)
	
	attacks = Vector()
	mobileTemplate.setDefaultAttack('meleeHit')
	mobileTemplate.setAttacks(attacks)
	
	lootPoolNames_1 = ['Junk']
	lootPoolChances_1 = [100]
	lootGroupChance_1 = 65
	mobileTemplate.addToLootGroups(lootPoolNames_1,lootPoolChances_1,lootGroupChance_1)
	
	lootPoolNames_2 = ['random_loot_primitives']
	lootPoolChances_2 = [100]
	lootGroupChance_2 = 35
	mobileTemplate.addToLootGroups(lootPoolNames_2,lootPoolChances_2,lootGroupChance_2)
	
	core.spawnService.addMobileTemplate('panshee_cub', mobileTemplate)
	return
#!/usr/bin/python
# -*- coding: utf8 -*-

import sys
import numpy as np
import pandas as pd
# from sklearn.metrics.pairwise import paired_distances
import re
import csv
from collections import Counter
from sklearn.feature_extraction import DictVectorizer
from scipy.spatial.distance import euclidean



# Idea: Have a database with for each feature how important it is for the user
# Feature is for example a specific artist
# To suggest a new song, find one with similar features

class MusicRecommender(object):
    """Item-based recommender for songs."""
    def __init__(self, songs_csv_path, feedback_file=None, preprocessed=True):
        super(MusicRecommender, self).__init__()
        self.songs_csv_path = songs_csv_path
        self.feedback_file = feedback_file
        if preprocessed:
            self.df = pd.read_csv(self.songs_csv_path, index_col=0)
        else:
            self.df = self.preprocess(self.songs_csv_path)
        self.rated_songs = {}

        self.used_features = [
            {'name': 'ArtistName', 'type': 'categorical'},
            {'name': 'Tempo', 'type': 'numerical'},
            {'name': 'KeySignature', 'type': 'categorical'},
            {'name': 'Danceability', 'type': 'numerical'},
            {'name': 'ArtistLocation', 'type': 'categorical'}
        ]

        self.vectors = {}
        for column_name in ['ArtistName', 'ArtistLocation', 'KeySignature']:
            counter = Counter(self.df['ArtistName'].values)
            vector = DictVectorizer(sparse=False)
            vector.fit([dict(counter)])
            self.vectors[column_name] = vector
        return

    def available_songs(self):
        return len(self.df)

    def preprocess(self, songs_csv_path):
        """Make a cleaned dataframe of the data in songs_csv_path."""
        df = pd.read_csv(songs_csv_path, index_col=0, na_values={'Year': [0], 'ArtistLocation': ["b''"]})
        regex1 = re.compile(r"b'(.*)'\"?")
        regex2 = re.compile(r"b(.*)\"\"")

        def clean_value(x):
            try:
                new_title, n_changes = regex1.subn(r"\1", x)
            except:
                return x
            if n_changes > 0:
                return new_title
            else:
                return regex2.sub(r"\1", x)

        df['Title'] = df['Title'].apply(clean_value)
        df['ArtistName'] = df['ArtistName'].apply(clean_value)
        df['ArtistLocation'] = df['ArtistLocation'].apply(clean_value)
        df['ArtistID'] = df['ArtistID'].apply(clean_value)
        df['SongID'] = df['SongID'].apply(clean_value)
        df['AlbumName'] = df['AlbumName'].apply(clean_value)
        return df

    def get_song_information(self, song_id):
        """Retrieve a song with id song_id from the dataframe."""
        return self.df.loc[song_id]

    def song_vector(self, song_id, extra_information=[], flattened=False):
        """Puts the song_id, extra_information and the features used for recommendation in a (flattened) array."""
        song = self.df.loc[song_id]
        song_vector = [] + extra_information
        for feature in self.used_features:
            name = feature['name']
            if feature['type'] == 'categorical':
                song_vector.append(self.vectors[name].transform([{song[name]: 1}])[0])
            else:
                song_vector.append(song[name])
        if flattened:
            return np.hstack(song_vector)
        else:
            return np.array(song_vector, dtype=np.object)
# song_vector = np.vectorize(song_vector, otypes=np.object)

    def recommend_song(self, sample_size=50, include_heard_songs=False):
        """Recommend a song (by giving it's id) based on the user's preferences"""
        songs_arr = np.array(list(self.rated_songs.values()), dtype=np.object)
        songs_ids = list(self.rated_songs.keys())
        songs_scores = songs_arr[:, 0]  # How much the user liked it
        songs_features = songs_arr[:, 1:]
        # print("Making profile")
        profile = []
        for i, feature in enumerate(self.used_features):
            if feature['type'] == 'categorical':
                profile.extend(np.sum(songs_features[:, i] * songs_scores))
            else:
                profile.append(np.mean(songs_features[:, i] * songs_scores))
        profile = np.array(profile)
        # print("Making song vectors")
        if include_heard_songs:
            songs_subset = np.random.choice(self.df.index, min(sample_size, len(self.df)))
        else:
            songs_subset = np.random.choice(np.setdiff1d(self.df.index, songs_ids), min(sample_size, len(self.df) - len(songs_ids)), replace=False)
        song_vectors = np.array([self.song_vector(i, flattened=True) for i in songs_subset])

        def similarity(x):
            """Calculate the euclidean distance between the profile and the features of a song vector"""
            return np.linalg.norm(profile - x)
        # similarity = np.vectorize(similarity)
        # print("Computing similarities")
        # similarities = similarity(song_vectors)
        similarities = [similarity(x) for x in song_vectors]
        return songs_subset[np.argmin(similarities)]

    def song_feedback(self, song_id, score=1):
        """Rate the song with id song_id. By default gives a score of 1."""
        self.rated_songs[song_id] = self.song_vector(song_id, extra_information=[score])
        return

    def read_feedback(self):
        """Add the feedback of multiple songs from a file."""
        if not(self.feedback_file):
            print("Please give a value for feedback_file first.")
            return
        f = open(self.feedback_file)
        reader = csv.reader(f)
        next(reader)  # Skip the header
        for song_id, score in reader:
            self.song_feedback(int(song_id), score=int(score))
        f.close()
        return

    def save_feedback(self):
        """Save the feedback of songs to a file"""
        if not(self.feedback_file):
            print("Please give a value for feedback_file first.")
            return
        f = open(self.feedback_file, 'w')
        writer = csv.writer(f)
        writer.writerow(['id', 'score'])
        for song in self.rated_songs:
            writer.writerow(song[:2])
        f.close()
        return

if __name__ == '__main__':
    if len(sys.argv) < 2:
        print("Please provide the path to a CSV file with songs information.")
        sys.exit(1)
    recommender = MusicRecommender(sys.argv[1])
    recommender.song_feedback(5)
    recommender.song_feedback(343)
    recommender.song_feedback(234)
    recommended = recommender.recommend_song()
    song = recommender.get_song_information(recommended)
    print("Recommended: '{}' by '{}' (id {})".format(song['Title'], song['ArtistName'], recommended))

# -*- coding: utf-8 -*-

"""
***************************************************************************
    gdalinfo.py
    ---------------------
    Date                 : August 2012
    Copyright            : (C) 2012 by Victor Olaya
    Email                : volayaf at gmail dot com
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""

__author__ = 'Victor Olaya'
__date__ = 'August 2012'
__copyright__ = '(C) 2012, Victor Olaya'

# This will get replaced with a git SHA1 when you do a git archive

__revision__ = '$Format:%H$'

import os

from qgis.PyQt.QtGui import QIcon
from qgis.core import (QgsProcessingException,
                       QgsProcessingParameterRasterLayer,
                       QgsProcessingParameterBoolean,
                       QgsProcessingParameterFileDestination)
from processing.algs.gdal.GdalAlgorithm import GdalAlgorithm
from processing.algs.gdal.GdalUtils import GdalUtils

pluginPath = os.path.split(os.path.split(os.path.dirname(__file__))[0])[0]


class gdalinfo(GdalAlgorithm):

    INPUT = 'INPUT'
    MIN_MAX = 'MIN_MAX'
    STATS = 'STATS'
    NO_GCP = 'NOGCP'
    NO_METADATA = 'NO_METADATA'
    OUTPUT = 'OUTPUT'

    def __init__(self):
        super().__init__()

    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterRasterLayer(self.INPUT,
                                                            self.tr('Input layer')))
        self.addParameter(QgsProcessingParameterBoolean(self.MIN_MAX,
                                                        self.tr('Force computation of the actual min/max values for each band'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.STATS,
                                                        self.tr('Read and display image statistics (force computation if necessary)'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.NO_GCP,
                                                        self.tr('Suppress GCP info'),
                                                        defaultValue=False))
        self.addParameter(QgsProcessingParameterBoolean(self.NO_METADATA,
                                                        self.tr('Suppress metadata info'),
                                                        defaultValue=False))

        self.addParameter(QgsProcessingParameterFileDestination(self.OUTPUT,
                                                                self.tr('Layer information'),
                                                                self.tr('HTML files (*.html)')))

    def name(self):
        return 'gdalinfo'

    def displayName(self):
        return self.tr('Raster information')

    def group(self):
        return self.tr('Raster miscellaneous')

    def groupId(self):
        return 'rastermiscellaneous'

    def icon(self):
        return QIcon(os.path.join(pluginPath, 'images', 'gdaltools', 'raster-info.png'))

    def commandName(self):
        return 'gdalinfo'

    def getConsoleCommands(self, parameters, context, feedback, executing=True):
        arguments = []
        if self.parameterAsBoolean(parameters, self.MIN_MAX, context):
            arguments.append('-mm')
        if self.parameterAsBoolean(parameters, self.STATS, context):
            arguments.append('-stats')
        if self.parameterAsBoolean(parameters, self.NO_GCP, context):
            arguments.append('-nogcp')
        if self.parameterAsBoolean(parameters, self.NO_METADATA, context):
            arguments.append('-nomd')
        raster = self.parameterAsRasterLayer(parameters, self.INPUT, context)
        if raster is None:
            raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))

        arguments.append(raster.source())
        return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]

    def processAlgorithm(self, parameters, context, feedback):
        GdalUtils.runGdal(self.getConsoleCommands(parameters, context, feedback), feedback)
        output = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
        with open(output, 'w') as f:
            f.write('<pre>')
            for s in GdalUtils.getConsoleOutput()[1:]:
                f.write(str(s))
            f.write('</pre>')

        return {self.OUTPUT: output}

import unittest

from django.contrib.gis.gdal import HAS_GDAL
from django.contrib.gis.tests.utils import (no_mysql, no_oracle, oracle, postgis,
    spatialite, HAS_SPATIALREFSYS, SpatialRefSys)
from django.db import connection
from django.utils import six


test_srs = ({'srid': 4326,
             'auth_name': ('EPSG', True),
             'auth_srid': 4326,
             # Only the beginning, because there are differences depending on installed libs
             'srtext': 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84"',
             # +ellps=WGS84 has been removed in the 4326 proj string in proj-4.8
             'proj4_re': r'\+proj=longlat (\+ellps=WGS84 )?(\+datum=WGS84 |\+towgs84=0,0,0,0,0,0,0 )\+no_defs ',
             'spheroid': 'WGS 84', 'name': 'WGS 84',
             'geographic': True, 'projected': False, 'spatialite': True,
             'ellipsoid': (6378137.0, 6356752.3, 298.257223563),  # From proj's "cs2cs -le" and Wikipedia (semi-minor only)
             'eprec': (1, 1, 9),
             },
            {'srid': 32140,
             'auth_name': ('EPSG', False),
             'auth_srid': 32140,
             'srtext': 'PROJCS["NAD83 / Texas South Central",GEOGCS["NAD83",DATUM["North_American_Datum_1983",SPHEROID["GRS 1980"',
             'proj4_re': r'\+proj=lcc \+lat_1=30.28333333333333 \+lat_2=28.38333333333333 \+lat_0=27.83333333333333 '
                         r'\+lon_0=-99 \+x_0=600000 \+y_0=4000000 (\+ellps=GRS80 )?'
                         r'(\+datum=NAD83 |\+towgs84=0,0,0,0,0,0,0 )?\+units=m \+no_defs ',
             'spheroid': 'GRS 1980', 'name': 'NAD83 / Texas South Central',
             'geographic': False, 'projected': True, 'spatialite': False,
             'ellipsoid': (6378137.0, 6356752.31414, 298.257222101),  # From proj's "cs2cs -le" and Wikipedia (semi-minor only)
             'eprec': (1, 5, 10),
             },
            )


@unittest.skipUnless(HAS_GDAL and HAS_SPATIALREFSYS,
    "SpatialRefSysTest needs gdal support and a spatial database")
class SpatialRefSysTest(unittest.TestCase):

    @no_mysql
    def test_retrieve(self):
        """
        Test retrieval of SpatialRefSys model objects.
        """
        for sd in test_srs:
            srs = SpatialRefSys.objects.get(srid=sd['srid'])
            self.assertEqual(sd['srid'], srs.srid)

            # Some of the authority names are borked on Oracle, e.g., SRID=32140.
            #  also, Oracle Spatial seems to add extraneous info to fields, hence the
            #  the testing with the 'startswith' flag.
            auth_name, oracle_flag = sd['auth_name']
            if postgis or (oracle and oracle_flag):
                self.assertEqual(True, srs.auth_name.startswith(auth_name))

            self.assertEqual(sd['auth_srid'], srs.auth_srid)

            # No proj.4 and different srtext on oracle backends :(
            if postgis:
                self.assertTrue(srs.wkt.startswith(sd['srtext']))
                six.assertRegex(self, srs.proj4text, sd['proj4_re'])

    @no_mysql
    def test_osr(self):
        """
        Test getting OSR objects from SpatialRefSys model objects.
        """
        for sd in test_srs:
            sr = SpatialRefSys.objects.get(srid=sd['srid'])
            self.assertEqual(True, sr.spheroid.startswith(sd['spheroid']))
            self.assertEqual(sd['geographic'], sr.geographic)
            self.assertEqual(sd['projected'], sr.projected)

            if not (spatialite and not sd['spatialite']):
                # Can't get 'NAD83 / Texas South Central' from PROJ.4 string
                # on SpatiaLite
                self.assertEqual(True, sr.name.startswith(sd['name']))

            # Testing the SpatialReference object directly.
            if postgis or spatialite:
                srs = sr.srs
                six.assertRegex(self, srs.proj4, sd['proj4_re'])
                # No `srtext` field in the `spatial_ref_sys` table in SpatiaLite < 4
                if not spatialite or connection.ops.spatial_version[0] >= 4:
                    self.assertTrue(srs.wkt.startswith(sd['srtext']))

    @no_mysql
    def test_ellipsoid(self):
        """
        Test the ellipsoid property.
        """
        for sd in test_srs:
            # Getting the ellipsoid and precision parameters.
            ellps1 = sd['ellipsoid']
            prec = sd['eprec']

            # Getting our spatial reference and its ellipsoid
            srs = SpatialRefSys.objects.get(srid=sd['srid'])
            ellps2 = srs.ellipsoid

            for i in range(3):
                self.assertAlmostEqual(ellps1[i], ellps2[i], prec[i])

    @no_mysql
    @no_oracle
    def test_add_entry(self):
        """
        Test adding a new entry in the SpatialRefSys model using the
        add_srs_entry utility.
        """
        from django.contrib.gis.utils import add_srs_entry

        add_srs_entry(3857)
        self.assertTrue(
            SpatialRefSys.objects.filter(srid=3857).exists()
        )
        srs = SpatialRefSys.objects.get(srid=3857)
        self.assertTrue(
            SpatialRefSys.get_spheroid(srs.wkt).startswith('SPHEROID[')
        )

#
# pause.py
#
# Copyright (C) 2008-2009 Ido Abramovich <ido.deluge@gmail.com>
# Copyright (C) 2009 Andrew Resch <andrewresch@gmail.com>
#
# Deluge is free software.
#
# You may redistribute it and/or modify it under the terms of the
# GNU General Public License, as published by the Free Software
# Foundation; either version 3 of the License, or (at your option)
# any later version.
#
# deluge is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with deluge.    If not, write to:
# 	The Free Software Foundation, Inc.,
# 	51 Franklin Street, Fifth Floor
# 	Boston, MA  02110-1301, USA.
#
#    In addition, as a special exception, the copyright holders give
#    permission to link the code of portions of this program with the OpenSSL
#    library.
#    You must obey the GNU General Public License in all respects for all of
#    the code used other than OpenSSL. If you modify file(s) with this
#    exception, you may extend this exception to your version of the file(s),
#    but you are not obligated to do so. If you do not wish to do so, delete
#    this exception statement from your version. If you delete this exception
#    statement from all source files in the program, then also delete it here.
#
#
from deluge.ui.console.main import BaseCommand
from deluge.ui.client import client
import deluge.ui.console.colors as colors
import deluge.component as component

class Command(BaseCommand):
    """Pause a torrent"""
    usage = "Usage: pause [ * | <torrent-id> [<torrent-id> ...] ]"
    def handle(self, *args, **options):
        self.console = component.get("ConsoleUI")

        if len(args) == 0:
            self.console.write(self.usage)
            return
        if len(args) > 0 and args[0].lower() == '*':
            client.core.pause_all_torrents()
            return

        torrent_ids = []
        for arg in args:
            torrent_ids.extend(self.console.match_torrent(arg))

        if torrent_ids:
            return client.core.pause_torrent(torrent_ids)

    def complete(self, line):
        # We use the ConsoleUI torrent tab complete method
        return component.get("ConsoleUI").tab_complete_torrent(line)

# Copyright (c) 2017 MetPy Developers.
# Distributed under the terms of the BSD 3-Clause License.
# SPDX-License-Identifier: BSD-3-Clause
"""
Meteogram
=========

Plots time series data as a meteogram.
"""

import datetime as dt

import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np

from metpy.calc import dewpoint_from_relative_humidity
from metpy.cbook import get_test_data
from metpy.plots import add_metpy_logo
from metpy.units import units


def calc_mslp(t, p, h):
    return p * (1 - (0.0065 * h) / (t + 0.0065 * h + 273.15)) ** (-5.257)


# Make meteogram plot
class Meteogram:
    """ Plot a time series of meteorological data from a particular station as a
    meteogram with standard variables to visualize, including thermodynamic,
    kinematic, and pressure. The functions below control the plotting of each
    variable.
    TO DO: Make the subplot creation dynamic so the number of rows is not
    static as it is currently. """

    def __init__(self, fig, dates, probeid, time=None, axis=0):
        """
        Required input:
            fig: figure object
            dates: array of dates corresponding to the data
            probeid: ID of the station
        Optional Input:
            time: Time the data is to be plotted
            axis: number that controls the new axis to be plotted (FOR FUTURE)
        """
        if not time:
            time = dt.datetime.utcnow()
        self.start = dates[0]
        self.fig = fig
        self.end = dates[-1]
        self.axis_num = 0
        self.dates = mpl.dates.date2num(dates)
        self.time = time.strftime('%Y-%m-%d %H:%M UTC')
        self.title = f'Latest Ob Time: {self.time}\nProbe ID: {probeid}'

    def plot_winds(self, ws, wd, wsmax, plot_range=None):
        """
        Required input:
            ws: Wind speeds (knots)
            wd: Wind direction (degrees)
            wsmax: Wind gust (knots)
        Optional Input:
            plot_range: Data range for making figure (list of (min,max,step))
        """
        # PLOT WIND SPEED AND WIND DIRECTION
        self.ax1 = fig.add_subplot(4, 1, 1)
        ln1 = self.ax1.plot(self.dates, ws, label='Wind Speed')
        self.ax1.fill_between(self.dates, ws, 0)
        self.ax1.set_xlim(self.start, self.end)
        if not plot_range:
            plot_range = [0, 20, 1]
        self.ax1.set_ylabel('Wind Speed (knots)', multialignment='center')
        self.ax1.set_ylim(plot_range[0], plot_range[1], plot_range[2])
        self.ax1.grid(b=True, which='major', axis='y', color='k', linestyle='--',
                      linewidth=0.5)
        ln2 = self.ax1.plot(self.dates, wsmax, '.r', label='3-sec Wind Speed Max')

        ax7 = self.ax1.twinx()
        ln3 = ax7.plot(self.dates, wd, '.k', linewidth=0.5, label='Wind Direction')
        ax7.set_ylabel('Wind\nDirection\n(degrees)', multialignment='center')
        ax7.set_ylim(0, 360)
        ax7.set_yticks(np.arange(45, 405, 90))
        ax7.set_yticklabels(['NE', 'SE', 'SW', 'NW'])
        lines = ln1 + ln2 + ln3
        labs = [line.get_label() for line in lines]
        ax7.xaxis.set_major_formatter(mpl.dates.DateFormatter('%d/%H UTC'))
        ax7.legend(lines, labs, loc='upper center',
                   bbox_to_anchor=(0.5, 1.2), ncol=3, prop={'size': 12})

    def plot_thermo(self, t, td, plot_range=None):
        """
        Required input:
            T: Temperature (deg F)
            TD: Dewpoint (deg F)
        Optional Input:
            plot_range: Data range for making figure (list of (min,max,step))
        """
        # PLOT TEMPERATURE AND DEWPOINT
        if not plot_range:
            plot_range = [10, 90, 2]
        self.ax2 = fig.add_subplot(4, 1, 2, sharex=self.ax1)
        ln4 = self.ax2.plot(self.dates, t, 'r-', label='Temperature')
        self.ax2.fill_between(self.dates, t, td, color='r')

        self.ax2.set_ylabel('Temperature\n(F)', multialignment='center')
        self.ax2.grid(b=True, which='major', axis='y', color='k', linestyle='--',
                      linewidth=0.5)
        self.ax2.set_ylim(plot_range[0], plot_range[1], plot_range[2])

        ln5 = self.ax2.plot(self.dates, td, 'g-', label='Dewpoint')
        self.ax2.fill_between(self.dates, td, self.ax2.get_ylim()[0], color='g')

        ax_twin = self.ax2.twinx()
        ax_twin.set_ylim(plot_range[0], plot_range[1], plot_range[2])
        lines = ln4 + ln5
        labs = [line.get_label() for line in lines]
        ax_twin.xaxis.set_major_formatter(mpl.dates.DateFormatter('%d/%H UTC'))

        self.ax2.legend(lines, labs, loc='upper center',
                        bbox_to_anchor=(0.5, 1.2), ncol=2, prop={'size': 12})

    def plot_rh(self, rh, plot_range=None):
        """
        Required input:
            RH: Relative humidity (%)
        Optional Input:
            plot_range: Data range for making figure (list of (min,max,step))
        """
        # PLOT RELATIVE HUMIDITY
        if not plot_range:
            plot_range = [0, 100, 4]
        self.ax3 = fig.add_subplot(4, 1, 3, sharex=self.ax1)
        self.ax3.plot(self.dates, rh, 'g-', label='Relative Humidity')
        self.ax3.legend(loc='upper center', bbox_to_anchor=(0.5, 1.22), prop={'size': 12})
        self.ax3.grid(b=True, which='major', axis='y', color='k', linestyle='--',
                      linewidth=0.5)
        self.ax3.set_ylim(plot_range[0], plot_range[1], plot_range[2])

        self.ax3.fill_between(self.dates, rh, self.ax3.get_ylim()[0], color='g')
        self.ax3.set_ylabel('Relative Humidity\n(%)', multialignment='center')
        self.ax3.xaxis.set_major_formatter(mpl.dates.DateFormatter('%d/%H UTC'))
        axtwin = self.ax3.twinx()
        axtwin.set_ylim(plot_range[0], plot_range[1], plot_range[2])

    def plot_pressure(self, p, plot_range=None):
        """
        Required input:
            P: Mean Sea Level Pressure (hPa)
        Optional Input:
            plot_range: Data range for making figure (list of (min,max,step))
        """
        # PLOT PRESSURE
        if not plot_range:
            plot_range = [970, 1030, 2]
        self.ax4 = fig.add_subplot(4, 1, 4, sharex=self.ax1)
        self.ax4.plot(self.dates, p, 'm', label='Mean Sea Level Pressure')
        self.ax4.set_ylabel('Mean Sea\nLevel Pressure\n(mb)', multialignment='center')
        self.ax4.set_ylim(plot_range[0], plot_range[1], plot_range[2])

        axtwin = self.ax4.twinx()
        axtwin.set_ylim(plot_range[0], plot_range[1], plot_range[2])
        axtwin.fill_between(self.dates, p, axtwin.get_ylim()[0], color='m')
        axtwin.xaxis.set_major_formatter(mpl.dates.DateFormatter('%d/%H UTC'))

        self.ax4.legend(loc='upper center', bbox_to_anchor=(0.5, 1.2), prop={'size': 12})
        self.ax4.grid(b=True, which='major', axis='y', color='k', linestyle='--',
                      linewidth=0.5)
        # OTHER OPTIONAL AXES TO PLOT
        # plot_irradiance
        # plot_precipitation


# set the starttime and endtime for plotting, 24 hour range
endtime = dt.datetime(2016, 3, 31, 22, 0, 0, 0)
starttime = endtime - dt.timedelta(hours=24)

# Height of the station to calculate MSLP
hgt_example = 292.


# Parse dates from .csv file, knowing their format as a string and convert to datetime
def parse_date(date):
    return dt.datetime.strptime(date.decode('ascii'), '%Y-%m-%d %H:%M:%S')


testdata = np.genfromtxt(get_test_data('timeseries.csv', False), names=True, dtype=None,
                         usecols=list(range(1, 8)),
                         converters={'DATE': parse_date}, delimiter=',')

# Temporary variables for ease
temp = testdata['T']
pres = testdata['P']
rh = testdata['RH']
ws = testdata['WS']
wsmax = testdata['WSMAX']
wd = testdata['WD']
date = testdata['DATE']

# ID For Plotting on Meteogram
probe_id = '0102A'

data = {'wind_speed': (np.array(ws) * units('m/s')).to(units('knots')),
        'wind_speed_max': (np.array(wsmax) * units('m/s')).to(units('knots')),
        'wind_direction': np.array(wd) * units('degrees'),
        'dewpoint': dewpoint_from_relative_humidity((np.array(temp) * units.degC).to(units.K),
                                                    np.array(rh) / 100.).to(units('degF')),
        'air_temperature': (np.array(temp) * units('degC')).to(units('degF')),
        'mean_slp': calc_mslp(np.array(temp), np.array(pres), hgt_example) * units('hPa'),
        'relative_humidity': np.array(rh), 'times': np.array(date)}

fig = plt.figure(figsize=(20, 16))
add_metpy_logo(fig, 250, 180)
meteogram = Meteogram(fig, data['times'], probe_id)
meteogram.plot_winds(data['wind_speed'], data['wind_direction'], data['wind_speed_max'])
meteogram.plot_thermo(data['air_temperature'], data['dewpoint'])
meteogram.plot_rh(data['relative_humidity'])
meteogram.plot_pressure(data['mean_slp'])
fig.subplots_adjust(hspace=0.5)
plt.show()

#
#    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.

from webob import exc

from senlin.api.common import util
from senlin.api.common import wsgi
from senlin.common import consts
from senlin.common.i18n import _
from senlin.common import utils


class ActionData(object):
    """All required data fields for an action."""

    PARAMS = (consts.ACTION_NAME, consts.ACTION_TARGET, consts.ACTION_ACTION)

    def __init__(self, data):
        self.data = data

    def name(self):
        if consts.ACTION_NAME not in self.data:
            raise exc.HTTPBadRequest(_("No action name specified"))
        return self.data[consts.ACTION_NAME]

    def target(self):
        if consts.ACTION_TARGET not in self.data:
            raise exc.HTTPBadRequest(_("No target specified"))
        return self.data[consts.ACTION_TARGET]

    def action(self):
        if consts.ACTION_ACTION not in self.data:
            raise exc.HTTPBadRequest(_("No action specified"))
        return self.data[consts.ACTION_ACTION]

    def params(self):
        data = self.data.items()
        return dict((k, v) for k, v in data if k not in self.PARAMS)


class ActionController(wsgi.Controller):
    """WSGI controller for Actions in Senlin v1 API."""

    # Define request scope (must match what is in policy.json)
    REQUEST_SCOPE = 'actions'

    @util.policy_enforce
    def index(self, req):
        filter_whitelist = {
            consts.ACTION_NAME: 'mixed',
            consts.ACTION_TARGET: 'mixed',
            consts.ACTION_ACTION: 'mixed',
            consts.ACTION_STATUS: 'mixed',
        }
        param_whitelist = {
            consts.PARAM_LIMIT: 'single',
            consts.PARAM_MARKER: 'single',
            consts.PARAM_SORT: 'single',
            consts.PARAM_GLOBAL_PROJECT: 'single',
        }
        for key in req.params.keys():
            if (key not in param_whitelist.keys() and key not in
                    filter_whitelist.keys()):
                raise exc.HTTPBadRequest(_('Invalid parameter %s') % key)
        params = util.get_allowed_params(req.params, param_whitelist)
        filters = util.get_allowed_params(req.params, filter_whitelist)

        key = consts.PARAM_LIMIT
        if key in params:
            params[key] = utils.parse_int_param(key, params[key])

        key = consts.PARAM_GLOBAL_PROJECT
        if key in params:
            global_project = utils.parse_bool_param(key, params[key])
            params.pop(key)
            params['project_safe'] = not global_project

        if not filters:
            filters = None

        actions = self.rpc_client.action_list(req.context, filters=filters,
                                              **params)

        return {'actions': actions}

    @util.policy_enforce
    def create(self, req, body):
        data = ActionData(body)
        result = self.rpc_client.action_create(req.context,
                                               data.name(),
                                               data.target(),
                                               data.action(),
                                               data.params())

        return result

    @util.policy_enforce
    def get(self, req, action_id):
        action = self.rpc_client.action_get(req.context, action_id)
        if not action:
            raise exc.HTTPNotFound()

        return {'action': action}

"""
A set of request processors that return dictionaries to be merged into a
template context. Each function takes the request object as its only parameter
and returns a dictionary to add to the context.

These are referenced from the setting TEMPLATE_CONTEXT_PROCESSORS and used by
RequestContext.
"""

from django.conf import settings
from django.middleware.csrf import get_token
from django.utils.functional import lazy

def auth(request):
    """
    DEPRECATED. This context processor is the old location, and has been moved
    to `django.contrib.auth.context_processors`.

    This function still exists for backwards-compatibility; it will be removed
    in Django 1.4.
    """
    import warnings
    warnings.warn(
        "The context processor at `django.core.context_processors.auth` is " \
        "deprecated; use the path `django.contrib.auth.context_processors.auth` " \
        "instead.",
        PendingDeprecationWarning
    )
    from django.contrib.auth.context_processors import auth as auth_context_processor
    return auth_context_processor(request)

def csrf(request):
    """
    Context processor that provides a CSRF token, or the string 'NOTPROVIDED' if
    it has not been provided by either a view decorator or the middleware
    """
    def _get_val():
        token = get_token(request)
        if token is None:
            # In order to be able to provide debugging info in the
            # case of misconfiguration, we use a sentinel value
            # instead of returning an empty dict.
            return 'NOTPROVIDED'
        else:
            return token
    _get_val = lazy(_get_val, str)

    return {'csrf_token': _get_val() }

def debug(request):
    "Returns context variables helpful for debugging."
    context_extras = {}
    if settings.DEBUG and request.META.get('REMOTE_ADDR') in settings.INTERNAL_IPS:
        context_extras['debug'] = True
        from django.db import connection
        context_extras['sql_queries'] = connection.queries
    return context_extras

def i18n(request):
    from django.utils import translation

    context_extras = {}
    context_extras['LANGUAGES'] = settings.LANGUAGES
    context_extras['LANGUAGE_CODE'] = translation.get_language()
    context_extras['LANGUAGE_BIDI'] = translation.get_language_bidi()

    return context_extras

def media(request):
    """
    Adds media-related context variables to the context.

    """
    return {'MEDIA_URL': settings.MEDIA_URL}

def request(request):
    return {'request': request}

# PermWrapper and PermLookupDict proxy the permissions system into objects that
# the template system can understand.

class PermLookupDict(object):
    def __init__(self, user, module_name):
        self.user, self.module_name = user, module_name

    def __repr__(self):
        return str(self.user.get_all_permissions())

    def __getitem__(self, perm_name):
        return self.user.has_perm("%s.%s" % (self.module_name, perm_name))

    def __nonzero__(self):
        return self.user.has_module_perms(self.module_name)

class PermWrapper(object):
    def __init__(self, user):
        self.user = user

    def __getitem__(self, module_name):
        return PermLookupDict(self.user, module_name)

    def __iter__(self):
        # I am large, I contain multitudes.
        raise TypeError("PermWrapper is not iterable.")

# Generated by h2py from /usr/include/netinet/in.h

# Included from net/nh.h

# Included from sys/machine.h
LITTLE_ENDIAN = 1234
BIG_ENDIAN = 4321
PDP_ENDIAN = 3412
BYTE_ORDER = BIG_ENDIAN
DEFAULT_GPR = 0xDEADBEEF
MSR_EE = 0x8000
MSR_PR = 0x4000
MSR_FP = 0x2000
MSR_ME = 0x1000
MSR_FE = 0x0800
MSR_FE0 = 0x0800
MSR_SE = 0x0400
MSR_BE = 0x0200
MSR_IE = 0x0100
MSR_FE1 = 0x0100
MSR_AL = 0x0080
MSR_IP = 0x0040
MSR_IR = 0x0020
MSR_DR = 0x0010
MSR_PM = 0x0004
DEFAULT_MSR = (MSR_EE | MSR_ME | MSR_AL | MSR_IR | MSR_DR)
DEFAULT_USER_MSR = (DEFAULT_MSR | MSR_PR)
CR_LT = 0x80000000
CR_GT = 0x40000000
CR_EQ = 0x20000000
CR_SO = 0x10000000
CR_FX = 0x08000000
CR_FEX = 0x04000000
CR_VX = 0x02000000
CR_OX = 0x01000000
XER_SO = 0x80000000
XER_OV = 0x40000000
XER_CA = 0x20000000
def XER_COMP_BYTE(xer): return ((xer >> 8) & 0x000000FF)

def XER_LENGTH(xer): return (xer & 0x0000007F)

DSISR_IO = 0x80000000
DSISR_PFT = 0x40000000
DSISR_LOCK = 0x20000000
DSISR_FPIO = 0x10000000
DSISR_PROT = 0x08000000
DSISR_LOOP = 0x04000000
DSISR_DRST = 0x04000000
DSISR_ST = 0x02000000
DSISR_SEGB = 0x01000000
DSISR_DABR = 0x00400000
DSISR_EAR = 0x00100000
SRR_IS_PFT = 0x40000000
SRR_IS_ISPEC = 0x20000000
SRR_IS_IIO = 0x10000000
SRR_IS_GUARD = 0x10000000
SRR_IS_PROT = 0x08000000
SRR_IS_LOOP = 0x04000000
SRR_PR_FPEN = 0x00100000
SRR_PR_INVAL = 0x00080000
SRR_PR_PRIV = 0x00040000
SRR_PR_TRAP = 0x00020000
SRR_PR_IMPRE = 0x00010000
def BUID_7F_SRVAL(raddr): return (0x87F00000 | (((uint)(raddr)) >> 28))

BT_256M = 0x1FFC
BT_128M = 0x0FFC
BT_64M = 0x07FC
BT_32M = 0x03FC
BT_16M = 0x01FC
BT_8M = 0x00FC
BT_4M = 0x007C
BT_2M = 0x003C
BT_1M = 0x001C
BT_512K = 0x000C
BT_256K = 0x0004
BT_128K = 0x0000
BT_NOACCESS = 0x0
BT_RDONLY = 0x1
BT_WRITE = 0x2
BT_VS = 0x2
BT_VP = 0x1
def BAT_ESEG(dbatu): return (((uint)(dbatu) >> 28))

MIN_BAT_SIZE = 0x00020000
MAX_BAT_SIZE = 0x10000000
def ntohl(x): return (x)

def ntohs(x): return (x)

def htonl(x): return (x)

def htons(x): return (x)

IPPROTO_IP = 0
IPPROTO_ICMP = 1
IPPROTO_IGMP = 2
IPPROTO_GGP = 3
IPPROTO_TCP = 6
IPPROTO_EGP = 8
IPPROTO_PUP = 12
IPPROTO_UDP = 17
IPPROTO_IDP = 22
IPPROTO_TP = 29
IPPROTO_LOCAL = 63
IPPROTO_EON = 80
IPPROTO_BIP = 0x53
IPPROTO_RAW = 255
IPPROTO_MAX = 256
IPPORT_RESERVED = 1024
IPPORT_USERRESERVED = 5000
IPPORT_TIMESERVER = 37
def IN_CLASSA(i): return (((int)(i) & 0x80000000) == 0)

IN_CLASSA_NET = 0xff000000
IN_CLASSA_NSHIFT = 24
IN_CLASSA_HOST = 0x00ffffff
IN_CLASSA_MAX = 128
def IN_CLASSB(i): return (((int)(i) & 0xc0000000) == 0x80000000)

IN_CLASSB_NET = 0xffff0000
IN_CLASSB_NSHIFT = 16
IN_CLASSB_HOST = 0x0000ffff
IN_CLASSB_MAX = 65536
def IN_CLASSC(i): return (((int)(i) & 0xe0000000) == 0xc0000000)

IN_CLASSC_NET = 0xffffff00
IN_CLASSC_NSHIFT = 8
IN_CLASSC_HOST = 0x000000ff
def IN_CLASSD(i): return (((int)(i) & 0xf0000000) == 0xe0000000)

def IN_MULTICAST(i): return IN_CLASSD(i)

IN_CLASSD_NET = 0xf0000000
IN_CLASSD_NSHIFT = 28
IN_CLASSD_HOST = 0x0fffffff
INADDR_UNSPEC_GROUP = 0xe0000000
INADDR_ALLHOSTS_GROUP = 0xe0000001
INADDR_MAX_LOCAL_GROUP = 0xe00000ff
def IN_EXPERIMENTAL(i): return (((int)(i) & 0xe0000000) == 0xe0000000)

def IN_BADCLASS(i): return (((int)(i) & 0xf0000000) == 0xf0000000)

INADDR_ANY = 0x00000000
INADDR_BROADCAST = 0xffffffff
INADDR_LOOPBACK = 0x7f000001
INADDR_NONE = 0xffffffff
IN_LOOPBACKNET = 127
IP_OPTIONS = 1
IP_HDRINCL = 2
IP_TOS = 3
IP_TTL = 4
IP_RECVOPTS = 5
IP_RECVRETOPTS = 6
IP_RECVDSTADDR = 7
IP_RETOPTS = 8
IP_MULTICAST_IF = 9
IP_MULTICAST_TTL = 10
IP_MULTICAST_LOOP = 11
IP_ADD_MEMBERSHIP = 12
IP_DROP_MEMBERSHIP = 13
IP_DEFAULT_MULTICAST_TTL = 1
IP_DEFAULT_MULTICAST_LOOP = 1
IP_MAX_MEMBERSHIPS = 20

import os
from PIL import Image #Requires pillow
import time
#import json
import shutil #Requires shutil
import simplejson
from decimal import Decimal
#python 3 


path = 'textures' #E.G The name of a folder everything is in Just set it to bypass  The Manual input
if not path: 
    path = input('''The name of the folder with the DMI textures in.
Plonk name of folder here >> ''')


isto = input(''' What is the current value of  textureFormat: just put int value ''')
setto = input(''' textureFormat: Set what value just put int value ''')



start_time = time.time()

AID = 0
Name_store = set([])
    
for root, dirs, files in os.walk(path):
    print(root)
    for name in files:
        if ".png.meta" in name:
            #if name in Name_store:
            metaFilePath = os.path.join(root, (name))
            with open(metaFilePath, "r+") as RmetaFile:
                Data = RmetaFile.read()
                RmetaFile.close()
            metaFile = open(metaFilePath,"w+")
            metaFile.write(Data.replace('textureFormat: '+ isto,"textureFormat: "+ setto))
            metaFile.close()
            AID = AID + 1

            
        

print(AID, " Files")

print("--- %s seconds ---" % (time.time() - start_time)) #Total time



#    Copyright 2014-2018 ARM Limited
#
# 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.
#


import os

from wa import Instrument, Parameter
from wa.framework.exception import InstrumentError
from wa.framework.instrument import slow
from wa.utils.misc import ensure_file_directory_exists as _f


class DmesgInstrument(Instrument):
    # pylint: disable=no-member,attribute-defined-outside-init
    """
    Collected dmesg output before and during the run.

    """

    name = 'dmesg'

    parameters = [
        Parameter('loglevel', kind=int, allowed_values=list(range(8)),
                  description='Set loglevel for console output.')
    ]

    loglevel_file = '/proc/sys/kernel/printk'

    def initialize(self, context):  # pylint: disable=unused-argument
        self.need_root = self.target.os == 'android'
        if self.need_root and not self.target.is_rooted:
            raise InstrumentError('Need root to collect dmesg on Android')

    def setup(self, context):
        if self.loglevel:
            self.old_loglevel = self.target.read_int(self.loglevel_file)
            self.target.write_value(self.loglevel_file, self.loglevel, verify=False)
        self.before_file = _f(os.path.join(context.output_directory, 'dmesg', 'before'))
        self.after_file = _f(os.path.join(context.output_directory, 'dmesg', 'after'))

    @slow
    def start(self, context):
        with open(self.before_file, 'w') as wfh:
            wfh.write(self.target.execute('dmesg', as_root=self.need_root))
        context.add_artifact('dmesg_before', self.before_file, kind='data')
        if self.target.is_rooted:
            self.target.execute('dmesg -c', as_root=True)

    @slow
    def stop(self, context):
        with open(self.after_file, 'w') as wfh:
            wfh.write(self.target.execute('dmesg', as_root=self.need_root))
        context.add_artifact('dmesg_after', self.after_file, kind='data')

    def teardown(self, context):  # pylint: disable=unused-argument
        if self.loglevel:
            self.target.write_value(self.loglevel_file, self.old_loglevel, verify=False)

from dtest import Tester
from assertions import *

import re
from ccmlib.cluster import Cluster
import ast

class TestConfiguration(Tester):

    def compression_chunk_length_test(self):
        """ Verify the setting of compression chunk_length [#3558]"""
        cluster = self.cluster

        cluster.populate(1).start()
        node = cluster.nodelist()[0]
        cursor = self.patient_cql_connection(node).cursor()
        self.create_ks(cursor, 'ks', 1)

        create_table_query = "CREATE TABLE test_table (row varchar, name varchar, value int, PRIMARY KEY (row, name));"
        alter_chunk_len_query = "ALTER TABLE test_table WITH compression = {{'sstable_compression' : 'SnappyCompressor', 'chunk_length_kb' : {chunk_length}}};"

        cursor.execute( create_table_query, 1 )

        cursor.execute( alter_chunk_len_query.format(chunk_length=32) )
        self._check_chunk_length( cursor, 32 )

        cursor.execute( alter_chunk_len_query.format(chunk_length=64) )
        self._check_chunk_length( cursor, 64 )

        
    def _check_chunk_length(self, cursor, value):
        describe_table_query = "SELECT * FROM system.schema_columnfamilies WHERE keyspace_name='ks' AND columnfamily_name='test_table';"
        cursor.execute( describe_table_query )
        results = cursor.fetchall()[0]
        #Now extract the param list
        params = ''
        for result in results:
            if 'sstable_compression' in str(result):
                params = result

        assert params is not '', "Looking for a row with the string 'sstable_compression' in system.schema_columnfamilies, but could not find it."

        params = ast.literal_eval( params )
        chunk_length = int( params['chunk_length_kb'] )

        assert chunk_length == value, "Expected chunk_length: %s.  We got: %s" % (value, chunk_length)

# coding=utf-8
"""Accesses data in Sacred's MongoDB."""
import pymongo

from sacredboard.app.data.datastorage import Cursor, DataStorage
from sacredboard.app.data.pymongo import GenericDAO, MongoMetricsDAO, MongoFilesDAO
from sacredboard.app.data.pymongo.rundao import MongoRunDAO


class MongoDbCursor(Cursor):
    """Implements Cursor for mongodb."""

    def __init__(self, mongodb_cursor):
        """Initialize a MongoDB cursor."""
        self.mongodb_cursor = mongodb_cursor

    def count(self):
        """Return the number of items in this cursor."""
        return self.mongodb_cursor.count()

    def __iter__(self):
        """Iterate over runs."""
        return self.mongodb_cursor


class PyMongoDataAccess(DataStorage):
    """Access records in MongoDB."""

    def __init__(self, uri, database_name, collection_name):
        """
        Set up MongoDB access layer, don't connect yet.

        Better use the static methods build_data_access
        or build_data_access_with_uri
        """
        super().__init__()
        self._uri = uri
        self._db_name = database_name
        self._client = None
        self._db = None
        self._collection_name = collection_name
        self._generic_dao = None

    def connect(self):
        """Initialize the database connection."""
        self._client = self._create_client()
        self._db = getattr(self._client, self._db_name)
        self._generic_dao = GenericDAO(self._client, self._db_name)

    def _create_client(self):
        """Return a new Mongo Client."""
        return pymongo.MongoClient(host=self._uri)

    @staticmethod
    def build_data_access(host, port, database_name, collection_name):
        """
        Create data access gateway.

        :param host: The database server to connect to.
        :type host: str
        :param port: Database port.
        :type port: int
        :param database_name: Database name.
        :type database_name: str
        :param collection_name: Name of the collection with Sacred runs.
        :type collection_name: str
        """
        return PyMongoDataAccess("mongodb://%s:%d" % (host, port),
                                 database_name, collection_name)

    @staticmethod
    def build_data_access_with_uri(uri, database_name, collection_name):
        """
        Create data access gateway given a MongoDB URI.

        :param uri: Connection string as defined in
                https://docs.mongodb.com/manual/reference/connection-string/
        :type uri: str
        :param database_name: Database name
        :type database_name: str
        :param collection_name: Name of the collection
        where Sacred stores its runs
        :type collection_name: str
        """
        return PyMongoDataAccess(uri, database_name, collection_name)

    def get_metrics_dao(self):
        """
        Return a data access object for metrics.

        The method can be called only after a connection to DB is established.
        Issue: https://github.com/chovanecm/sacredboard/issues/62

        :return MetricsDAO
        """
        return MongoMetricsDAO(self._generic_dao)

    def get_run_dao(self):
        """
        Return a data access object for Runs.

        :return: RunDAO
        """
        return MongoRunDAO(self._generic_dao, self._collection_name)

    def get_files_dao(self):
        """
        Return a data access object for Files.

        :return: RunDAO
        """
        return MongoFilesDAO(self._generic_dao)

"""Shared utilities for different supported platforms."""
import asyncio
from datetime import datetime, timedelta
import logging

import aiohttp
import async_timeout
from buienradar.buienradar import parse_data
from buienradar.constants import (
    ATTRIBUTION,
    CONDITION,
    CONTENT,
    DATA,
    FORECAST,
    HUMIDITY,
    MESSAGE,
    PRESSURE,
    STATIONNAME,
    STATUS_CODE,
    SUCCESS,
    TEMPERATURE,
    VISIBILITY,
    WINDAZIMUTH,
    WINDSPEED,
)
from buienradar.urls import JSON_FEED_URL, json_precipitation_forecast_url

from homeassistant.const import CONF_LATITUDE, CONF_LONGITUDE, HTTP_OK
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.helpers.event import async_track_point_in_utc_time
from homeassistant.util import dt as dt_util

from .const import SCHEDULE_NOK, SCHEDULE_OK

__all__ = ["BrData"]
_LOGGER = logging.getLogger(__name__)

"""
Log at WARN level after WARN_THRESHOLD failures, otherwise log at
DEBUG level.
"""
WARN_THRESHOLD = 4


def threshold_log(count: int, *args, **kwargs) -> None:
    """Log at warn level after WARN_THRESHOLD failures, debug otherwise."""
    if count >= WARN_THRESHOLD:
        _LOGGER.warning(*args, **kwargs)
    else:
        _LOGGER.debug(*args, **kwargs)


class BrData:
    """Get the latest data and updates the states."""

    # Initialize to warn immediately if the first call fails.
    load_error_count: int = WARN_THRESHOLD
    rain_error_count: int = WARN_THRESHOLD

    def __init__(self, hass, coordinates, timeframe, devices):
        """Initialize the data object."""
        self.devices = devices
        self.data = {}
        self.hass = hass
        self.coordinates = coordinates
        self.timeframe = timeframe

    async def update_devices(self):
        """Update all devices/sensors."""
        if not self.devices:
            return

        # Update all devices
        for dev in self.devices:
            dev.data_updated(self.data)

    async def schedule_update(self, minute=1):
        """Schedule an update after minute minutes."""
        _LOGGER.debug("Scheduling next update in %s minutes", minute)
        nxt = dt_util.utcnow() + timedelta(minutes=minute)
        async_track_point_in_utc_time(self.hass, self.async_update, nxt)

    async def get_data(self, url):
        """Load data from specified url."""
        _LOGGER.debug("Calling url: %s...", url)
        result = {SUCCESS: False, MESSAGE: None}
        resp = None
        try:
            websession = async_get_clientsession(self.hass)
            with async_timeout.timeout(10):
                resp = await websession.get(url)

                result[STATUS_CODE] = resp.status
                result[CONTENT] = await resp.text()
                if resp.status == HTTP_OK:
                    result[SUCCESS] = True
                else:
                    result[MESSAGE] = "Got http statuscode: %d" % (resp.status)

                return result
        except (asyncio.TimeoutError, aiohttp.ClientError) as err:
            result[MESSAGE] = "%s" % err
            return result
        finally:
            if resp is not None:
                await resp.release()

    async def async_update(self, *_):
        """Update the data from buienradar."""
        content = await self.get_data(JSON_FEED_URL)

        if content.get(SUCCESS) is not True:
            # unable to get the data
            self.load_error_count += 1
            threshold_log(
                self.load_error_count,
                "Unable to retrieve json data from Buienradar" "(Msg: %s, status: %s,)",
                content.get(MESSAGE),
                content.get(STATUS_CODE),
            )
            # schedule new call
            await self.schedule_update(SCHEDULE_NOK)
            return
        self.load_error_count = 0

        # rounding coordinates prevents unnecessary redirects/calls
        lat = self.coordinates[CONF_LATITUDE]
        lon = self.coordinates[CONF_LONGITUDE]
        rainurl = json_precipitation_forecast_url(lat, lon)
        raincontent = await self.get_data(rainurl)

        if raincontent.get(SUCCESS) is not True:
            self.rain_error_count += 1
            # unable to get the data
            threshold_log(
                self.rain_error_count,
                "Unable to retrieve rain data from Buienradar" "(Msg: %s, status: %s)",
                raincontent.get(MESSAGE),
                raincontent.get(STATUS_CODE),
            )
            # schedule new call
            await self.schedule_update(SCHEDULE_NOK)
            return
        self.rain_error_count = 0

        result = parse_data(
            content.get(CONTENT),
            raincontent.get(CONTENT),
            self.coordinates[CONF_LATITUDE],
            self.coordinates[CONF_LONGITUDE],
            self.timeframe,
            False,
        )

        _LOGGER.debug("Buienradar parsed data: %s", result)
        if result.get(SUCCESS) is not True:
            if int(datetime.now().strftime("%H")) > 0:
                _LOGGER.warning(
                    "Unable to parse data from Buienradar. (Msg: %s)",
                    result.get(MESSAGE),
                )
            await self.schedule_update(SCHEDULE_NOK)
            return

        self.data = result.get(DATA)
        await self.update_devices()
        await self.schedule_update(SCHEDULE_OK)

    @property
    def attribution(self):
        """Return the attribution."""
        return self.data.get(ATTRIBUTION)

    @property
    def stationname(self):
        """Return the name of the selected weatherstation."""
        return self.data.get(STATIONNAME)

    @property
    def condition(self):
        """Return the condition."""
        return self.data.get(CONDITION)

    @property
    def temperature(self):
        """Return the temperature, or None."""
        try:
            return float(self.data.get(TEMPERATURE))
        except (ValueError, TypeError):
            return None

    @property
    def pressure(self):
        """Return the pressure, or None."""
        try:
            return float(self.data.get(PRESSURE))
        except (ValueError, TypeError):
            return None

    @property
    def humidity(self):
        """Return the humidity, or None."""
        try:
            return int(self.data.get(HUMIDITY))
        except (ValueError, TypeError):
            return None

    @property
    def visibility(self):
        """Return the visibility, or None."""
        try:
            return int(self.data.get(VISIBILITY))
        except (ValueError, TypeError):
            return None

    @property
    def wind_speed(self):
        """Return the windspeed, or None."""
        try:
            return float(self.data.get(WINDSPEED))
        except (ValueError, TypeError):
            return None

    @property
    def wind_bearing(self):
        """Return the wind bearing, or None."""
        try:
            return int(self.data.get(WINDAZIMUTH))
        except (ValueError, TypeError):
            return None

    @property
    def forecast(self):
        """Return the forecast data."""
        return self.data.get(FORECAST)

#
# (c) 2016 Red Hat Inc.
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

DOCUMENTATION = """
---
cliconf: netvisor
short_description: Use netvisor cliconf to run command on Pluribus netvisor platform
description:
  - This netvisor plugin provides low level abstraction apis for
    sending and receiving CLI commands from Pluribus netvisor devices.
version_added: 2.8
"""

import json
from ansible.plugins.cliconf import CliconfBase


class Cliconf(CliconfBase):

    def get(self, command=None, prompt=None, answer=None, sendonly=False, output=None, newline=True, check_all=False):
        if not command:
            raise ValueError('must provide value of command to execute')
        if output:
            raise ValueError("'output' value %s is not supported for get" % output)

        return self.send_command(command=command, prompt=prompt, answer=answer, sendonly=sendonly, newline=newline, check_all=check_all)

    def get_option_values(self):
        return {
            'format': ['text'],
            'diff_match': ['line', 'strict', 'exact', 'none'],
            'diff_replace': ['line', 'block'],
            'output': []
        }

    def get_capabilities(self):
        result = dict()
        result['rpc'] = self.get_base_rpc()
        result['network_api'] = 'cliconf'
        result['device_info'] = self.get_device_info()
        result.update(self.get_option_values())
        return json.dumps(result)

    def get_device_info(self):
        device_info = {}
        device_info['network_os'] = 'netvisor'

        return device_info

# Copyright (c) 2001-2004 Twisted Matrix Laboratories.
# See LICENSE for details.


"""
Maintainer: Jp Calderone
"""

from twisted.news import nntp
from twisted.internet import protocol, reactor

import time

class NNTPFactory(protocol.ServerFactory):
    """A factory for NNTP server protocols."""
    
    protocol = nntp.NNTPServer
    
    def __init__(self, backend):
        self.backend = backend
    
    def buildProtocol(self, connection):
        p = self.protocol()
        p.factory = self
        return p


class UsenetClientFactory(protocol.ClientFactory):
    def __init__(self, groups, storage):
        self.lastChecks = {}
        self.groups = groups
        self.storage = storage


    def clientConnectionLost(self, connector, reason):
        pass


    def clientConnectionFailed(self, connector, reason):
        print 'Connection failed: ', reason
    
    
    def updateChecks(self, addr):
        self.lastChecks[addr] = time.mktime(time.gmtime())


    def buildProtocol(self, addr):
        last = self.lastChecks.setdefault(addr, time.mktime(time.gmtime()) - (60 * 60 * 24 * 7))
        p = nntp.UsenetClientProtocol(self.groups, last, self.storage)
        p.factory = self
        return p


# XXX - Maybe this inheritence doesn't make so much sense?
class UsenetServerFactory(NNTPFactory):
    """A factory for NNTP Usenet server protocols."""

    protocol = nntp.NNTPServer

    def __init__(self, backend, remoteHosts = None, updatePeriod = 60):
        NNTPFactory.__init__(self, backend)
        self.updatePeriod = updatePeriod
        self.remoteHosts = remoteHosts or []
        self.clientFactory = UsenetClientFactory(self.remoteHosts, self.backend)


    def startFactory(self):
        self._updateCall = reactor.callLater(0, self.syncWithRemotes)


    def stopFactory(self):
        if self._updateCall:
            self._updateCall.cancel()
            self._updateCall = None


    def buildProtocol(self, connection):
        p = self.protocol()
        p.factory = self
        return p


    def syncWithRemotes(self):
        for remote in self.remoteHosts:
            reactor.connectTCP(remote, 119, self.clientFactory)
        self._updateCall = reactor.callLater(self.updatePeriod, self.syncWithRemotes)


# backwards compatability
Factory = UsenetServerFactory

from django.conf.urls import patterns, include, url
from django.views.generic import RedirectView
from django.views.generic.base import TemplateView

# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()

urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'smkcpanel.views.home', name='home'),
    # url(r'^smkcpanel/', include('smkcpanel.foo.urls')),

    # Uncomment the admin/doc line below to enable admin documentation:
    # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),

    # Uncomment the next line to enable the admin:
    # url(r'^admin/', include(admin.site.urls)),
    url(r'^$', RedirectView.as_view(url='/server/')),
    url(r'server', include('smkcpanel.dashboard.urls')),

    url(r'^accounts/login/$', 'django.contrib.auth.views.login'),
    url(r'^accounts/logout/$', 'django.contrib.auth.views.logout'),
	#url('^accounts/', include('django.contrib.auth.urls')),
    #url(r'^accounts/', include('smkcpanel.allauth.urls')),
    #url(r'^accounts/profile/$', TemplateView.as_view(template_name='allauth/plain/example/profile.html')),
)

# -*- coding: utf-8 -*-
#
# Eliot documentation build configuration file, created by
# sphinx-quickstart on Mon Apr 14 12:04:03 2014.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.

import sys
import os

# Make sure local eliot is used when importing:
sys.path.insert(0, os.path.abspath(os.path.join('..', '..')))

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))

# -- General configuration ------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'

# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = []

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix of source filenames.
source_suffix = '.rst'

# The encoding of source files.
#source_encoding = 'utf-8-sig'

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = u'Eliot'
copyright = u'2014-2015, ClusterHQ'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
import eliot
version = eliot.__version__
# Versioneer adds .dirty suffix to version if checkout is dirty, and
# therefore ReadTheDocs somehow ends up with this in its version, so strip
# it out.
if version.endswith(".dirty"):
    version = version[:-len(".dirty")]
# The full version, including alpha/beta/rc tags.
release = version

# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None

# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = []

# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None

# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True

# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True

# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'

# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []

# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False


# -- Options for HTML output ----------------------------------------------

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
html_theme = 'default'

# Theme options are theme-specific and customize the look and feel of a theme
# further.  For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}

# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []

# The name for this set of Sphinx documents.  If None, it defaults to
# "<project> v<release> documentation".
#html_title = None

# A shorter title for the navigation bar.  Default is the same as html_title.
#html_short_title = None

# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None

# The name of an image file (within the static path) to use as favicon of the
# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None

# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']

# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []

# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'

# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True

# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}

# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}

# If false, no module index is generated.
#html_domain_indices = True

# If false, no index is generated.
#html_use_index = True

# If true, the index is split into individual pages for each letter.
#html_split_index = False

# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True

# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True

# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True

# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it.  The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''

# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None

# Output file base name for HTML help builder.
htmlhelp_basename = 'Eliotdoc'


# -- Options for LaTeX output ---------------------------------------------

latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',

# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',

# Additional stuff for the LaTeX preamble.
#'preamble': '',
}

# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
#  author, documentclass [howto, manual, or own class]).
latex_documents = [
  ('index', 'Eliot.tex', u'Eliot Documentation',
   u'ClusterHQ', 'manual'),
]

# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None

# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False

# If true, show page references after internal links.
#latex_show_pagerefs = False

# If true, show URL addresses after external links.
#latex_show_urls = False

# Documents to append as an appendix to all manuals.
#latex_appendices = []

# If false, no module index is generated.
#latex_domain_indices = True


# -- Options for manual page output ---------------------------------------

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
    ('index', 'eliot', u'Eliot Documentation',
     [u'ClusterHQ'], 1)
]

# If true, show URL addresses after external links.
#man_show_urls = False


# -- Options for Texinfo output -------------------------------------------

# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
#  dir menu entry, description, category)
texinfo_documents = [
  ('index', 'Eliot', u'Eliot Documentation',
   u'ClusterHQ', 'Eliot', 'One line description of project.',
   'Miscellaneous'),
]

# Documents to append as an appendix to all manuals.
#texinfo_appendices = []

# If false, no module index is generated.
#texinfo_domain_indices = True

# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'

# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False


class MockLambdaContext(object):
    aws_request_id = 'a3de505e-f16b-42f4-b3e6-bcd2e4a73903'
    log_stream_name = '2015/10/26/[$LATEST]c71058d852474b9895a0f221f73402ad'
    invoked_function_arn = 'arn:aws:lambda:us-west-2:123456789012:function:ExampleCloudFormationStackName-ExampleLambdaFunctionResourceName-AULC3LB8Q02F'
    client_context = None
    log_group_name = '/aws/lambda/ExampleCloudFormationStackName-ExampleLambdaFunctionResourceName-AULC3LB8Q02F'
    function_name = 'ExampleCloudFormationStackName-ExampleLambdaFunctionResourceName-AULC3LB8Q02F'
    function_version = '$LATEST'
    identity = {}
    memory_limit_in_mb = 128

    def get_remaining_time_in_millis(self):
        v = int(10000)
        print(type(v))
        return v


class MockLambdaEvents(object):
    cloudformation_creation = {
        "StackId": "arn:aws:cloudformation:us-west-2:EXAMPLE/stack-name/guid",
        "ResponseURL": "http://pre-signed-S3-url-for-response",
        "ResourceProperties": {
            "StackName": "stack-name",
            "List": [
                "1",
                "2",
                "3"
            ]
        },
        "RequestType": "Create",
        "ResourceType": "Custom::TestResource",
        "RequestId": "unique id for this create request",
        "LogicalResourceId": "MyTestResource"
    }

    cloudformation_update = {
        "StackId": "arn:aws:cloudformation:us-west-2:EXAMPLE/stack-name/guid",
        "ResponseURL": "http://pre-signed-S3-url-for-response",
        "ResourceProperties": {
            "StackName": "stack-name",
            "List": [
                "1",
                "2",
                "3"
            ]
        },
        "RequestType": "Update",
        "ResourceType": "Custom::TestResource",
        "RequestId": "unique id for this create request",
        "LogicalResourceId": "MyTestResource"
    }

    cloudformation_deletion = {
        "StackId": "arn:aws:cloudformation:us-west-2:EXAMPLE/stack-name/guid",
        "ResponseURL": "http://pre-signed-S3-url-for-response",
        "ResourceProperties": {
            "StackName": "stack-name",
            "List": [
                "1",
                "2",
                "3"
            ]
        },
        "RequestType": "Delete",
        "ResourceType": "Custom::TestResource",
        "RequestId": "unique id for this create request",
        "LogicalResourceId": "MyTestResource"
    }

"""Redis Server Commands Mixin"""
from tornado import concurrent

from tredis import common, exceptions

# Python 2 support for ascii()
if 'ascii' not in dir(__builtins__):  # pragma: nocover
    from tredis.compat import ascii


class ServerMixin(object):
    """Redis Server Commands Mixin"""

    def auth(self, password):
        """Request for authentication in a password-protected Redis server.
        Redis can be instructed to require a password before allowing clients
        to execute commands. This is done using the ``requirepass`` directive
        in the configuration file.

        If the password does not match, an
        :exc:`~tredis.exceptions.AuthError` exception
        will be raised.

        :param password: The password to authenticate with
        :type password: :class:`str`, :class:`bytes`
        :rtype: bool
        :raises: :exc:`~tredis.exceptions.AuthError`,
                 :exc:`~tredis.exceptions.RedisError`

        """
        future = concurrent.TracebackFuture()

        def on_response(response):
            """Process the redis response

            :param response: The future with the response
            :type response: tornado.concurrent.Future

            """
            exc = response.exception()
            if exc:
                if exc.args[0] == b'invalid password':
                    future.set_exception(exceptions.AuthError(exc))
                else:
                    future.set_exception(exc)
            else:
                future.set_result(response.result())

        execute_future = self._execute([b'AUTH', password], b'OK')
        self.io_loop.add_future(execute_future, on_response)
        return future

    def echo(self, message):
        """Returns the message that was sent to the Redis server.

        :param message: The message to echo
        :type message: :class:`str`, :class:`bytes`
        :rtype: bytes
        :raises: :exc:`~tredis.exceptions.RedisError`

        """
        return self._execute([b'ECHO', message])

    def info(self, section=None):
        """The INFO command returns information and statistics about the server
        in a format that is simple to parse by computers and easy to read by
        humans.

        The optional parameter can be used to select a specific section of
        information:

            - server: General information about the Redis server
            - clients: Client connections section
            - memory: Memory consumption related information
            - persistence: RDB and AOF related information
            - stats: General statistics
            - replication: Master/slave replication information
            - cpu: CPU consumption statistics
            - commandstats: Redis command statistics
            - cluster: Redis Cluster section
            - keyspace: Database related statistics

        It can also take the following values:

            - all: Return all sections
            - default: Return only the default set of sections

        When no parameter is provided, the default option is assumed.

        :param str section: Optional
        :return: dict

        """
        cmd = [b'INFO']
        if section:
            cmd.append(section)
        return self._execute(cmd, format_callback=common.format_info_response)

    def ping(self):
        """Returns ``PONG`` if no argument is provided, otherwise return a copy
        of the argument as a bulk. This command is often used to test if a
        connection is still alive, or to measure latency.

        If the client is subscribed to a channel or a pattern, it will instead
        return a multi-bulk with a ``pong`` in the first position and an empty
        bulk in the second position, unless an argument is provided in which
        case it returns a copy of the argument.

        :rtype: bytes
        :raises: :exc:`~tredis.exceptions.RedisError`

        """
        return self._execute([b'PING'])

    def quit(self):
        """Ask the server to close the connection. The connection is closed as
        soon as all pending replies have been written to the client.

        :rtype: bool
        :raises: :exc:`~tredis.exceptions.RedisError`

        """
        self._closing = True
        return self._execute([b'QUIT'], b'OK')

    def select(self, index=0):
        """Select the DB with having the specified zero-based numeric index.
        New connections always use DB ``0``.

        :param int index: The database to select
        :rtype: bool
        :raises: :exc:`~tredis.exceptions.RedisError`
        :raises: :exc:`~tredis.exceptions.InvalidClusterCommand`

        """
        if self._clustering:
            raise exceptions.InvalidClusterCommand
        future = self._execute(
            [b'SELECT', ascii(index).encode('ascii')], b'OK')

        def on_selected(f):
            self._connection.database = index

        self.io_loop.add_future(future, on_selected)
        return future

    def time(self):
        """Retrieve the current time from the redis server.

        :rtype: float
        :raises: :exc:`~tredis.exceptions.RedisError`

        """

        def format_response(value):
            """Format a TIME response into a datetime.datetime

            :param list value: TIME response is a list of the number
                of seconds since the epoch and the number of micros
                as two byte strings
            :rtype: float

            """
            seconds, micros = value
            return float(seconds) + (float(micros) / 1000000.0)

        return self._execute([b'TIME'], format_callback=format_response)

#!/usr/bin/env python

# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2013 Violin Memory, Inc.
# All Rights Reserved.
#
#    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.

from cinder.volume.drivers.violin.vxg.core.node import XGNode
from cinder.volume.drivers.violin.vxg.core.error import *
from cinder.volume.drivers.violin.vxg.core.request import XGAction
from cinder.volume.drivers.violin.vxg.core.request import XGEvent
from cinder.volume.drivers.violin.vxg.core.request import XGQuery
from cinder.volume.drivers.violin.vxg.core.request import XGSet

"""
Here's an example of how to extend the functionality in this module:

class LUNManager_3(LUNManager_2):
    def __init__(self, basic):
        super(LUNManager_3, self).__init__(basic)

    def new_function(self, *args):
        pass

"""


class LUNManager(object):
    def __init__(self, basic):
        self._basic = basic

    def create_lun(self, container, name, size, quantity, nozero,
                   thin, readonly, startnum, blksize=None):
        """
        Create a LUN.

        Arguments:
            container -- string
            name      -- string
            size      -- string
            quantity  -- uint64
            nozero    -- string
            thin      -- string
            readonly  -- string
            startnum  -- uint64
            blksize   -- uint32 (optional)

        Returns:
            Action result as a dict.

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('name', 'string', name))
        nodes.append(XGNode('size', 'string', size))
        nodes.append(XGNode('quantity', 'uint64', quantity))
        nodes.append(XGNode('nozero', 'string', nozero))
        nodes.append(XGNode('thin', 'string', thin))
        nodes.append(XGNode('readonly', 'string', readonly))
        nodes.append(XGNode('action', 'string', 'c'))
        nodes.append(XGNode('startnum', 'uint64', startnum))
        if blksize is not None:
            nodes.append(XGNode('blksize', 'uint32', blksize))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/create', nodes)

    def bulk_delete_luns(self, container, luns):
        """
        Delete one or more LUNs.

        Arguments:
            container -- string
            luns      -- string (string or list)

        Returns:
            Action result as a dict.

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.extend(XGNode.as_node_list('lun/{0}', 'string', luns))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/bulk_delete', nodes)

    def export_lun(self, container, name, ports, initiators, lun_id):
        """
        Export a LUN.

        Arguments:
            container  -- string
            name       -- string
            ports      -- string
            initiators -- string
            lun_id     -- int16

        Returns:
            Action result as a dict.

        """
        return self._lun_export(container, name, ports,
                                initiators, lun_id, False)

    def unexport_lun(self, container, name, ports, initiators, lun_id):
        """
        Unexport a LUN.

        Arguments:
            container  -- string
            name       -- string
            ports      -- string
            initiators -- string
            lun_id     -- int16

        Returns:
            Action result as a dict.

        """
        return self._lun_export(container, name, ports,
                                initiators, lun_id, True)

    # Begin internal functions

    def _lun_export(self, container, name, ports,
                    initiators, lun_id, unexport):
        """
        Internal work function for:
            export_lun
            unexport_lun

        """

        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('name', 'string', name))
        nodes.append(XGNode('initiators', 'string', initiators))
        nodes.append(XGNode('ports', 'string', ports))
        if lun_id == 'auto':
            nodes.append(XGNode('lun_id', 'int16', -1))
        else:
            nodes.append(XGNode('lun_id', 'int16', lun_id))
        nodes.append(XGNode('unexport', 'bool', unexport))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/export', nodes)


class LUNManager_1(LUNManager):
    def __init__(self, basic):
        super(LUNManager_1, self).__init__(basic)

    def export_lun(self, container, names, ports, initiators, lun_id):
        """
        Export a LUN.

        Arguments:
            container  -- string
            names      -- string (string or list)
            ports      -- string (string or list)
            initiators -- string (string or list)
            lun_id     -- int16

        Returns:
            Action result as a dict.

        """
        return self._lun_export(container, names, ports,
                                initiators, lun_id, False)

    def unexport_lun(self, container, names, ports, initiators, lun_id):
        """
        Unexport a LUN.

        Arguments:
            container  -- string
            names      -- string (string or list)
            ports      -- string (string or list)
            initiators -- string (string or list)
            lun_id     -- int16

        Returns:
            Action result as a dict.

        """
        return self._lun_export(container, names, ports,
                                initiators, lun_id, True)

    # Begin internal functions

    def _lun_export(self, container, names, ports,
                    initiators, lun_id, unexport):
        """
        Internal work function for:
            export_lun
            unexport_lun

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.extend(XGNode.as_node_list('names/{0}', 'string', names))
        nodes.extend(XGNode.as_node_list('initiators/{0}', 'string',
                                         initiators))
        nodes.extend(XGNode.as_node_list('ports/{0}', 'string', ports))
        if lun_id == 'auto':
            nodes.append(XGNode('lun_id', 'int16', -1))
        else:
            nodes.append(XGNode('lun_id', 'int16', lun_id))
        nodes.append(XGNode('unexport', 'bool', unexport))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/export', nodes)


class LUNManager_2(LUNManager_1):
    def __init__(self, basic):
        super(LUNManager_2, self).__init__(basic)

    def set(self, container, lun, read_only, port_A, port_B):
        """
        Perform LUN modification.

        Arguments:
            container -- string
            lun       -- string
            read_only -- bool
            port_A    -- bool
            port_B    -- bool

        Returns:
            Action result as a dict.

        """

        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('lun', 'string', lun))
        nodes.append(XGNode('read_only', 'bool', read_only))
        nodes.append(XGNode('port_A', 'bool', port_A))
        nodes.append(XGNode('port_B', 'bool', port_B))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/set', nodes)

    def rename_lun(self, container, lun_old, lun_new):
        """
        Rename a LUN.

        Arguments:
            container -- string
            lun_old   -- string
            lun_new   -- string

        Returns:
            Action result as a dict.

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('lun_old', 'string', lun_old))
        nodes.append(XGNode('lun_new', 'string', lun_new))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/rename', nodes)


class LUNManager_3(LUNManager_2):
    def __init__(self, basic):
        super(LUNManager_3, self).__init__(basic)

    def create_lun_group(self, container, name,
                         lun_names, description=None):
        """
        Create a LUN group.

        Arguments:
            container   -- string
            name        -- string
            lun_names   -- string (string or list)
            description -- string (optional)

        Returns:
            Action result as a dict.

        """
        return self._lungroup_create(container, name, lun_names,
                                     'create', description)

    def delete_lun_group(self, container, name):
        """
        Deletes a LUN group.

        Arguments:
            container -- string
            name      -- string

        Returns:
            Action result as a dict.

        """
        return self._lungroup_create(container, name, None,
                                     'delete', None)

    def _lungroup_create(self, container, name,
                         lun_names, action, description):
        """
        Internal work function for:
            create_lun_group
            delete_lun_group

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('name', 'string', name))
        nodes.extend(XGNode.as_node_list('lun_names/{0}', 'string', lun_names))
        nodes.append(XGNode('action', 'string', action))
        if description is not None:
            nodes.append(XGNode('description', 'string', description))

        return self._basic.perform_action('/vshare/actions/vdm' +
                                          '/lungroup/create', nodes)

    def add_to_lun_group(self, container, name, lun_names=None,
                         new_name=None, description=None):
        """
        Update a LUN group and add LUNs.

        Arguments:
            container   -- string
            name        -- string
            lun_names   -- string (string or list, optional)
            new_name    -- string (optional)
            description -- string (optional)

        Returns:
            Action result as a dict.

        """
        return self._lungroup_update(container, name, new_name,
                                     lun_names, False, description)

    def remove_from_lun_group(self, container, name, lun_names=None,
                              new_name=None, description=None):
        """
        Update a LUN group and remove LUNs.

        Arguments:
            container   -- string
            name        -- string
            lun_names   -- string (string or list, optional)
            new_name    -- string (optional)
            description -- string

        Returns:
            Action result as a dict.

        """
        return self._lungroup_update(container, name, new_name,
                                     lun_names, True, description)

    def _lungroup_update(self, container, name, new_name,
                         lun_names, remove, description):
        """
        Internal work function for:
            add_to_lun_group
            remove_from_lun_group

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('name', 'string', name))
        if new_name is not None:
            nodes.append(XGNode('new_name', 'string', new_name))
        nodes.extend(XGNode.as_node_list('lun_names/{0}', 'string', lun_names))
        if remove is not None:
            nodes.append(XGNode('remove', 'bool', remove))
        if description is not None:
            nodes.append(XGNode('description', 'string', description))

        return self._basic.perform_action('/vshare/actions/vdm' +
                                          '/lungroup/update', nodes)

    def export_lun_group(self, container, name, initiators,
                         ports):
        """
        Exports a LUN group.

        Arguments:
            container  -- string
            name       -- string
            initiators -- string (string or list)
            ports      -- string (string or list)

        Returns:
            Action result as a dict.

        """
        return self._lungroup_export(container, name,
                                     initiators, ports, False)

    def unexport_lun_group(self, container, name,
                           initiators, ports):
        """
        Unexports a LUN group.

        Arguments:
            container  -- string
            name       -- string
            initiators -- string (string or list)
            ports      -- string (string or list)

        Returns:
            Action result as a dict.

        """
        return self._lungroup_export(container, name,
                                     initiators, ports, True)

    def _lungroup_export(self, container, name, initiators,
                         ports, unexport):
        """
        Internal work function for:
            export_lun_group
            unexport_lun_group

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('name', 'string', name))
        nodes.extend(XGNode.as_node_list('initiators/{0}', 'string',
                                         initiators))
        nodes.extend(XGNode.as_node_list('ports/{0}', 'string', ports))
        nodes.append(XGNode('unexport', 'bool', unexport))

        return self._basic.perform_action('/vshare/actions/vdm' +
                                          '/lungroup/export', nodes)

    def create_lun(self, container, name, size, quantity, nozero,
                   thin, readonly, startnum, blksize=None,
                   naca=None, alua=None, preferredport=None):
        """
        Create a LUN.

        Arguments:
            container        -- string
            name             -- string
            size             -- string
            quantity         -- uint64
            nozero           -- string
            thin             -- string
            readonly         -- string
            startnum         -- uint64
            blksize          -- uint32 (optional)
            naca             -- bool (optional)
            alua             -- bool (optional)
            preferredport    -- uint8 (optional)

        Returns:
            Action result as a dict.

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        nodes.append(XGNode('name', 'string', name))
        nodes.append(XGNode('size', 'string', size))
        nodes.append(XGNode('quantity', 'uint64', quantity))
        nodes.append(XGNode('nozero', 'string', nozero))
        nodes.append(XGNode('thin', 'string', thin))
        nodes.append(XGNode('readonly', 'string', readonly))
        nodes.append(XGNode('action', 'string', 'c'))
        nodes.append(XGNode('startnum', 'uint64', startnum))
        if blksize is not None:
            nodes.append(XGNode('blksize', 'uint32', blksize))
        if naca is not None:
            nodes.append(XGNode('naca', 'bool', naca))
        if alua is not None:
            nodes.append(XGNode('alua', 'bool', alua))
        if preferredport is not None:
            nodes.append(XGNode('preferredport', 'uint8', preferredport))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/create', nodes)

    def set(self, container, lun=None, read_only=None, port_A=None,
            port_B=None, devid=None, naca=None, alua=None,
            preferredport=None, encrypted=None, threshold_type=None,
            threshold_hard_val=None, threshold_soft_val=None):
        """
        Perform LUN modification.

        Arguments:
            container          -- string
            lun                -- string (optional)
            read_only          -- bool (optional)
            port_A             -- bool (optional)
            port_B             -- bool (optional)
            devid              -- string (optional)
            naca               -- bool (optional)
            alua               -- bool (optional)
            preferredport      -- uint8 (optional)
            encrypted          -- bool (optional)
            threshold_type     -- string (optional)
            threshold_hard_val -- uint32 (optional)
            threshold_soft_val -- uint32 (optional)

        Returns:
            Action result as a dict.

        """
        nodes = []
        nodes.append(XGNode('container', 'string', container))
        if lun is not None:
            nodes.append(XGNode('lun', 'string', lun))
        if read_only is not None:
            nodes.append(XGNode('read_only', 'bool', read_only))
        if port_A is not None:
            nodes.append(XGNode('port_A', 'bool', port_A))
        if port_B is not None:
            nodes.append(XGNode('port_B', 'bool', port_B))
        if devid is not None:
            nodes.append(XGNode('devid', 'string', devid))
        if naca is not None:
            nodes.append(XGNode('naca', 'bool', naca))
        if alua is not None:
            nodes.append(XGNode('alua', 'bool', alua))
        if preferredport is not None:
            nodes.append(XGNode('preferredport', 'uint8', preferredport))
        if encrypted is not None:
            nodes.append(XGNode('encrypted', 'bool', encrypted))
        if threshold_type is not None:
            nodes.append(XGNode('threshold_type', 'string', threshold_type))
        if threshold_hard_val is not None:
            nodes.append(XGNode('threshold_hard_val', 'uint32',
                                threshold_hard_val))
        if threshold_soft_val is not None:
            nodes.append(XGNode('threshold_soft_val', 'uint32',
                                threshold_soft_val))

        return self._basic.perform_action('/vshare/actions' +
                                          '/lun/set', nodes)

"""
Copyright (C) 2012-2013 Jussi Leinonen

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software is furnished to do so,
subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""

from numpy import pi, arange, zeros, hstack, sqrt, sin, cos
from scipy.special import jv, yv


class MieCoeffs(object):
    """Wrapper for the Mie coefficients.
    """
    def __init__(self, par):
        (self.an, self.bn, self.nmax) = mie_coeffs(par)


def mie_coeffs(params):
    """Input validation and function selection for the Mie coefficients.
    """

    eps = complex(params["eps"]) if params["eps"] is not None else None
    x = float(params["x"]) if params["x"] is not None else None

    if (x==None) or (eps==None):
        raise ValueError("Must specify x and either eps or m.")

    mu = complex(params["mu"]) if params["mu"] is not None else complex(1.0)

    y = float(params["y"]) if params["y"] is not None else None
    eps2 = complex(params["eps2"]) if params["eps2"] is not None else None

    coated = (y is not None)
    if coated == (eps2 is None):
        raise ValueError("Must specify both y and m2 for coated particles.")

    if coated and mu!=complex(1.0):
        raise ValueError("Multilayer calculations for magnetic particles " + \
            "are not currently supported.")

    if not coated:
        y = x
        eps2 = eps

    # Do not use the coated version if it is not necessary
    if x==y or eps==eps2:
        coeffs = single_mie_coeff(eps,mu,y)
    elif x==0:
        coeffs = single_mie_coeff(eps2,mu,y)
    else:
        coeffs = coated_mie_coeff(eps,eps2,x,y)

    return coeffs


def single_mie_coeff(eps,mu,x):
    """Mie coefficients for the single-layered sphere.

    Args:
        eps: The complex relative permittivity.
        mu: The complex relative permeability.
        x: The size parameter.

    Returns:
        A tuple containing (an, bn, nmax) where an and bn are the Mie
        coefficients and nmax is the maximum number of coefficients.
    """
    z = sqrt(eps*mu)*x
    m = sqrt(eps/mu)

    nmax = int(round(2+x+4*x**(1.0/3.0)))
    nmax1 = nmax-1
    nmx = int(round(max(nmax,abs(z))+16))
    n = arange(nmax)
    nu = n+1.5

    sx = sqrt(0.5*pi*x)
    px = sx*jv(nu,x)
    p1x = hstack((sin(x), px[:nmax1]))
    chx = -sx*yv(nu,x)
    ch1x = hstack((cos(x), chx[:nmax1]))
    gsx = px-complex(0,1)*chx
    gs1x = p1x-complex(0,1)*ch1x

    dnx = zeros(nmx,dtype=complex)
    for j in xrange(nmx-1,0,-1):
        r = (j+1.0)/z
        dnx[j-1] = r - 1.0/(dnx[j]+r)
    dn = dnx[:nmax]
    n1 = n+1
    da = dn/m + n1/x
    db = dn*m + n1/x

    an = (da*px-p1x)/(da*gsx-gs1x)
    bn = (db*px-p1x)/(db*gsx-gs1x)

    return (an, bn, nmax)


def coated_mie_coeff(eps1,eps2,x,y):
    """Mie coefficients for the dual-layered (coated) sphere.

       Args:
          eps: The complex relative permittivity of the core.
          eps2: The complex relative permittivity of the shell.
          x: The size parameter of the core.
          y: The size parameter of the shell.

       Returns:
          A tuple containing (an, bn, nmax) where an and bn are the Mie
          coefficients and nmax is the maximum number of coefficients.
    """
    m1 = sqrt(eps1)
    m2 = sqrt(eps2)
    m = m2/m1
    u = m1*x
    v = m2*x
    w = m2*y

    nmax = int(round(2+y+4*y**(1.0/3.0)))
    mx = max(abs(m1*y),abs(w))
    nmx = int(round(max(nmax,mx)+16))
    nmax1 = nmax-1
    n = arange(nmax)

    dnu = zeros(nmax,dtype=complex)
    dnv = zeros(nmax,dtype=complex)
    dnw = zeros(nmax,dtype=complex)
    dnx = zeros(nmx,dtype=complex)

    for (z, dn) in zip((u,v,w),(dnu,dnv,dnw)):
        for j in xrange(nmx-1,0,-1):
            r = (j+1.0)/z
            dnx[j-1] = r - 1.0/(dnx[j]+r)
        dn[:] = dnx[:nmax]

    nu = n+1.5
    vwy = [v,w,y]
    sx = [sqrt(0.5*pi*xx) for xx in vwy]
    (pv,pw,py) = [s*jv(nu,xx) for (s,xx) in zip(sx,vwy)]
    (chv,chw,chy) = [-s*yv(nu,xx) for (s,xx) in zip(sx,vwy)]
    p1y = hstack((sin(y), py[:nmax1]))
    ch1y = hstack((cos(y), chy[:nmax1]))
    gsy = py-complex(0,1)*chy
    gs1y = p1y-complex(0,1)*ch1y

    uu = m*dnu-dnv
    vv = dnu/m-dnv
    fv = pv/chv
    fw = pw/chw
    ku1 = uu*fv/pw
    kv1 = vv*fv/pw
    pt = pw-chw*fv
    prat = pw/pv/chv
    ku2 = uu*pt+prat
    kv2 = vv*pt+prat
    dns1 = ku1/ku2
    gns1 = kv1/kv2

    dns = dns1+dnw
    gns = gns1+dnw
    nrat = (n+1)/y
    a1 = dns/m2+nrat
    b1 = m2*gns+nrat
    an = (py*a1-p1y)/(gsy*a1-gs1y)
    bn = (py*b1-p1y)/(gsy*b1-gs1y)

    return (an, bn, nmax)

"""Newton-CG trust-region optimization."""
from __future__ import division, print_function, absolute_import

import math

import numpy as np
import scipy.linalg
from ._trustregion import (_minimize_trust_region, BaseQuadraticSubproblem)

__all__ = []


def _minimize_trust_ncg(fun, x0, args=(), jac=None, hess=None, hessp=None,
                        **trust_region_options):
    """
    Minimization of scalar function of one or more variables using
    the Newton conjugate gradient trust-region algorithm.

    Options
    -------
    initial_trust_radius : float
        Initial trust-region radius.
    max_trust_radius : float
        Maximum value of the trust-region radius. No steps that are longer
        than this value will be proposed.
    eta : float
        Trust region related acceptance stringency for proposed steps.
    gtol : float
        Gradient norm must be less than `gtol` before successful
        termination.

    """
    if jac is None:
        raise ValueError('Jacobian is required for Newton-CG trust-region '
                         'minimization')
    if hess is None and hessp is None:
        raise ValueError('Either the Hessian or the Hessian-vector product '
                         'is required for Newton-CG trust-region minimization')
    return _minimize_trust_region(fun, x0, args=args, jac=jac, hess=hess,
                                  hessp=hessp, subproblem=CGSteihaugSubproblem,
                                  **trust_region_options)


class CGSteihaugSubproblem(BaseQuadraticSubproblem):
    """Quadratic subproblem solved by a conjugate gradient method"""
    def solve(self, trust_radius):
        """
        Solve the subproblem using a conjugate gradient method.

        Parameters
        ----------
        trust_radius : float
            We are allowed to wander only this far away from the origin.

        Returns
        -------
        p : ndarray
            The proposed step.
        hits_boundary : bool
            True if the proposed step is on the boundary of the trust region.

        Notes
        -----
        This is algorithm (7.2) of Nocedal and Wright 2nd edition.
        Only the function that computes the Hessian-vector product is required.
        The Hessian itself is not required, and the Hessian does
        not need to be positive semidefinite.
        """

        # get the norm of jacobian and define the origin
        p_origin = np.zeros_like(self.jac)

        # define a default tolerance
        tolerance = min(0.5, math.sqrt(self.jac_mag)) * self.jac_mag

        # Stop the method if the search direction
        # is a direction of nonpositive curvature.
        if self.jac_mag < tolerance:
            hits_boundary = False
            return p_origin, hits_boundary

        # init the state for the first iteration
        z = p_origin
        r = self.jac
        d = -r

        # Search for the min of the approximation of the objective function.
        while True:

            # do an iteration
            Bd = self.hessp(d)
            dBd = np.dot(d, Bd)
            if dBd <= 0:
                # Look at the two boundary points.
                # Find both values of t to get the boundary points such that
                # ||z + t d|| == trust_radius
                # and then choose the one with the predicted min value.
                ta, tb = self.get_boundaries_intersections(z, d, trust_radius)
                pa = z + ta * d
                pb = z + tb * d
                if self(pa) < self(pb):
                    p_boundary = pa
                else:
                    p_boundary = pb
                hits_boundary = True
                return p_boundary, hits_boundary
            r_squared = np.dot(r, r)
            alpha = r_squared / dBd
            z_next = z + alpha * d
            if scipy.linalg.norm(z_next) >= trust_radius:
                # Find t >= 0 to get the boundary point such that
                # ||z + t d|| == trust_radius
                ta, tb = self.get_boundaries_intersections(z, d, trust_radius)
                p_boundary = z + tb * d
                hits_boundary = True
                return p_boundary, hits_boundary
            r_next = r + alpha * Bd
            r_next_squared = np.dot(r_next, r_next)
            if math.sqrt(r_next_squared) < tolerance:
                hits_boundary = False
                return z_next, hits_boundary
            beta_next = r_next_squared / r_squared
            d_next = -r_next + beta_next * d

            # update the state for the next iteration
            z = z_next
            r = r_next
            d = d_next

# Copyright (c) 2015 Red Hat, Inc.
# All Rights Reserved.
#
#    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.

import six
import testscenarios

from neutron import context
from neutron.db import agents_db
from neutron.db import agentschedulers_db
from neutron.db import common_db_mixin
from neutron.scheduler import dhcp_agent_scheduler
from neutron.tests.unit.scheduler import (test_dhcp_agent_scheduler as
                                          test_dhcp_sch)
from operator import attrgetter

# Required to generate tests from scenarios. Not compatible with nose.
load_tests = testscenarios.load_tests_apply_scenarios


class BaseTestScheduleNetwork(object):
    """Base class which defines scenarios for schedulers.

        agent_count
            Number of dhcp agents (also number of hosts).

        max_agents_per_network
            Maximum  DHCP Agents that can be scheduled for a network.

        scheduled_agent_count
            Number of agents the network has previously scheduled

        down_agent_count
            Number of dhcp agents which are down

        expected_scheduled_agent_count
            Number of scheduled agents the schedule() should return
            or 'None' if the schedule() cannot schedule the network.
    """

    scenarios = [
        ('No agents scheduled if no agents are present',
         dict(agent_count=0,
              max_agents_per_network=1,
              scheduled_agent_count=0,
              down_agent_count=0,
              expected_scheduled_agent_count=None)),

        ('No agents scheduled if network already hosted and'
         ' max_agents_per_network reached',
         dict(agent_count=1,
              max_agents_per_network=1,
              scheduled_agent_count=1,
              down_agent_count=0,
              expected_scheduled_agent_count=None)),

        ('No agents scheduled if all agents are down',
         dict(agent_count=2,
              max_agents_per_network=1,
              scheduled_agent_count=0,
              down_agent_count=2,
              expected_scheduled_agent_count=None)),

        ('Agent scheduled to the network if network is not yet hosted',
         dict(agent_count=1,
              max_agents_per_network=1,
              scheduled_agent_count=0,
              down_agent_count=0,
              expected_scheduled_agent_count=1)),

        ('Additional Agents scheduled to the network if max_agents_per_network'
         ' is not yet reached',
         dict(agent_count=3,
              max_agents_per_network=3,
              scheduled_agent_count=1,
              down_agent_count=0,
              expected_scheduled_agent_count=2)),

        ('No agent scheduled if agent is dead',
         dict(agent_count=3,
              max_agents_per_network=3,
              scheduled_agent_count=1,
              down_agent_count=1,
              expected_scheduled_agent_count=1)),
    ]


class TestChanceScheduleNetwork(test_dhcp_sch.TestDhcpSchedulerBaseTestCase,
                                agentschedulers_db.DhcpAgentSchedulerDbMixin,
                                agents_db.AgentDbMixin,
                                common_db_mixin.CommonDbMixin,
                                BaseTestScheduleNetwork):
    """Test various scenarios for ChanceScheduler.schedule."""

    def test_schedule_network(self):
        self.config(dhcp_agents_per_network=self.max_agents_per_network)
        scheduler = dhcp_agent_scheduler.ChanceScheduler()

        # create dhcp agents
        hosts = ['host-%s' % i for i in range(self.agent_count)]
        dhcp_agents = self._create_and_set_agents_down(
            hosts, down_agent_count=self.down_agent_count)

        active_agents = dhcp_agents[self.down_agent_count:]

        # schedule some agents before calling schedule
        if self.scheduled_agent_count:
            # schedule the network
            schedule_agents = active_agents[:self.scheduled_agent_count]
            scheduler.resource_filter.bind(self.ctx,
                                           schedule_agents, self.network_id)
        actual_scheduled_agents = scheduler.schedule(self, self.ctx,
                                                     self.network)
        if self.expected_scheduled_agent_count:
            self.assertEqual(self.expected_scheduled_agent_count,
                             len(actual_scheduled_agents))
            hosted_agents = self.list_dhcp_agents_hosting_network(
                self.ctx, self.network_id)
            self.assertEqual(self.scheduled_agent_count +
                             len(actual_scheduled_agents),
                             len(hosted_agents['agents']))
        else:
            self.assertEqual([], actual_scheduled_agents)


class TestWeightScheduleNetwork(test_dhcp_sch.TestDhcpSchedulerBaseTestCase,
                                agentschedulers_db.DhcpAgentSchedulerDbMixin,
                                agents_db.AgentDbMixin,
                                common_db_mixin.CommonDbMixin,
                                BaseTestScheduleNetwork):
    """Test various scenarios for WeightScheduler.schedule."""

    def test_weight_schedule_network(self):
        self.config(dhcp_agents_per_network=self.max_agents_per_network)
        scheduler = dhcp_agent_scheduler.WeightScheduler()

        # create dhcp agents
        hosts = ['host-%s' % i for i in range(self.agent_count)]
        dhcp_agents = self._create_and_set_agents_down(
            hosts, down_agent_count=self.down_agent_count)

        active_agents = dhcp_agents[self.down_agent_count:]

        unscheduled_active_agents = list(active_agents)
        # schedule some agents before calling schedule
        if self.scheduled_agent_count:
            # schedule the network
            schedule_agents = active_agents[:self.scheduled_agent_count]
            scheduler.resource_filter.bind(self.ctx,
                                           schedule_agents, self.network_id)
            for agent in schedule_agents:
                unscheduled_active_agents.remove(agent)
        actual_scheduled_agents = scheduler.schedule(self, self.ctx,
                                                     self.network)
        if self.expected_scheduled_agent_count:
            sorted_unscheduled_active_agents = sorted(
                unscheduled_active_agents,
                key=attrgetter('load'))[0:self.expected_scheduled_agent_count]
            self.assertItemsEqual(
                (agent['id'] for agent in actual_scheduled_agents),
                (agent['id'] for agent in sorted_unscheduled_active_agents))
            self.assertEqual(self.expected_scheduled_agent_count,
                             len(actual_scheduled_agents))
            hosted_agents = self.list_dhcp_agents_hosting_network(
                self.ctx, self.network_id)
            self.assertEqual(self.scheduled_agent_count +
                             len(actual_scheduled_agents),
                             len(hosted_agents['agents']))
        else:
            self.assertEqual([], actual_scheduled_agents)


class TestAutoSchedule(test_dhcp_sch.TestDhcpSchedulerBaseTestCase,
                       agentschedulers_db.DhcpAgentSchedulerDbMixin,
                       agents_db.AgentDbMixin,
                       common_db_mixin.CommonDbMixin):
    """Test various scenarios for ChanceScheduler.auto_schedule_networks.

        Below is the brief description of the scenario variables
        --------------------------------------------------------
        agent_count
            number of DHCP agents (also number of hosts).

        max_agents_per_network
            Maximum  DHCP Agents that can be scheduled for a network.

        network_count
            Number of networks.

        networks_with_dhcp_disabled
            List of networks with dhcp disabled

        hosted_networks
            A mapping of agent id to the ids of the networks that they
            should be initially hosting.

        expected_auto_schedule_return_value
            Expected return value of 'auto_schedule_networks'.

        expected_hosted_networks
            This stores the expected networks that should have been scheduled
            (or that could have already been scheduled) for each agent
            after the 'auto_schedule_networks' function is called.
    """

    scenarios = [
        ('Agent scheduled to the network if network is not yet hosted',
         dict(agent_count=1,
              max_agents_per_network=1,
              network_count=1,
              networks_with_dhcp_disabled=[],
              hosted_networks={},
              expected_auto_schedule_return_value=True,
              expected_hosted_networks={'agent-0': ['network-0']})),

        ('No agent scheduled if no networks are present',
         dict(agent_count=1,
              max_agents_per_network=1,
              network_count=0,
              networks_with_dhcp_disabled=[],
              hosted_networks={},
              expected_auto_schedule_return_value=False,
              expected_hosted_networks={'agent-0': []})),

        ('Agents scheduled to the networks if networks are not yet hosted',
         dict(agent_count=2,
              max_agents_per_network=3,
              network_count=2,
              networks_with_dhcp_disabled=[],
              hosted_networks={},
              expected_auto_schedule_return_value=True,
              expected_hosted_networks={'agent-0': ['network-0',
                                                    'network-1'],
                                        'agent-1': ['network-0',
                                                    'network-1']})),

        ('No new agents scheduled if networks are already hosted',
         dict(agent_count=2,
              max_agents_per_network=3,
              network_count=2,
              networks_with_dhcp_disabled=[],
              hosted_networks={'agent-0': ['network-0', 'network-1'],
                               'agent-1': ['network-0', 'network-1']},
              expected_auto_schedule_return_value=True,
              expected_hosted_networks={'agent-0': ['network-0',
                                                    'network-1'],
                                        'agent-1': ['network-0',
                                                    'network-1']})),

        ('Additional agents scheduled to the networks if'
         ' max_agents_per_network is not yet reached',
         dict(agent_count=4,
              max_agents_per_network=3,
              network_count=4,
              networks_with_dhcp_disabled=[],
              hosted_networks={'agent-0': ['network-0', 'network-1'],
                               'agent-1': ['network-0'],
                               'agent-2': ['network-2'],
                               'agent-3': ['network-0', 'network-2']},
              expected_auto_schedule_return_value=True,
              expected_hosted_networks={'agent-0': ['network-0',
                                                    'network-1',
                                                    'network-2',
                                                    'network-3'],
                                        'agent-1': ['network-0',
                                                    'network-1',
                                                    'network-2',
                                                    'network-3'],
                                        'agent-2': ['network-1',
                                                    'network-2',
                                                    'network-3'],
                                        'agent-3': ['network-0',
                                                    'network-1',
                                                    'network-2',
                                                    'network-3']})),

        ('No agents scheduled if networks already hosted and'
         ' max_agents_per_network reached',
         dict(agent_count=4,
              max_agents_per_network=1,
              network_count=4,
              networks_with_dhcp_disabled=[],
              hosted_networks={'agent-0': ['network-0'],
                               'agent-1': ['network-2'],
                               'agent-2': ['network-1'],
                               'agent-3': ['network-3']},
              expected_auto_schedule_return_value=True,
              expected_hosted_networks={'agent-0': ['network-0'],
                                        'agent-1': ['network-2'],
                                        'agent-2': ['network-1'],
                                        'agent-3': ['network-3']})),

        ('No agents scheduled to the network with dhcp disabled',
         dict(agent_count=2,
              max_agents_per_network=3,
              network_count=2,
              networks_with_dhcp_disabled=['network-1'],
              hosted_networks={},
              expected_auto_schedule_return_value=True,
              expected_hosted_networks={'agent-0': ['network-0'],
                                        'agent-1': ['network-0']})),

        ('No agents scheduled if all networks have dhcp disabled',
         dict(agent_count=2,
              max_agents_per_network=3,
              network_count=2,
              networks_with_dhcp_disabled=['network-0', 'network-1'],
              hosted_networks={},
              expected_auto_schedule_return_value=False,
              expected_hosted_networks={'agent-0': [],
                                        'agent-1': []})),
    ]

    def _strip_host_index(self, name):
        """Strips the host index.

        Eg. if name = '2-agent-3', then 'agent-3' is returned.
        """
        return name[name.find('-') + 1:]

    def _extract_index(self, name):
        """Extracts the index number and returns.

        Eg. if name = '2-agent-3', then 3 is returned
        """
        return int(name.split('-')[-1])

    def get_subnets(self, context, fields=None):
        subnets = []
        for net_id in self._networks:
            enable_dhcp = (not self._strip_host_index(net_id) in
                           self.networks_with_dhcp_disabled)
            subnets.append({'network_id': net_id,
                            'enable_dhcp': enable_dhcp})
        return subnets

    def _get_hosted_networks_on_dhcp_agent(self, agent_id):
        query = self.ctx.session.query(
            agentschedulers_db.NetworkDhcpAgentBinding.network_id)
        query = query.filter(
            agentschedulers_db.NetworkDhcpAgentBinding.dhcp_agent_id ==
            agent_id)

        return [item[0] for item in query]

    def _test_auto_schedule(self, host_index):
        self.config(dhcp_agents_per_network=self.max_agents_per_network)
        scheduler = dhcp_agent_scheduler.ChanceScheduler()
        self.ctx = context.get_admin_context()
        msg = 'host_index = %s' % host_index

        # create dhcp agents
        hosts = ['%s-agent-%s' % (host_index, i)
                 for i in range(self.agent_count)]
        dhcp_agents = self._create_and_set_agents_down(hosts)

        # create networks
        self._networks = ['%s-network-%s' % (host_index, i)
                          for i in range(self.network_count)]
        self._save_networks(self._networks)

        # pre schedule the networks to the agents defined in
        # self.hosted_networks before calling auto_schedule_network
        for agent, networks in six.iteritems(self.hosted_networks):
            agent_index = self._extract_index(agent)
            for net in networks:
                net_index = self._extract_index(net)
                scheduler.resource_filter.bind(self.ctx,
                                               [dhcp_agents[agent_index]],
                                               self._networks[net_index])

        retval = scheduler.auto_schedule_networks(self, self.ctx,
                                                  hosts[host_index])
        self.assertEqual(self.expected_auto_schedule_return_value, retval,
                         message=msg)

        agent_id = dhcp_agents[host_index].id
        hosted_networks = self._get_hosted_networks_on_dhcp_agent(agent_id)
        hosted_net_ids = [self._strip_host_index(net)
                          for net in hosted_networks]
        expected_hosted_networks = self.expected_hosted_networks['agent-%s' %
                                                                 host_index]
        self.assertItemsEqual(hosted_net_ids, expected_hosted_networks, msg)

    def test_auto_schedule(self):
        for i in range(self.agent_count):
            self._test_auto_schedule(i)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#
# Copyright (C) 2014 University of Dundee & Open Microscopy Environment.
#                    All Rights Reserved.
# Use is subject to license terms supplied in LICENSE.txt
#

"""
FOR TRAINING PURPOSES ONLY!
"""

from omero.gateway import BlitzGateway
from Parse_OMERO_Properties import USERNAME, PASSWORD, HOST, PORT
from Parse_OMERO_Properties import imageId

"""
start-code
"""


# Create a connection
# ===================
conn = BlitzGateway(USERNAME, PASSWORD, host=HOST, port=PORT)
conn.connect()


# Retrieve a given plane
# ======================
# Use the pixelswrapper to retrieve the plane as
# a 2D numpy array see https://github.com/scipy/scipy
#
# Numpy array can be used for various analysis routines
#
image = conn.getObject("Image", imageId)
size_z = image.getSizeZ()
size_c = image.getSizeC()
size_t = image.getSizeT()
z, t, c = 0, 0, 0                     # first plane of the image
pixels = image.getPrimaryPixels()
plane = pixels.getPlane(z, c, t)      # get a numpy array.
print "\nPlane at zct: ", z, c, t
print plane
print "shape: ", plane.shape
print "min:", plane.min(), " max:", plane.max(),\
    "pixel type:", plane.dtype.name


# Retrieve a given stack
# ======================
# Get a Z-stack of tiles. Using getTiles or getPlanes (see below) returns
# a generator of data (not all the data in hand) The RawPixelsStore is
# only opened once (not closed after each plane) Alternative is to use
# getPlane() or getTile() multiple times - slightly slower.
c, t = 0, 0                 # First channel and timepoint
tile = (50, 50, 10, 10)     # x, y, width, height of tile

# list of [ (0,0,0,(x,y,w,h)), (1,0,0,(x,y,w,h)), (2,0,0,(x,y,w,h))... ]
zct_list = [(iz, c, t, tile) for iz in range(size_z)]
print "\nZ stack of tiles:"
planes = pixels.getTiles(zct_list)
for i, p in enumerate(planes):
    print "Tile:", zct_list[i], " min:", p.min(),\
        " max:", p.max(), " sum:", p.sum()


# Retrieve a given hypercube
# ==========================
zct_list = []
for z in range(size_z / 2, size_z):     # get the top half of the Z-stack
    for c in range(size_c):          # all channels
        for t in range(size_t):      # all time-points
            zct_list.append((z, c, t))
print "\nHyper stack of planes:"
planes = pixels.getPlanes(zct_list)
for i, p in enumerate(planes):
    print "plane zct:", zct_list[i], " min:", p.min(), " max:", p.max()


# Close connection
# ================
# When you are done, close the session to free up server resources.
conn.close()

# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

# Make coding more python3-ish
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import multiprocessing
import os
import sys
import traceback

from jinja2.exceptions import TemplateNotFound

HAS_PYCRYPTO_ATFORK = False
try:
    from Crypto.Random import atfork
    HAS_PYCRYPTO_ATFORK = True
except Exception:
    # We only need to call atfork if pycrypto is used because it will need to
    # reinitialize its RNG.  Since old paramiko could be using pycrypto, we
    # need to take charge of calling it.
    pass

from ansible.errors import AnsibleConnectionFailure
from ansible.executor.task_executor import TaskExecutor
from ansible.executor.task_result import TaskResult
from ansible.module_utils._text import to_text
from ansible.utils.display import Display

__all__ = ['WorkerProcess']

display = Display()


class WorkerProcess(multiprocessing.Process):
    '''
    The worker thread class, which uses TaskExecutor to run tasks
    read from a job queue and pushes results into a results queue
    for reading later.
    '''

    def __init__(self, final_q, task_vars, host, task, play_context, loader, variable_manager, shared_loader_obj):

        super(WorkerProcess, self).__init__()
        # takes a task queue manager as the sole param:
        self._final_q = final_q
        self._task_vars = task_vars
        self._host = host
        self._task = task
        self._play_context = play_context
        self._loader = loader
        self._variable_manager = variable_manager
        self._shared_loader_obj = shared_loader_obj

    def _save_stdin(self):
        self._new_stdin = os.devnull
        try:
            if sys.stdin.isatty() and sys.stdin.fileno() is not None:
                try:
                    self._new_stdin = os.fdopen(os.dup(sys.stdin.fileno()))
                except OSError:
                    # couldn't dupe stdin, most likely because it's
                    # not a valid file descriptor, so we just rely on
                    # using the one that was passed in
                    pass
        except (AttributeError, ValueError):
            # couldn't get stdin's fileno, so we just carry on
            pass

    def start(self):
        '''
        multiprocessing.Process replaces the worker's stdin with a new file
        opened on os.devnull, but we wish to preserve it if it is connected to
        a terminal. Therefore dup a copy prior to calling the real start(),
        ensuring the descriptor is preserved somewhere in the new child, and
        make sure it is closed in the parent when start() completes.
        '''

        self._save_stdin()
        try:
            return super(WorkerProcess, self).start()
        finally:
            if self._new_stdin != os.devnull:
                self._new_stdin.close()

    def _hard_exit(self, e):
        '''
        There is no safe exception to return to higher level code that does not
        risk an innocent try/except finding itself executing in the wrong
        process. All code executing above WorkerProcess.run() on the stack
        conceptually belongs to another program.
        '''

        try:
            display.debug(u"WORKER HARD EXIT: %s" % to_text(e))
        except BaseException:
            # If the cause of the fault is IOError being generated by stdio,
            # attempting to log a debug message may trigger another IOError.
            # Try printing once then give up.
            pass

        os._exit(1)

    def run(self):
        '''
        Wrap _run() to ensure no possibility an errant exception can cause
        control to return to the StrategyBase task loop, or any other code
        higher in the stack.

        As multiprocessing in Python 2.x provides no protection, it is possible
        a try/except added in far-away code can cause a crashed child process
        to suddenly assume the role and prior state of its parent.
        '''
        try:
            return self._run()
        except BaseException as e:
            self._hard_exit(e)

    def _run(self):
        '''
        Called when the process is started.  Pushes the result onto the
        results queue. We also remove the host from the blocked hosts list, to
        signify that they are ready for their next task.
        '''

        # import cProfile, pstats, StringIO
        # pr = cProfile.Profile()
        # pr.enable()

        if HAS_PYCRYPTO_ATFORK:
            atfork()

        try:
            # execute the task and build a TaskResult from the result
            display.debug("running TaskExecutor() for %s/%s" % (self._host, self._task))
            executor_result = TaskExecutor(
                self._host,
                self._task,
                self._task_vars,
                self._play_context,
                self._new_stdin,
                self._loader,
                self._shared_loader_obj,
                self._final_q
            ).run()

            display.debug("done running TaskExecutor() for %s/%s [%s]" % (self._host, self._task, self._task._uuid))
            self._host.vars = dict()
            self._host.groups = []
            task_result = TaskResult(
                self._host.name,
                self._task._uuid,
                executor_result,
                task_fields=self._task.dump_attrs(),
            )

            # put the result on the result queue
            display.debug("sending task result for task %s" % self._task._uuid)
            self._final_q.put(task_result)
            display.debug("done sending task result for task %s" % self._task._uuid)

        except AnsibleConnectionFailure:
            self._host.vars = dict()
            self._host.groups = []
            task_result = TaskResult(
                self._host.name,
                self._task._uuid,
                dict(unreachable=True),
                task_fields=self._task.dump_attrs(),
            )
            self._final_q.put(task_result, block=False)

        except Exception as e:
            if not isinstance(e, (IOError, EOFError, KeyboardInterrupt, SystemExit)) or isinstance(e, TemplateNotFound):
                try:
                    self._host.vars = dict()
                    self._host.groups = []
                    task_result = TaskResult(
                        self._host.name,
                        self._task._uuid,
                        dict(failed=True, exception=to_text(traceback.format_exc()), stdout=''),
                        task_fields=self._task.dump_attrs(),
                    )
                    self._final_q.put(task_result, block=False)
                except Exception:
                    display.debug(u"WORKER EXCEPTION: %s" % to_text(e))
                    display.debug(u"WORKER TRACEBACK: %s" % to_text(traceback.format_exc()))

        display.debug("WORKER PROCESS EXITING")

        # pr.disable()
        # s = StringIO.StringIO()
        # sortby = 'time'
        # ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
        # ps.print_stats()
        # with open('worker_%06d.stats' % os.getpid(), 'w') as f:
        #     f.write(s.getvalue())

doctests = """
########### Tests borrowed from or inspired by test_genexps.py ############

Test simple loop with conditional

    >>> sum([i*i for i in range(100) if i&1 == 1])
    166650

Test simple nesting

    >>> [(i,j) for i in range(3) for j in range(4)]
    [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]

Test nesting with the inner expression dependent on the outer

    >>> [(i,j) for i in range(4) for j in range(i)]
    [(1, 0), (2, 0), (2, 1), (3, 0), (3, 1), (3, 2)]

Make sure the induction variable is not exposed

    >>> i = 20
    >>> sum([i*i for i in range(100)])
    328350

    >>> i
    20

Verify that syntax error's are raised for listcomps used as lvalues

    >>> [y for y in (1,2)] = 10          # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
       ...
    SyntaxError: ...

    >>> [y for y in (1,2)] += 10         # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
       ...
    SyntaxError: ...


########### Tests borrowed from or inspired by test_generators.py ############

Make a nested list comprehension that acts like range()

    >>> def frange(n):
    ...     return [i for i in range(n)]
    >>> frange(10)
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Same again, only as a lambda expression instead of a function definition

    >>> lrange = lambda n:  [i for i in range(n)]
    >>> lrange(10)
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Generators can call other generators:

    >>> def grange(n):
    ...     for x in [i for i in range(n)]:
    ...         yield x
    >>> list(grange(5))
    [0, 1, 2, 3, 4]


Make sure that None is a valid return value

    >>> [None for i in range(10)]
    [None, None, None, None, None, None, None, None, None, None]

########### Tests for various scoping corner cases ############

Return lambdas that use the iteration variable as a default argument

    >>> items = [(lambda i=i: i) for i in range(5)]
    >>> [x() for x in items]
    [0, 1, 2, 3, 4]

Same again, only this time as a closure variable

    >>> items = [(lambda: i) for i in range(5)]
    >>> [x() for x in items]
    [4, 4, 4, 4, 4]

Another way to test that the iteration variable is local to the list comp

    >>> items = [(lambda: i) for i in range(5)]
    >>> i = 20
    >>> [x() for x in items]
    [4, 4, 4, 4, 4]

And confirm that a closure can jump over the list comp scope

    >>> items = [(lambda: y) for i in range(5)]
    >>> y = 2
    >>> [x() for x in items]
    [2, 2, 2, 2, 2]

We also repeat each of the above scoping tests inside a function

    >>> def test_func():
    ...     items = [(lambda i=i: i) for i in range(5)]
    ...     return [x() for x in items]
    >>> test_func()
    [0, 1, 2, 3, 4]

    >>> def test_func():
    ...     items = [(lambda: i) for i in range(5)]
    ...     return [x() for x in items]
    >>> test_func()
    [4, 4, 4, 4, 4]

    >>> def test_func():
    ...     items = [(lambda: i) for i in range(5)]
    ...     i = 20
    ...     return [x() for x in items]
    >>> test_func()
    [4, 4, 4, 4, 4]

    >>> def test_func():
    ...     items = [(lambda: y) for i in range(5)]
    ...     y = 2
    ...     return [x() for x in items]
    >>> test_func()
    [2, 2, 2, 2, 2]

"""


__test__ = {'doctests' : doctests}

def test_main(verbose=None):
    import sys
    from test import support
    from test import test_listcomps
    support.run_doctest(test_listcomps, verbose)

    # verify reference counting
    if verbose and hasattr(sys, "gettotalrefcount"):
        import gc
        counts = [None] * 5
        for i in range(len(counts)):
            support.run_doctest(test_genexps, verbose)
            gc.collect()
            counts[i] = sys.gettotalrefcount()
        print(counts)

if __name__ == "__main__":
    test_main(verbose=True)

#!/usr/bin/env python
from __future__ import print_function
from builtins import str
import sys
import pmagpy.pmag as pmag

def main():
    """
    NAME
        sites_locations.py

    DESCRIPTION
        reads in er_sites.txt file and finds all locations and bounds of locations
        outputs er_locations.txt file

    SYNTAX
        sites_locations.py [command line options]

    OPTIONS
        -h prints help message and quits
        -f: specimen input er_sites format file, default is "er_sites.txt"
        -F: locations table: default is "er_locations.txt"
    """
# set defaults
    site_file="er_sites.txt"
    loc_file="er_locations.txt"
    Names,user=[],"unknown"
    Done=[]
    version_num=pmag.get_version()
    args=sys.argv
    dir_path='.'
# get command line stuff
    if '-WD' in args:
        ind=args.index("-WD")
        dir_path=args[ind+1]
    if "-h" in args:
        print(main.__doc__)
        sys.exit()
    if '-f' in args:
        ind=args.index("-f")
        site_file=args[ind+1]
    if '-F' in args:
        ind=args.index("-F")
        loc_file=args[ind+1]
    #
    site_file=dir_path+'/'+site_file
    loc_file=dir_path+'/'+loc_file
    Sites,file_type=pmag.magic_read(site_file)
    if file_type != 'er_sites':
        print(file_type)
        print(file_type,"This is not a valid er_sites file ")
        sys.exit()
    # read in site data
    #
    LocNames,Locations=[],[]
    for site in Sites:
        if site['er_location_name'] not in LocNames: # new location name
            LocNames.append(site['er_location_name'])
            sites_locs=pmag.get_dictitem(Sites,'er_location_name',site['er_location_name'],'T') # get all sites for this loc
            lats=pmag.get_dictkey(sites_locs,'site_lat','f') # get all the latitudes as floats
            lons=pmag.get_dictkey(sites_locs,'site_lon','f') # get all the longitudes as floats
            LocRec={'er_citation_names':'This study','er_location_name':site['er_location_name'],'location_type':''}
            LocRec['location_begin_lat']=str(min(lats))
            LocRec['location_end_lat']=str(max(lats))
            LocRec['location_begin_lon']=str(min(lons))
            LocRec['location_end_lon']=str(max(lons))
            Locations.append(LocRec)
    if len(Locations)>0:
        pmag.magic_write(loc_file,Locations,"er_locations")
        print("Locations written to: ",loc_file)

if __name__ == "__main__":
    main()

# Copyright 2015 OpenStack Foundation
# All Rights Reserved.
#
#    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.

from oslo_utils import timeutils
import six
from tempest.api.identity import base
from tempest import test


class TokensV3Test(base.BaseIdentityV3Test):

    @test.idempotent_id('6f8e4436-fc96-4282-8122-e41df57197a9')
    def test_create_token(self):

        creds = self.os.credentials
        user_id = creds.user_id
        username = creds.username
        password = creds.password

        token_id, resp = self.non_admin_token.get_token(user_id=user_id,
                                                        password=password,
                                                        auth_data=True)

        self.assertNotEmpty(token_id)
        self.assertIsInstance(token_id, six.string_types)

        now = timeutils.utcnow()
        expires_at = timeutils.normalize_time(
            timeutils.parse_isotime(resp['expires_at']))
        self.assertGreater(resp['expires_at'],
                           resp['issued_at'])
        self.assertGreater(expires_at, now)

        subject_id = resp['user']['id']
        self.assertEqual(subject_id, user_id)

        subject_name = resp['user']['name']
        self.assertEqual(subject_name, username)

        self.assertEqual(resp['methods'][0], 'password')

"""Support for Genius Hub switch/outlet devices."""
from homeassistant.components.switch import SwitchDevice, DEVICE_CLASS_OUTLET
from homeassistant.helpers.typing import ConfigType, HomeAssistantType

from . import DOMAIN, GeniusZone

ATTR_DURATION = "duration"

GH_ON_OFF_ZONE = "on / off"


async def async_setup_platform(
    hass: HomeAssistantType, config: ConfigType, async_add_entities, discovery_info=None
) -> None:
    """Set up the Genius Hub switch entities."""
    if discovery_info is None:
        return

    broker = hass.data[DOMAIN]["broker"]

    async_add_entities(
        [
            GeniusSwitch(broker, z)
            for z in broker.client.zone_objs
            if z.data["type"] == GH_ON_OFF_ZONE
        ]
    )


class GeniusSwitch(GeniusZone, SwitchDevice):
    """Representation of a Genius Hub switch."""

    @property
    def device_class(self):
        """Return the class of this device, from component DEVICE_CLASSES."""
        return DEVICE_CLASS_OUTLET

    @property
    def is_on(self) -> bool:
        """Return the current state of the on/off zone.

        The zone is considered 'on' if & only if it is override/on (e.g. timer/on is 'off').
        """
        return self._zone.data["mode"] == "override" and self._zone.data["setpoint"]

    async def async_turn_off(self, **kwargs) -> None:
        """Send the zone to Timer mode.

        The zone is deemed 'off' in this mode, although the plugs may actually be on.
        """
        await self._zone.set_mode("timer")

    async def async_turn_on(self, **kwargs) -> None:
        """Set the zone to override/on ({'setpoint': true}) for x seconds."""
        await self._zone.set_override(1, kwargs.get(ATTR_DURATION, 3600))

# Copyright (c) The PyAMF Project.
# See LICENSE.txt for details.

"""
Provides XML support.

@since: 0.6
"""

#: list of supported third party packages that support the C{etree}
#: interface. At least enough for our needs anyway.
ETREE_MODULES = [
    'defusedxml.lxml',
    'defusedxml.cElementTree',
    'defusedxml.ElementTree',
]

#: A tuple of class/type objects that are used to represent XML objects.
types = None
#: A mapping of type -> module for all known xml types.
modules = {}
#: The module that will be used to create C{ElementTree} instances.
ET = None

__all__ = ['set_default_interface']


def set_default_interface(etree):
    """
    Sets the default interface that PyAMF will use to deal with XML entities
    (both objects and blobs).
    """
    global types, ET, modules

    t = _get_etree_type(etree)

    _types = set(types or [])
    _types.update([t])

    types = tuple(_types)

    modules[t] = etree

    old, ET = ET, etree

    return old


def find_libs():
    """
    Run through L{ETREE_MODULES} and find C{ElementTree} implementations so
    that any type can be encoded.

    We work through the C implementations first, then the pure Python versions.
    The downside to this is that B{all} libraries will be imported but I{only}
    one is ever used. The libs are small (relatively) and the flexibility that
    this gives seems to outweigh the cost. Time will tell.
    """
    from pyamf.util import get_module

    types = []
    mapping = {}

    for mod in ETREE_MODULES:
        try:
            etree = get_module(mod)
        except ImportError:
            continue

        t = _get_etree_type(etree)

        types.append(t)
        mapping[t] = etree

    return tuple(types), mapping


def is_xml(obj):
    """
    Determines C{obj} is a valid XML type.

    If L{types} is not populated then L{find_libs} be called.
    """
    global types

    try:
        _bootstrap()
    except ImportError:
        return False

    return isinstance(obj, types)


def _get_type(e):
    """
    Returns the type associated with handling XML objects from this etree
    interface.
    """
    try:
        return e.__class__
    except AttributeError:
        return type(e)


def _get_etree_type(etree):
    """
    Returns the type associated with handling XML objects from this etree
    interface.
    """
    e = etree.fromstring('<foo/>')

    return _get_type(e)


def _no_et():
    raise ImportError(
        'Unable to find at least one compatible ElementTree library, use '
        'pyamf.set_default_etree to enable XML support'
    )


def _bootstrap():
    global types, modules, ET

    if types is None:
        types, modules = find_libs()

    if ET is None:
        try:
            etree = modules[types[0]]
        except IndexError:
            _no_et()

        set_default_interface(etree)


def tostring(element, *args, **kwargs):
    """
    Helper func to provide easy access to the (possibly) moving target that is
    C{ET}.
    """
    global modules

    _bootstrap()
    t = _get_type(element)

    etree = modules.get(t, None)

    if not etree:
        raise RuntimeError(
            'Unable to find the etree implementation related to %r '
            '(type %r)' % (element, t)
        )

    return etree.tostring(element, *args, **kwargs)


def fromstring(*args, **kwargs):
    """
    Helper func to provide easy access to the (possibly) moving target that is
    C{ET}.
    """
    global ET

    _bootstrap()

    kwargs.setdefault('forbid_dtd', True)
    kwargs.setdefault('forbid_entities', True)

    return ET.fromstring(*args, **kwargs)

"""
You are given two arrays A and B each containing integers.
You need to choose exactly one number from A and exactly one number from B such that
the index of the two chosen numbers is not same and the sum of
the 2 chosen values is minimum.

Your objective is to find and print this minimum value.
"""

#!/bin/python3

import sys

def twinArrays(ar1, ar2):

    result = 0
    l = len(ar1)

    first_min = sec_min = sys.maxsize

    index_1 = 0

    min_2 = first_min
    index_2 = 0


    # get the smallest value
    for i in range(l):
        if ar1[i] < first_min :
            # get the second smallest value
            sec_min = first_min
            # get the first smallest value
            first_min = ar1[i]
            index_1 = i

        if ar2[i] < min_2:
            min_2 = ar2[i]
            index_2 = i


        elif ar1[i] < sec_min and ar1[i] != first_min:
            sec_min = ar1[i]


    print(index_1, "first min:",first_min)
    print(index_2, "second min:", min_2)
    print(sec_min)

    if index_1 != index_2:
        result = first_min + min_2
    else:
        result = sec_min + min_2

    return result

# Unit Test
ar1 = [3,6,5,7,3,4]
ar2 = [2,5,2,1,6,9]
result = twinArrays(ar1, ar2)
print(result)

# Copyright (c) 2013, Gustav Tiger
# All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# 
# * Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
# 
# * Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
# 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

import urllib
import json

class Filmtipset:
    """Class for communicating with the Filmtipset API"""
    
    URL_API = "http://www.filmtipset.se/api/api.cgi"
    
    def __init__(self, access_key, user_key, user):
        self.access_key = access_key
        self.user_key = user_key
        self.user = user

    def _request(self, action, parameters):
        """Filmtipset API request, takes an action (imdb, movie, grade, etc)
           and a map of additional parameters"""
        values = {"accesskey": self.access_key,
                  "userkey": self.user_key,
                  "user": self.user,
                  "returntype": "json",
                  "action": action}
        
        values.update(parameters)
        
        url = Filmtipset.URL_API + "?" + urllib.urlencode(values)
        return json.load(urllib.urlopen(url), "iso-8859-1")

    def get_movie(self, movie):
        """ Get movie information from a filmtipset id"""
        data = self._request("movie", {"id": movie, "nocomments": 1})
        return data[0]["data"][0]["movie"]
        
    def get_movie_imdb(self, imdb):
        """ Get movie information from an iMDB id"""
        if imdb.startswith("tt"):
            imdb = imdb[2:]
        data = self._request("imdb", {"id": imdb, "nocomments": 1})
        return data[0]["data"][0]["movie"]

    def grade(self, movie, grade):
        """ Grade movie specified by a filmtipset id, and a grade [1-5]"""
        response = self._request("grade", {"id": movie, "grade": grade})[0]
        try:
            movie = response["data"][0]["movie"]
            seen  = movie["grade"]["type"] == "seen"
            return seen and int(movie["grade"]["value"]) == int(grade)
        except KeyError:
            return False

# $Id$
#
#  Copyright (C) 2002-2008  greg Landrum and Rational Discovery LLC
#
#   @@ All Rights Reserved @@
#  This file is part of the RDKit.
#  The contents are covered by the terms of the BSD license
#  which is included in the file license.txt, found at the root
#  of the RDKit source tree.
#
""" command line utility to report on the contributions of descriptors to
tree-based composite models

Usage:  AnalyzeComposite [optional args] <models>

      <models>: file name(s) of pickled composite model(s)
        (this is the name of the db table if using a database)

    Optional Arguments:

      -n number: the number of levels of each model to consider

      -d dbname: the database from which to read the models

      -N Note: the note string to search for to pull models from the database

      -v: be verbose whilst screening
"""
from __future__ import print_function

import sys

import numpy

from rdkit.Dbase.DbConnection import DbConnect
from rdkit.ML import ScreenComposite
from rdkit.ML.Data import Stats
from rdkit.ML.DecTree import TreeUtils, Tree
from rdkit.six.moves import cPickle


__VERSION_STRING = "2.2.0"


def ProcessIt(composites, nToConsider=3, verbose=0):
  composite = composites[0]
  nComposites = len(composites)
  ns = composite.GetDescriptorNames()
  # nDesc = len(ns)-2
  if len(ns) > 2:
    globalRes = {}

    nDone = 1
    descNames = {}
    for composite in composites:
      if verbose > 0:
        print('#------------------------------------')
        print('Doing: ', nDone)
      nModels = len(composite)
      nDone += 1
      res = {}
      for i in range(len(composite)):
        model = composite.GetModel(i)
        if isinstance(model, Tree.TreeNode):
          levels = TreeUtils.CollectLabelLevels(model, {}, 0, nToConsider)
          TreeUtils.CollectDescriptorNames(model, descNames, 0, nToConsider)
          for descId in levels.keys():
            v = res.get(descId, numpy.zeros(nToConsider, numpy.float))
            v[levels[descId]] += 1. / nModels
            res[descId] = v
      for k in res:
        v = globalRes.get(k, numpy.zeros(nToConsider, numpy.float))
        v += res[k] / nComposites
        globalRes[k] = v
      if verbose > 0:
        for k in res.keys():
          name = descNames[k]
          strRes = ', '.join(['%4.2f' % x for x in res[k]])
          print('%s,%s,%5.4f' % (name, strRes, sum(res[k])))

        print()

    if verbose >= 0:
      print('# Average Descriptor Positions')
    retVal = []
    for k in globalRes:
      name = descNames[k]
      if verbose >= 0:
        strRes = ', '.join(['%4.2f' % x for x in globalRes[k]])
        print('%s,%s,%5.4f' % (name, strRes, sum(globalRes[k])))
      tmp = [name]
      tmp.extend(globalRes[k])
      tmp.append(sum(globalRes[k]))
      retVal.append(tmp)
    if verbose >= 0:
      print()
  else:
    retVal = []
  return retVal


def ErrorStats(conn, where, enrich=1):
  fields = ('overall_error,holdout_error,overall_result_matrix,' +
            'holdout_result_matrix,overall_correct_conf,overall_incorrect_conf,' +
            'holdout_correct_conf,holdout_incorrect_conf')
  try:
    data = conn.GetData(fields=fields, where=where)
  except Exception:
    import traceback
    traceback.print_exc()
    return None
  nPts = len(data)
  if not nPts:
    sys.stderr.write('no runs found\n')
    return None
  overall = numpy.zeros(nPts, numpy.float)
  overallEnrich = numpy.zeros(nPts, numpy.float)
  oCorConf = 0.0
  oInCorConf = 0.0
  holdout = numpy.zeros(nPts, numpy.float)
  holdoutEnrich = numpy.zeros(nPts, numpy.float)
  hCorConf = 0.0
  hInCorConf = 0.0
  overallMatrix = None
  holdoutMatrix = None
  for i in range(nPts):
    if data[i][0] is not None:
      overall[i] = data[i][0]
      oCorConf += data[i][4]
      oInCorConf += data[i][5]
    if data[i][1] is not None:
      holdout[i] = data[i][1]
      haveHoldout = 1
    else:
      haveHoldout = 0
    tmpOverall = 1. * eval(data[i][2])
    if enrich >= 0:
      overallEnrich[i] = ScreenComposite.CalcEnrichment(tmpOverall, tgt=enrich)
    if haveHoldout:
      tmpHoldout = 1. * eval(data[i][3])
      if enrich >= 0:
        holdoutEnrich[i] = ScreenComposite.CalcEnrichment(tmpHoldout, tgt=enrich)
    if overallMatrix is None:
      if data[i][2] is not None:
        overallMatrix = tmpOverall
      if haveHoldout and data[i][3] is not None:
        holdoutMatrix = tmpHoldout
    else:
      overallMatrix += tmpOverall
      if haveHoldout:
        holdoutMatrix += tmpHoldout
    if haveHoldout:
      hCorConf += data[i][6]
      hInCorConf += data[i][7]

  avgOverall = sum(overall) / nPts
  oCorConf /= nPts
  oInCorConf /= nPts
  overallMatrix /= nPts
  oSort = numpy.argsort(overall)
  oMin = overall[oSort[0]]
  overall -= avgOverall
  devOverall = numpy.sqrt(sum(overall**2) / (nPts - 1))
  res = {}
  res['oAvg'] = 100 * avgOverall
  res['oDev'] = 100 * devOverall
  res['oCorrectConf'] = 100 * oCorConf
  res['oIncorrectConf'] = 100 * oInCorConf
  res['oResultMat'] = overallMatrix
  res['oBestIdx'] = oSort[0]
  res['oBestErr'] = 100 * oMin

  if enrich >= 0:
    mean, dev = Stats.MeanAndDev(overallEnrich)
    res['oAvgEnrich'] = mean
    res['oDevEnrich'] = dev

  if haveHoldout:
    avgHoldout = sum(holdout) / nPts
    hCorConf /= nPts
    hInCorConf /= nPts
    holdoutMatrix /= nPts
    hSort = numpy.argsort(holdout)
    hMin = holdout[hSort[0]]
    holdout -= avgHoldout
    devHoldout = numpy.sqrt(sum(holdout**2) / (nPts - 1))
    res['hAvg'] = 100 * avgHoldout
    res['hDev'] = 100 * devHoldout
    res['hCorrectConf'] = 100 * hCorConf
    res['hIncorrectConf'] = 100 * hInCorConf
    res['hResultMat'] = holdoutMatrix
    res['hBestIdx'] = hSort[0]
    res['hBestErr'] = 100 * hMin
    if enrich >= 0:
      mean, dev = Stats.MeanAndDev(holdoutEnrich)
      res['hAvgEnrich'] = mean
      res['hDevEnrich'] = dev
  return res


def ShowStats(statD, enrich=1):
  statD = statD.copy()
  statD['oBestIdx'] = statD['oBestIdx'] + 1
  txt = """
# Error Statistics:
\tOverall: %(oAvg)6.3f%% (%(oDev)6.3f)  %(oCorrectConf)4.1f/%(oIncorrectConf)4.1f
\t\tBest: %(oBestIdx)d %(oBestErr)6.3f%%""" % (statD)
  if 'hAvg' in statD:
    statD['hBestIdx'] = statD['hBestIdx'] + 1
    txt += """
\tHoldout: %(hAvg)6.3f%% (%(hDev)6.3f)  %(hCorrectConf)4.1f/%(hIncorrectConf)4.1f
\t\tBest: %(hBestIdx)d %(hBestErr)6.3f%%
  """ % (statD)
  print(txt)
  print()
  print('# Results matrices:')
  print('\tOverall:')
  tmp = numpy.transpose(statD['oResultMat'])
  colCounts = sum(tmp)
  rowCounts = sum(tmp, 1)
  for i in range(len(tmp)):
    if rowCounts[i] == 0:
      rowCounts[i] = 1
    row = tmp[i]
    print('\t\t', end='')
    for j in range(len(row)):
      print('% 6.2f' % row[j], end='')
    print('\t| % 4.2f' % (100. * tmp[i, i] / rowCounts[i]))
  print('\t\t', end='')
  for i in range(len(tmp)):
    print('------', end='')
  print()
  print('\t\t', end='')
  for i in range(len(tmp)):
    if colCounts[i] == 0:
      colCounts[i] = 1
    print('% 6.2f' % (100. * tmp[i, i] / colCounts[i]), end='')
  print()
  if enrich > -1 and 'oAvgEnrich' in statD:
    print('\t\tEnrich(%d): %.3f (%.3f)' % (enrich, statD['oAvgEnrich'], statD['oDevEnrich']))

  if 'hResultMat' in statD:
    print('\tHoldout:')
    tmp = numpy.transpose(statD['hResultMat'])
    colCounts = sum(tmp)
    rowCounts = sum(tmp, 1)
    for i in range(len(tmp)):
      if rowCounts[i] == 0:
        rowCounts[i] = 1
      row = tmp[i]
      print('\t\t', end='')
      for j in range(len(row)):
        print('% 6.2f' % row[j], end='')
      print('\t| % 4.2f' % (100. * tmp[i, i] / rowCounts[i]))
    print('\t\t', end='')
    for i in range(len(tmp)):
      print('------', end='')
    print()
    print('\t\t', end='')
    for i in range(len(tmp)):
      if colCounts[i] == 0:
        colCounts[i] = 1
      print('% 6.2f' % (100. * tmp[i, i] / colCounts[i]), end='')
    print()
    if enrich > -1 and 'hAvgEnrich' in statD:
      print('\t\tEnrich(%d): %.3f (%.3f)' % (enrich, statD['hAvgEnrich'], statD['hDevEnrich']))

  return


def Usage():
  print(__doc__)
  sys.exit(-1)


if __name__ == "__main__":
  import getopt
  try:
    args, extras = getopt.getopt(sys.argv[1:], 'n:d:N:vX', ('skip',
                                                            'enrich=', ))
  except Exception:
    Usage()

  count = 3
  db = None
  note = ''
  verbose = 0
  skip = 0
  enrich = 1
  for arg, val in args:
    if arg == '-n':
      count = int(val) + 1
    elif arg == '-d':
      db = val
    elif arg == '-N':
      note = val
    elif arg == '-v':
      verbose = 1
    elif arg == '--skip':
      skip = 1
    elif arg == '--enrich':
      enrich = int(val)
  composites = []
  if db is None:
    for arg in extras:
      composite = cPickle.load(open(arg, 'rb'))
      composites.append(composite)
  else:
    tbl = extras[0]
    conn = DbConnect(db, tbl)
    if note:
      where = "where note='%s'" % (note)
    else:
      where = ''
    if not skip:
      pkls = conn.GetData(fields='model', where=where)
      composites = []
      for pkl in pkls:
        pkl = str(pkl[0])
        comp = cPickle.loads(pkl)
        composites.append(comp)

  if len(composites):
    ProcessIt(composites, count, verbose=verbose)
  elif not skip:
    print('ERROR: no composite models found')
    sys.exit(-1)

  if db:
    res = ErrorStats(conn, where, enrich=enrich)
    if res:
      ShowStats(res)

# pyOCD debugger
# Copyright (c) 2020 Arm Limited
# Copyright (c) 2021 Chris Reed
# SPDX-License-Identifier: Apache-2.0
#
# 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.

import logging
from enum import Enum

from .component import CoreSightComponent
from ..core import exceptions
from ..utility.timeout import Timeout

LOG = logging.getLogger(__name__)

class ComPortError(exceptions.Error):
    """! @brief Base class for SDC-600 exceptions."""
    pass

class UnexpectedFlagError(ComPortError):
    """! @brief Received an unexpected or out of order flag byte."""
    pass

class LinkError(ComPortError):
    """! @brief Received a link error flag (LERR)."""
    pass

class LinkClosedException(ComPortError):
    """! @brief Received an unexpected or out of order flag byte."""
    def __init__(self, phase):
        self._phase = phase
    
    @property
    def phase(self):
        """! @brief The link phase that was closed from the other side."""
        return self._phase

class SDC600(CoreSightComponent):
    """! @brief SDC-600 component.
    """
    
    ## Default timeout for an operation or packet transfer.
    TRANSFER_TIMEOUT = 30.0
    
    class LinkPhase(Enum):
        """! @brief COM Port link phases."""
        ## Hardware-defined link phase.
        PHASE1 = 1
        ## Software-defiend link phase.
        PHASE2 = 2
    
    class Register:
        """! @brief Namespace for SDC-600 register offset constants."""
        # Register offsets.
        VIDR        = 0xD00
        FIDTXR      = 0xD08
        FIDRXR      = 0xD0C
        ICSR        = 0xD10
        DR          = 0xD20
        SR          = 0xD2C
        DBR         = 0xD30
        SR_ALIAS    = 0xD3C

        # FIDTXR and FIDRXR bit definitions.
        FIDxXR_xXI_MASK     = (0x00000001)
        FIDxXR_xXI_SHIFT    = (0)
        FIDxXR_xXINT_MASK   = (0x00000002)
        FIDxXR_xXINT_SHIFT  = (1)
        FIDxXR_xXW_MASK     = (0x000000f0)
        FIDxXR_xXW_SHIFT    = (4)
        FIDxXR_xXSZ8_MASK   = (0x00000100)
        FIDxXR_xXSZ8_SHIFT  = (8)
        FIDxXR_xXSZ16_MASK  = (0x00000200)
        FIDxXR_xXSZ16_SHIFT = (9)
        FIDxXR_xXSZ32_MASK  = (0x00000400)
        FIDxXR_xXSZ32_SHIFT = (10)
        FIDxXR_xXFD_MASK    = (0x000f0000)
        FIDxXR_xXFD_SHIFT   = (16)
        
        # SR bit definitions.
        SR_TXS_MASK         = (0x000000ff)
        SR_TXS_SHIFT        = (0)
        SR_RRDIS_MASK       = (0x00001000)
        SR_RRDIS_SHIFT      = (12)
        SR_TXOE_MASK        = (0x00002000)
        SR_TXOE_SHIFT       = (13)
        SR_TXLE_MASK        = (0x00004000)
        SR_TXLE_SHIFT       = (14)
        SR_TRINPROG_MASK    = (0x00008000)
        SR_TRINPROG_SHIFT   = (18)
        SR_RXF_MASK         = (0x00ff0000)
        SR_RXF_SHIFT        = (16)
        SR_RXLE_MASK        = (0x40000000)
        SR_RXLE_SHIFT       = (30)
        SR_PEN_MASK         = (0x80000000)
        SR_PEN_SHIFT        = (31)
    
    class Flag:
        """! @brief Namespace with SDC-600 flag byte constants."""
        IDR     = 0xA0
        IDA     = 0xA1
        LPH1RA  = 0xA6
        LPH1RL  = 0xA7
        LPH2RA  = 0xA8
        LPH2RL  = 0xA9
        LPH2RR  = 0xAA
        LERR    = 0xAB
        START   = 0xAC
        END     = 0xAD
        ESC     = 0xAE
        NULL    = 0xAF
        
        # All bytes with 0b101 in bits [7:5] are flag bytes.
        MASK = 0xE0
        IDENTIFIER = 0b10100000
        
        ## Map from flag value to name.
        NAME = {
            IDR     : "IDR",
            IDA     : "IDA",
            LPH1RA  : "LPH1RA",
            LPH1RL  : "LPH1RL",
            LPH2RA  : "LPH2RA",
            LPH2RL  : "LPH2RL",
            LPH2RR  : "LPH2RR",
            LERR    : "LERR",
            START   : "START",
            END     : "END",
            ESC     : "ESC",
            NULL    : "NULL",
            }
    
    ## NULL bytes must be written to the upper bytes, and will be present in the upper bytes
    # when read.
    NULL_FILL = 0xAFAFAF00
    
    def __init__(self, ap, cmpid=None, addr=None):
        super(SDC600, self).__init__(ap, cmpid, addr)
        self._tx_width = 0
        self._rx_width = 0
        self._current_link_phase = None

    def init(self):
        """! @brief Inits the component.
        
        Reads the RX and TX widths and whether the SDC-600 is enabled. All error flags are cleared.
        """
        fidtx = self.ap.read32(self.Register.FIDTXR)
        LOG.debug("fidtx=0x%08x", fidtx)
        fidrx = self.ap.read32(self.Register.FIDRXR)
        LOG.debug("fidrx=0x%08x", fidrx)
        
        self._tx_width = (fidtx & self.Register.FIDxXR_xXW_MASK) >> self.Register.FIDxXR_xXW_SHIFT
        
        self._rx_width = (fidrx & self.Register.FIDxXR_xXW_MASK) >> self.Register.FIDxXR_xXW_SHIFT
        
        status = self.ap.read32(self.Register.SR)
        LOG.debug("status=0x%08x", status)
        self._is_enabled = (status & self.Register.SR_PEN_MASK) != 0
        
        # Clear any error flags.
        error_flags = status & (self.Register.SR_TXOE_MASK | self.Register.SR_TXLE_MASK)
        if error_flags:
            self.ap.write32(self.Register.SR, error_flags)
    
    @property
    def is_enabled(self):
        """! @brief Whether the SDC-600 is enabled."""
        return self._is_enabled
    
    @property
    def is_reboot_request_enabled(self):
        """! @brief Whether the Reboot Request feature is enabled in the SDC-600."""
        return (self.ap.read32(self.Register.SR) & self.Register.SR_RRDIS_MASK) == 0
    
    @property
    def current_link_phase(self):
        """! @brief Currently established link phase.
        @return Either None or one of the SDC600.LinkPhase enums.
        """
        return self._current_link_phase

    def _read1(self, to_):
        """! @brief Read a single byte.
        
        If a NULL byte is received, it is ignored and another byte is read. No other flag bytes
        are processed.
        
        @exception TimeoutError
        """
        while True:
            # Wait until a byte is ready in the receive FIFO.
            while to_.check():
                if (self.ap.read32(self.Register.SR) & self.Register.SR_RXF_MASK) != 0:
                    break
            else:
                raise exceptions.TimeoutError("timeout while reading from SDC-600")

            # Read the data register and strip off NULL bytes in high bytes.
            value = self.ap.read32(self.Register.DR) & 0xFF

            # Ignore NULL flag bytes.
            if value == self.Flag.NULL:
                continue
            
            return value
        
    def _write1(self, value, to_):
        """! @brief Write one or more bytes.
        @exception TimeoutError
        """
        # Wait until room is available in the transmit FIFO.
        while to_.check():
            if (self.ap.read32(self.Register.SR) & self.Register.SR_TXS_MASK) != 0:
                break
        else:
            raise exceptions.TimeoutError("timeout while writing to SDC-600")

        # Write this byte to the transmit FIFO.
        dbr_value = self.NULL_FILL | (value & 0xFF)
        self.ap.write32(self.Register.DR, dbr_value)

    def _check_flags(self, value, to_):
        """! @brief Handle link and error related flag bytes.
        @param self
        @param value Integer byte value to check.
        @param to_ Timeout object.
        @exception UnexpectedFlagError
        @exception LinkClosedException
        @exception LinkError
        @exception TimeoutError
        """
        if value == self.Flag.LPH1RL:
            LOG.debug("got LPH1RL!")
            self._current_link_phase = None
            raise LinkClosedException(self.LinkPhase.PHASE1)
        elif value == self.Flag.LPH2RL:
            LOG.debug("got LPH2RL!")
            # Target killed the phase 2 connection. Send required reply.
            self._current_link_phase = self.LinkPhase.PHASE1
            self._write1(self.Flag.LPH2RL, to_)
            raise LinkClosedException(self.LinkPhase.PHASE2)
        elif value == self.Flag.LERR:
            LOG.debug("got LERR!")
            raise LinkError()
        # Catch reserved flags.
        elif (0xA2 <= value <= 0xA5) or (0xB0 <= value <= 0xBF):
            raise UnexpectedFlagError("received reserved flag value ({:#04x})".format(value))

    def _expect_flag(self, flag, to_):
        """! @brief Read a byte and compare to expected value.
        @param self
        @param flag Integer flag byte value to match.
        @param to_ Timeout object.
        @exception UnexpectedFlagError
        @exception LinkClosedException
        @exception TimeoutError
        """
        value = self._read1(to_)
        if value != flag:
            # Check certain flags we have to handle. This will raise if a flag is handled.
            self._check_flags(value, to_)
            # _check_flags() did not raise, so we should .
            raise UnexpectedFlagError("got {:#04x} instead of expected {} ({:#04x})".format(
                        value, self.Flag.NAME[flag], flag))
        else:
            LOG.debug("got expected %s", self.Flag.NAME[value])

    def _stuff(self, data):
        """! @brief Perform COM Encapsulation byte stuffing.
        @param self
        @param data List of integers of the original data.
        @return List of integers for the escaped version of _data_.
        """
        result = []
        for value in data:
            # Values matching flag bytes just get copied to output.
            if (value & self.Flag.MASK) == self.Flag.IDENTIFIER:
                # Insert escape flag.
                result.append(self.Flag.ESC)
                
                # Invert high bit.
                value ^= 0x80
            
            result.append(value)
        return result

    def _destuff(self, data):
        """! @brief Remove COM Encapsulation byte stuffing.
        @param self
        @param data List of integers. The only acceptable flag byte is ESC.
        @return List of integers properly de-stuffed.
        """
        result = []
        i = 0
        while i < len(data):
            value = data[i]
            
            # Check for escaped bytes.
            if value == self.Flag.ESC:
                # Skip over escape.
                i += 1
                
                # Get escaped byte and invert high bit to destuff it.
                value = data[i] ^ 0x80
            
            result.append(value)
            
            i += 1
        return result

    def _read_packet_data_to_end(self, to_):
        """! @brief Read an escaped packet from the first message byte to the end.
        @exception UnexpectedFlagError
        @exception LinkClosedException
        @exception TimeoutError
        """
        result = []
        while to_.check():
            value = self._read1(to_)
            
            # Check for the packet end marker flag.
            if value == self.Flag.END:
                break
            # Handle other flag bytes. This will raise on any detected flags.
            elif (value & self.Flag.MASK) == self.Flag.IDENTIFIER:
                self._check_flags(value, to_)

            # Append data bytes.
            result.append(value)
        else:
            raise exceptions.TimeoutError("timeout while reading from SDC-600")
        
        return self._destuff(result)

    def receive_packet(self, timeout=TRANSFER_TIMEOUT):
        """! @brief Read a data packet.
        
        Reads a packet (PDU) from the target and removes byte stuffing. The timeout for reading the
        entire packet can be set via the _timeout_ parameter.
        
        As data is read from the target, special flags for link errors or to close either phase of
        the link are handled and an appropriate exception is raised.
        
        The connection must be in link phase 2.
        
        @param self
        @param timeout Optional timeout for reading the entire packet. If reading times out, a
            TimeoutError exception is raised.
        @return List of integer byte values of the de-escaped packet contents.
        
        @exception UnexpectedFlagError
        @exception LinkClosedException
        @exception TimeoutError
        """
        assert self._current_link_phase == self.LinkPhase.PHASE2
        with Timeout(timeout) as to_:
            self._expect_flag(self.Flag.START, to_)
            return self._read_packet_data_to_end(to_)
    
    def send_packet(self, data, timeout=TRANSFER_TIMEOUT):
        """! @brief Send a data packet.
        
        Sends the provided data to the target as a single packet (PDU), escaping bytes as necessary.
        No data is read while the packet is sent, so if the target closes the connection it will
        not be detected.
        
        The connection must be in link phase 2.
        
        @param self
        @param data List of integer byte values to send. Must not be pre-escaped.
        @param timeout Optional timeout for reading the entire packet. If reading times out, a
            TimeoutError exception is raised.
        
        @exception UnexpectedFlagError
        @exception TimeoutError
        """
        assert self._current_link_phase == self.LinkPhase.PHASE2
        with Timeout(timeout) as to_:
            self._write1(self.Flag.START, to_)
            for value in self._stuff(data):
                self._write1(value, to_)
            self._write1(self.Flag.END, to_)
    
    def open_link(self, phase, timeout=TRANSFER_TIMEOUT):
        """! @brief Send the LPH1RA or LPH2RA flag.
        @exception UnexpectedFlagError
        @exception LinkClosedException
        @exception TimeoutError
        """
        with Timeout(timeout) as to_:
            if phase == self.LinkPhase.PHASE1:
                assert self._current_link_phase is None

                # Close link phase 1 first, to put it in a known state.
                self.close_link(self.LinkPhase.PHASE1)
        
                LOG.debug("sending LPH1RA")
                self._write1(self.Flag.LPH1RA, to_)
                self._expect_flag(self.Flag.LPH1RA, to_)
                
                self._current_link_phase = self.LinkPhase.PHASE1
            elif phase == self.LinkPhase.PHASE2:
                assert self._current_link_phase == self.LinkPhase.PHASE1

                LOG.debug("sending LPH2RA")
                self._write1(self.Flag.LPH2RA, to_)
                self._expect_flag(self.Flag.LPH2RA, to_)
                
                self._current_link_phase = self.LinkPhase.PHASE2
            else:
                raise ValueError("unrecognized phase value")

    def close_link(self, phase, timeout=TRANSFER_TIMEOUT):
        """! @brief Send the LPH1RL or LPH2RL flag.
        
        Link phase 1 can be closed from any state. Link phase 2 can only be closed when the
        connection is already in that phase.
        
        @exception UnexpectedFlagError
        @exception TimeoutError
        """
        with Timeout(timeout) as to_:
            if phase == self.LinkPhase.PHASE1:
                # Link phase 1 can be closed from any state, so we don't assert here.
                LOG.debug("sending LPH1RL")
                self._write1(self.Flag.LPH1RL, to_)
                self._expect_flag(self.Flag.LPH1RL, to_)
            
                self._current_link_phase = None
            elif phase == self.LinkPhase.PHASE2:
                assert self._current_link_phase == self.LinkPhase.PHASE2

                LOG.debug("sending LPH2RL")
                self._write1(self.Flag.LPH2RL, to_)
                self._expect_flag(self.Flag.LPH2RL, to_)
            
                self._current_link_phase = self.LinkPhase.PHASE1
            else:
                raise ValueError("unrecognized phase value")

    def _log_status(self):
        status = self.ap.read32(self.Register.SR)
        LOG.info("status=0x%08x phase=%s", status, self._current_link_phase)

    def read_protocol_id(self, timeout=TRANSFER_TIMEOUT):
        """! @brief Read and return the 6-byte protocol ID.
        @exception UnexpectedFlagError
        @exception LinkClosedException
        @exception TimeoutError
        """
        with Timeout(timeout) as to_:
            self._write1(self.Flag.IDR, to_)
            self._expect_flag(self.Flag.IDA, to_)
            return self._read_packet_data_to_end(to_)
    
    def send_reboot_request(self, timeout=TRANSFER_TIMEOUT):
        """! @brief Send remote reboot request."""
        with Timeout(timeout) as to_:
            self._write1(self.Flag.LPH2RR, to_)
    
    def __repr__(self):
        return "<SDC-600@{:x}: en={} txw={} rxw={} phase={}>".format(id(self),
            self._is_enabled, self._tx_width, self._rx_width, self._current_link_phase)
        



"""
DE-specific Form helpers
"""

from __future__ import absolute_import, unicode_literals

import re

from django.contrib.localflavor.de.de_states import STATE_CHOICES
from django.core.validators import EMPTY_VALUES
from django.forms import ValidationError
from django.forms.fields import Field, RegexField, Select
from django.utils.translation import ugettext_lazy as _


id_re = re.compile(r"^(?P<residence>\d{10})(?P<origin>\w{1,3})[-\ ]?(?P<birthday>\d{7})[-\ ]?(?P<validity>\d{7})[-\ ]?(?P<checksum>\d{1})$")

class DEZipCodeField(RegexField):
    default_error_messages = {
        'invalid': _('Enter a zip code in the format XXXXX.'),
    }
    def __init__(self, max_length=None, min_length=None, *args, **kwargs):
        super(DEZipCodeField, self).__init__(r'^\d{5}$',
            max_length, min_length, *args, **kwargs)

class DEStateSelect(Select):
    """
    A Select widget that uses a list of DE states as its choices.
    """
    def __init__(self, attrs=None):
        super(DEStateSelect, self).__init__(attrs, choices=STATE_CHOICES)

class DEIdentityCardNumberField(Field):
    """
    A German identity card number.

    Checks the following rules to determine whether the number is valid:

        * Conforms to the XXXXXXXXXXX-XXXXXXX-XXXXXXX-X format.
        * No group consists entirely of zeroes.
        * Included checksums match calculated checksums

    Algorithm is documented at http://de.wikipedia.org/wiki/Personalausweis
    """
    default_error_messages = {
        'invalid': _('Enter a valid German identity card number in XXXXXXXXXXX-XXXXXXX-XXXXXXX-X format.'),
    }

    def has_valid_checksum(self, number):
        given_number, given_checksum = number[:-1], number[-1]
        calculated_checksum = 0
        fragment = ""
        parameter = 7

        for i in range(len(given_number)):
            fragment = str(int(given_number[i]) * parameter)
            if fragment.isalnum():
                calculated_checksum += int(fragment[-1])
            if parameter == 1:
                parameter = 7
            elif parameter == 3:
                parameter = 1
            elif parameter ==7:
                parameter = 3

        return str(calculated_checksum)[-1] == given_checksum

    def clean(self, value):
        super(DEIdentityCardNumberField, self).clean(value)
        if value in EMPTY_VALUES:
            return ''
        match = re.match(id_re, value)
        if not match:
            raise ValidationError(self.error_messages['invalid'])

        gd = match.groupdict()
        residence, origin = gd['residence'], gd['origin']
        birthday, validity, checksum = gd['birthday'], gd['validity'], gd['checksum']

        if residence == '0000000000' or birthday == '0000000' or validity == '0000000':
            raise ValidationError(self.error_messages['invalid'])

        all_digits = "%s%s%s%s" % (residence, birthday, validity, checksum)
        if not self.has_valid_checksum(residence) or not self.has_valid_checksum(birthday) or \
            not self.has_valid_checksum(validity) or not self.has_valid_checksum(all_digits):
                raise ValidationError(self.error_messages['invalid'])

        return '%s%s-%s-%s-%s' % (residence, origin, birthday, validity, checksum)

# Copyright (C) 2002 Python Software Foundation

"""Email address parsing code.

Lifted directly from rfc822.py.  This should eventually be rewritten.
"""

import time
from types import TupleType

try:
    True, False
except NameError:
    True = 1
    False = 0

SPACE = ' '
EMPTYSTRING = ''
COMMASPACE = ', '

# Parse a date field
_monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul',
               'aug', 'sep', 'oct', 'nov', 'dec',
               'january', 'february', 'march', 'april', 'may', 'june', 'july',
               'august', 'september', 'october', 'november', 'december']

_daynames = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun']

# The timezone table does not include the military time zones defined
# in RFC822, other than Z.  According to RFC1123, the description in
# RFC822 gets the signs wrong, so we can't rely on any such time
# zones.  RFC1123 recommends that numeric timezone indicators be used
# instead of timezone names.

_timezones = {'UT':0, 'UTC':0, 'GMT':0, 'Z':0,
              'AST': -400, 'ADT': -300,  # Atlantic (used in Canada)
              'EST': -500, 'EDT': -400,  # Eastern
              'CST': -600, 'CDT': -500,  # Central
              'MST': -700, 'MDT': -600,  # Mountain
              'PST': -800, 'PDT': -700   # Pacific
              }


def parsedate_tz(data):
    """Convert a date string to a time tuple.

    Accounts for military timezones.
    """
    data = data.split()
    # The FWS after the comma after the day-of-week is optional, so search and
    # adjust for this.
    if data[0].endswith(',') or data[0].lower() in _daynames:
        # There's a dayname here. Skip it
        del data[0]
    else:
        i = data[0].rfind(',')
        if i >= 0:
            data[0] = data[0][i+1:]
    if len(data) == 3: # RFC 850 date, deprecated
        stuff = data[0].split('-')
        if len(stuff) == 3:
            data = stuff + data[1:]
    if len(data) == 4:
        s = data[3]
        i = s.find('+')
        if i > 0:
            data[3:] = [s[:i], s[i+1:]]
        else:
            data.append('') # Dummy tz
    if len(data) < 5:
        return None
    data = data[:5]
    [dd, mm, yy, tm, tz] = data
    mm = mm.lower()
    if mm not in _monthnames:
        dd, mm = mm, dd.lower()
        if mm not in _monthnames:
            return None
    mm = _monthnames.index(mm) + 1
    if mm > 12:
        mm -= 12
    if dd[-1] == ',':
        dd = dd[:-1]
    i = yy.find(':')
    if i > 0:
        yy, tm = tm, yy
    if yy[-1] == ',':
        yy = yy[:-1]
    if not yy[0].isdigit():
        yy, tz = tz, yy
    if tm[-1] == ',':
        tm = tm[:-1]
    tm = tm.split(':')
    if len(tm) == 2:
        [thh, tmm] = tm
        tss = '0'
    elif len(tm) == 3:
        [thh, tmm, tss] = tm
    else:
        return None
    try:
        yy = int(yy)
        dd = int(dd)
        thh = int(thh)
        tmm = int(tmm)
        tss = int(tss)
    except ValueError:
        return None
    tzoffset = None
    tz = tz.upper()
    if _timezones.has_key(tz):
        tzoffset = _timezones[tz]
    else:
        try:
            tzoffset = int(tz)
        except ValueError:
            pass
    # Convert a timezone offset into seconds ; -0500 -> -18000
    if tzoffset:
        if tzoffset < 0:
            tzsign = -1
            tzoffset = -tzoffset
        else:
            tzsign = 1
        tzoffset = tzsign * ( (tzoffset/100)*3600 + (tzoffset % 100)*60)
    tuple = (yy, mm, dd, thh, tmm, tss, 0, 0, 0, tzoffset)
    return tuple


def parsedate(data):
    """Convert a time string to a time tuple."""
    t = parsedate_tz(data)
    if isinstance(t, TupleType):
        return t[:9]
    else:
        return t


def mktime_tz(data):
    """Turn a 10-tuple as returned by parsedate_tz() into a UTC timestamp."""
    if data[9] is None:
        # No zone info, so localtime is better assumption than GMT
        return time.mktime(data[:8] + (-1,))
    else:
        t = time.mktime(data[:8] + (0,))
        return t - data[9] - time.timezone


def quote(str):
    """Add quotes around a string."""
    return str.replace('\\', '\\\\').replace('"', '\\"')


class AddrlistClass:
    """Address parser class by Ben Escoto.

    To understand what this class does, it helps to have a copy of RFC 2822 in
    front of you.

    Note: this class interface is deprecated and may be removed in the future.
    Use rfc822.AddressList instead.
    """

    def __init__(self, field):
        """Initialize a new instance.

        `field' is an unparsed address header field, containing
        one or more addresses.
        """
        self.specials = '()<>@,:;.\"[]'
        self.pos = 0
        self.LWS = ' \t'
        self.CR = '\r\n'
        self.atomends = self.specials + self.LWS + self.CR
        # Note that RFC 2822 now specifies `.' as obs-phrase, meaning that it
        # is obsolete syntax.  RFC 2822 requires that we recognize obsolete
        # syntax, so allow dots in phrases.
        self.phraseends = self.atomends.replace('.', '')
        self.field = field
        self.commentlist = []

    def gotonext(self):
        """Parse up to the start of the next address."""
        while self.pos < len(self.field):
            if self.field[self.pos] in self.LWS + '\n\r':
                self.pos += 1
            elif self.field[self.pos] == '(':
                self.commentlist.append(self.getcomment())
            else:
                break

    def getaddrlist(self):
        """Parse all addresses.

        Returns a list containing all of the addresses.
        """
        result = []
        while self.pos < len(self.field):
            ad = self.getaddress()
            if ad:
                result += ad
            else:
                result.append(('', ''))
        return result

    def getaddress(self):
        """Parse the next address."""
        self.commentlist = []
        self.gotonext()

        oldpos = self.pos
        oldcl = self.commentlist
        plist = self.getphraselist()

        self.gotonext()
        returnlist = []

        if self.pos >= len(self.field):
            # Bad email address technically, no domain.
            if plist:
                returnlist = [(SPACE.join(self.commentlist), plist[0])]

        elif self.field[self.pos] in '.@':
            # email address is just an addrspec
            # this isn't very efficient since we start over
            self.pos = oldpos
            self.commentlist = oldcl
            addrspec = self.getaddrspec()
            returnlist = [(SPACE.join(self.commentlist), addrspec)]

        elif self.field[self.pos] == ':':
            # address is a group
            returnlist = []

            fieldlen = len(self.field)
            self.pos += 1
            while self.pos < len(self.field):
                self.gotonext()
                if self.pos < fieldlen and self.field[self.pos] == ';':
                    self.pos += 1
                    break
                returnlist = returnlist + self.getaddress()

        elif self.field[self.pos] == '<':
            # Address is a phrase then a route addr
            routeaddr = self.getrouteaddr()

            if self.commentlist:
                returnlist = [(SPACE.join(plist) + ' (' +
                               ' '.join(self.commentlist) + ')', routeaddr)]
            else:
                returnlist = [(SPACE.join(plist), routeaddr)]

        else:
            if plist:
                returnlist = [(SPACE.join(self.commentlist), plist[0])]
            elif self.field[self.pos] in self.specials:
                self.pos += 1

        self.gotonext()
        if self.pos < len(self.field) and self.field[self.pos] == ',':
            self.pos += 1
        return returnlist

    def getrouteaddr(self):
        """Parse a route address (Return-path value).

        This method just skips all the route stuff and returns the addrspec.
        """
        if self.field[self.pos] != '<':
            return

        expectroute = False
        self.pos += 1
        self.gotonext()
        adlist = ''
        while self.pos < len(self.field):
            if expectroute:
                self.getdomain()
                expectroute = False
            elif self.field[self.pos] == '>':
                self.pos += 1
                break
            elif self.field[self.pos] == '@':
                self.pos += 1
                expectroute = True
            elif self.field[self.pos] == ':':
                self.pos += 1
            else:
                adlist = self.getaddrspec()
                self.pos += 1
                break
            self.gotonext()

        return adlist

    def getaddrspec(self):
        """Parse an RFC 2822 addr-spec."""
        aslist = []

        self.gotonext()
        while self.pos < len(self.field):
            if self.field[self.pos] == '.':
                aslist.append('.')
                self.pos += 1
            elif self.field[self.pos] == '"':
                aslist.append('"%s"' % self.getquote())
            elif self.field[self.pos] in self.atomends:
                break
            else:
                aslist.append(self.getatom())
            self.gotonext()

        if self.pos >= len(self.field) or self.field[self.pos] != '@':
            return EMPTYSTRING.join(aslist)

        aslist.append('@')
        self.pos += 1
        self.gotonext()
        return EMPTYSTRING.join(aslist) + self.getdomain()

    def getdomain(self):
        """Get the complete domain name from an address."""
        sdlist = []
        while self.pos < len(self.field):
            if self.field[self.pos] in self.LWS:
                self.pos += 1
            elif self.field[self.pos] == '(':
                self.commentlist.append(self.getcomment())
            elif self.field[self.pos] == '[':
                sdlist.append(self.getdomainliteral())
            elif self.field[self.pos] == '.':
                self.pos += 1
                sdlist.append('.')
            elif self.field[self.pos] in self.atomends:
                break
            else:
                sdlist.append(self.getatom())
        return EMPTYSTRING.join(sdlist)

    def getdelimited(self, beginchar, endchars, allowcomments=True):
        """Parse a header fragment delimited by special characters.

        `beginchar' is the start character for the fragment.
        If self is not looking at an instance of `beginchar' then
        getdelimited returns the empty string.

        `endchars' is a sequence of allowable end-delimiting characters.
        Parsing stops when one of these is encountered.

        If `allowcomments' is non-zero, embedded RFC 2822 comments are allowed
        within the parsed fragment.
        """
        if self.field[self.pos] != beginchar:
            return ''

        slist = ['']
        quote = False
        self.pos += 1
        while self.pos < len(self.field):
            if quote:
                slist.append(self.field[self.pos])
                quote = False
            elif self.field[self.pos] in endchars:
                self.pos += 1
                break
            elif allowcomments and self.field[self.pos] == '(':
                slist.append(self.getcomment())
            elif self.field[self.pos] == '\\':
                quote = True
            else:
                slist.append(self.field[self.pos])
            self.pos += 1

        return EMPTYSTRING.join(slist)

    def getquote(self):
        """Get a quote-delimited fragment from self's field."""
        return self.getdelimited('"', '"\r', False)

    def getcomment(self):
        """Get a parenthesis-delimited fragment from self's field."""
        return self.getdelimited('(', ')\r', True)

    def getdomainliteral(self):
        """Parse an RFC 2822 domain-literal."""
        return '[%s]' % self.getdelimited('[', ']\r', False)

    def getatom(self, atomends=None):
        """Parse an RFC 2822 atom.

        Optional atomends specifies a different set of end token delimiters
        (the default is to use self.atomends).  This is used e.g. in
        getphraselist() since phrase endings must not include the `.' (which
        is legal in phrases)."""
        atomlist = ['']
        if atomends is None:
            atomends = self.atomends

        while self.pos < len(self.field):
            if self.field[self.pos] in atomends:
                break
            else:
                atomlist.append(self.field[self.pos])
            self.pos += 1

        return EMPTYSTRING.join(atomlist)

    def getphraselist(self):
        """Parse a sequence of RFC 2822 phrases.

        A phrase is a sequence of words, which are in turn either RFC 2822
        atoms or quoted-strings.  Phrases are canonicalized by squeezing all
        runs of continuous whitespace into one space.
        """
        plist = []

        while self.pos < len(self.field):
            if self.field[self.pos] in self.LWS:
                self.pos += 1
            elif self.field[self.pos] == '"':
                plist.append(self.getquote())
            elif self.field[self.pos] == '(':
                self.commentlist.append(self.getcomment())
            elif self.field[self.pos] in self.phraseends:
                break
            else:
                plist.append(self.getatom(self.phraseends))

        return plist

class AddressList(AddrlistClass):
    """An AddressList encapsulates a list of parsed RFC 2822 addresses."""
    def __init__(self, field):
        AddrlistClass.__init__(self, field)
        if field:
            self.addresslist = self.getaddrlist()
        else:
            self.addresslist = []

    def __len__(self):
        return len(self.addresslist)

    def __str__(self):
        return COMMASPACE.join(map(dump_address_pair, self.addresslist))

    def __add__(self, other):
        # Set union
        newaddr = AddressList(None)
        newaddr.addresslist = self.addresslist[:]
        for x in other.addresslist:
            if not x in self.addresslist:
                newaddr.addresslist.append(x)
        return newaddr

    def __iadd__(self, other):
        # Set union, in-place
        for x in other.addresslist:
            if not x in self.addresslist:
                self.addresslist.append(x)
        return self

    def __sub__(self, other):
        # Set difference
        newaddr = AddressList(None)
        for x in self.addresslist:
            if not x in other.addresslist:
                newaddr.addresslist.append(x)
        return newaddr

    def __isub__(self, other):
        # Set difference, in-place
        for x in other.addresslist:
            if x in self.addresslist:
                self.addresslist.remove(x)
        return self

    def __getitem__(self, index):
        # Make indexing, slices, and 'in' work
        return self.addresslist[index]

# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------

from msrest.service_client import ServiceClient
from msrest import Serializer, Deserializer
from msrestazure import AzureConfiguration
from .version import VERSION
from .operations.paths_operations import PathsOperations
from . import models


class AutoRestParameterizedHostTestClientConfiguration(AzureConfiguration):
    """Configuration for AutoRestParameterizedHostTestClient
    Note that all parameters used to create this instance are saved as instance
    attributes.

    :param credentials: Credentials needed for the client to connect to Azure.
    :type credentials: :mod:`A msrestazure Credentials
     object<msrestazure.azure_active_directory>`
    :param host: A string value that is used as a global part of the
     parameterized host
    :type host: str
    :param accept_language: Gets or sets the preferred language for the
     response.
    :type accept_language: str
    :param long_running_operation_retry_timeout: Gets or sets the retry
     timeout in seconds for Long Running Operations. Default value is 30.
    :type long_running_operation_retry_timeout: int
    :param generate_client_request_id: When set to true a unique
     x-ms-client-request-id value is generated and included in each request.
     Default is true.
    :type generate_client_request_id: bool
    :param str filepath: Existing config
    """

    def __init__(
            self, credentials, host, accept_language='en-US', long_running_operation_retry_timeout=30, generate_client_request_id=True, filepath=None):

        if credentials is None:
            raise ValueError("Parameter 'credentials' must not be None.")
        if host is None:
            raise ValueError("Parameter 'host' must not be None.")
        if not isinstance(host, str):
            raise TypeError("Parameter 'host' must be str.")
        if accept_language is not None and not isinstance(accept_language, str):
            raise TypeError("Optional parameter 'accept_language' must be str.")
        base_url = 'http://{accountName}{host}'

        super(AutoRestParameterizedHostTestClientConfiguration, self).__init__(base_url, filepath)

        self.add_user_agent('autorestparameterizedhosttestclient/{}'.format(VERSION))
        self.add_user_agent('Azure-SDK-For-Python')

        self.credentials = credentials
        self.host = host
        self.accept_language = accept_language
        self.long_running_operation_retry_timeout = long_running_operation_retry_timeout
        self.generate_client_request_id = generate_client_request_id


class AutoRestParameterizedHostTestClient(object):
    """Test Infrastructure for AutoRest

    :ivar config: Configuration for client.
    :vartype config: AutoRestParameterizedHostTestClientConfiguration

    :ivar paths: Paths operations
    :vartype paths: .operations.PathsOperations

    :param credentials: Credentials needed for the client to connect to Azure.
    :type credentials: :mod:`A msrestazure Credentials
     object<msrestazure.azure_active_directory>`
    :param host: A string value that is used as a global part of the
     parameterized host
    :type host: str
    :param accept_language: Gets or sets the preferred language for the
     response.
    :type accept_language: str
    :param long_running_operation_retry_timeout: Gets or sets the retry
     timeout in seconds for Long Running Operations. Default value is 30.
    :type long_running_operation_retry_timeout: int
    :param generate_client_request_id: When set to true a unique
     x-ms-client-request-id value is generated and included in each request.
     Default is true.
    :type generate_client_request_id: bool
    :param str filepath: Existing config
    """

    def __init__(
            self, credentials, host, accept_language='en-US', long_running_operation_retry_timeout=30, generate_client_request_id=True, filepath=None):

        self.config = AutoRestParameterizedHostTestClientConfiguration(credentials, host, accept_language, long_running_operation_retry_timeout, generate_client_request_id, filepath)
        self._client = ServiceClient(self.config.credentials, self.config)

        client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
        self._serialize = Serializer(client_models)
        self._deserialize = Deserializer(client_models)

        self.paths = PathsOperations(
            self._client, self.config, self._serialize, self._deserialize)

#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

# this script tests vtkImageReslice with different interpolation modes,
# with the wrap-pad feature turned on
# Image pipeline
reader = vtk.vtkImageReader()
reader.ReleaseDataFlagOff()
reader.SetDataByteOrderToLittleEndian()
reader.SetDataExtent(0,63,0,63,1,93)
reader.SetDataSpacing(3.2,3.2,1.5)
reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter")
reader.SetDataMask(0x7fff)
reslice1 = vtk.vtkImageReslice()
reslice1.SetInputConnection(reader.GetOutputPort())
reslice1.MirrorOn()
reslice1.SetInterpolationModeToCubic()
reslice1.SetResliceAxesDirectionCosines([0,1,0,-1,0,0,0,0,1])
reslice1.SetResliceAxesOrigin(0,0,40)
reslice1.SetOutputSpacing(2.0,2.0,1.5)
reslice1.SetOutputOrigin(-32,-32,0)
reslice1.SetOutputExtent(0,127,0,127,0,0)
reslice2 = vtk.vtkImageReslice()
reslice2.SetInputConnection(reader.GetOutputPort())
reslice2.MirrorOn()
reslice2.SetResliceAxesDirectionCosines([0,1,0,-1,0,0,0,0,1])
reslice2.SetResliceAxesOrigin(0,0,40)
reslice2.SetInterpolationModeToLinear()
reslice2.SetOutputSpacing(2.0,2.0,1.5)
reslice2.SetOutputOrigin(-32,-32,0)
reslice2.SetOutputExtent(0,127,0,127,0,0)
reslice3 = vtk.vtkImageReslice()
reslice3.SetInputConnection(reader.GetOutputPort())
reslice3.MirrorOn()
reslice3.SetResliceAxesDirectionCosines([0,1,0,-1,0,0,0,0,1])
reslice3.SetResliceAxesOrigin(0,0,40)
reslice3.SetInterpolationModeToNearestNeighbor()
reslice3.SetOutputSpacing(2.0,2.0,1.5)
reslice3.SetOutputOrigin(-32,-32,0)
reslice3.SetOutputExtent(0,127,0,127,0,0)
reslice4 = vtk.vtkImageReslice()
reslice4.SetInputConnection(reader.GetOutputPort())
reslice4.MirrorOn()
reslice4.SetResliceAxesDirectionCosines([0,1,0,-1,0,0,0,0,1])
reslice4.SetResliceAxesOrigin(0,0,40)
reslice4.SetInterpolationModeToLinear()
reslice4.SetOutputSpacing(3.2,3.2,1.5)
reslice4.SetOutputOrigin(-102.4,-102.4,0)
reslice4.SetOutputExtent(0,127,0,127,0,0)
mapper1 = vtk.vtkImageMapper()
mapper1.SetInputConnection(reslice1.GetOutputPort())
mapper1.SetColorWindow(2000)
mapper1.SetColorLevel(1000)
mapper1.SetZSlice(0)
mapper2 = vtk.vtkImageMapper()
mapper2.SetInputConnection(reslice2.GetOutputPort())
mapper2.SetColorWindow(2000)
mapper2.SetColorLevel(1000)
mapper2.SetZSlice(0)
mapper3 = vtk.vtkImageMapper()
mapper3.SetInputConnection(reslice3.GetOutputPort())
mapper3.SetColorWindow(2000)
mapper3.SetColorLevel(1000)
mapper3.SetZSlice(0)
mapper4 = vtk.vtkImageMapper()
mapper4.SetInputConnection(reslice4.GetOutputPort())
mapper4.SetColorWindow(2000)
mapper4.SetColorLevel(1000)
mapper4.SetZSlice(0)
actor1 = vtk.vtkActor2D()
actor1.SetMapper(mapper1)
actor2 = vtk.vtkActor2D()
actor2.SetMapper(mapper2)
actor3 = vtk.vtkActor2D()
actor3.SetMapper(mapper3)
actor4 = vtk.vtkActor2D()
actor4.SetMapper(mapper4)
imager1 = vtk.vtkRenderer()
imager1.AddActor2D(actor1)
imager1.SetViewport(0.5,0.0,1.0,0.5)
imager2 = vtk.vtkRenderer()
imager2.AddActor2D(actor2)
imager2.SetViewport(0.0,0.0,0.5,0.5)
imager3 = vtk.vtkRenderer()
imager3.AddActor2D(actor3)
imager3.SetViewport(0.5,0.5,1.0,1.0)
imager4 = vtk.vtkRenderer()
imager4.AddActor2D(actor4)
imager4.SetViewport(0.0,0.5,0.5,1.0)
imgWin = vtk.vtkRenderWindow()
imgWin.AddRenderer(imager1)
imgWin.AddRenderer(imager2)
imgWin.AddRenderer(imager3)
imgWin.AddRenderer(imager4)
imgWin.SetSize(256,256)
imgWin.Render()
# --- end of script --

"""
Linux swap file.

Documentation: Linux kernel source code, files:
 - mm/swapfile.c
 - include/linux/swap.h

Author: Victor Stinner
Creation date: 25 december 2006 (christmas ;-))
"""

from lib.hachoir_parser import Parser
from lib.hachoir_core.field import (ParserError, GenericVector,
    UInt32, String,
    Bytes, NullBytes, RawBytes)
from lib.hachoir_core.endian import LITTLE_ENDIAN
from lib.hachoir_core.tools import humanFilesize
from lib.hachoir_core.bits import str2hex

PAGE_SIZE = 4096

# Definition of MAX_SWAP_BADPAGES in Linux kernel:
#  (__swapoffset(magic.magic) - __swapoffset(info.badpages)) / sizeof(int)
MAX_SWAP_BADPAGES = ((PAGE_SIZE - 10) - 1536) // 4

class Page(RawBytes):
    static_size = PAGE_SIZE*8
    def __init__(self, parent, name):
        RawBytes.__init__(self, parent, name, PAGE_SIZE)

class UUID(Bytes):
    static_size = 16*8
    def __init__(self, parent, name):
        Bytes.__init__(self, parent, name, 16)
    def createDisplay(self):
        text = str2hex(self.value, format=r"%02x")
        return "%s-%s-%s-%s-%s" % (
            text[:8], text[8:12], text[12:16], text[16:20], text[20:])

class LinuxSwapFile(Parser):
    PARSER_TAGS = {
        "id": "linux_swap",
        "file_ext": ("",),
        "category": "file_system",
        "min_size": PAGE_SIZE*8,
        "description": "Linux swap file",
        "magic": (
            ("SWAP-SPACE", (PAGE_SIZE-10)*8),
            ("SWAPSPACE2", (PAGE_SIZE-10)*8),
            ("S1SUSPEND\0", (PAGE_SIZE-10)*8),
        ),
    }
    endian = LITTLE_ENDIAN

    def validate(self):
        magic = self.stream.readBytes((PAGE_SIZE-10)*8, 10)
        if magic not in ("SWAP-SPACE", "SWAPSPACE2", "S1SUSPEND\0"):
            return "Unknown magic string"
        if MAX_SWAP_BADPAGES < self["nb_badpage"].value:
            return "Invalid number of bad page (%u)" % self["nb_badpage"].value
        return True

    def getPageCount(self):
        """
        Number of pages which can really be used for swapping:
        number of page minus bad pages minus one page (used for the header)
        """
        # -1 because first page is used for the header
        return self["last_page"].value - self["nb_badpage"].value - 1

    def createDescription(self):
        if self["magic"].value == "S1SUSPEND\0":
            text = "Suspend swap file version 1"
        elif self["magic"].value == "SWAPSPACE2":
            text = "Linux swap file version 2"
        else:
            text = "Linux swap file version 1"
        nb_page = self.getPageCount()
        return "%s, page size: %s, %s pages" % (
            text, humanFilesize(PAGE_SIZE), nb_page)

    def createFields(self):
        # First kilobyte: boot sectors
        yield RawBytes(self, "boot", 1024, "Space for disklabel etc.")

        # Header
        yield UInt32(self, "version")
        yield UInt32(self, "last_page")
        yield UInt32(self, "nb_badpage")
        yield UUID(self, "sws_uuid")
        yield UUID(self, "sws_volume")
        yield NullBytes(self, "reserved", 117*4)

        # Read bad pages (if any)
        count = self["nb_badpage"].value
        if count:
            if MAX_SWAP_BADPAGES < count:
                raise ParserError("Invalid number of bad page (%u)" % count)
            yield GenericVector(self, "badpages", count, UInt32, "badpage")

        # Read magic
        padding = self.seekByte(PAGE_SIZE - 10, "padding", null=True)
        if padding:
            yield padding
        yield String(self, "magic", 10, charset="ASCII")

        # Read all pages
        yield GenericVector(self, "pages", self["last_page"].value, Page, "page")

        # Padding at the end
        padding = self.seekBit(self.size, "end_padding", null=True)
        if padding:
            yield padding


# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models


class Migration(SchemaMigration):

    def forwards(self, orm):
        # Adding model 'Forum'
        db.create_table('django_simple_forum_forum', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('title', self.gf('django.db.models.fields.CharField')(max_length=60)),
            ('description', self.gf('django.db.models.fields.TextField')(default='', blank=True)),
            ('updated', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
            ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
            ('creator', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'], null=True, blank=True)),
        ))
        db.send_create_signal('django_simple_forum', ['Forum'])

        # Adding model 'Topic'
        db.create_table('django_simple_forum_topic', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('title', self.gf('django.db.models.fields.CharField')(max_length=60)),
            ('forum', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['django_simple_forum.Forum'])),
            ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
            ('creator', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'], null=True, blank=True)),
            ('updated', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
            ('closed', self.gf('django.db.models.fields.BooleanField')(default=False)),
        ))
        db.send_create_signal('django_simple_forum', ['Topic'])

        # Adding model 'Post'
        db.create_table('django_simple_forum_post', (
            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
            ('title', self.gf('django.db.models.fields.CharField')(max_length=60)),
            ('created', self.gf('django.db.models.fields.DateTimeField')(auto_now_add=True, blank=True)),
            ('creator', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['auth.User'], null=True, blank=True)),
            ('updated', self.gf('django.db.models.fields.DateTimeField')(auto_now=True, blank=True)),
            ('topic', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['django_simple_forum.Topic'])),
            ('body', self.gf('django.db.models.fields.TextField')(max_length=10000)),
            ('user_ip', self.gf('django.db.models.fields.GenericIPAddressField')(max_length=39, null=True, blank=True)),
        ))
        db.send_create_signal('django_simple_forum', ['Post'])


    def backwards(self, orm):
        # Deleting model 'Forum'
        db.delete_table('django_simple_forum_forum')

        # Deleting model 'Topic'
        db.delete_table('django_simple_forum_topic')

        # Deleting model 'Post'
        db.delete_table('django_simple_forum_post')


    models = {
        'auth.group': {
            'Meta': {'object_name': 'Group'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
        },
        'auth.permission': {
            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        'auth.user': {
            'Meta': {'object_name': 'User'},
            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
        },
        'contenttypes.contenttype': {
            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'django_simple_forum.forum': {
            'Meta': {'object_name': 'Forum'},
            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'creator': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'}),
            'description': ('django.db.models.fields.TextField', [], {'default': "''", 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'title': ('django.db.models.fields.CharField', [], {'max_length': '60'}),
            'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
        },
        'django_simple_forum.post': {
            'Meta': {'object_name': 'Post'},
            'body': ('django.db.models.fields.TextField', [], {'max_length': '10000'}),
            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'creator': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'title': ('django.db.models.fields.CharField', [], {'max_length': '60'}),
            'topic': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['django_simple_forum.Topic']"}),
            'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'user_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39', 'null': 'True', 'blank': 'True'})
        },
        'django_simple_forum.topic': {
            'Meta': {'object_name': 'Topic'},
            'closed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'creator': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'}),
            'forum': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['django_simple_forum.Forum']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'title': ('django.db.models.fields.CharField', [], {'max_length': '60'}),
            'updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'})
        }
    }

    complete_apps = ['django_simple_forum']
"""
URL patterns for the views included in ``django.contrib.auth``.

Including these URLs (via the ``include()`` directive) will set up the
following patterns based at whatever URL prefix they are included
under:

* User login at ``login/``.

* User logout at ``logout/``.

* The two-step password change at ``password/change/`` and
  ``password/change/done/``.

* The four-step password reset at ``password/reset/``,
  ``password/reset/confirm/``, ``password/reset/complete/`` and
  ``password/reset/done/``.

The default registration backend already has an ``include()`` for
these URLs, so under the default setup it is not necessary to manually
include these views. Other backends may or may not include them;
consult a specific backend's documentation for details.

"""

from django.conf.urls import include
from django.conf.urls import patterns
from django.conf.urls import url

from django.contrib.auth import views as auth_views


urlpatterns = patterns('',
                       url(r'^login/$',
                           auth_views.login,
                           {'template_name': 'registration/login.html'},
                           name='auth_login'),
                       url(r'^logout/$',
                           auth_views.logout,
                           {'template_name': 'registration/logout.html'},
                           name='auth_logout'),
                       url(r'^password/change/$',
                           auth_views.password_change,
                           name='auth_password_change'),
                       url(r'^password/change/done/$',
                           auth_views.password_change_done,
                           name='auth_password_change_done'),
                       url(r'^password/reset/$',
                           auth_views.password_reset,
                           name='auth_password_reset'),
                       url(r'^password/reset/confirm/(?P<uidb36>[0-9A-Za-z]+)-(?P<token>.+)/$',
                           auth_views.password_reset_confirm,
                           name='auth_password_reset_confirm'),
                       url(r'^password/reset/complete/$',
                           auth_views.password_reset_complete,
                           name='auth_password_reset_complete'),
                       url(r'^password/reset/done/$',
                           auth_views.password_reset_done,
                           name='auth_password_reset_done'),
)

# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models


class Migration(SchemaMigration):

    def forwards(self, orm):
        # Adding field 'Order.cart_pk'
        db.add_column('shop_order', 'cart_pk',
                      self.gf('django.db.models.fields.PositiveIntegerField')(null=True, blank=True),
                      keep_default=False)


    def backwards(self, orm):
        # Deleting field 'Order.cart_pk'
        db.delete_column('shop_order', 'cart_pk')


    models = {
        'auth.group': {
            'Meta': {'object_name': 'Group'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
        },
        'auth.permission': {
            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
        },
        'auth.user': {
            'Meta': {'object_name': 'User'},
            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
        },
        'contenttypes.contenttype': {
            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
        },
        'shop.cart': {
            'Meta': {'object_name': 'Cart'},
            'date_created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'last_updated': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'user': ('django.db.models.fields.related.OneToOneField', [], {'to': "orm['auth.User']", 'unique': 'True', 'null': 'True', 'blank': 'True'})
        },
        'shop.cartitem': {
            'Meta': {'object_name': 'CartItem'},
            'cart': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'items'", 'to': "orm['shop.Cart']"}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'product': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['shop.Product']"}),
            'quantity': ('django.db.models.fields.IntegerField', [], {})
        },
        'shop.extraorderitempricefield': {
            'Meta': {'object_name': 'ExtraOrderItemPriceField'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'label': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'order_item': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['shop.OrderItem']"}),
            'value': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'})
        },
        'shop.extraorderpricefield': {
            'Meta': {'object_name': 'ExtraOrderPriceField'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'is_shipping': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'label': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'order': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['shop.Order']"}),
            'value': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'})
        },
        'shop.order': {
            'Meta': {'object_name': 'Order'},
            'billing_address_text': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'cart_pk': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
            'created': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'order_subtotal': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'}),
            'order_total': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'}),
            'shipping_address_text': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
            'status': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'})
        },
        'shop.orderextrainfo': {
            'Meta': {'object_name': 'OrderExtraInfo'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'order': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'extra_info'", 'to': "orm['shop.Order']"}),
            'text': ('django.db.models.fields.TextField', [], {})
        },
        'shop.orderitem': {
            'Meta': {'object_name': 'OrderItem'},
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'line_subtotal': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'}),
            'line_total': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'}),
            'order': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'items'", 'to': "orm['shop.Order']"}),
            'product': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['shop.Product']", 'null': 'True', 'on_delete': 'models.SET_NULL', 'blank': 'True'}),
            'product_name': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
            'product_reference': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'quantity': ('django.db.models.fields.IntegerField', [], {}),
            'unit_price': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'})
        },
        'shop.orderpayment': {
            'Meta': {'object_name': 'OrderPayment'},
            'amount': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'order': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['shop.Order']"}),
            'payment_method': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'transaction_id': ('django.db.models.fields.CharField', [], {'max_length': '255'})
        },
        'shop.product': {
            'Meta': {'object_name': 'Product'},
            'active': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
            'date_added': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
            'last_modified': ('django.db.models.fields.DateTimeField', [], {'auto_now': 'True', 'blank': 'True'}),
            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
            'polymorphic_ctype': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'polymorphic_shop.product_set'", 'null': 'True', 'to': "orm['contenttypes.ContentType']"}),
            'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '50'}),
            'unit_price': ('django.db.models.fields.DecimalField', [], {'default': "'0.0'", 'max_digits': '30', 'decimal_places': '2'})
        }
    }

    complete_apps = ['shop']
#!/usr/bin/env python
#
# Copyright (C) 2011, 2012 Nippon Telegraph and Telephone Corporation.
# Copyright (C) 2011 Isaku Yamahata <yamahata at valinux co jp>
#
# 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.

from ryu.lib import hub
hub.patch(thread=False)

# TODO:
#   Right now, we have our own patched copy of ovs python bindings
#   Once our modification is upstreamed and widely deployed,
#   use it
#
# NOTE: this modifies sys.path and thus affects the following imports.
import ryu.contrib
ryu.contrib.update_module_path()

from ryu import cfg
import logging
import sys

from ryu import log
log.early_init_log(logging.DEBUG)

from ryu import flags
from ryu import version
from ryu.app import wsgi
from ryu.base.app_manager import AppManager
from ryu.controller import controller
from ryu.topology import switches


CONF = cfg.CONF
CONF.register_cli_opts([
    cfg.ListOpt('app-lists', default=[],
                help='application module name to run'),
    cfg.MultiStrOpt('app', positional=True, default=[],
                    help='application module name to run'),
    cfg.StrOpt('pid-file', default=None, help='pid file name'),
    cfg.BoolOpt('enable-debugger', default=False,
                help='don\'t overwrite Python standard threading library'
                '(use only for debugging)'),
])


def main(args=None, prog=None):
    try:
        CONF(args=args, prog=prog,
             project='ryu', version='ryu-manager %s' % version,
             default_config_files=['/usr/local/etc/ryu/ryu.conf'])
    except cfg.ConfigFilesNotFoundError:
        CONF(args=args, prog=prog,
             project='ryu', version='ryu-manager %s' % version)

    log.init_log()

    if CONF.enable_debugger:
        LOG = logging.getLogger('ryu.cmd.manager')
        msg = 'debugging is available (--enable-debugger option is turned on)'
        LOG.info(msg)
    else:
        hub.patch(thread=True)

    if CONF.pid_file:
        import os
        with open(CONF.pid_file, 'w') as pid_file:
            pid_file.write(str(os.getpid()))

    app_lists = CONF.app_lists + CONF.app
    # keep old behaivor, run ofp if no application is specified.
    if not app_lists:
        app_lists = ['ryu.controller.ofp_handler']

    app_mgr = AppManager.get_instance()
    app_mgr.load_apps(app_lists)
    contexts = app_mgr.create_contexts()
    services = []
    services.extend(app_mgr.instantiate_apps(**contexts))

    webapp = wsgi.start_service(app_mgr)
    if webapp:
        thr = hub.spawn(webapp)
        services.append(thr)

    try:
        hub.joinall(services)
    finally:
        app_mgr.close()


if __name__ == "__main__":
    main()

# This file is a part of MediaDrop (http://www.mediadrop.net),
# Copyright 2009-2015 MediaDrop contributors
# For the exact contribution history, see the git revision log.
# The source code contained in this file is licensed under the GPLv3 or
# (at your option) any later version.
# See LICENSE.txt in the main project directory, for more information.

from tw.api import WidgetsList
from tw.forms.validators import FieldStorageUploadConverter

from mediadrop.lib.i18n import N_
from mediadrop.forms import ListForm, TextField, XHTMLTextArea, FileField, SubmitButton, email_validator
from mediadrop.plugin import events

validators = dict(
    description = XHTMLTextArea.validator(
        messages = {'empty': N_('At least give it a short description...')},
        not_empty = True,
    ),
    name = TextField.validator(
        messages = {'empty': N_("You've gotta have a name!")},
        not_empty = True,
    ),
    title = TextField.validator(
        messages = {'empty': N_("You've gotta have a title!")},
        not_empty = True,
    ),
    url = TextField.validator(
        if_missing = None,
    ),
)

class UploadForm(ListForm):
    template = 'upload/form.html'
    id = 'upload-form'
    css_class = 'form'
    show_children_errors = False
    params = ['async_action']
    
    events = events.UploadForm
    
    class fields(WidgetsList):
        name = TextField(validator=validators['name'], label_text=N_('Your Name:'), maxlength=50)
        email = TextField(validator=email_validator(not_empty=True), label_text=N_('Your Email:'), help_text=N_('(will never be published)'), maxlength=255)
        title = TextField(validator=validators['title'], label_text=N_('Title:'), maxlength=255)
        description = XHTMLTextArea(validator=validators['description'], label_text=N_('Description:'), attrs=dict(rows=5, cols=25))
        url = TextField(validator=validators['url'], label_text=N_('Add a YouTube, Vimeo or Amazon S3 link:'), maxlength=255)
        file = FileField(validator=FieldStorageUploadConverter(if_missing=None, messages={'empty':N_('Oops! You forgot to enter a file.')}), label_text=N_('OR:'))
        submit = SubmitButton(default=N_('Submit'), css_classes=['mcore-btn', 'btn-submit'])

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

import re
import locale


class WikiFRTranslator(object):
    @staticmethod
    def IsAllowedTitle(title):
        return title not in [
            u'Modèle', u'Catégorie', u'Portail', u'Fichier', u'Wikipédia',
            u'Projet', u'Référence', u'MediaWiki', u'Aide', u'Module',
            u'File']

    def __init__(self):
        # Templates that allow inclusion of }} in parameters will fail....
        # We should use the dropNested thing  maybe?
        # TODO
        self.fr_saveNobrTemplatesRE = re.compile(
            r'{{nobr\|((?:[^{]+)|(?:[^{]*{{[^}]+}}[^}]*))}}', re.IGNORECASE|re.UNICODE)
        self.fr_saveHeureTemplatesRE = re.compile(
            r'{{heure((\|(\d\d?))+)}}', re.IGNORECASE|re.UNICODE)
        self.fr_saveDateTemplatesRE = re.compile(
            r'{{date(?: de naissance| de décès)?\|(|\d+(?:er)?)\|([^|}]+)\|?(\d*)(?:\|[^}]+)?}}',
            re.IGNORECASE|re.UNICODE)
        self.fr_saveDateShortTemplatesRE = re.compile(
            r'{{1er (janvier|f.vrier|mars|avril|mai|juin|juillet|ao.t|septembre|octobre|novembre|d.cembre)}}',
            re.IGNORECASE|re.UNICODE)
        self.fr_saveLangTemplatesRE = re.compile(
            r'{{(lang(?:ue)?(?:-\w+)?(?:\|[^}\|]+)+)}}', re.IGNORECASE|re.UNICODE)
        self.fr_saveUnitsTemplatesRE = re.compile(
            r'{{(?:unit.|nombre|num|nau)\|([^|{}]+(?:\|[^{}|]*)*)}}', re.IGNORECASE|re.UNICODE)
        self.fr_saveTemperatureTemplatesRE = re.compile(
            r'{{tmp\|([^\|]+)\|°C}}', re.IGNORECASE|re.UNICODE)
        self.fr_saveRefIncTemplatesRE = re.compile(
            r'{{Référence [^|}]+\|([^|]+)}}', re.IGNORECASE)
        self.fr_saveNumeroTemplatesRE = re.compile(
            r'{{(numéro|n°|nº)}}', re.IGNORECASE)
        self.fr_saveCitationTemplatesRE = re.compile(
            r'{{citation ?(?:bloc|nécessaire)?\|([^}]+)}}', re.IGNORECASE)
        self.fr_savePassageEvasifTemplatesRE = re.compile(
            r'{{passage évasif\|([^}]+)}}', re.IGNORECASE)
        # not in my wikipedia
        #self.fr_savePassNonNeutreTemplatesRE = re.compile(r'{{(?:passage non neutre|non neutre|nonneutre)\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveDouteuxTemplatesRE = re.compile(
            r'{{douteux\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_savePasspromotionnelTemplatesRE = re.compile(
            r'{{(?:passage promotionnel|pub !|promo !)\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_savePassIneditTemplatesRE = re.compile(
            r'{{passage inédit\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_savePasClairTemplatesRE = re.compile(
            r'{{pas clair\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveWTFTemplatesRE = re.compile(
            r'{{incomprénsible\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_savePrecNecTemplatesRE = re.compile(
            r'{{Précision nécessaire\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveQuoiTemplatesRE = re.compile(
            r'{{Quoi\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_savePourquoiTemplatesRE = re.compile(
            r'{{Pourquoi\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveCommentTemplatesRE = re.compile(
            r'{{Comment\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveWhereTemplatesRE = re.compile(
            r'{{Où\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveQuandTemplatesRE = re.compile(
            r'{{Quand\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveDepuisQuandTemplatesRE = re.compile(
            r'{{Depuis Quand\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveQuiQuoiTemplatesRE = re.compile(
            r'{{(?:Qui|Lequel|combien|enquoi|en quoi|lesquels|laquelle|lesquelles|par qui|parqui|pour qui)\|([^\|]+)}}',
            re.IGNORECASE)
        self.fr_savestyleTemplatesRE = re.compile(
            r'{{style\|([^\|]+)(?:\|[^}]+)?}}', re.IGNORECASE)
        self.fr_saveFormatnumTemplatesRE = re.compile(
            r'{{(?:formatnum):([0-9.,]+)}}', re.IGNORECASE)
        self.fr_saveWeirdNumbersTemplatesRE = re.compile(
            r'{{((?:(exp|ind)\|[^}]+)|\d|e|1er|1re|2nd|2nde)}}', re.IGNORECASE)
        self.fr_saveCouleursTemplatesRE = re.compile(
            r'{{(rouge|bleu|vert|jaune|orange|gris|marron|rose)\|([^\|}]+)}}', re.IGNORECASE)
        self.fr_saveCodeTemplatesRE = re.compile(
            r'{{code\|([^\|}]+)}}', re.IGNORECASE)
        self.fr_saveJaponaisTemplatesRE = re.compile(
            r'{{japonais\|([^\|]+)\|([^}]+)}}', re.IGNORECASE)
        self.fr_saveSimpleSieclesTempaltesRE = re.compile(
            r'{{([^}]+ (?:si.cle|mill.naire)[^}]*)}}', re.IGNORECASE|re.LOCALE)
        self.fr_saveSieclesTempaltesRE = re.compile(
            r'{{(?:([^|}]+(?:si.cle|mill.naire)[^|}]*)|(-?s2?-?(?:\|[^|}]+\|e)+))\|?}}',
            re.IGNORECASE)
        self.fr_saveSieclesGTempaltesRE = re.compile(
            r'{{(-?sp-?(\|[^|}]+\|er?\|[^|}]+\|[^|}]+\|er?\|?s?))}}', re.IGNORECASE)
        self.fr_saveNapoleonTemplatesRE = re.compile(
            r'{{(Napoléon I)er}}', re.IGNORECASE)

        self.aRE = re.compile(r'<math>')
        self.bRE = re.compile(r'</math>')
        self.locale_set = False


    def Translate(self, input_text):
        if not self.locale_set:
            locale.setlocale(locale.LC_ALL, u'fr_FR.utf-8')
            self.locale_set = True
        text = input_text
        text = self.fr_saveHeureTemplates(text)
        text = self.fr_saveNobrTemplates(text)
        text = self.fr_saveTemperatureTemplates(text)
        text = self.fr_saveFormatnumTemplates(text)
        text = self.fr_saveUnitsTemplates(text)
        text = self.fr_saveWeirdNumbersTemplates(text)
        text = self.fr_saveNumeroTemplate(text)
        text = self.fr_saveSieclesGTemplates(text)
        text = self.fr_saveSieclesTemplates(text)
        text = self.fr_saveLangTemplates(text)
        text = self.fr_saveCouleursTemplates(text)
        text = self.fr_saveRefIncTemplates(text)
        text = self.fr_saveDateTemplates(text)
        text = self.fr_saveQuiQuoiTemplates(text)
        text = self.fr_saveCodeTemplates(text)
        text = self.fr_saveCitationTemplate(text)
        text = self.fr_saveNapoleonTemplates(text)
        text = self.fr_saveDateShortTemplates(text)
        text = self.fr_saveJaponaisTemplates(text)
#        text = self.fr_savePasspromotionnelTemplates(text)
#        text = self.fr_savePassIneditTemplates(text)
#        text = self.fr_savePasClairTemplates(text)
#        text = self.fr_saveWTFTemplates(text)
#        text = self.fr_savePrecNecTemplates(text)
#        text = self.fr_savestyleTemplates(text)
        return text

    def replheures(self, m):
        res = ""
        t = m.group(1).split("|")
        l = len(t)
# HELLO I LOVE YOU CAN I HAVE SWITCH CASE FFS
        if l == 2:
            res = "%s h"%t[1]
        elif l == 3:
            res = "%s h %s"%(t[1], t[2])
        elif l == 4:
            res = "%s h %s min %s s"%(t[1], t[2], t[3])
        return res.strip()

    def fr_saveHeureTemplates(self, text):
        return re.sub(self.fr_saveHeureTemplatesRE, self.replheures, text)

    def replnobr(self, m):
        pute = m.group(1)
        return "<span class=\"nowrap\">%s</span>"%pute

    def fr_saveNobrTemplates(self, text):
        #return self.fr_saveNobrTemplatesRE.sub(r'\1', text)
        #return self.fr_saveNobrTemplatesRE.sub(r'<span class="nowrap">\1</span>', text)
        return re.sub(self.fr_saveNobrTemplatesRE, self.replnobr, text)

    def fr_saveNapoleonTemplates(self, text):
        return self.fr_saveNapoleonTemplatesRE.sub(r'Napoléon I<sup>er</sup>', text)

    def fr_saveDouteuxTemplates(self, text):
        return self.fr_saveDouteuxTemplatesRE.sub(r'\1<sup>[douteux]</sup>', text)

    def fr_savePasspromotionnelTemplates(self, text):
        return self.fr_savePasspromotionnelTemplatesRE.sub(
            r'\1<sup>[passage promotionnel]</sup>', text)

    def fr_savePassIneditTemplates(self, text):
        return self.fr_savePassIneditTemplatesRE.sub(
            r'\1<sup>[interprétion personnelle]</sup>', text)

    def fr_savePasClairTemplates(self, text):
        return self.fr_savePasClairTemplatesRE.sub(r'\1<sup>[pas clair]</sup>', text)

    def fr_saveWTFTemplates(self, text):
        return self.fr_saveWTFTemplatesRE.sub(r'\1<sup>[incomprénsible]</sup>', text)

    def fr_savePrecNecTemplates(self, text):
        return self.fr_savePrecNecTemplatesRE.sub(r'\1<sup>[précision néssaire]</sup>', text)

    def fr_saveQuiQuoiTemplates(self, text):
        return self.fr_saveQuiQuoiTemplatesRE.sub(r'\1', text)

    def fr_savestyleTemplates(self, text):
        return self.fr_savestyleTemplatesRE.sub(r'\1', text)

    def replsiecles(self, m):
        nb = m.group(2)
        if nb:
            try:
                avjc = u''
                a, b, c = nb.split(u'|', 2)
                if a.startswith(u'-'):
                    avjc = u' av. J.-C. '
                if a.startswith(u's2'):
                    _, d, _ = c.split(u'|')
                    return b+u'e et '+d+u'e siècles'+avjc
                elif a.startswith(u'-s2'):
                    _, d, _ = c.split(u'|')
                    return b+u'e et '+d+u'e siècles'+avjc

                else:
                    return b+u'e siècle'+avjc
            except ValueError:
                # Failing humbly...
                return nb
        else:
            nb = m.group(1)
            return nb

    def fr_saveSieclesTemplates(self, text):
        return re.sub(self.fr_saveSieclesTempaltesRE, self.replsiecles, text)

    def replgsiecles(self, m):
        nb = m.group(1)
        res = u''
        if nb:
            try:
                a, b, c, d, e, f = nb.split(u'|', 5)
                if a.startswith(u'-'):
                    res = u' av. J.-C.'
                index = f.find(u'|')
                si = u'siècle'
                if index > 0:
                    f, s = f.split(u'|')
                    if s != u'':
                        si = u'siècles'

                return u'%s%s %s %s%s %s%s'%(b, c, d, e, f, si, res)
            except ValueError as e:
                raise e
                # Failing humbly...
                #return nb
#        else:
#            nb = m.group(1)
#            return nb

    def fr_saveSieclesGTemplates(self, text):
        return re.sub(self.fr_saveSieclesGTempaltesRE, self.replgsiecles, text)

    def fr_saveSimpleSieclesTemplates(self, text):
        return self.fr_saveSimpleSieclesTempaltesRE.sub(r'\1', text, re.LOCALE)

    def fr_saveCitationTemplate(self, text):
        return self.fr_saveCitationTemplatesRE.sub(r'«&#160;<i>\1</i>&#160;»', text)

    def fr_savePassageEvasifTemplates(self, text):
        return self.fr_savePassageEvasifTemplatesRE.sub(r'<u>\1</u><sup>[evasif??]</sup>', text)

    def fr_saveNumeroTemplate(self, text):
        return self.fr_saveNumeroTemplatesRE.sub(u"n°", text)

    def fr_saveRefIncTemplates(self, text):
        return self.fr_saveRefIncTemplatesRE.sub(r'<u>\1</u><sup>[ref incomplète??]</sup>', text)

    def repldate(self, m):
        res = u''
        if m.group(1) == u'':
            res = u'%s %s'%(m.group(2), m.group(3))
        elif m.group(1) == u'1':
            res = u'1er %s %s'%(m.group(2).lstrip(), m.group(3))
        else:
            res = u'%s %s %s'%(m.group(1), m.group(2).lstrip(), m.group(3))
        return res.strip()

    def fr_saveDateTemplates(self, text):
        return re.sub(self.fr_saveDateTemplatesRE, self.repldate, text)

    def fr_saveDateShortTemplates(self, text):
        return self.fr_saveDateShortTemplatesRE.sub(r'1<sup>er</sup> \1', text)

    def repllang(self, m):
        lol = m.group(1).split(u'|')
        if re.match(r'.*\[\[.+\|.+\]\]', m.group(0)):
            return u'|'.join(lol[2:])

        if re.match(r'lang-\w+', lol[0], re.IGNORECASE):
            return lol[1]
        else:
            reste = lol[2:]
            if len(reste) == 1:
                return reste[0].replace(u'texte=', u'')
            else:
                for p in reste:
                    coin = re.match(r'texte=(.*)', p, re.IGNORECASE)
                    if coin:
                        return coin.group(1)


    def fr_saveLangTemplates(self, text):
        return re.sub(self.fr_saveLangTemplatesRE, self.repllang, text)

    def replcolors(self, m):
        col = m.group(1)
        t = m.group(2)
        if col.lower == u'rouge':
            return u'<font color=\'red\'>%s</font>'%t
        elif col.lower == u'bleu':
            return u'<font color=\'blue\'>%s</font>'%t
        elif col.lower == u'vert':
            return u'<font color=\'green\'>%s</font>'%t
        elif col.lower == u'jaune':
            return u'<font color=\'yellow\'>%s</font>'%t
        elif col.lower == u'orange':
            return u'<font color=\'orange\'>%s</font>'%t
        elif col.lower == u'gris':
            return u'<font color=\'grey\'>%s</font>'%t
        elif col.lower == u'marron':
            return u'<font color=\'brown\'>%s</font>'%t
        elif col.lower == u'rose':
            return u'<font color=\'pink\'>%s</font>'%t
        else:
            return t

    def fr_saveCodeTemplates(self, text):
        return self.fr_saveCodeTemplatesRE.sub(
            r'<span style=\"font-family:monospace, Courier\">\1</span>', text)

    def fr_saveTemperatureTemplates(self, text):
        return self.fr_saveTemperatureTemplatesRE.sub(r'\1°C', text)

    def repljaponais(self, m):
        return m.group(1)+u' ('+m.group(2).replace(u'|', u', ').replace(u'extra=', u'')+u')'

    def fr_saveJaponaisTemplates(self, text):
        return re.sub(self.fr_saveJaponaisTemplatesRE, self.repljaponais, text)

    def fr_saveCouleursTemplates(self, text):
        return re.sub(self.fr_saveCouleursTemplatesRE, self.replcolors, text)

    def replweirdnum(self, m):
        nb = m.group(1)
        if nb.find(u'|') >= 0:
            lol, nb = nb.split(u'|', 1)
            if lol == u'exp':
                return u'<sup>%s</sup>'%nb
            elif lol == u'ind':
                return u'<sub>%s</sub>'%nb
        else:
            if nb == u'e':
                return u'<sup>e</sup>'
            elif nb == u'1er':
                return u'1<sup>er</sup>'
            elif nb == u'1re':
                return u'1<sup>re</sup>'
            elif nb == u'2nd':
                return u'2<sup>nd</sup>'
            elif nb == U'2NDE':
                return u'2<sup>de</sup>'
            else:
                return u'<sup>%s</sup>'%nb

    def fr_saveWeirdNumbersTemplates(self, text):
        return re.sub(self.fr_saveWeirdNumbersTemplatesRE, self.replweirdnum, text)

    def replformat(self, m):
        nb = m.group(1)
        try:
            if nb:
                if nb.find(u'.') > 0 or nb.find(u',') > 0:
                    return locale.format(u'%f', float(nb), grouping=True)
                else:
                    return locale.format(u'%d', int(nb), grouping=True)
        except ValueError:
            # Failing humbly...
            return nb

    def fr_saveFormatnumTemplates(self, text):
        return re.sub(self.fr_saveFormatnumTemplatesRE, self.replformat, text)

    def num_to_loc(self, num):
        try:
            virg = num.replace(u' ', u'').replace(u',', u'.').split(r'.')
            res = locale.format(u'%d', int(virg[0]), grouping=True)
            if len(virg) > 1:
                res += u'.' + virg[1]
            return res
        except ValueError:
            # Failing humbly...
            return num

    def replunit(self, m):
        l = m.group(1).split('|')
        if len(l) == 1:
            a = self.num_to_loc(l[0])
            return u'%s'%(a)
        else:
            # It becomes clear in the test function testUnit below THAT THIS IS A FUCKING MESS
            dot = u''
            exp = u' '
            tab = []
            for s in l[1:]:
                index = s.find(u'=')
                if index > 0:
                    s = s[2:]
                    exp = u'×10'
                if re.match(r'-?[0-9]', s):
                    tab.append(u'%s<sup>%s</sup>'%(dot, self.num_to_loc(s)))
                elif s == u'':
                    tab.append(dot)
                else:
                    dot = s
            res = self.num_to_loc(l[0]) + exp
            if len(tab) == 0:
                res += dot
            elif len(tab) == 1:
                res += tab[0]
            else:
                res += u'⋅'.join(tab)
                res = re.sub(r'×10<sup>([^<]+)</sup>', r'×10<sup>\1</sup> ', res)
            return res

    def fr_saveUnitsTemplates(self, text):
        return re.sub(self.fr_saveUnitsTemplatesRE, self.replunit, text)

'''
Problem
 You recive a credit C at a local sotre and would like to buy two items. You first walk
 through the store and create a list L of all available items. From this list you woluld like to
 buy two items that add up to the entire value of the credit. The solution you provide will
 consist of the two integers indicating the positions of the items in your list (smaler
 number first).
Input
 The first line of input gives the number of cases, N. N test cases follow. For each test case
 there will be:
     * One line containing the value C, the amount of credit you have at the store.
     * One line containing the value I, the number of items in the store.
     * One line containing a space separated list fo I integers. Each integer P indicates the
       price of an item in the store.
     * Each test case will have exactly one solution.
 Output
  For each test case, output one line containing "Case #x: " followed by the indices of the
  two items whose price adds up to the store credit. The lower index should be output first.
 Limits
  5 <= C <= 1000
  1 <= P <= 1000
 Small dataset
  N = 10
  3 <= I <= 100
 Large dataset
  N = 50
  3 <= I <= 2000
 Sample
 # Input                         Output
 #  3                             case #1: 2 3
 #  100                           case #2: 1 4
 #  3                             case #3: 4 5
 #  5 75 25
 #  200
 #  7
 #  150 24 79 50 88 345 3
 #  8
 #  8
 #  2 1 9 4 4 56 90 3
'''

class StoreCredit(object):
    _credit = None
    _store_size = None
    _store = None
    
    def __init__(self, *args):
        super(StoreCredit, self).__init__(*args)
        
    def setCredit(self, credit):
        self._credit = self._checkCredit(credit)
        
    def setListSize(self, size):
        self._store_size = size
        
    def setItemsList(self, list):
        self._store = self._checkStoreList(list)
        
    def buyItems(self):
        items = []
        for index_a, item_a in enumerate(self._store, 1):
            if item_a < self._credit:
                for index_b, item_b in enumerate(self._store[index_a:], index_a + 1):
                    if (item_a + item_b) == self._credit:
                        items.append(index_a)
                        items.append(index_b)
                        break 
        return items
        
    def _checkCredit(self, credit):
        if not (5 <= credit <= 1000):
            raise Exception('Credit out of limit')
        return credit
            
    def _checkStoreList(self, list):
        if len(list) != self._store_size:
            raise Exception('Incorrect number of items')
        for price in list:
            self._checkProductPrice(price)
        return list
            
    def _checkProductPrice(self, price):
        if not (1 <= price <= 1000):
            raise Exception('Price out of limit')
        
def main():
    # Parsear el fichero con el input
    store = StoreCredit()
    store.setCredit(200)
    store.setListSize(7)
    store.setItemsList((150, 24, 79, 50, 88, 345, 3))
    items = store.buyItems()
    print items
    pass
            
if __name__ == "__main__":
    main()
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.

from __future__ import with_statement

import datetime

from libcloud import __version__
from libcloud.common.base import ConnectionUserAndKey, BaseDriver
from libcloud.dns.types import RecordType

__all__ = [
    'Zone',
    'Record',
    'DNSDriver'
]


class Zone(object):
    """
    DNS zone.
    """

    def __init__(self, id, domain, type, ttl, driver, extra=None):
        """
        :param id: Zone id.
        :type id: ``str``

        :param domain: The name of the domain.
        :type domain: ``str``

        :param type: Zone type (master, slave).
        :type type: ``str``

        :param ttl: Default TTL for records in this zone (in seconds).
        :type ttl: ``int``

        :param driver: DNSDriver instance.
        :type driver: :class:`DNSDriver`

        :param extra: (optional) Extra attributes (driver specific).
        :type extra: ``dict``
        """
        self.id = str(id) if id else None
        self.domain = domain
        self.type = type
        self.ttl = ttl or None
        self.driver = driver
        self.extra = extra or {}

    def list_records(self):
        return self.driver.list_records(zone=self)

    def create_record(self, name, type, data, extra=None):
        return self.driver.create_record(name=name, zone=self, type=type,
                                         data=data, extra=extra)

    def update(self, domain=None, type=None, ttl=None, extra=None):
        return self.driver.update_zone(zone=self, domain=domain, type=type,
                                       ttl=ttl, extra=extra)

    def delete(self):
        return self.driver.delete_zone(zone=self)

    def export_to_bind_format(self):
        return self.driver.export_zone_to_bind_format(zone=self)

    def export_to_bind_zone_file(self, file_path):
        self.driver.export_zone_to_bind_zone_file(zone=self,
                                                  file_path=file_path)

    def __repr__(self):
        return ('<Zone: domain=%s, ttl=%s, provider=%s ...>' %
                (self.domain, self.ttl, self.driver.name))


class Record(object):
    """
    Zone record / resource.
    """

    def __init__(self, id, name, type, data, zone, driver, extra=None):
        """
        :param id: Record id
        :type id: ``str``

        :param name: Hostname or FQDN.
        :type name: ``str``

        :param type: DNS record type (A, AAAA, ...).
        :type type: :class:`RecordType`

        :param data: Data for the record (depends on the record type).
        :type data: ``str``

        :param zone: Zone instance.
        :type zone: :class:`Zone`

        :param driver: DNSDriver instance.
        :type driver: :class:`DNSDriver`

        :param extra: (optional) Extra attributes (driver specific).
        :type extra: ``dict``
        """
        self.id = str(id) if id else None
        self.name = name
        self.type = type
        self.data = data
        self.zone = zone
        self.driver = driver
        self.extra = extra or {}

    def update(self, name=None, type=None, data=None, extra=None):
        return self.driver.update_record(record=self, name=name, type=type,
                                         data=data, extra=extra)

    def delete(self):
        return self.driver.delete_record(record=self)

    def _get_numeric_id(self):
        record_id = self.id

        if record_id.isdigit():
            record_id = int(record_id)

        return record_id

    def __repr__(self):
        return ('<Record: zone=%s, name=%s, type=%s, data=%s, provider=%s '
                '...>' %
                (self.zone.id, self.name, self.type, self.data,
                 self.driver.name))


class DNSDriver(BaseDriver):
    """
    A base DNSDriver class to derive from

    This class is always subclassed by a specific driver.
    """
    connectionCls = ConnectionUserAndKey
    name = None
    website = None

    # Map libcloud record type enum to provider record type name
    RECORD_TYPE_MAP = {}

    def __init__(self, key, secret=None, secure=True, host=None, port=None,
                 **kwargs):
        """
        :param    key: API key or username to used (required)
        :type     key: ``str``

        :param    secret: Secret password to be used (required)
        :type     secret: ``str``

        :param    secure: Weither to use HTTPS or HTTP. Note: Some providers
                only support HTTPS, and it is on by default.
        :type     secure: ``bool``

        :param    host: Override hostname used for connections.
        :type     host: ``str``

        :param    port: Override port used for connections.
        :type     port: ``int``

        :return: ``None``
        """
        super(DNSDriver, self).__init__(key=key, secret=secret, secure=secure,
                                        host=host, port=port, **kwargs)

    def list_record_types(self):
        """
        Return a list of RecordType objects supported by the provider.

        :return: ``list`` of :class:`RecordType`
        """
        return list(self.RECORD_TYPE_MAP.keys())

    def iterate_zones(self):
        """
        Return a generator to iterate over available zones.

        :rtype: ``generator`` of :class:`Zone`
        """
        raise NotImplementedError(
            'iterate_zones not implemented for this driver')

    def list_zones(self):
        """
        Return a list of zones.

        :return: ``list`` of :class:`Zone`
        """
        return list(self.iterate_zones())

    def iterate_records(self, zone):
        """
        Return a generator to iterate over records for the provided zone.

        :param zone: Zone to list records for.
        :type zone: :class:`Zone`

        :rtype: ``generator`` of :class:`Record`
        """
        raise NotImplementedError(
            'iterate_records not implemented for this driver')

    def list_records(self, zone):
        """
        Return a list of records for the provided zone.

        :param zone: Zone to list records for.
        :type zone: :class:`Zone`

        :return: ``list`` of :class:`Record`
        """
        return list(self.iterate_records(zone))

    def get_zone(self, zone_id):
        """
        Return a Zone instance.

        :param zone_id: ID of the required zone
        :type  zone_id: ``str``

        :rtype: :class:`Zone`
        """
        raise NotImplementedError(
            'get_zone not implemented for this driver')

    def get_record(self, zone_id, record_id):
        """
        Return a Record instance.

        :param zone_id: ID of the required zone
        :type  zone_id: ``str``

        :param record_id: ID of the required record
        :type  record_id: ``str``

        :rtype: :class:`Record`
        """
        raise NotImplementedError(
            'get_record not implemented for this driver')

    def create_zone(self, domain, type='master', ttl=None, extra=None):
        """
        Create a new zone.

        :param domain: Zone domain name (e.g. example.com)
        :type domain: ``str``

        :param type: Zone type (master / slave).
        :type  type: ``str``

        :param ttl: TTL for new records. (optional)
        :type  ttl: ``int``

        :param extra: Extra attributes (driver specific). (optional)
        :type extra: ``dict``

        :rtype: :class:`Zone`
        """
        raise NotImplementedError(
            'create_zone not implemented for this driver')

    def update_zone(self, zone, domain, type='master', ttl=None, extra=None):
        """
        Update en existing zone.

        :param zone: Zone to update.
        :type  zone: :class:`Zone`

        :param domain: Zone domain name (e.g. example.com)
        :type  domain: ``str``

        :param type: Zone type (master / slave).
        :type  type: ``str``

        :param ttl: TTL for new records. (optional)
        :type  ttl: ``int``

        :param extra: Extra attributes (driver specific). (optional)
        :type  extra: ``dict``

        :rtype: :class:`Zone`
        """
        raise NotImplementedError(
            'update_zone not implemented for this driver')

    def create_record(self, name, zone, type, data, extra=None):
        """
        Create a new record.

        :param name: Record name without the domain name (e.g. www).
                     Note: If you want to create a record for a base domain
                     name, you should specify empty string ('') for this
                     argument.
        :type  name: ``str``

        :param zone: Zone where the requested record is created.
        :type  zone: :class:`Zone`

        :param type: DNS record type (A, AAAA, ...).
        :type  type: :class:`RecordType`

        :param data: Data for the record (depends on the record type).
        :type  data: ``str``

        :param extra: Extra attributes (driver specific). (optional)
        :type extra: ``dict``

        :rtype: :class:`Record`
        """
        raise NotImplementedError(
            'create_record not implemented for this driver')

    def update_record(self, record, name, type, data, extra):
        """
        Update an existing record.

        :param record: Record to update.
        :type  record: :class:`Record`

        :param name: Record name without the domain name (e.g. www).
                     Note: If you want to create a record for a base domain
                     name, you should specify empty string ('') for this
                     argument.
        :type  name: ``str``

        :param type: DNS record type (A, AAAA, ...).
        :type  type: :class:`RecordType`

        :param data: Data for the record (depends on the record type).
        :type  data: ``str``

        :param extra: (optional) Extra attributes (driver specific).
        :type  extra: ``dict``

        :rtype: :class:`Record`
        """
        raise NotImplementedError(
            'update_record not implemented for this driver')

    def delete_zone(self, zone):
        """
        Delete a zone.

        Note: This will delete all the records belonging to this zone.

        :param zone: Zone to delete.
        :type  zone: :class:`Zone`

        :rtype: ``bool``
        """
        raise NotImplementedError(
            'delete_zone not implemented for this driver')

    def delete_record(self, record):
        """
        Delete a record.

        :param record: Record to delete.
        :type  record: :class:`Record`

        :rtype: ``bool``
        """
        raise NotImplementedError(
            'delete_record not implemented for this driver')

    def export_zone_to_bind_format(self, zone):
        """
        Export Zone object to the BIND compatible format.

        :param zone: Zone to export.
        :type  zone: :class:`Zone`

        :return: Zone data in BIND compatible format.
        :rtype: ``str``
        """
        if zone.type != 'master':
            raise ValueError('You can only generate BIND out for master zones')

        lines = []

        # For consistent output, records are sorted based on the id
        records = zone.list_records()
        records = sorted(records, key=Record._get_numeric_id)

        date = datetime.datetime.now().strftime('%Y-%m-%d %H:%m:%S')
        values = {'version': __version__, 'date': date}

        lines.append('; Generated by Libcloud v%(version)s on %(date)s' %
                     values)
        lines.append('$ORIGIN %(domain)s.' % {'domain': zone.domain})
        lines.append('$TTL %(domain_ttl)s\n' % {'domain_ttl': zone.ttl})

        for record in records:
            line = self._get_bind_record_line(record=record)
            lines.append(line)

        output = '\n'.join(lines)
        return output

    def export_zone_to_bind_zone_file(self, zone, file_path):
        """
        Export Zone object to the BIND compatible format and write result to a
        file.

        :param zone: Zone to export.
        :type  zone: :class:`Zone`

        :param file_path: File path where the output will be saved.
        :type  file_path: ``str``
        """
        result = self.export_zone_to_bind_format(zone=zone)

        with open(file_path, 'w') as fp:
            fp.write(result)

    def _get_bind_record_line(self, record):
        """
        Generate BIND record line for the provided record.

        :param record: Record to generate the line for.
        :type  record: :class:`Record`

        :return: Bind compatible record line.
        :rtype: ``str``
        """
        parts = []

        if record.name:
            name = '%(name)s.%(domain)s' % {'name': record.name,
                                            'domain': record.zone.domain}
        else:
            name = record.zone.domain

        name += '.'

        ttl = record.extra['ttl'] if 'ttl' in record.extra else record.zone.ttl
        ttl = str(ttl)
        data = record.data

        if record.type in [RecordType.CNAME, RecordType.DNAME, RecordType.MX,
                           RecordType.PTR, RecordType.SRV]:
            # Make sure trailing dot is present
            if data[len(data) - 1] != '.':
                data += '.'

        if record.type in [RecordType.TXT, RecordType.SPF] and ' ' in data:
            # Escape the quotes
            data = data.replace('"', '\\"')

            # Quote the string
            data = '"%s"' % (data)

        if record.type in [RecordType.MX, RecordType.SRV]:
            priority = str(record.extra['priority'])
            parts = [name, ttl, 'IN', record.type, priority, data]
        else:
            parts = [name, ttl, 'IN', record.type, data]

        line = '\t'.join(parts)
        return line

    def _string_to_record_type(self, string):
        """
        Return a string representation of a DNS record type to a
        libcloud RecordType ENUM.

        :rtype: ``str``
        """
        string = string.upper()
        record_type = getattr(RecordType, string)
        return record_type

# This file is part of the Frescobaldi project, http://www.frescobaldi.org/
#
# Copyright (c) 2008 - 2016 by Wilbert Berendsen
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
# See http://www.gnu.org/licenses/ for more information.

"""
Various routines to display meaningful tooltips (text or graphical).

The show() function displays a tooltip showing part of a Document.

"""


from PyQt5.QtCore import QSize
from PyQt5.QtGui import (
    QFont, QPainter, QPixmap, QTextCursor, QTextDocument)
from PyQt5.QtWidgets import QLabel

import metainfo
import tokeniter
import highlighter
import textformats
import gadgets.customtooltip
import tokeniter
import ly.lex.lilypond


def pixmap(cursor, num_lines=6, scale=0.8):
    """Return a QPixmap displaying the selected lines of the document.

    If the cursor has no selection, num_lines are drawn.

    By default the text is drawn 0.8 * the normal font size. You can change
    that by supplying the scale parameter.

    """
    block = cursor.document().findBlock(cursor.selectionStart())
    c2 = QTextCursor(block)
    if cursor.hasSelection():
        c2.setPosition(cursor.selectionEnd(), QTextCursor.KeepAnchor)
        c2.movePosition(QTextCursor.EndOfBlock, QTextCursor.KeepAnchor)
    else:
        c2.movePosition(QTextCursor.NextBlock, QTextCursor.KeepAnchor, num_lines)

    data = textformats.formatData('editor')
    doc = QTextDocument()
    font = QFont(data.font)
    font.setPointSizeF(font.pointSizeF() * scale)
    doc.setDefaultFont(font)
    doc.setPlainText(c2.selection().toPlainText())
    if metainfo.info(cursor.document()).highlighting:
        highlighter.highlight(doc, state=tokeniter.state(block))
    size = doc.size().toSize() + QSize(8, -4)
    pix = QPixmap(size)
    pix.fill(data.baseColors['background'])
    doc.drawContents(QPainter(pix))
    return pix


def show(cursor, pos=None, num_lines=6):
    """Displays a tooltip showing part of the cursor's Document.

    If the cursor has a selection, those blocks are displayed.
    Otherwise, num_lines lines are displayed.

    If pos is not given, the global mouse position is used.

    """
    pix = pixmap(cursor, num_lines)
    label = QLabel()
    label.setPixmap(pix)
    label.setStyleSheet("QLabel { border: 1px solid #777; }")
    label.resize(pix.size())
    gadgets.customtooltip.show(label, pos)


def text(cursor):
    """Return basic tooltip text displaying filename, line and column information.

    If the position is inside a music expression, the name of the variable the
    expression is assigned to is also appended on a new line. If the time
    position can be determined it is appended on a third line.

    """
    filename = cursor.document().documentName()
    line = cursor.blockNumber() + 1
    column = cursor.position() - cursor.block().position()
    text = "{0} ({1}:{2})".format(filename, line, column)
    definition = get_definition(cursor)
    if definition:
        text += '\n' + definition
    time_pos = time_position(cursor)
    if time_pos:
        text += '\n' + _("Position: {pos}").format(pos=time_pos)
    return text


def get_definition(cursor):
    """Return the variable name the cursor's music expression is assigned to.

    If the music is in a \\score instead, "\\score" is returned.
    Returns None if no variable name can be found.

    """
    block = cursor.block()
    while block.isValid():
        state = tokeniter.state(block)
        if isinstance(state.parser(), ly.lex.lilypond.ParseGlobal):
            for t in tokeniter.tokens(block)[:2]:
                if type(t) is ly.lex.lilypond.Name:
                    return t[:]
                elif isinstance(t, ly.lex.lilypond.Keyword) and t == '\\score':
                    return '\\score'
        block = block.previous()


def time_position(cursor):
    """Returns the time position of the music the cursor points at.

    Format the value as "5/1" etc.

    """
    import documentinfo
    pos = documentinfo.music(cursor.document()).time_position(cursor.position())
    if pos is not None:
        import ly.duration
        return ly.duration.format_fraction(pos)



# Copyright (c) 2015 Institute of Computing Technology, CAS
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Jiuyue Ma

from m5.params import *
from m5.proxy import *
from Uart import Uart
from X86IntPin import X86IntSourcePin

class I8250X(Uart):
    type = 'I8250X'
    cxx_class = 'X86ISA::I8250X'
    cxx_header = "dev/cellx/i8250x.hh"
    int_pin = Param.X86IntSourcePin(X86IntSourcePin(),
            'Pin to signal uart interrupts to')


# Copyright 2014 DreamHost, LLC
#
# Author: DreamHost, LLC
#
# 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.


from horizon.base import Horizon


nova_dashboard = Horizon.get_dashboard('project')
compute_panel_group = nova_dashboard.get_panel_group('network')
compute_panel_group.panels.append('networking')

#
# Manually override the definition of the router detail view method
# to properly look up port data w/ akanda. May God have mercy on my soul.
#
from openstack_dashboard.dashboards.project.routers import views
from akanda.horizon.routers.views import get_interfaces_data
views.DetailView.get_interfaces_data = get_interfaces_data

#!/usr/bin/python -tt
# -*- coding: utf-8 -*-

# (c) 2013, Evgenii Terechkov
# Written by Evgenii Terechkov <evg@altlinux.org> 
# Based on urpmi module written by Philippe Makowski <philippem@mageia.org> 
#
# This module is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This software is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this software.  If not, see <http://www.gnu.org/licenses/>.


ANSIBLE_METADATA = {'status': ['preview'],
                    'supported_by': 'community',
                    'version': '1.0'}

DOCUMENTATION = '''
---
module: apt_rpm
short_description: apt_rpm package manager
description:
  - Manages packages with I(apt-rpm). Both low-level (I(rpm)) and high-level (I(apt-get)) package manager binaries required.
version_added: "1.5"
options:
  pkg:
    description:
      - name of package to install, upgrade or remove.
    required: true
    default: null
  state:
    description:
      - Indicates the desired package state
    required: false
    default: present
    choices: [ "absent", "present" ]
  update_cache:
    description:
      - update the package database first C(apt-get update).
    required: false
    default: no
    choices: [ "yes", "no" ]
author: "Evgenii Terechkov (@evgkrsk)"
notes:  []
'''

EXAMPLES = '''
# install package foo
- apt_rpm:
    pkg: foo
    state: present

# remove package foo
- apt_rpm:
    pkg: foo
    state: absent

# description: remove packages foo and bar
- apt_rpm:
    pkg: foo,bar
    state: absent

# description: update the package database and install bar (bar will be the updated if a newer version exists)
- apt_rpm:
    name: bar
    state: present
    update_cache: yes
'''


try:
    import json
except ImportError:
    import simplejson as json

import shlex
import os
import sys

APT_PATH="/usr/bin/apt-get"
RPM_PATH="/usr/bin/rpm"

def query_package(module, name):
    # rpm -q returns 0 if the package is installed,
    # 1 if it is not installed
    rc, out, err = module.run_command("%s -q %s" % (RPM_PATH,name))
    if rc == 0:
        return True
    else:
        return False

def query_package_provides(module, name):
    # rpm -q returns 0 if the package is installed,
    # 1 if it is not installed
    rc, out, err = module.run_command("%s -q --provides %s" % (RPM_PATH,name))
    return rc == 0

def update_package_db(module):
    rc, out, err = module.run_command("%s update" % APT_PATH)

    if rc != 0:
        module.fail_json(msg="could not update package db: %s" % err)

def remove_packages(module, packages):
    
    remove_c = 0
    # Using a for loop in case of error, we can report the package that failed
    for package in packages:
        # Query the package first, to see if we even need to remove
        if not query_package(module, package):
            continue

        rc, out, err = module.run_command("%s -y remove %s" % (APT_PATH,package))

        if rc != 0:
            module.fail_json(msg="failed to remove %s: %s" % (package, err))
    
        remove_c += 1

    if remove_c > 0:
        module.exit_json(changed=True, msg="removed %s package(s)" % remove_c)

    module.exit_json(changed=False, msg="package(s) already absent")


def install_packages(module, pkgspec):

    packages = ""
    for package in pkgspec:
        if not query_package_provides(module, package):
            packages += "'%s' " % package

    if len(packages) != 0:

        rc, out, err = module.run_command("%s -y install %s" % (APT_PATH, packages))

        installed = True
        for packages in pkgspec:
            if not query_package_provides(module, package):
                installed = False

        # apt-rpm always have 0 for exit code if --force is used
        if rc or not installed:
            module.fail_json(msg="'apt-get -y install %s' failed: %s" % (packages, err))
        else:
            module.exit_json(changed=True, msg="%s present(s)" % packages)
    else:
        module.exit_json(changed=False)


def main():
    module = AnsibleModule(
            argument_spec    = dict(
                state        = dict(default='installed', choices=['installed', 'removed', 'absent', 'present']),
                update_cache = dict(default=False, aliases=['update-cache'], type='bool'),
                package      = dict(aliases=['pkg', 'name'], required=True)))
                

    if not os.path.exists(APT_PATH) or not os.path.exists(RPM_PATH):
        module.fail_json(msg="cannot find /usr/bin/apt-get and/or /usr/bin/rpm")

    p = module.params

    if p['update_cache']:
        update_package_db(module)

    packages = p['package'].split(',')

    if p['state'] in [ 'installed', 'present' ]:
        install_packages(module, packages)

    elif p['state'] in [ 'removed', 'absent' ]:
        remove_packages(module, packages)

# this is magic, see lib/ansible/module_common.py
from ansible.module_utils.basic import *
    
if __name__ == '__main__':
    main()

#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

# Create the RenderWindow, Renderer and both Actors
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

# load in the texture map
#
pngReader = vtk.vtkPNGReader()
pngReader.SetFileName(VTK_DATA_ROOT + "/Data/camscene.png")
pngReader.Update()

xWidth = pngReader.GetOutput().GetDimensions()[0]
yHeight = pngReader.GetOutput().GetDimensions()[1]

wl = vtk.vtkWarpLens()
wl.SetInputConnection(pngReader.GetOutputPort())
wl.SetPrincipalPoint(2.4507, 1.7733)
wl.SetFormatWidth(4.792)
wl.SetFormatHeight(3.6)
wl.SetImageWidth(xWidth)
wl.SetImageHeight(yHeight)
wl.SetK1(0.01307)
wl.SetK2(0.0003102)
wl.SetP1(1.953e-005)
wl.SetP2(-9.655e-005)

gf = vtk.vtkGeometryFilter()
gf.SetInputConnection(wl.GetOutputPort())

tf = vtk.vtkTriangleFilter()
tf.SetInputConnection(gf.GetOutputPort())

strip = vtk.vtkStripper()
strip.SetInputConnection(tf.GetOutputPort())
strip.SetMaximumLength(250)

dsm = vtk.vtkPolyDataMapper()
dsm.SetInputConnection(strip.GetOutputPort())

planeActor = vtk.vtkActor()
planeActor.SetMapper(dsm)

# Add the actors to the renderer, set the background and size
ren1.AddActor(planeActor)
ren1.SetBackground(0.1, 0.2, 0.4)

renWin.SetSize(300, 300)

# render the image
iren.Initialize()

renWin.Render()

ren1.GetActiveCamera().Zoom(1.4)

renWin.Render()

#iren.Start()

from pybench import Test

class SimpleListManipulation(Test):

    version = 2.0
    operations = 5* (6 + 6 + 6)
    rounds = 130000

    def test(self):

        l = []
        append = l.append

        for i in range(self.rounds):

            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            x = l[0]
            x = l[1]
            x = l[2]
            x = l[3]
            x = l[4]
            x = l[5]

            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            x = l[0]
            x = l[1]
            x = l[2]
            x = l[3]
            x = l[4]
            x = l[5]

            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            x = l[0]
            x = l[1]
            x = l[2]
            x = l[3]
            x = l[4]
            x = l[5]

            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            x = l[0]
            x = l[1]
            x = l[2]
            x = l[3]
            x = l[4]
            x = l[5]

            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            x = l[0]
            x = l[1]
            x = l[2]
            x = l[3]
            x = l[4]
            x = l[5]

            if len(l) > 10000:
                # cut down the size
                del l[:]

    def calibrate(self):

        l = []
        append = l.append

        for i in range(self.rounds):
            pass

class ListSlicing(Test):

    version = 2.0
    operations = 25*(3+1+2+1)
    rounds = 800

    def test(self):

        n = list(range(100))
        r = list(range(25))

        for i in range(self.rounds):

            l = n[:]

            for j in r:

                m = l[50:]
                m = l[:25]
                m = l[50:55]
                l[:3] = n
                m = l[:-1]
                m = l[1:]
                l[-1:] = n

    def calibrate(self):

        n = list(range(100))
        r = list(range(25))

        for i in range(self.rounds):
            for j in r:
                pass

class SmallLists(Test):

    version = 2.0
    operations = 5*(1+ 6 + 6 + 3 + 1)
    rounds = 80000

    def test(self):

        for i in range(self.rounds):

            l = []

            append = l.append
            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            l[:3] = [1,2,3]
            m = l[:-1]
            m = l[1:]

            l[-1:] = [4,5,6]

            l = []

            append = l.append
            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            l[:3] = [1,2,3]
            m = l[:-1]
            m = l[1:]

            l[-1:] = [4,5,6]

            l = []

            append = l.append
            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            l[:3] = [1,2,3]
            m = l[:-1]
            m = l[1:]

            l[-1:] = [4,5,6]

            l = []

            append = l.append
            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            l[:3] = [1,2,3]
            m = l[:-1]
            m = l[1:]

            l[-1:] = [4,5,6]

            l = []

            append = l.append
            append(2)
            append(3)
            append(4)
            append(2)
            append(3)
            append(4)

            l[0] = 3
            l[1] = 4
            l[2] = 5
            l[3] = 3
            l[4] = 4
            l[5] = 5

            l[:3] = [1,2,3]
            m = l[:-1]
            m = l[1:]

            l[-1:] = [4,5,6]

    def calibrate(self):

        for i in range(self.rounds):
            pass

class SimpleListComprehensions(Test):

    version = 2.0
    operations = 6
    rounds = 20000

    def test(self):

        n = list(range(10)) * 10

        for i in range(self.rounds):
            l = [x for x in n]
            l = [x for x in n if x]
            l = [x for x in n if not x]

            l = [x for x in n]
            l = [x for x in n if x]
            l = [x for x in n if not x]

    def calibrate(self):

        n = list(range(10)) * 10

        for i in range(self.rounds):
            pass

class NestedListComprehensions(Test):

    version = 2.0
    operations = 6
    rounds = 20000

    def test(self):

        m = list(range(10))
        n = list(range(10))

        for i in range(self.rounds):
            l = [x for x in n for y in m]
            l = [y for x in n for y in m]

            l = [x for x in n for y in m if y]
            l = [y for x in n for y in m if x]

            l = [x for x in n for y in m if not y]
            l = [y for x in n for y in m if not x]

    def calibrate(self):

        m = list(range(10))
        n = list(range(10))

        for i in range(self.rounds):
            pass

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you 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.

from pylint.checkers import BaseChecker
from pylint.interfaces import IAstroidChecker
from pylint.lint import PyLinter


class DoNotUseAssertsChecker(BaseChecker):
    __implements__ = IAstroidChecker

    name = 'do-not-use-asserts'
    priority = -1
    msgs = {
        'E7401': (
            'Do not use asserts.',
            'do-not-use-asserts',
            'Asserts should not be used in the main Airflow code.',
        ),
    }

    def visit_assert(self, node):
        self.add_message(
            self.name,
            node=node,
        )


def register(linter: PyLinter):
    linter.register_checker(DoNotUseAssertsChecker(linter))

#!/usr/bin/env python

# test_notify.py - unit test for async notifications
#
# Copyright (C) 2010-2011 Daniele Varrazzo  <daniele.varrazzo@gmail.com>
#
# psycopg2 is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published
# by the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# In addition, as a special exception, the copyright holders give
# permission to link this program with the OpenSSL library (or with
# modified versions of OpenSSL that use the same license as OpenSSL),
# and distribute linked combinations including the two.
#
# You must obey the GNU Lesser General Public License in all respects for
# all of the code used other than OpenSSL.
#
# psycopg2 is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
# License for more details.

from testutils import unittest

import psycopg2
from psycopg2 import extensions
from testutils import ConnectingTestCase, script_to_py3
from testconfig import dsn

import sys
import time
import select
from subprocess import Popen, PIPE


class NotifiesTests(ConnectingTestCase):

    def autocommit(self, conn):
        """Set a connection in autocommit mode."""
        conn.set_isolation_level(extensions.ISOLATION_LEVEL_AUTOCOMMIT)

    def listen(self, name):
        """Start listening for a name on self.conn."""
        curs = self.conn.cursor()
        curs.execute("LISTEN " + name)
        curs.close()

    def notify(self, name, sec=0, payload=None):
        """Send a notification to the database, eventually after some time."""
        if payload is None:
            payload = ''
        else:
            payload = ", %r" % payload

        script = ("""\
import time
time.sleep(%(sec)s)
import psycopg2
import psycopg2.extensions
conn = psycopg2.connect(%(dsn)r)
conn.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)
print conn.get_backend_pid()
curs = conn.cursor()
curs.execute("NOTIFY " %(name)r %(payload)r)
curs.close()
conn.close()
"""
            % { 'dsn': dsn, 'sec': sec, 'name': name, 'payload': payload})

        return Popen([sys.executable, '-c', script_to_py3(script)], stdout=PIPE)

    def test_notifies_received_on_poll(self):
        self.autocommit(self.conn)
        self.listen('foo')

        proc = self.notify('foo', 1)

        t0 = time.time()
        ready = select.select([self.conn], [], [], 5)
        t1 = time.time()
        self.assert_(0.99 < t1 - t0 < 4, t1 - t0)

        pid = int(proc.communicate()[0])
        self.assertEqual(0, len(self.conn.notifies))
        self.assertEqual(extensions.POLL_OK, self.conn.poll())
        self.assertEqual(1, len(self.conn.notifies))
        self.assertEqual(pid, self.conn.notifies[0][0])
        self.assertEqual('foo', self.conn.notifies[0][1])

    def test_many_notifies(self):
        self.autocommit(self.conn)
        for name in ['foo', 'bar', 'baz']:
            self.listen(name)

        pids = {}
        for name in ['foo', 'bar', 'baz', 'qux']:
            pids[name] = int(self.notify(name).communicate()[0])

        self.assertEqual(0, len(self.conn.notifies))
        for i in range(10):
            self.assertEqual(extensions.POLL_OK, self.conn.poll())
        self.assertEqual(3, len(self.conn.notifies))

        names = dict.fromkeys(['foo', 'bar', 'baz'])
        for (pid, name) in self.conn.notifies:
            self.assertEqual(pids[name], pid)
            names.pop(name) # raise if name found twice

    def test_notifies_received_on_execute(self):
        self.autocommit(self.conn)
        self.listen('foo')
        pid = int(self.notify('foo').communicate()[0])
        self.assertEqual(0, len(self.conn.notifies))
        self.conn.cursor().execute('select 1;')
        self.assertEqual(1, len(self.conn.notifies))
        self.assertEqual(pid, self.conn.notifies[0][0])
        self.assertEqual('foo', self.conn.notifies[0][1])

    def test_notify_object(self):
        self.autocommit(self.conn)
        self.listen('foo')
        self.notify('foo').communicate()
        time.sleep(0.5)
        self.conn.poll()
        notify = self.conn.notifies[0]
        self.assert_(isinstance(notify, psycopg2.extensions.Notify))

    def test_notify_attributes(self):
        self.autocommit(self.conn)
        self.listen('foo')
        pid = int(self.notify('foo').communicate()[0])
        time.sleep(0.5)
        self.conn.poll()
        self.assertEqual(1, len(self.conn.notifies))
        notify = self.conn.notifies[0]
        self.assertEqual(pid, notify.pid)
        self.assertEqual('foo', notify.channel)
        self.assertEqual('', notify.payload)

    def test_notify_payload(self):
        if self.conn.server_version < 90000:
            return self.skipTest("server version %s doesn't support notify payload"
                % self.conn.server_version)
        self.autocommit(self.conn)
        self.listen('foo')
        pid = int(self.notify('foo', payload="Hello, world!").communicate()[0])
        time.sleep(0.5)
        self.conn.poll()
        self.assertEqual(1, len(self.conn.notifies))
        notify = self.conn.notifies[0]
        self.assertEqual(pid, notify.pid)
        self.assertEqual('foo', notify.channel)
        self.assertEqual('Hello, world!', notify.payload)

    def test_notify_init(self):
        n = psycopg2.extensions.Notify(10, 'foo')
        self.assertEqual(10, n.pid)
        self.assertEqual('foo', n.channel)
        self.assertEqual('', n.payload)
        (pid, channel) = n
        self.assertEqual((pid, channel), (10, 'foo'))

        n = psycopg2.extensions.Notify(42, 'bar', 'baz')
        self.assertEqual(42, n.pid)
        self.assertEqual('bar', n.channel)
        self.assertEqual('baz', n.payload)
        (pid, channel) = n
        self.assertEqual((pid, channel), (42, 'bar'))

    def test_compare(self):
        data = [(10, 'foo'), (20, 'foo'), (10, 'foo', 'bar'), (10, 'foo', 'baz')]
        for d1 in data:
            for d2 in data:
                n1 = psycopg2.extensions.Notify(*d1)
                n2 = psycopg2.extensions.Notify(*d2)
                self.assertEqual((n1 == n2), (d1 == d2))
                self.assertEqual((n1 != n2), (d1 != d2))

    def test_compare_tuple(self):
        from psycopg2.extensions import Notify
        self.assertEqual((10, 'foo'), Notify(10, 'foo'))
        self.assertEqual((10, 'foo'), Notify(10, 'foo', 'bar'))
        self.assertNotEqual((10, 'foo'), Notify(20, 'foo'))
        self.assertNotEqual((10, 'foo'), Notify(10, 'bar'))

    def test_hash(self):
        from psycopg2.extensions import Notify
        self.assertEqual(hash((10, 'foo')), hash(Notify(10, 'foo')))
        self.assertNotEqual(hash(Notify(10, 'foo', 'bar')),
            hash(Notify(10, 'foo')))

def test_suite():
    return unittest.TestLoader().loadTestsFromName(__name__)

if __name__ == "__main__":
    unittest.main()


from mongoengine import ReferenceField, ListField
from mongoengine.base import BaseDocument, DocumentMetaclass, get_document

from wtforms import fields, validators
from flask_mongoengine.wtf import orm, fields as mongo_fields

from flask_admin import form
from flask_admin.model.form import FieldPlaceholder
from flask_admin.model.fields import InlineFieldList, AjaxSelectField, AjaxSelectMultipleField
from flask_admin.model.widgets import InlineFormWidget
from flask_admin._compat import iteritems

from .fields import ModelFormField, MongoFileField, MongoImageField
from .subdoc import EmbeddedForm


class CustomModelConverter(orm.ModelConverter):
    """
        Customized MongoEngine form conversion class.

        Injects various Flask-Admin widgets and handles lists with
        customized InlineFieldList field.
    """

    def __init__(self, view):
        super(CustomModelConverter, self).__init__()

        self.view = view

    def _get_field_override(self, name):
        form_overrides = getattr(self.view, 'form_overrides', None)

        if form_overrides:
            return form_overrides.get(name)

        return None

    def _get_subdocument_config(self, name):
        config = getattr(self.view, '_form_subdocuments', {})

        p = config.get(name)
        if not p:
            return EmbeddedForm()

        return p

    def _convert_choices(self, choices):
        for c in choices:
            if isinstance(c, tuple):
                yield c
            else:
                yield (c, c)

    def clone_converter(self, view):
        return self.__class__(view)

    def convert(self, model, field, field_args):
        # Check if it is overridden field
        if isinstance(field, FieldPlaceholder):
            return form.recreate_field(field.field)

        kwargs = {
            'label': getattr(field, 'verbose_name', field.name),
            'description': getattr(field, 'help_text', ''),
            'validators': [],
            'filters': [],
            'default': field.default
        }

        if field_args:
            kwargs.update(field_args)

        if kwargs['validators']:
            # Create a copy of the list since we will be modifying it.
            kwargs['validators'] = list(kwargs['validators'])

        if field.required:
            kwargs['validators'].append(validators.InputRequired())
        elif not isinstance(field, ListField):
            kwargs['validators'].append(validators.Optional())

        ftype = type(field).__name__

        if field.choices:
            kwargs['choices'] = list(self._convert_choices(field.choices))

            if ftype in self.converters:
                kwargs["coerce"] = self.coerce(ftype)
            if kwargs.pop('multiple', False):
                return fields.SelectMultipleField(**kwargs)
            return fields.SelectField(**kwargs)

        ftype = type(field).__name__

        if hasattr(field, 'to_form_field'):
            return field.to_form_field(model, kwargs)

        override = self._get_field_override(field.name)
        if override:
            return override(**kwargs)

        if ftype in self.converters:
            return self.converters[ftype](model, field, kwargs)

    @orm.converts('DateTimeField')
    def conv_DateTime(self, model, field, kwargs):
        kwargs['widget'] = form.DateTimePickerWidget()
        return orm.ModelConverter.conv_DateTime(self, model, field, kwargs)

    @orm.converts('ListField')
    def conv_List(self, model, field, kwargs):
        if field.field is None:
            raise ValueError('ListField "%s" must have field specified for model %s' % (field.name, model))

        if isinstance(field.field, ReferenceField):
            loader = getattr(self.view, '_form_ajax_refs', {}).get(field.name)
            if loader:
                return AjaxSelectMultipleField(loader, **kwargs)

            kwargs['widget'] = form.Select2Widget(multiple=True)
            kwargs.setdefault('validators', []).append(validators.Optional())

            # TODO: Support AJAX multi-select
            doc_type = field.field.document_type
            return mongo_fields.ModelSelectMultipleField(model=doc_type, **kwargs)

        # Create converter
        view = self._get_subdocument_config(field.name)
        converter = self.clone_converter(view)

        if field.field.choices:
            kwargs['multiple'] = True
            return converter.convert(model, field.field, kwargs)

        unbound_field = converter.convert(model, field.field, {})
        return InlineFieldList(unbound_field, min_entries=0, **kwargs)

    @orm.converts('EmbeddedDocumentField')
    def conv_EmbeddedDocument(self, model, field, kwargs):
        # FormField does not support validators
        kwargs['validators'] = []

        view = self._get_subdocument_config(field.name)

        form_opts = form.FormOpts(widget_args=getattr(view, 'form_widget_args', None),
                                  form_rules=view._form_rules)

        form_class = view.get_form()
        if form_class is None:
            converter = self.clone_converter(view)
            form_class = get_form(field.document_type_obj, converter,
                                  base_class=view.form_base_class or form.BaseForm,
                                  only=view.form_columns,
                                  exclude=view.form_excluded_columns,
                                  field_args=view.form_args,
                                  extra_fields=view.form_extra_fields)

            form_class = view.postprocess_form(form_class)

        return ModelFormField(field.document_type_obj, view, form_class, form_opts=form_opts, **kwargs)

    @orm.converts('ReferenceField')
    def conv_Reference(self, model, field, kwargs):
        kwargs['allow_blank'] = not field.required

        loader = getattr(self.view, '_form_ajax_refs', {}).get(field.name)
        if loader:
            return AjaxSelectField(loader, **kwargs)

        kwargs['widget'] = form.Select2Widget()

        return orm.ModelConverter.conv_Reference(self, model, field, kwargs)

    @orm.converts('FileField')
    def conv_File(self, model, field, kwargs):
        return MongoFileField(**kwargs)

    @orm.converts('ImageField')
    def conv_image(self, model, field, kwargs):
        return MongoImageField(**kwargs)


def get_form(model, converter,
             base_class=form.BaseForm,
             only=None,
             exclude=None,
             field_args=None,
             extra_fields=None):
    """
    Create a wtforms Form for a given mongoengine Document schema::

        from flask_mongoengine.wtf import model_form
        from myproject.myapp.schemas import Article
        ArticleForm = model_form(Article)

    :param model:
        A mongoengine Document schema class
    :param base_class:
        Base form class to extend from. Must be a ``wtforms.Form`` subclass.
    :param only:
        An optional iterable with the property names that should be included in
        the form. Only these properties will have fields.
    :param exclude:
        An optional iterable with the property names that should be excluded
        from the form. All other properties will have fields.
    :param field_args:
        An optional dictionary of field names mapping to keyword arguments used
        to construct each field object.
    :param converter:
        A converter to generate the fields based on the model properties. If
        not set, ``ModelConverter`` is used.
    """

    if isinstance(model, str):
        model = get_document(model)

    if not isinstance(model, (BaseDocument, DocumentMetaclass)):
        raise TypeError('Model must be a mongoengine Document schema')

    field_args = field_args or {}

    # Find properties
    properties = sorted(((k, v) for k, v in iteritems(model._fields)),
                        key=lambda v: v[1].creation_counter)

    if only:
        props = dict(properties)

        def find(name):
            if extra_fields and name in extra_fields:
                return FieldPlaceholder(extra_fields[name])

            p = props.get(name)
            if p is not None:
                return p

            raise ValueError('Invalid model property name %s.%s' % (model, name))

        properties = ((p, find(p)) for p in only)
    elif exclude:
        properties = (p for p in properties if p[0] not in exclude)

    # Create fields
    field_dict = {}
    for name, p in properties:
        field = converter.convert(model, p, field_args.get(name))
        if field is not None:
            field_dict[name] = field

    # Contribute extra fields
    if not only and extra_fields:
        for name, field in iteritems(extra_fields):
            field_dict[name] = form.recreate_field(field)

    field_dict['model_class'] = model
    return type(model.__name__ + 'Form', (base_class,), field_dict)

# Copyright 2014 Brocade Communications System, Inc.
# All rights reserved.
#
#    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.


"""Implentation of Brocade ML2 Mechanism driver for ML2 Plugin."""

from neutron.i18n import _LE
from neutron.i18n import _LI
from neutron.plugins.ml2 import driver_api
from neutron.plugins.ml2.drivers.brocade.db import models as brocade_db
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import importutils

LOG = logging.getLogger(__name__)
MECHANISM_VERSION = 0.9
NOS_DRIVER = 'networking_brocade.vdx.ml2driver.nos.nosdriver.NOSdriver'

ML2_BROCADE = [cfg.StrOpt('address', default='',
                          help=_('The address of the host to SSH to')),
               cfg.StrOpt('username', default='admin',
                          help=_('The SSH username to use')),
               cfg.StrOpt('password', default='password', secret=True,
                          help=_('The SSH password to use')),
               cfg.StrOpt('physical_networks', default='',
                          help=_('Allowed physical networks')),
               cfg.StrOpt('ostype', default='NOS',
                          help=_('OS Type of the switch')),
               cfg.StrOpt('osversion', default='4.0.0',
                          help=_('OS Version number'))
               ]

cfg.CONF.register_opts(ML2_BROCADE, "ml2_brocade")


class BrocadeMechanism(driver_api.MechanismDriver):
    """ML2 Mechanism driver for Brocade VDX switches.

    This is the upper layer driver class that interfaces to
    lower layer (NETCONF) below.
    """

    def __init__(self):
        self._driver = None
        self._physical_networks = None
        self._switch = None
        self.initialize()

    def initialize(self):
        """Initilize of variables needed by this class."""

        self._physical_networks = cfg.CONF.ml2_brocade.physical_networks
        self.brocade_init()

    def brocade_init(self):
        """Brocade specific initialization for this class."""

        osversion = None
        self._switch = {
            'address': cfg.CONF.ml2_brocade.address,
            'username': cfg.CONF.ml2_brocade.username,
            'password': cfg.CONF.ml2_brocade.password,
            'ostype': cfg.CONF.ml2_brocade.ostype,
            'osversion': cfg.CONF.ml2_brocade.osversion}

        self._driver = importutils.import_object(NOS_DRIVER)

        # Detect version of NOS on the switch
        osversion = self._switch['osversion']
        if osversion == "autodetect":
            osversion = self._driver.get_nos_version(
                self._switch['address'],
                self._switch['username'],
                self._switch['password'])

        virtual_fabric_enabled = self._driver.is_virtual_fabric_enabled(
            self._switch['address'],
            self._switch['username'],
            self._switch['password'])

        if virtual_fabric_enabled:
            LOG.debug("Virtual Fabric: enabled")
        else:
            LOG.debug("Virtual Fabric: not enabled")

        self.set_features_enabled(osversion, virtual_fabric_enabled)

    def set_features_enabled(self, nos_version, virtual_fabric_enabled):
        self._virtual_fabric_enabled = virtual_fabric_enabled
        version = nos_version.split(".", 2)

        # Starting 4.1.0 port profile domains are supported
        if int(version[0]) >= 5 or (int(version[0]) >= 4
                                    and int(version[1]) >= 1):
            self._pp_domains_supported = True
        else:
            self._pp_domains_supported = False
        self._driver.set_features_enabled(self._pp_domains_supported,
                                          self._virtual_fabric_enabled)

    def get_features_enabled(self):
        return self._pp_domains_supported, self._virtual_fabric_enabled

    def create_network_precommit(self, mech_context):
        """Create Network in the mechanism specific database table."""

        network = mech_context.current
        context = mech_context._plugin_context
        tenant_id = network['tenant_id']
        network_id = network['id']

        segments = mech_context.network_segments
        # currently supports only one segment per network
        segment = segments[0]

        network_type = segment['network_type']
        vlan_id = segment['segmentation_id']
        segment_id = segment['id']

        if segment['physical_network'] not in self._physical_networks:
            raise Exception(
                _("Brocade Mechanism: failed to create network, "
                  "network cannot be created in the configured "
                  "physical network"))

        if network_type != 'vlan':
            raise Exception(
                _("Brocade Mechanism: failed to create network, "
                  "only network type vlan is supported"))

        try:
            brocade_db.create_network(context, network_id, vlan_id,
                                      segment_id, network_type, tenant_id)
        except Exception:
            LOG.exception(
                _LE("Brocade Mechanism: failed to create network in db"))
            raise Exception(
                _("Brocade Mechanism: create_network_precommit failed"))

        LOG.info(_LI("create network (precommit): %(network_id)s "
                     "of network type = %(network_type)s "
                     "with vlan = %(vlan_id)s "
                     "for tenant %(tenant_id)s"),
                 {'network_id': network_id,
                  'network_type': network_type,
                  'vlan_id': vlan_id,
                  'tenant_id': tenant_id})

    def create_network_postcommit(self, mech_context):
        """Create Network as a portprofile on the switch."""

        LOG.debug("create_network_postcommit: called")

        network = mech_context.current
        # use network_id to get the network attributes
        # ONLY depend on our db for getting back network attributes
        # this is so we can replay postcommit from db
        context = mech_context._plugin_context

        network_id = network['id']
        network = brocade_db.get_network(context, network_id)
        network_type = network['network_type']
        tenant_id = network['tenant_id']
        vlan_id = network['vlan']

        try:
            self._driver.create_network(self._switch['address'],
                                        self._switch['username'],
                                        self._switch['password'],
                                        vlan_id)
        except Exception:
            LOG.exception(_LE("Brocade NOS driver: failed in create network"))
            brocade_db.delete_network(context, network_id)
            raise Exception(
                _("Brocade Mechanism: create_network_postcommmit failed"))

        LOG.info(_LI("created network (postcommit): %(network_id)s"
                     " of network type = %(network_type)s"
                     " with vlan = %(vlan_id)s"
                     " for tenant %(tenant_id)s"),
                 {'network_id': network_id,
                  'network_type': network_type,
                  'vlan_id': vlan_id,
                  'tenant_id': tenant_id})

    def delete_network_precommit(self, mech_context):
        """Delete Network from the plugin specific database table."""

        LOG.debug("delete_network_precommit: called")

        network = mech_context.current
        network_id = network['id']
        vlan_id = network['provider:segmentation_id']
        tenant_id = network['tenant_id']

        context = mech_context._plugin_context

        try:
            brocade_db.delete_network(context, network_id)
        except Exception:
            LOG.exception(
                _LE("Brocade Mechanism: failed to delete network in db"))
            raise Exception(
                _("Brocade Mechanism: delete_network_precommit failed"))

        LOG.info(_LI("delete network (precommit): %(network_id)s"
                     " with vlan = %(vlan_id)s"
                     " for tenant %(tenant_id)s"),
                 {'network_id': network_id,
                  'vlan_id': vlan_id,
                  'tenant_id': tenant_id})

    def delete_network_postcommit(self, mech_context):
        """Delete network.

        This translates to removng portprofile
        from the switch.
        """

        LOG.debug("delete_network_postcommit: called")
        network = mech_context.current
        network_id = network['id']
        vlan_id = network['provider:segmentation_id']
        tenant_id = network['tenant_id']

        try:
            self._driver.delete_network(self._switch['address'],
                                        self._switch['username'],
                                        self._switch['password'],
                                        vlan_id)
        except Exception:
            LOG.exception(_LE("Brocade NOS driver: failed to delete network"))
            raise Exception(
                _("Brocade switch exception, "
                  "delete_network_postcommit failed"))

        LOG.info(_LI("delete network (postcommit): %(network_id)s"
                     " with vlan = %(vlan_id)s"
                     " for tenant %(tenant_id)s"),
                 {'network_id': network_id,
                  'vlan_id': vlan_id,
                  'tenant_id': tenant_id})

    def update_network_precommit(self, mech_context):
        """Noop now, it is left here for future."""
        pass

    def update_network_postcommit(self, mech_context):
        """Noop now, it is left here for future."""
        pass

    def create_port_precommit(self, mech_context):
        """Create logical port on the switch (db update)."""

        LOG.debug("create_port_precommit: called")

        port = mech_context.current
        port_id = port['id']
        network_id = port['network_id']
        tenant_id = port['tenant_id']
        admin_state_up = port['admin_state_up']

        context = mech_context._plugin_context

        network = brocade_db.get_network(context, network_id)
        vlan_id = network['vlan']

        try:
            brocade_db.create_port(context, port_id, network_id,
                                   None,
                                   vlan_id, tenant_id, admin_state_up)
        except Exception:
            LOG.exception(_LE("Brocade Mechanism: failed to create port"
                              " in db"))
            raise Exception(
                _("Brocade Mechanism: create_port_precommit failed"))

    def create_port_postcommit(self, mech_context):
        """Associate the assigned MAC address to the portprofile."""

        LOG.debug("create_port_postcommit: called")

        port = mech_context.current
        port_id = port['id']
        network_id = port['network_id']
        tenant_id = port['tenant_id']

        context = mech_context._plugin_context

        network = brocade_db.get_network(context, network_id)
        vlan_id = network['vlan']

        interface_mac = port['mac_address']

        # convert mac format: xx:xx:xx:xx:xx:xx -> xxxx.xxxx.xxxx
        mac = self.mac_reformat_62to34(interface_mac)
        try:
            self._driver.associate_mac_to_network(self._switch['address'],
                                                  self._switch['username'],
                                                  self._switch['password'],
                                                  vlan_id,
                                                  mac)
        except Exception:
            LOG.exception(
                _LE("Brocade NOS driver: failed to associate mac %s"),
                interface_mac)
            raise Exception(
                _("Brocade switch exception: create_port_postcommit failed"))

        LOG.info(
            _LI("created port (postcommit): port_id=%(port_id)s"
                " network_id=%(network_id)s tenant_id=%(tenant_id)s"),
            {'port_id': port_id,
             'network_id': network_id, 'tenant_id': tenant_id})

    def delete_port_precommit(self, mech_context):
        """Delete logical port on the switch (db update)."""

        LOG.debug("delete_port_precommit: called")
        port = mech_context.current
        port_id = port['id']

        context = mech_context._plugin_context

        try:
            brocade_db.delete_port(context, port_id)
        except Exception:
            LOG.exception(_LE("Brocade Mechanism: failed to delete port"
                              " in db"))
            raise Exception(
                _("Brocade Mechanism: delete_port_precommit failed"))

    def delete_port_postcommit(self, mech_context):
        """Dissociate MAC address from the portprofile."""

        LOG.debug("delete_port_postcommit: called")
        port = mech_context.current
        port_id = port['id']
        network_id = port['network_id']
        tenant_id = port['tenant_id']

        context = mech_context._plugin_context

        network = brocade_db.get_network(context, network_id)
        vlan_id = network['vlan']

        interface_mac = port['mac_address']

        # convert mac format: xx:xx:xx:xx:xx:xx -> xxxx.xxxx.xxxx
        mac = self.mac_reformat_62to34(interface_mac)
        try:
            self._driver.dissociate_mac_from_network(
                self._switch['address'],
                self._switch['username'],
                self._switch['password'],
                vlan_id,
                mac)
        except Exception:
            LOG.exception(
                _LE("Brocade NOS driver: failed to dissociate MAC %s"),
                interface_mac)
            raise Exception(
                _("Brocade switch exception, delete_port_postcommit failed"))

        LOG.info(
            _LI("delete port (postcommit): port_id=%(port_id)s"
                " network_id=%(network_id)s tenant_id=%(tenant_id)s"),
            {'port_id': port_id,
             'network_id': network_id, 'tenant_id': tenant_id})

    def update_port_precommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("update_port_precommit(self: called")

    def update_port_postcommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("update_port_postcommit: called")

    def create_subnet_precommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("create_subnetwork_precommit: called")

    def create_subnet_postcommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("create_subnetwork_postcommit: called")

    def delete_subnet_precommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("delete_subnetwork_precommit: called")

    def delete_subnet_postcommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("delete_subnetwork_postcommit: called")

    def update_subnet_precommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("update_subnet_precommit(self: called")

    def update_subnet_postcommit(self, mech_context):
        """Noop now, it is left here for future."""
        LOG.debug("update_subnet_postcommit: called")

    @staticmethod
    def mac_reformat_62to34(interface_mac):
        """Transform MAC address format.

        Transforms from 6 groups of 2 hexadecimal numbers delimited by ":"
        to 3 groups of 4 hexadecimals numbers delimited by ".".

        :param interface_mac: MAC address in the format xx:xx:xx:xx:xx:xx
        :type interface_mac: string
        :returns: MAC address in the format xxxx.xxxx.xxxx
        :rtype: string
        """

        mac = interface_mac.replace(":", "")
        mac = mac[0:4] + "." + mac[4:8] + "." + mac[8:12]
        return mac

"""
Tests for django test runner
"""
from __future__ import unicode_literals

import unittest

from admin_scripts.tests import AdminScriptTestCase

from django import db
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.core.management import call_command
from django.test import (
    TestCase, TransactionTestCase, mock, skipUnlessDBFeature, testcases,
)
from django.test.runner import DiscoverRunner, dependency_ordered
from django.test.testcases import connections_support_transactions
from django.utils import six
from django.utils.encoding import force_text

from .models import Person


class DependencyOrderingTests(unittest.TestCase):

    def test_simple_dependencies(self):
        raw = [
            ('s1', ('s1_db', ['alpha'])),
            ('s2', ('s2_db', ['bravo'])),
            ('s3', ('s3_db', ['charlie'])),
        ]
        dependencies = {
            'alpha': ['charlie'],
            'bravo': ['charlie'],
        }

        ordered = dependency_ordered(raw, dependencies=dependencies)
        ordered_sigs = [sig for sig, value in ordered]

        self.assertIn('s1', ordered_sigs)
        self.assertIn('s2', ordered_sigs)
        self.assertIn('s3', ordered_sigs)
        self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1'))
        self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2'))

    def test_chained_dependencies(self):
        raw = [
            ('s1', ('s1_db', ['alpha'])),
            ('s2', ('s2_db', ['bravo'])),
            ('s3', ('s3_db', ['charlie'])),
        ]
        dependencies = {
            'alpha': ['bravo'],
            'bravo': ['charlie'],
        }

        ordered = dependency_ordered(raw, dependencies=dependencies)
        ordered_sigs = [sig for sig, value in ordered]

        self.assertIn('s1', ordered_sigs)
        self.assertIn('s2', ordered_sigs)
        self.assertIn('s3', ordered_sigs)

        # Explicit dependencies
        self.assertLess(ordered_sigs.index('s2'), ordered_sigs.index('s1'))
        self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2'))

        # Implied dependencies
        self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1'))

    def test_multiple_dependencies(self):
        raw = [
            ('s1', ('s1_db', ['alpha'])),
            ('s2', ('s2_db', ['bravo'])),
            ('s3', ('s3_db', ['charlie'])),
            ('s4', ('s4_db', ['delta'])),
        ]
        dependencies = {
            'alpha': ['bravo', 'delta'],
            'bravo': ['charlie'],
            'delta': ['charlie'],
        }

        ordered = dependency_ordered(raw, dependencies=dependencies)
        ordered_sigs = [sig for sig, aliases in ordered]

        self.assertIn('s1', ordered_sigs)
        self.assertIn('s2', ordered_sigs)
        self.assertIn('s3', ordered_sigs)
        self.assertIn('s4', ordered_sigs)

        # Explicit dependencies
        self.assertLess(ordered_sigs.index('s2'), ordered_sigs.index('s1'))
        self.assertLess(ordered_sigs.index('s4'), ordered_sigs.index('s1'))
        self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s2'))
        self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s4'))

        # Implicit dependencies
        self.assertLess(ordered_sigs.index('s3'), ordered_sigs.index('s1'))

    def test_circular_dependencies(self):
        raw = [
            ('s1', ('s1_db', ['alpha'])),
            ('s2', ('s2_db', ['bravo'])),
        ]
        dependencies = {
            'bravo': ['alpha'],
            'alpha': ['bravo'],
        }

        self.assertRaises(ImproperlyConfigured, dependency_ordered, raw, dependencies=dependencies)

    def test_own_alias_dependency(self):
        raw = [
            ('s1', ('s1_db', ['alpha', 'bravo']))
        ]
        dependencies = {
            'alpha': ['bravo']
        }

        with self.assertRaises(ImproperlyConfigured):
            dependency_ordered(raw, dependencies=dependencies)

        # reordering aliases shouldn't matter
        raw = [
            ('s1', ('s1_db', ['bravo', 'alpha']))
        ]

        with self.assertRaises(ImproperlyConfigured):
            dependency_ordered(raw, dependencies=dependencies)


class MockTestRunner(object):
    def __init__(self, *args, **kwargs):
        pass

MockTestRunner.run_tests = mock.Mock(return_value=[])


class ManageCommandTests(unittest.TestCase):

    def test_custom_test_runner(self):
        call_command('test', 'sites',
                     testrunner='test_runner.tests.MockTestRunner')
        MockTestRunner.run_tests.assert_called_with(('sites',))

    def test_bad_test_runner(self):
        with self.assertRaises(AttributeError):
            call_command('test', 'sites',
                testrunner='test_runner.NonExistentRunner')


class CustomTestRunnerOptionsTests(AdminScriptTestCase):

    def setUp(self):
        settings = {
            'TEST_RUNNER': '\'test_runner.runner.CustomOptionsTestRunner\'',
        }
        self.write_settings('settings.py', sdict=settings)

    def tearDown(self):
        self.remove_settings('settings.py')

    def test_default_options(self):
        args = ['test', '--settings=test_project.settings']
        out, err = self.run_django_admin(args)
        self.assertNoOutput(err)
        self.assertOutput(out, '1:2:3')

    def test_default_and_given_options(self):
        args = ['test', '--settings=test_project.settings', '--option_b=foo']
        out, err = self.run_django_admin(args)
        self.assertNoOutput(err)
        self.assertOutput(out, '1:foo:3')

    def test_option_name_and_value_separated(self):
        args = ['test', '--settings=test_project.settings', '--option_b', 'foo']
        out, err = self.run_django_admin(args)
        self.assertNoOutput(err)
        self.assertOutput(out, '1:foo:3')

    def test_all_options_given(self):
        args = ['test', '--settings=test_project.settings', '--option_a=bar',
                '--option_b=foo', '--option_c=31337']
        out, err = self.run_django_admin(args)
        self.assertNoOutput(err)
        self.assertOutput(out, 'bar:foo:31337')


class Ticket17477RegressionTests(AdminScriptTestCase):
    def setUp(self):
        self.write_settings('settings.py')

    def tearDown(self):
        self.remove_settings('settings.py')

    def test_ticket_17477(self):
        """'manage.py help test' works after r16352."""
        args = ['help', 'test']
        out, err = self.run_manage(args)
        self.assertNoOutput(err)


class Sqlite3InMemoryTestDbs(TestCase):

    available_apps = []

    @unittest.skipUnless(all(db.connections[conn].vendor == 'sqlite' for conn in db.connections),
                         "This is an sqlite-specific issue")
    def test_transaction_support(self):
        """Ticket #16329: sqlite3 in-memory test databases"""
        for option_key, option_value in (
                ('NAME', ':memory:'), ('TEST', {'NAME': ':memory:'})):
            tested_connections = db.ConnectionHandler({
                'default': {
                    'ENGINE': 'django.db.backends.sqlite3',
                    option_key: option_value,
                },
                'other': {
                    'ENGINE': 'django.db.backends.sqlite3',
                    option_key: option_value,
                },
            })
            with mock.patch('django.db.connections', new=tested_connections):
                with mock.patch('django.test.testcases.connections', new=tested_connections):
                    other = tested_connections['other']
                    DiscoverRunner(verbosity=0).setup_databases()
                    msg = ("DATABASES setting '%s' option set to sqlite3's ':memory:' value "
                           "shouldn't interfere with transaction support detection." % option_key)
                    # Transaction support should be properly initialized for the 'other' DB
                    self.assertTrue(other.features.supports_transactions, msg)
                    # And all the DBs should report that they support transactions
                    self.assertTrue(connections_support_transactions(), msg)


class DummyBackendTest(unittest.TestCase):
    def test_setup_databases(self):
        """
        Test that setup_databases() doesn't fail with dummy database backend.
        """
        tested_connections = db.ConnectionHandler({})
        with mock.patch('django.test.runner.connections', new=tested_connections):
            runner_instance = DiscoverRunner(verbosity=0)
            try:
                old_config = runner_instance.setup_databases()
                runner_instance.teardown_databases(old_config)
            except Exception as e:
                self.fail("setup_databases/teardown_databases unexpectedly raised "
                          "an error: %s" % e)


class AliasedDefaultTestSetupTest(unittest.TestCase):
    def test_setup_aliased_default_database(self):
        """
        Test that setup_datebases() doesn't fail when 'default' is aliased
        """
        tested_connections = db.ConnectionHandler({
            'default': {
                'NAME': 'dummy'
            },
            'aliased': {
                'NAME': 'dummy'
            }
        })
        with mock.patch('django.test.runner.connections', new=tested_connections):
            runner_instance = DiscoverRunner(verbosity=0)
            try:
                old_config = runner_instance.setup_databases()
                runner_instance.teardown_databases(old_config)
            except Exception as e:
                self.fail("setup_databases/teardown_databases unexpectedly raised "
                          "an error: %s" % e)


class SetupDatabasesTests(unittest.TestCase):

    def setUp(self):
        self.runner_instance = DiscoverRunner(verbosity=0)

    def test_setup_aliased_databases(self):
        tested_connections = db.ConnectionHandler({
            'default': {
                'ENGINE': 'django.db.backends.dummy',
                'NAME': 'dbname',
            },
            'other': {
                'ENGINE': 'django.db.backends.dummy',
                'NAME': 'dbname',
            }
        })

        with mock.patch('django.db.backends.dummy.base.DatabaseCreation') as mocked_db_creation:
            with mock.patch('django.test.runner.connections', new=tested_connections):
                old_config = self.runner_instance.setup_databases()
                self.runner_instance.teardown_databases(old_config)
        mocked_db_creation.return_value.destroy_test_db.assert_called_once_with('dbname', 0, False)

    def test_destroy_test_db_restores_db_name(self):
        tested_connections = db.ConnectionHandler({
            'default': {
                'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"],
                'NAME': 'xxx_test_database',
            },
        })
        # Using the real current name as old_name to not mess with the test suite.
        old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
        with mock.patch('django.db.connections', new=tested_connections):
            tested_connections['default'].creation.destroy_test_db(old_name, verbosity=0, keepdb=True)
            self.assertEqual(tested_connections['default'].settings_dict["NAME"], old_name)

    def test_serialization(self):
        tested_connections = db.ConnectionHandler({
            'default': {
                'ENGINE': 'django.db.backends.dummy',
            },
        })
        with mock.patch('django.db.backends.dummy.base.DatabaseCreation') as mocked_db_creation:
            with mock.patch('django.test.runner.connections', new=tested_connections):
                self.runner_instance.setup_databases()
        mocked_db_creation.return_value.create_test_db.assert_called_once_with(
            verbosity=0, autoclobber=False, serialize=True, keepdb=False
        )

    def test_serialized_off(self):
        tested_connections = db.ConnectionHandler({
            'default': {
                'ENGINE': 'django.db.backends.dummy',
                'TEST': {'SERIALIZE': False},
            },
        })
        with mock.patch('django.db.backends.dummy.base.DatabaseCreation') as mocked_db_creation:
            with mock.patch('django.test.runner.connections', new=tested_connections):
                self.runner_instance.setup_databases()
        mocked_db_creation.return_value.create_test_db.assert_called_once_with(
            verbosity=0, autoclobber=False, serialize=False, keepdb=False
        )


class DeprecationDisplayTest(AdminScriptTestCase):
    # tests for 19546
    def setUp(self):
        settings = {
            'DATABASES': '{"default": {"ENGINE":"django.db.backends.sqlite3", "NAME":":memory:"}}'
        }
        self.write_settings('settings.py', sdict=settings)

    def tearDown(self):
        self.remove_settings('settings.py')

    def test_runner_deprecation_verbosity_default(self):
        args = ['test', '--settings=test_project.settings', 'test_runner_deprecation_app']
        out, err = self.run_django_admin(args)
        self.assertIn("Ran 1 test", force_text(err))
        six.assertRegex(self, err, r"RemovedInDjango\d+Warning: warning from test")
        six.assertRegex(self, err, r"RemovedInDjango\d+Warning: module-level warning from deprecation_app")

    def test_runner_deprecation_verbosity_zero(self):
        args = ['test', '--settings=test_project.settings', '--verbosity=0', 'test_runner_deprecation_app']
        out, err = self.run_django_admin(args)
        self.assertIn("Ran 1 test", err)
        self.assertNotIn("warning from test", err)


class AutoIncrementResetTest(TransactionTestCase):
    """
    Here we test creating the same model two times in different test methods,
    and check that both times they get "1" as their PK value. That is, we test
    that AutoField values start from 1 for each transactional test case.
    """

    available_apps = ['test_runner']

    reset_sequences = True

    @skipUnlessDBFeature('supports_sequence_reset')
    def test_autoincrement_reset1(self):
        p = Person.objects.create(first_name='Jack', last_name='Smith')
        self.assertEqual(p.pk, 1)

    @skipUnlessDBFeature('supports_sequence_reset')
    def test_autoincrement_reset2(self):
        p = Person.objects.create(first_name='Jack', last_name='Smith')
        self.assertEqual(p.pk, 1)


class EmptyDefaultDatabaseTest(unittest.TestCase):
    def test_empty_default_database(self):
        """
        Test that an empty default database in settings does not raise an ImproperlyConfigured
        error when running a unit test that does not use a database.
        """
        testcases.connections = db.ConnectionHandler({'default': {}})
        connection = testcases.connections[db.utils.DEFAULT_DB_ALIAS]
        self.assertEqual(connection.settings_dict['ENGINE'], 'django.db.backends.dummy')
        try:
            connections_support_transactions()
        except Exception as e:
            self.fail("connections_support_transactions() unexpectedly raised an error: %s" % e)

#!/usr/bin/env python

#
# original code from 
#    https://github.com/giampaolo/psutil/blob/master/examples/
#
# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""
A clone of 'who' command; print information about users who are
currently logged in.
$ python examples/who.py
giampaolo       tty7            2014-02-23 17:25  (:0)
giampaolo       pts/7           2014-02-24 18:25  (:192.168.1.56)
giampaolo       pts/8           2014-02-24 18:25  (:0)
giampaolo       pts/9           2014-02-27 01:32  (:0)
"""

from datetime import datetime

import psutil


from scouter.lang.pack import *
from scouter.lang.value import *


def main():
    users = psutil.get_users()
    for user in users:
        print("%-15s %-15s %s  (%s)" % (
            user.name,
            user.terminal or '-',
            datetime.fromtimestamp(user.started).strftime("%Y-%m-%d %H:%M"),
            user.host))
if __name__ == '__main__':
    main()
    
def process(param):
    pack = MapPack()
    nameList = pack.newList("name")
    terminalList = pack.newList("terminal")
    startedList = pack.newList("started")
    hostList = pack.newList("host")
    users = psutil.users()
    for user in users:
        nameList.addStr(user.name)
        terminalList.addStr(user.terminal or '-')
        startedList.addStr(datetime.fromtimestamp(user.started).strftime("%Y-%m-%d %H:%M"))
        hostList.addStr(user.host)
    return pack

# -*-coding:Utf-8 -*

# Copyright (c) 2010-2017 LE GOFF Vincent
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
#   list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
# * Neither the name of the copyright holder nor the names of its contributors
#   may be used to endorse or promote products derived from this software
#   without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.


"""Fichier contenant la fonction nb_points_guilde."""

from fractions import Fraction

from primaires.format.fonctions import supprimer_accents
from primaires.scripting.fonction import Fonction
from primaires.scripting.instruction import ErreurExecution

class ClasseFonction(Fonction):

    """Retourne le nombre de points de guilde disponibles du personnage."""

    @classmethod
    def init_types(cls):
        cls.ajouter_types(cls.nb_points_guilde, "Personnage")

    @staticmethod
    def nb_points_guilde(personnage):
        """Retourne le nombre de points de guilde disponibles du personnage.

        Paramètres à préciser :

          * personnage : le personnage à préciser

        Exemple d'utilisation :

          nb = nb_points_guilde(personnage)

        """
        return Fraction(importeur.crafting.get_points_guilde_disponibles(
                personnage))

#=======================================================================
# helpers_test.py
#=======================================================================

import pytest

from helpers import *
from Bits    import Bits

def test_get_nbits():

  assert get_nbits( 0 ) == 1
  assert get_nbits( 1 ) == 1
  assert get_nbits( 2 ) == 2
  assert get_nbits( 3 ) == 2
  assert get_nbits( 4 ) == 3
  assert get_nbits( 5 ) == 3
  assert get_nbits( 6 ) == 3
  assert get_nbits( 7 ) == 3
  assert get_nbits( 8 ) == 4

  assert get_nbits( 0x000f ) == 4
  assert get_nbits( 0x00ff ) == 8
  assert get_nbits( 0x0fff ) == 12
  assert get_nbits( 0xffff ) == 16

  assert get_nbits( -1 ) == 2
  assert get_nbits( -2 ) == 3
  assert get_nbits( -3 ) == 3
  assert get_nbits( -4 ) == 4
  assert get_nbits( -5 ) == 4
  assert get_nbits( -6 ) == 4
  assert get_nbits( -7 ) == 4
  assert get_nbits( -8 ) == 5


def test_clog2():

  assert clog2( 1 ) == 0  # TODO: return 1 or 0 here?
  assert clog2( 2 ) == 1
  assert clog2( 3 ) == 2
  assert clog2( 4 ) == 2
  assert clog2( 5 ) == 3
  assert clog2( 6 ) == 3
  assert clog2( 7 ) == 3
  assert clog2( 8 ) == 3
  assert clog2( 9 ) == 4

  assert clog2(  16 ) == 4
  assert clog2(  32 ) == 5
  assert clog2(  64 ) == 6
  assert clog2( 128 ) == 7
  assert clog2( 256 ) == 8

  assert get_nbits( 0x000f ) == 4
  assert get_nbits( 0x00ff ) == 8
  assert get_nbits( 0x0fff ) == 12
  assert get_nbits( 0xffff ) == 16

  with pytest.raises( AssertionError ):
    assert clog2( 0 ) == 1

  with pytest.raises( AssertionError ):
    assert clog2( -1 ) == 2


def test_zext():

  assert zext( Bits( 4,  2 ),  8 ) == Bits( 8, 0x02 )
  assert zext( Bits( 4,  4 ),  8 ) == Bits( 8, 0x04 )
  assert zext( Bits( 4, 15 ),  8 ) == Bits( 8, 0x0f )

  assert zext( Bits( 4, -2  ), 8 ) == Bits( 8, 0x0e )
  assert zext( Bits( 4, -4  ), 8 ) == Bits( 8, 0x0c )


def test_sext():

  assert sext( Bits( 4,  2 ), 8 )  == Bits( 8, 0x02 )
  assert sext( Bits( 4,  4 ), 8 )  == Bits( 8, 0x04 )
  assert sext( Bits( 4, 15 ), 8 )  == Bits( 8, 0xff )

  assert sext( Bits( 4, -2  ), 8 ) == Bits( 8, 0xfe )
  assert sext( Bits( 4, -4  ), 8 ) == Bits( 8, 0xfc )


def test_concat():

  assert concat( Bits(4,0xf), Bits(4,0x2) ) == Bits( 8, 0xf2 )
  assert concat( Bits(2,0x2), Bits(4,0xf) ) == Bits( 6, 0x2f )

  assert concat( Bits(2,0x2), Bits(4,0), Bits(4,0xf) ) == Bits( 10, 0x20f )
  assert concat( Bits(4,0x2), Bits(4,0), Bits(4,0xf) ) == Bits( 12, 0x20f )

def test_reduce_and():

  assert reduce_and( Bits(2,0b11) ) == 1
  assert reduce_and( Bits(2,0b01) ) == 0
  assert reduce_and( Bits(2,0b10) ) == 0
  assert reduce_and( Bits(2,0b00) ) == 0

  assert reduce_and( Bits(4,0b1111) ) == 1
  assert reduce_and( Bits(4,0b1010) ) == 0
  assert reduce_and( Bits(4,0b0101) ) == 0
  assert reduce_and( Bits(4,0b0000) ) == 0

def test_reduce_or():

  assert reduce_or( Bits(2,0b11) ) == 1
  assert reduce_or( Bits(2,0b01) ) == 1
  assert reduce_or( Bits(2,0b10) ) == 1
  assert reduce_or( Bits(2,0b00) ) == 0

  assert reduce_or( Bits(4,0b1111) ) == 1
  assert reduce_or( Bits(4,0b1010) ) == 1
  assert reduce_or( Bits(4,0b0101) ) == 1
  assert reduce_or( Bits(4,0b0000) ) == 0

def test_reduce_xor():
  assert reduce_xor( Bits(2,0b11) ) == 0
  assert reduce_xor( Bits(2,0b01) ) == 1
  assert reduce_xor( Bits(2,0b10) ) == 1
  assert reduce_xor( Bits(2,0b00) ) == 0

  assert reduce_xor( Bits(4,0b1111) ) == 0
  assert reduce_xor( Bits(4,0b1010) ) == 0
  assert reduce_xor( Bits(4,0b0101) ) == 0
  assert reduce_xor( Bits(4,0b0000) ) == 0

  assert reduce_xor( Bits(4,0b1001) ) == 0

  assert reduce_xor( Bits(4,0b1110) ) == 1
  assert reduce_xor( Bits(4,0b1101) ) == 1
  assert reduce_xor( Bits(4,0b1011) ) == 1
  assert reduce_xor( Bits(4,0b0111) ) == 1

  assert reduce_xor( Bits(4,0b0001) ) == 1
  assert reduce_xor( Bits(4,0b0010) ) == 1
  assert reduce_xor( Bits(4,0b0100) ) == 1
  assert reduce_xor( Bits(4,0b1000) ) == 1

  assert reduce_xor( Bits(3,0b111) ) == 1
  assert reduce_xor( Bits(3,0b100) ) == 1
  assert reduce_xor( Bits(3,0b010) ) == 1
  assert reduce_xor( Bits(3,0b001) ) == 1
  assert reduce_xor( Bits(3,0b011) ) == 0
  assert reduce_xor( Bits(3,0b101) ) == 0
  assert reduce_xor( Bits(3,0b110) ) == 0
  assert reduce_xor( Bits(3,0b000) ) == 0

# -*- coding: utf-8 -*-
from app.gui.configdialog import ConfigDialog
from app.gui.groupconfig_ui import Ui_GroupConfig
from app.gui.deletegroup_ui import Ui_DeleteGroupDialog
from PyQt4.QtGui import QLineEdit, QDialog


class GroupConfigDialog(ConfigDialog):
    def __init__(self, configObject):
        optionalAttributes = ['default_user_name', 'default_password']
        attributes = ['name'] + optionalAttributes
        super(GroupConfigDialog, self).__init__(configObject, Ui_GroupConfig,
                                                attributes, optionalAttributes)
        self.ui.showPassword.clicked.connect(self.changePasswordVisibility)

    def changePasswordVisibility(self):
        if self.ui.showPassword.isChecked():
            self.ui.default_password.setEchoMode(QLineEdit.Normal)
        else:
            self.ui.default_password.setEchoMode(QLineEdit.Password)


class DeleteGroupDialog(QDialog):
    def __init__(self, hosts):
        super(DeleteGroupDialog, self).__init__()
        self.ui = Ui_DeleteGroupDialog()
        self.ui.setupUi(self)

        self.hosts = hosts

    def setGroupList(self):
        groupList = self.hosts.getGroupsList()
        self.ui.groupsComboxBox.addItems(groupList)

    def deleteGroup(self):
        self.setGroupList()
        ret = self.exec_()
        if ret == QDialog.Rejected:
            return

        self.hosts.deleteGroup(self.ui.groupsComboxBox.currentText())

# Copyright (c) 2010 Pedro Matiello <pmatiello@gmail.com>

from mockito import any, mock, verify, when
from handlers.entity import entity_handler, entities_handler
from models.entity import entity

class entities_handler_spec():
    
    def setup(self):
        self.handler = object.__new__(entities_handler)
        self.repository = mock()
        self.handler.initialize(self.repository)
        self.entity_list = [1,2,3]
        when(self.repository).list().thenReturn(self.entity_list)
        when(self.handler).render().thenReturn(None)
    
    def should_list_all_instances(self):
        self.handler.get()
        verify(self.repository).list()
        verify(self.handler).render('entity/index.html', data=self.entity_list)
    
    def should_create_new_instances(self):
        when(self.handler).param('field1').thenReturn("Field1 data")
        when(self.handler).param('field2').thenReturn("Field2 data")
        self.handler.post()
        verify(self.repository).save(any(entity))

class entity_handler_spec():
    
    def setup(self):
        self.handler = object.__new__(entity_handler)
        self.repository = mock()
        self.handler.initialize(self.repository)
        self.entity = entity("Field1 data", "Field2 data")
        when(self.repository).load(1).thenReturn(self.entity)
        when(self.handler).render().thenReturn(None)
    
    def should_modify_instances(self):
        when(self.handler).param('field1').thenReturn("Field1 data updated")
        when(self.handler).param('field2').thenReturn("Field2 data updated")
        self.handler.put(1)
        assert self.entity.field1 == "Field1 data updated"
        assert self.entity.field2 == "Field2 data updated"
        verify(self.repository).save(self.entity)
    
    def should_delete_instances(self):
        self.handler.delete(1)
        verify(self.repository).remove(self.entity)

# -*- coding: utf-8 -*-
"""Test sequences for graphiness.
"""
#    Copyright (C) 2004-2015 by
#    Aric Hagberg <hagberg@lanl.gov>
#    Dan Schult <dschult@colgate.edu>
#    Pieter Swart <swart@lanl.gov>
#    All rights reserved.
#    BSD license.
from collections import defaultdict
import heapq
import networkx as nx
__author__ = "\n".join(['Aric Hagberg (hagberg@lanl.gov)',
                        'Pieter Swart (swart@lanl.gov)',
                        'Dan Schult (dschult@colgate.edu)'
                        'Joel Miller (joel.c.miller.research@gmail.com)'
                        'Ben Edwards'
                        'Brian Cloteaux <brian.cloteaux@nist.gov>'])

__all__ = ['is_graphical',
           'is_multigraphical',
           'is_pseudographical',
           'is_digraphical',
           'is_valid_degree_sequence_erdos_gallai',
           'is_valid_degree_sequence_havel_hakimi',
           'is_valid_degree_sequence', # deprecated
           ]

def is_graphical(sequence, method='eg'):
    """Returns True if sequence is a valid degree sequence.

    A degree sequence is valid if some graph can realize it.

    Parameters
    ----------
    sequence : list or iterable container
        A sequence of integer node degrees


    method : "eg" | "hh"
        The method used to validate the degree sequence.
        "eg" corresponds to the Erdős-Gallai algorithm, and
        "hh" to the Havel-Hakimi algorithm.

    Returns
    -------
    valid : bool
        True if the sequence is a valid degree sequence and False if not.

    Examples
    --------
    >>> G = nx.path_graph(4)
    >>> sequence = (d for n, d in G.degree())
    >>> nx.is_valid_degree_sequence(sequence)
    True

    References
    ----------
    Erdős-Gallai
        [EG1960]_, [choudum1986]_

    Havel-Hakimi
        [havel1955]_, [hakimi1962]_, [CL1996]_
    """
    if method == 'eg':
        valid = is_valid_degree_sequence_erdos_gallai(list(sequence))
    elif method == 'hh':
        valid = is_valid_degree_sequence_havel_hakimi(list(sequence))
    else:
        msg = "`method` must be 'eg' or 'hh'"
        raise nx.NetworkXException(msg)
    return valid

is_valid_degree_sequence = is_graphical

def _basic_graphical_tests(deg_sequence):
    # Sort and perform some simple tests on the sequence
    if not nx.utils.is_list_of_ints(deg_sequence):
        raise nx.NetworkXUnfeasible
    p = len(deg_sequence)
    num_degs = [0]*p
    dmax, dmin, dsum, n = 0, p, 0, 0
    for d in deg_sequence:
        # Reject if degree is negative or larger than the sequence length
        if d<0 or d>=p:
            raise nx.NetworkXUnfeasible
        # Process only the non-zero integers
        elif d>0:
            dmax, dmin, dsum, n = max(dmax,d), min(dmin,d), dsum+d, n+1
            num_degs[d] += 1
    # Reject sequence if it has odd sum or is oversaturated
    if dsum%2 or dsum>n*(n-1):
        raise nx.NetworkXUnfeasible
    return dmax,dmin,dsum,n,num_degs

def is_valid_degree_sequence_havel_hakimi(deg_sequence):
    r"""Returns True if deg_sequence can be realized by a simple graph.

    The validation proceeds using the Havel-Hakimi theorem.
    Worst-case run time is: O(s) where s is the sum of the sequence.

    Parameters
    ----------
    deg_sequence : list
        A list of integers where each element specifies the degree of a node
        in a graph.

    Returns
    -------
    valid : bool
        True if deg_sequence is graphical and False if not.

    Notes
    -----
    The ZZ condition says that for the sequence d if
    
    .. math::
        |d| >= \frac{(\max(d) + \min(d) + 1)^2}{4*\min(d)}

    then d is graphical.  This was shown in Theorem 6 in [1]_.

    References
    ----------
    .. [1] I.E. Zverovich and V.E. Zverovich. "Contributions to the theory
       of graphic sequences", Discrete Mathematics, 105, pp. 292-303 (1992).

    [havel1955]_, [hakimi1962]_, [CL1996]_

    """
    try:
        dmax,dmin,dsum,n,num_degs = _basic_graphical_tests(deg_sequence)
    except nx.NetworkXUnfeasible: 
        return False
    # Accept if sequence has no non-zero degrees or passes the ZZ condition
    if n==0 or 4*dmin*n >= (dmax+dmin+1) * (dmax+dmin+1):
        return True

    modstubs = [0]*(dmax+1)
    # Successively reduce degree sequence by removing the maximum degree
    while n > 0:
        # Retrieve the maximum degree in the sequence
        while num_degs[dmax] == 0:
            dmax -= 1;
        # If there are not enough stubs to connect to, then the sequence is
        # not graphical
        if dmax > n-1:
            return False

        # Remove largest stub in list
        num_degs[dmax], n = num_degs[dmax]-1, n-1
        # Reduce the next dmax largest stubs
        mslen = 0
        k = dmax
        for i in range(dmax):
            while num_degs[k] == 0:
                k -= 1
            num_degs[k], n = num_degs[k]-1, n-1
            if k > 1:
                modstubs[mslen] = k-1
                mslen += 1
        # Add back to the list any non-zero stubs that were removed
        for i  in range(mslen):
            stub = modstubs[i]
            num_degs[stub], n = num_degs[stub]+1, n+1
    return True


def is_valid_degree_sequence_erdos_gallai(deg_sequence):
    r"""Returns True if deg_sequence can be realized by a simple graph.

    The validation is done using the Erdős-Gallai theorem [EG1960]_.

    Parameters
    ----------
    deg_sequence : list
        A list of integers

    Returns
    -------
    valid : bool
        True if deg_sequence is graphical and False if not.

    Notes
    -----

    This implementation uses an equivalent form of the Erdős-Gallai criterion.
    Worst-case run time is: O(n) where n is the length of the sequence.

    Specifically, a sequence d is graphical if and only if the
    sum of the sequence is even and for all strong indices k in the sequence,

     .. math::

       \sum_{i=1}^{k} d_i \leq k(k-1) + \sum_{j=k+1}^{n} \min(d_i,k)
             = k(n-1) - ( k \sum_{j=0}^{k-1} n_j - \sum_{j=0}^{k-1} j n_j )

    A strong index k is any index where `d_k \geq k` and the value `n_j` is the
    number of occurrences of j in d.  The maximal strong index is called the
    Durfee index.

    This particular rearrangement comes from the proof of Theorem 3 in [2]_.

    The ZZ condition says that for the sequence d if
    
    .. math::
        |d| >= \frac{(\max(d) + \min(d) + 1)^2}{4*\min(d)}

    then d is graphical.  This was shown in Theorem 6 in [2]_.

    References
    ----------
    .. [1] A. Tripathi and S. Vijay. "A note on a theorem of Erdős & Gallai",
       Discrete Mathematics, 265, pp. 417-420 (2003).
    .. [2] I.E. Zverovich and V.E. Zverovich. "Contributions to the theory
       of graphic sequences", Discrete Mathematics, 105, pp. 292-303 (1992).

    [EG1960]_, [choudum1986]_
    """
    try:
        dmax,dmin,dsum,n,num_degs = _basic_graphical_tests(deg_sequence)
    except nx.NetworkXUnfeasible: 
        return False
    # Accept if sequence has no non-zero degrees or passes the ZZ condition
    if n==0 or 4*dmin*n >= (dmax+dmin+1) * (dmax+dmin+1):
        return True

    # Perform the EG checks using the reformulation of Zverovich and Zverovich
    k, sum_deg, sum_nj, sum_jnj = 0, 0, 0, 0
    for dk in range(dmax, dmin-1, -1):
        if dk < k+1:            # Check if already past Durfee index
            return True
        if num_degs[dk] > 0:
            run_size = num_degs[dk] # Process a run of identical-valued degrees
            if dk < k+run_size:     # Check if end of run is past Durfee index
                run_size = dk-k     # Adjust back to Durfee index
            sum_deg += run_size * dk
            for v in range(run_size):
                sum_nj += num_degs[k+v]
                sum_jnj += (k+v) * num_degs[k+v]
            k += run_size
            if sum_deg > k*(n-1) - k*sum_nj + sum_jnj:
                return False
    return True

def is_multigraphical(sequence):
    """Returns True if some multigraph can realize the sequence.

    Parameters
    ----------
    deg_sequence : list
        A list of integers

    Returns
    -------
    valid : bool
        True if deg_sequence is a multigraphic degree sequence and False if not.

    Notes
    -----
    The worst-case run time is O(n) where n is the length of the sequence.

    References
    ----------
    .. [1] S. L. Hakimi. "On the realizability of a set of integers as
       degrees of the vertices of a linear graph", J. SIAM, 10, pp. 496-506
       (1962).
    """
    deg_sequence = list(sequence)
    if not nx.utils.is_list_of_ints(deg_sequence):
        return False
    dsum, dmax = 0, 0
    for d in deg_sequence:
        if d<0:
            return False
        dsum, dmax = dsum+d, max(dmax,d)
    if dsum%2 or dsum<2*dmax:
        return False
    return True

def is_pseudographical(sequence):
    """Returns True if some pseudograph can realize the sequence.

    Every nonnegative integer sequence with an even sum is pseudographical
    (see [1]_).

    Parameters
    ----------
    sequence : list or iterable container
        A sequence of integer node degrees

    Returns
    -------
    valid : bool
      True if the sequence is a pseudographic degree sequence and False if not.

    Notes
    -----
    The worst-case run time is O(n) where n is the length of the sequence.

    References
    ----------
    .. [1] F. Boesch and F. Harary. "Line removal algorithms for graphs
       and their degree lists", IEEE Trans. Circuits and Systems, CAS-23(12),
       pp. 778-782 (1976).
    """
    s = list(sequence)
    if not nx.utils.is_list_of_ints(s):
        return False
    return sum(s)%2 == 0 and min(s) >= 0

def is_digraphical(in_sequence, out_sequence):
    r"""Returns True if some directed graph can realize the in- and out-degree 
    sequences.

    Parameters
    ----------
    in_sequence : list or iterable container
        A sequence of integer node in-degrees

    out_sequence : list or iterable container
        A sequence of integer node out-degrees

    Returns
    -------
    valid : bool
      True if in and out-sequences are digraphic False if not.

    Notes
    -----
    This algorithm is from Kleitman and Wang [1]_.
    The worst case runtime is O(s * log n) where s and n are the sum and length
    of the sequences respectively.

    References
    ----------
    .. [1] D.J. Kleitman and D.L. Wang
       Algorithms for Constructing Graphs and Digraphs with Given Valences
       and Factors, Discrete Mathematics, 6(1), pp. 79-88 (1973)
    """
    in_deg_sequence = list(in_sequence)
    out_deg_sequence = list(out_sequence)
    if not nx.utils.is_list_of_ints(in_deg_sequence):
        return False
    if not nx.utils.is_list_of_ints(out_deg_sequence):
        return False
    # Process the sequences and form two heaps to store degree pairs with
    # either zero or non-zero out degrees
    sumin, sumout, nin, nout = 0, 0, len(in_deg_sequence), len(out_deg_sequence)
    maxn = max(nin, nout)
    maxin = 0
    if maxn==0:
        return True
    stubheap, zeroheap = [ ], [ ]
    for n in range(maxn):
        in_deg, out_deg = 0, 0
        if n<nout:
            out_deg = out_deg_sequence[n]
        if n<nin:
            in_deg = in_deg_sequence[n]
        if in_deg<0 or out_deg<0:
            return False
        sumin, sumout, maxin = sumin+in_deg, sumout+out_deg, max(maxin, in_deg)
        if in_deg > 0:
            stubheap.append((-1*out_deg, -1*in_deg))
        elif out_deg > 0:
            zeroheap.append(-1*out_deg)
    if sumin != sumout:
        return False
    heapq.heapify(stubheap)
    heapq.heapify(zeroheap)

    modstubs = [(0,0)]*(maxin+1)
    # Successively reduce degree sequence by removing the maximum out degree
    while stubheap:
        # Take the first value in the sequence with non-zero in degree
        (freeout, freein) =  heapq.heappop( stubheap )
        freein *= -1
        if freein > len(stubheap)+len(zeroheap):
            return False

        # Attach out stubs to the nodes with the most in stubs
        mslen = 0
        for i in range(freein):
            if zeroheap and (not stubheap or stubheap[0][0] > zeroheap[0]):
                stubout = heapq.heappop(zeroheap)
                stubin = 0
            else:
                (stubout, stubin) = heapq.heappop(stubheap)
            if stubout == 0:
                return False
            # Check if target is now totally connected
            if stubout+1<0 or stubin<0:
                modstubs[mslen] =  (stubout+1, stubin)
                mslen += 1

        # Add back the nodes to the heap that still have available stubs
        for i in range(mslen):
            stub = modstubs[i]
            if stub[1] < 0:
                heapq.heappush(stubheap, stub)
            else:
                heapq.heappush(zeroheap, stub[0])
        if freeout<0:
            heapq.heappush(zeroheap, freeout)
    return True

# Copyright 2020 Google LLC
#
# 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.

import datetime
import math
import os

from absl import logging
from bokeh.layouts import column, row
from bokeh.models import CategoricalColorMapper, ColumnDataSource, Div, HoverTool
from bokeh.plotting import figure

import javascript_utils
import utils

import numpy as np

# For a given list of test_names and metric_names, find the history of metrics.
QUERY = """
SELECT
  metrics.test_name,
  metrics.metric_name,
  SAFE_CAST(DATE(metrics.timestamp, 'US/Pacific') AS STRING) AS run_date,
  metrics.metric_value,
  job.job_status,
  job.stackdriver_logs_link AS logs_link,
  job.logs_download_command,
  job.uuid
FROM (
  SELECT
    x.test_name,
    x.metric_name,
    x.timestamp,
    x.metric_value,
    x.uuid
  FROM (
    SELECT
      test_name,
      metric_name,
      SAFE_CAST(DATE(timestamp, 'US/Pacific') AS STRING) AS run_date,
      max(farm_fingerprint(uuid)) as max_uuid
    FROM
      `{metric_table_name}`
    WHERE
      timestamp > '{cutoff_date}' AND
      {test_name_where_clause} AND
      {metric_name_where_clause}
    GROUP BY
      test_name, metric_name, run_date
  ) AS y
  INNER JOIN `{metric_table_name}` AS x
  ON
    y.test_name = x.test_name AND
    y.metric_name = x.metric_name AND
    y.max_uuid = farm_fingerprint(x.uuid)
) AS metrics
INNER JOIN `{job_table_name}` AS job
ON
  metrics.uuid = job.uuid
ORDER BY
  run_date DESC
"""

def get_query_config(test_names, metric_names):
  query_params = []
  def _add_params(column_name, names):
    for i, name in enumerate(names):
      query_params.append({
        'name': f'{column_name}{i}',
        'parameterType': {'type': 'STRING'},
        'parameterValue': {'value': name},
      })
  _add_params('test_name', test_names)
  _add_params('metric_name', metric_names)
  return {
    'query': {
      'parameterMode': 'NAMED',
      'queryParameters': query_params,
    }
  }

def get_query(test_names, metric_names):
  # Note that Bigquery does not support ANY, otherwise we could use a simpler
  # query such as "WHERE test_name LIKE ANY(...)".
  def _make_where_clause(column_name, names):
    where_clause = f'({column_name} LIKE @{column_name}0'
    for i in range(1, len(names)):
      where_clause += f' OR {column_name} LIKE @{column_name}{i}'
    where_clause += ')'
    return where_clause
  # TODO: Maybe make the cutoff date configurable.
  cutoff_date = (datetime.datetime.now() - datetime.timedelta(
      days=30)).strftime('%Y-%m-%d')
  query = QUERY.format(**{
    'job_table_name': os.environ['JOB_HISTORY_TABLE_NAME'],
    'metric_table_name': os.environ['METRIC_HISTORY_TABLE_NAME'],
    'test_name_where_clause': _make_where_clause('test_name', test_names),
    'metric_name_where_clause': _make_where_clause(
        'metric_name', metric_names),
    'cutoff_date': cutoff_date,
  })
  return query

def fetch_data(test_names, metric_names):
  if not test_names or not metric_names:
    raise ValueError('Neither test_names nor metric_names can be empty.')
  dataframe = utils.run_query(
    get_query(test_names, metric_names),
    cache_key=('metrics-{}-{}'.format(str(test_names), str(metric_names))),
    config=get_query_config(test_names, metric_names))
  return dataframe

def make_html_table(data_grid):
  if not data_grid:
    return ''
  cell_width = 100
  normal_style = f'style="width:{cell_width}px; border:1px solid #cfcfcf"'
  alert_style = f'style="width:{cell_width}px; border:1px solid #cfcfcf; background-color: #ff8a8a"'
  table_width = cell_width * len(data_grid[0])
  table_html = f'<table style="width:{table_width}px">'
  first_row = True
  for row in data_grid:
    values = []
    for col in row:
      try:
        values.append(float(col))
      except ValueError:
        continue
    # First row uses '<th>' HTML tag, others use '<td>'.
    tag_type = 'h' if first_row else 'd'
    table_html += '<tr>'
    for col in row:
      # Use normal cell style unless the cell's value is unusually high or low.
      style = normal_style
      try:
        v = float(col)
        # Find the mean/stddev of this row's values but make sure to exclude
        # the current value.
        values_copy = list(values)
        for i, x in enumerate(values_copy):
          if math.isclose(x, v):
            values_copy.pop(i)
        mean = np.mean(values_copy) if len(values_copy) >= 5 else 0
        stddev = np.std(values_copy) if len(values_copy) >= 5 else 0
        if stddev > 0 and (abs(v - mean) / stddev) > 5.0:
          style = alert_style
      except ValueError:
        pass
      table_html += f'<t{tag_type} {style}>{col}</t{tag_type}>'
    table_html += '</tr>'
    first_row = False
  table_html += '</table>'
  return table_html

def make_plots(test_names, metric_names, dataframe):
  if not dataframe['metric_name'].any():
    logging.error("Found no data: {}\n{}".format(test_names, dataframe))
    return

  # Split data into 1 dataframe per metric so we can easily make 1 graph
  # per metric.
  metric_to_dataframe = {}
  for metric_name in set(np.unique(dataframe['metric_name']).tolist()):
    metric_dataframe = dataframe[dataframe['metric_name'] == metric_name]
    metric_to_dataframe[metric_name] = metric_dataframe

  all_rows = []
  for metric_name, dataframe in metric_to_dataframe.items():
    plot, table_row = _make_plot_and_table(
        metric_name, metric_to_dataframe[metric_name])
    all_rows.extend([plot, table_row])
  return all_rows


def _make_plot_and_table(metric_name, dataframe):
  # Record some global stats about the entire suite of tests.
  all_dates = np.unique(dataframe['run_date']).tolist()[-1::-1]
  y_max = 1.1 * dataframe['metric_value'].max()
  y_min = 0.9 * dataframe['metric_value'].min()
  if y_max == 0 and y_min == 0:
    y_max = 1.0
    y_min = 0.0

  # Split each test into its own dataframe.
  test_name_to_df = {}
  for test_name in np.unique(dataframe['test_name']).tolist():
    test_name_to_df[test_name] = dataframe[dataframe['test_name'] == test_name]

  tooltip_template = """
    Value: @test_name<br/>Metric Value: @metric_value<br/>Job status: @job_status<br/>Date: @run_date"""
  plot = figure(
      title=metric_name,
      plot_width=100*len(all_dates),
      y_range=(y_min, y_max),
      x_range=all_dates,
      toolbar_location=None,
      tools="tap",
      tooltips=tooltip_template)

  color_mapper = CategoricalColorMapper(
      factors=['success', 'failure', 'timeout'],
      palette=['#000000', '#ffffff', '#ffffff'])

  all_tables = []
  for test, df in test_name_to_df.items():
    source = ColumnDataSource(data=df)
    line = plot.line(
        x='run_date', y='metric_value', line_width=3, color='#000000',
        source=source)
    plot.circle(
        x='run_date',
        y='metric_value',
        source=source,
        fill_color={'field': 'job_status', 'transform': color_mapper},
        size=15)

  # Create a table representation of the data from the plot above.
  # Each date is a column and each row is a test.
  # Add an extra first row for the headers and an extra first
  # column for the test name.
  data_grid = [['-' for _ in range(len(all_dates) + 1)] for _ in range(len(
      test_name_to_df.keys()) + 1)]
  data_grid[0] = ['Test'] + all_dates
  # Offset by 1 to account for the test name column at index 0.
  run_date_to_column_index = {date: index + 1 for index, date in enumerate(
      all_dates)}
  for row_i, test_name in enumerate(test_name_to_df.keys()):
    row_i += 1  # Offset by 1 to account for the header row at index 0.
    data_grid[row_i][0] = \
        f"""<a href="metrics?test_name={test_name}">{test_name}</a>"""
    for row in test_name_to_df[test_name].iterrows():
      metric_value = row[1]['metric_value']
      run_date = row[1]['run_date']
      data_grid[row_i][run_date_to_column_index[run_date]] = \
          f'{metric_value:0.2f}'
  table = make_html_table(data_grid)
  table_row = Div(text=table)

  plot.xaxis.major_label_orientation = math.pi / 3
  return plot, table_row


# Authors:
#   Bram Cohen
#   Trevor Perrin - various changes
#
# See the LICENSE file for legal information regarding use of this file.
# Also see Bram Cohen's statement below

"""
A pure python (slow) implementation of rijndael with a decent interface

To include -

from rijndael import rijndael

To do a key setup -

r = rijndael(key, block_size = 16)

key must be a string of length 16, 24, or 32
blocksize must be 16, 24, or 32. Default is 16

To use -

ciphertext = r.encrypt(plaintext)
plaintext = r.decrypt(ciphertext)

If any strings are of the wrong length a ValueError is thrown
"""

# ported from the Java reference code by Bram Cohen, bram@gawth.com, April 2001
# this code is public domain, unless someone makes
# an intellectual property claim against the reference
# code, in which case it can be made public domain by
# deleting all the comments and renaming all the variables

import copy
import string

shifts = [[[0, 0], [1, 3], [2, 2], [3, 1]],
          [[0, 0], [1, 5], [2, 4], [3, 3]],
          [[0, 0], [1, 7], [3, 5], [4, 4]]]

# [keysize][block_size]
num_rounds = {16: {16: 10, 24: 12, 32: 14}, 24: {16: 12, 24: 12, 32: 14}, 32: {16: 14, 24: 14, 32: 14}}

A = [[1, 1, 1, 1, 1, 0, 0, 0],
     [0, 1, 1, 1, 1, 1, 0, 0],
     [0, 0, 1, 1, 1, 1, 1, 0],
     [0, 0, 0, 1, 1, 1, 1, 1],
     [1, 0, 0, 0, 1, 1, 1, 1],
     [1, 1, 0, 0, 0, 1, 1, 1],
     [1, 1, 1, 0, 0, 0, 1, 1],
     [1, 1, 1, 1, 0, 0, 0, 1]]

# produce log and alog tables, needed for multiplying in the
# field GF(2^m) (generator = 3)
alog = [1]
for i in range(255):
    j = (alog[-1] << 1) ^ alog[-1]
    if j & 0x100 != 0:
        j ^= 0x11B
    alog.append(j)

log = [0] * 256
for i in range(1, 255):
    log[alog[i]] = i

# multiply two elements of GF(2^m)
def mul(a, b):
    if a == 0 or b == 0:
        return 0
    return alog[(log[a & 0xFF] + log[b & 0xFF]) % 255]

# substitution box based on F^{-1}(x)
box = [[0] * 8 for i in range(256)]
box[1][7] = 1
for i in range(2, 256):
    j = alog[255 - log[i]]
    for t in range(8):
        box[i][t] = (j >> (7 - t)) & 0x01

B = [0, 1, 1, 0, 0, 0, 1, 1]

# affine transform:  box[i] <- B + A*box[i]
cox = [[0] * 8 for i in range(256)]
for i in range(256):
    for t in range(8):
        cox[i][t] = B[t]
        for j in range(8):
            cox[i][t] ^= A[t][j] * box[i][j]

# S-boxes and inverse S-boxes
S =  [0] * 256
Si = [0] * 256
for i in range(256):
    S[i] = cox[i][0] << 7
    for t in range(1, 8):
        S[i] ^= cox[i][t] << (7-t)
    Si[S[i] & 0xFF] = i

# T-boxes
G = [[2, 1, 1, 3],
    [3, 2, 1, 1],
    [1, 3, 2, 1],
    [1, 1, 3, 2]]

AA = [[0] * 8 for i in range(4)]

for i in range(4):
    for j in range(4):
        AA[i][j] = G[i][j]
        AA[i][i+4] = 1

for i in range(4):
    pivot = AA[i][i]
    if pivot == 0:
        t = i + 1
        while AA[t][i] == 0 and t < 4:
            t += 1
            assert t != 4, 'G matrix must be invertible'
            for j in range(8):
                AA[i][j], AA[t][j] = AA[t][j], AA[i][j]
            pivot = AA[i][i]
    for j in range(8):
        if AA[i][j] != 0:
            AA[i][j] = alog[(255 + log[AA[i][j] & 0xFF] - log[pivot & 0xFF]) % 255]
    for t in range(4):
        if i != t:
            for j in range(i+1, 8):
                AA[t][j] ^= mul(AA[i][j], AA[t][i])
            AA[t][i] = 0

iG = [[0] * 4 for i in range(4)]

for i in range(4):
    for j in range(4):
        iG[i][j] = AA[i][j + 4]

def mul4(a, bs):
    if a == 0:
        return 0
    r = 0
    for b in bs:
        r <<= 8
        if b != 0:
            r = r | mul(a, b)
    return r

T1 = []
T2 = []
T3 = []
T4 = []
T5 = []
T6 = []
T7 = []
T8 = []
U1 = []
U2 = []
U3 = []
U4 = []

for t in range(256):
    s = S[t]
    T1.append(mul4(s, G[0]))
    T2.append(mul4(s, G[1]))
    T3.append(mul4(s, G[2]))
    T4.append(mul4(s, G[3]))

    s = Si[t]
    T5.append(mul4(s, iG[0]))
    T6.append(mul4(s, iG[1]))
    T7.append(mul4(s, iG[2]))
    T8.append(mul4(s, iG[3]))

    U1.append(mul4(t, iG[0]))
    U2.append(mul4(t, iG[1]))
    U3.append(mul4(t, iG[2]))
    U4.append(mul4(t, iG[3]))

# round constants
rcon = [1]
r = 1
for t in range(1, 30):
    r = mul(2, r)
    rcon.append(r)

del A
del AA
del pivot
del B
del G
del box
del log
del alog
del i
del j
del r
del s
del t
del mul
del mul4
del cox
del iG

class rijndael:
    def __init__(self, key, block_size = 16):
        if block_size != 16 and block_size != 24 and block_size != 32:
            raise ValueError('Invalid block size: ' + str(block_size))
        if len(key) != 16 and len(key) != 24 and len(key) != 32:
            raise ValueError('Invalid key size: ' + str(len(key)))
        self.block_size = block_size

        ROUNDS = num_rounds[len(key)][block_size]
        BC = block_size // 4
        # encryption round keys
        Ke = [[0] * BC for i in range(ROUNDS + 1)]
        # decryption round keys
        Kd = [[0] * BC for i in range(ROUNDS + 1)]
        ROUND_KEY_COUNT = (ROUNDS + 1) * BC
        KC = len(key) // 4

        # copy user material bytes into temporary ints
        tk = []
        for i in range(0, KC):
            tk.append((key[i * 4] << 24) | (key[i * 4 + 1] << 16) |
                (key[i * 4 + 2] << 8) | key[i * 4 + 3])

        # copy values into round key arrays
        t = 0
        j = 0
        while j < KC and t < ROUND_KEY_COUNT:
            Ke[t // BC][t % BC] = tk[j]
            Kd[ROUNDS - (t // BC)][t % BC] = tk[j]
            j += 1
            t += 1
        tt = 0
        rconpointer = 0
        while t < ROUND_KEY_COUNT:
            # extrapolate using phi (the round key evolution function)
            tt = tk[KC - 1]
            tk[0] ^= (S[(tt >> 16) & 0xFF] & 0xFF) << 24 ^  \
                     (S[(tt >>  8) & 0xFF] & 0xFF) << 16 ^  \
                     (S[ tt        & 0xFF] & 0xFF) <<  8 ^  \
                     (S[(tt >> 24) & 0xFF] & 0xFF)       ^  \
                     (rcon[rconpointer]    & 0xFF) << 24
            rconpointer += 1
            if KC != 8:
                for i in range(1, KC):
                    tk[i] ^= tk[i-1]
            else:
                for i in range(1, KC // 2):
                    tk[i] ^= tk[i-1]
                tt = tk[KC // 2 - 1]
                tk[KC // 2] ^= (S[ tt        & 0xFF] & 0xFF)       ^ \
                              (S[(tt >>  8) & 0xFF] & 0xFF) <<  8 ^ \
                              (S[(tt >> 16) & 0xFF] & 0xFF) << 16 ^ \
                              (S[(tt >> 24) & 0xFF] & 0xFF) << 24
                for i in range(KC // 2 + 1, KC):
                    tk[i] ^= tk[i-1]
            # copy values into round key arrays
            j = 0
            while j < KC and t < ROUND_KEY_COUNT:
                Ke[t // BC][t % BC] = tk[j]
                Kd[ROUNDS - (t // BC)][t % BC] = tk[j]
                j += 1
                t += 1
        # inverse MixColumn where needed
        for r in range(1, ROUNDS):
            for j in range(BC):
                tt = Kd[r][j]
                Kd[r][j] = U1[(tt >> 24) & 0xFF] ^ \
                           U2[(tt >> 16) & 0xFF] ^ \
                           U3[(tt >>  8) & 0xFF] ^ \
                           U4[ tt        & 0xFF]
        self.Ke = Ke
        self.Kd = Kd

    def encrypt(self, plaintext):
        if len(plaintext) != self.block_size:
            raise ValueError('wrong block length, expected ' + str(self.block_size) + ' got ' + str(len(plaintext)))
        Ke = self.Ke

        BC = self.block_size // 4
        ROUNDS = len(Ke) - 1
        if BC == 4:
            SC = 0
        elif BC == 6:
            SC = 1
        else:
            SC = 2
        s1 = shifts[SC][1][0]
        s2 = shifts[SC][2][0]
        s3 = shifts[SC][3][0]
        a = [0] * BC
        # temporary work array
        t = []
        # plaintext to ints + key
        for i in range(BC):
            t.append((plaintext[i * 4    ] << 24 |
                      plaintext[i * 4 + 1] << 16 |
                      plaintext[i * 4 + 2] <<  8 |
                      plaintext[i * 4 + 3]        ) ^ Ke[0][i])
        # apply round transforms
        for r in range(1, ROUNDS):
            for i in range(BC):
                a[i] = (T1[(t[ i           ] >> 24) & 0xFF] ^
                        T2[(t[(i + s1) % BC] >> 16) & 0xFF] ^
                        T3[(t[(i + s2) % BC] >>  8) & 0xFF] ^
                        T4[ t[(i + s3) % BC]        & 0xFF]  ) ^ Ke[r][i]
            t = copy.copy(a)
        # last round is special
        result = []
        for i in range(BC):
            tt = Ke[ROUNDS][i]
            result.append((S[(t[ i           ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF)
            result.append((S[(t[(i + s1) % BC] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF)
            result.append((S[(t[(i + s2) % BC] >>  8) & 0xFF] ^ (tt >>  8)) & 0xFF)
            result.append((S[ t[(i + s3) % BC]        & 0xFF] ^  tt       ) & 0xFF)
        return bytearray(result)

    def decrypt(self, ciphertext):
        if len(ciphertext) != self.block_size:
            raise ValueError('wrong block length, expected ' + str(self.block_size) + ' got ' + str(len(plaintext)))
        Kd = self.Kd

        BC = self.block_size // 4
        ROUNDS = len(Kd) - 1
        if BC == 4:
            SC = 0
        elif BC == 6:
            SC = 1
        else:
            SC = 2
        s1 = shifts[SC][1][1]
        s2 = shifts[SC][2][1]
        s3 = shifts[SC][3][1]
        a = [0] * BC
        # temporary work array
        t = [0] * BC
        # ciphertext to ints + key
        for i in range(BC):
            t[i] = (ciphertext[i * 4    ] << 24 |
                    ciphertext[i * 4 + 1] << 16 |
                    ciphertext[i * 4 + 2] <<  8 |
                    ciphertext[i * 4 + 3]        ) ^ Kd[0][i]
        # apply round transforms
        for r in range(1, ROUNDS):
            for i in range(BC):
                a[i] = (T5[(t[ i           ] >> 24) & 0xFF] ^
                        T6[(t[(i + s1) % BC] >> 16) & 0xFF] ^
                        T7[(t[(i + s2) % BC] >>  8) & 0xFF] ^
                        T8[ t[(i + s3) % BC]        & 0xFF]  ) ^ Kd[r][i]
            t = copy.copy(a)
        # last round is special
        result = []
        for i in range(BC):
            tt = Kd[ROUNDS][i]
            result.append((Si[(t[ i           ] >> 24) & 0xFF] ^ (tt >> 24)) & 0xFF)
            result.append((Si[(t[(i + s1) % BC] >> 16) & 0xFF] ^ (tt >> 16)) & 0xFF)
            result.append((Si[(t[(i + s2) % BC] >>  8) & 0xFF] ^ (tt >>  8)) & 0xFF)
            result.append((Si[ t[(i + s3) % BC]        & 0xFF] ^  tt       ) & 0xFF)
        return bytearray(result)

def encrypt(key, block):
    return rijndael(key, len(block)).encrypt(block)

def decrypt(key, block):
    return rijndael(key, len(block)).decrypt(block)

def test():
    def t(kl, bl):
        b = 'b' * bl
        r = rijndael('a' * kl, bl)
        assert r.decrypt(r.encrypt(b)) == b
    t(16, 16)
    t(16, 24)
    t(16, 32)
    t(24, 16)
    t(24, 24)
    t(24, 32)
    t(32, 16)
    t(32, 24)
    t(32, 32)



#
# spyne - Copyright (C) Spyne contributors.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
#

"""Contains the ClientBase class and its helper objects."""

from spyne._base import MethodContext
from spyne.model.primitive import string_encoding


class Factory(object):
    def __init__(self, app):
        self.__app = app

    def create(self, object_name):
        return self.__app.interface.get_class_instance(object_name)


class RemoteService(object):
    def __init__(self, rpc_class, url, app, *args, **kwargs):
        self.__app = app
        self.__url = url
        self.out_header = None
        self.rpc_class = rpc_class
        self.args = args
        self.kwargs = kwargs

    def __getattr__(self, key):
        return self.rpc_class(self.__url, self.__app, key, self.out_header,
                                                    *self.args, **self.kwargs)


class RemoteProcedureBase(object):
    """Abstract base class that handles all (de)serialization.

    Child classes must implement the client transport in the __call__ method
    using the following method signature: ::

        def __call__(self, *args, **kwargs):

    :param url:  The url for the server endpoint.
    :param app:  The application instance the client belongs to.
    :param name: The string identifier for the remote method.
    :param out_header: The header that's going to be sent with the remote call.
    """

    def __init__(self, url, app, name, out_header=None):
        self.url = url
        self.app = app

        initial_ctx = MethodContext(self, MethodContext.CLIENT)
        initial_ctx.method_request_string = name
        initial_ctx.out_header = out_header

        self.contexts = initial_ctx.out_protocol.generate_method_contexts(
                                                                    initial_ctx)

    def __call__(self, *args, **kwargs):
        """Serializes its arguments, sends them, receives and deserializes the
        response and returns it."""

        raise NotImplementedError()

    def get_out_object(self, ctx, args, kwargs):
        """Serializes the method arguments to output document.

        :param args: Sequential arguments.
        :param kwargs: Name-based arguments.
        """

        assert ctx.out_object is None

        request_raw_class = ctx.descriptor.in_message
        request_type_info = request_raw_class._type_info
        request_raw = request_raw_class()

        for i in range(len(request_type_info)):
            if i < len(args):
                setattr(request_raw, request_type_info.keys()[i], args[i])
            else:
                setattr(request_raw, request_type_info.keys()[i], None)

        for k in request_type_info:
            if k in kwargs:
                setattr(request_raw, k, kwargs[k])

        ctx.out_object = list(request_raw)

    def get_out_string(self, ctx):
        """Serializes the output document to a bytestream."""

        assert ctx.out_document is None
        assert ctx.out_string is None

        ctx.out_protocol.serialize(ctx, ctx.out_protocol.REQUEST)

        if ctx.service_class != None:
            if ctx.out_error is None:
                ctx.service_class.event_manager.fire_event(
                                        'method_return_document', ctx)
            else:
                ctx.service_class.event_manager.fire_event(
                                        'method_exception_document', ctx)

        ctx.out_protocol.create_out_string(ctx, string_encoding)

        if ctx.service_class != None:
            if ctx.out_error is None:
                ctx.service_class.event_manager.fire_event(
                                            'method_return_string', ctx)
            else:
                ctx.service_class.event_manager.fire_event(
                                            'method_exception_string', ctx)

        if ctx.out_string is None:
            ctx.out_string = [""]

    def get_in_object(self, ctx):
        """Deserializes the response bytestream first as a document and then
        as a native python object.
        """

        assert ctx.in_string is not None
        assert ctx.in_document is None

        self.app.in_protocol.create_in_document(ctx)
        if ctx.service_class != None:
            ctx.service_class.event_manager.fire_event(
                                            'method_accept_document', ctx)

        # sets the ctx.in_body_doc and ctx.in_header_doc properties
        self.app.in_protocol.decompose_incoming_envelope(ctx,
                                        message=self.app.in_protocol.RESPONSE)

        # this sets ctx.in_object
        self.app.in_protocol.deserialize(ctx,
                                        message=self.app.in_protocol.RESPONSE)

        type_info = ctx.descriptor.out_message._type_info

        # TODO: Non-Wrapped Object Support
        if len(ctx.descriptor.out_message._type_info) == 1:
            wrapper_attribute = type_info.keys()[0]
            ctx.in_object = getattr(ctx.in_object, wrapper_attribute, None)


class ClientBase(object):
    """The base class for all client applications. ``self.service`` attribute
    should be initialized in the constructor of the child class.
    """

    def __init__(self, url, app):
        self.factory = Factory(app)

    def set_options(self, **kwargs):
        """Sets call options.

        :param out_header:  Sets the header object that's going to be sent with
                            the remote procedure call.
        :param soapheaders: A suds-compatible alias for out_header.
        """

        if ('soapheaders' in kwargs) and ('out_header' in kwargs):
            raise ValueError('you should specify only one of "soapheaders" or '
                             '"out_header" keyword arguments.')

        self.service.out_header = kwargs.get('soapheaders', None)
        if self.service.out_header is None:
            self.service.out_header = kwargs.get('out_header', None)

#!/usr/bin/env python
# Copyright (C) 2013 Intel Corporation
#
# Released under the MIT license (see COPYING.MIT)

# test runner which support run testing on target device

"""test runner for target device"""
import sys
from optparse import make_option
from baserunner import TestRunnerBase

class TargetTestRunner(TestRunnerBase):
    '''test runner which support target DUT access'''
    def __init__(self, context=None):
        super(TargetTestRunner, self).__init__(context)
        self.option_list.extend([
            make_option("-c", "--controller", dest="controller",
                    help="the target controller to bridge host and target")])

    def _get_arg_val(self, dest_name, store_val=True):
        '''get arg value from testrunner args'''
        args = sys.argv
        for opt in self.option_list:
            if opt.dest == dest_name:
                arg_names = opt._short_opts + opt._long_opts
                break
        else:
            return None

        for cur_arg in arg_names:
            try:
                ind = args.index(cur_arg)
                return args[ind+1] if store_val else True
            except:
                pass
        return None

    def configure(self, options):
        '''configure before testing'''
        super(TargetTestRunner, self).configure(options)
        print "configure target test runner"

if __name__ == "__main__":
    runner = TargetTestRunner()
    runner.configure(runner.get_options())
    suite = runner.filtertest(runner.loadtest())
    print "Found %s tests" % suite.countTestCases()
    runner.start(suite)

#!/usr/bin/env python
import vtk
from vtk.test import Testing
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()

# Demonstrates vtkCellDerivatives for all cell types
#
ren1 = vtk.vtkRenderer()
renWin = vtk.vtkRenderWindow()
renWin.AddRenderer(ren1)
iren = vtk.vtkRenderWindowInteractor()
iren.SetRenderWindow(renWin)

# create a scene with one of each cell type
# Voxel
voxelPoints = vtk.vtkPoints()
voxelPoints.SetNumberOfPoints(8)
voxelPoints.InsertPoint(0, 0, 0, 0)
voxelPoints.InsertPoint(1, 1, 0, 0)
voxelPoints.InsertPoint(2, 0, 1, 0)
voxelPoints.InsertPoint(3, 1, 1, 0)
voxelPoints.InsertPoint(4, 0, 0, 1)
voxelPoints.InsertPoint(5, 1, 0, 1)
voxelPoints.InsertPoint(6, 0, 1, 1)
voxelPoints.InsertPoint(7, 1, 1, 1)

aVoxel = vtk.vtkVoxel()
aVoxel.GetPointIds().SetId(0, 0)
aVoxel.GetPointIds().SetId(1, 1)
aVoxel.GetPointIds().SetId(2, 2)
aVoxel.GetPointIds().SetId(3, 3)
aVoxel.GetPointIds().SetId(4, 4)
aVoxel.GetPointIds().SetId(5, 5)
aVoxel.GetPointIds().SetId(6, 6)
aVoxel.GetPointIds().SetId(7, 7)

aVoxelGrid = vtk.vtkUnstructuredGrid()
aVoxelGrid.Allocate(1, 1)
aVoxelGrid.InsertNextCell(aVoxel.GetCellType(), aVoxel.GetPointIds())
aVoxelGrid.SetPoints(voxelPoints)

aVoxelMapper = vtk.vtkDataSetMapper()
aVoxelMapper.SetInputData(aVoxelGrid)

aVoxelActor = vtk.vtkActor()
aVoxelActor.SetMapper(aVoxelMapper)
aVoxelActor.GetProperty().BackfaceCullingOn()

# Hexahedron
hexahedronPoints = vtk.vtkPoints()
hexahedronPoints.SetNumberOfPoints(8)
hexahedronPoints.InsertPoint(0, 0, 0, 0)
hexahedronPoints.InsertPoint(1, 1, 0, 0)
hexahedronPoints.InsertPoint(2, 1, 1, 0)
hexahedronPoints.InsertPoint(3, 0, 1, 0)
hexahedronPoints.InsertPoint(4, 0, 0, 1)
hexahedronPoints.InsertPoint(5, 1, 0, 1)
hexahedronPoints.InsertPoint(6, 1, 1, 1)
hexahedronPoints.InsertPoint(7, 0, 1, 1)

aHexahedron = vtk.vtkHexahedron()
aHexahedron.GetPointIds().SetId(0, 0)
aHexahedron.GetPointIds().SetId(1, 1)
aHexahedron.GetPointIds().SetId(2, 2)
aHexahedron.GetPointIds().SetId(3, 3)
aHexahedron.GetPointIds().SetId(4, 4)
aHexahedron.GetPointIds().SetId(5, 5)
aHexahedron.GetPointIds().SetId(6, 6)
aHexahedron.GetPointIds().SetId(7, 7)

aHexahedronGrid = vtk.vtkUnstructuredGrid()
aHexahedronGrid.Allocate(1, 1)
aHexahedronGrid.InsertNextCell(aHexahedron.GetCellType(), aHexahedron.GetPointIds())
aHexahedronGrid.SetPoints(hexahedronPoints)

aHexahedronMapper = vtk.vtkDataSetMapper()
aHexahedronMapper.SetInputData(aHexahedronGrid)

aHexahedronActor = vtk.vtkActor()
aHexahedronActor.SetMapper(aHexahedronMapper)
aHexahedronActor.AddPosition(2, 0, 0)
aHexahedronActor.GetProperty().BackfaceCullingOn()

# Tetra
tetraPoints = vtk.vtkPoints()
tetraPoints.SetNumberOfPoints(4)
tetraPoints.InsertPoint(0, 0, 0, 0)
tetraPoints.InsertPoint(1, 1, 0, 0)
tetraPoints.InsertPoint(2, 0, 1, 0)
tetraPoints.InsertPoint(3, 1, 1, 1)

aTetra = vtk.vtkTetra()
aTetra.GetPointIds().SetId(0, 0)
aTetra.GetPointIds().SetId(1, 1)
aTetra.GetPointIds().SetId(2, 2)
aTetra.GetPointIds().SetId(3, 3)

aTetraGrid = vtk.vtkUnstructuredGrid()
aTetraGrid.Allocate(1, 1)
aTetraGrid.InsertNextCell(aTetra.GetCellType(), aTetra.GetPointIds())
aTetraGrid.SetPoints(tetraPoints)

aTetraMapper = vtk.vtkDataSetMapper()
aTetraMapper.SetInputData(aTetraGrid)

aTetraActor = vtk.vtkActor()
aTetraActor.SetMapper(aTetraMapper)
aTetraActor.AddPosition(4, 0, 0)
aTetraActor.GetProperty().BackfaceCullingOn()

# Wedge
wedgePoints = vtk.vtkPoints()
wedgePoints.SetNumberOfPoints(6)
wedgePoints.InsertPoint(0, 0, 1, 0)
wedgePoints.InsertPoint(1, 0, 0, 0)
wedgePoints.InsertPoint(2, 0, .5, .5)
wedgePoints.InsertPoint(3, 1, 1, 0)
wedgePoints.InsertPoint(4, 1, 0, 0)
wedgePoints.InsertPoint(5, 1, .5, .5)

aWedge = vtk.vtkWedge()
aWedge.GetPointIds().SetId(0, 0)
aWedge.GetPointIds().SetId(1, 1)
aWedge.GetPointIds().SetId(2, 2)
aWedge.GetPointIds().SetId(3, 3)
aWedge.GetPointIds().SetId(4, 4)
aWedge.GetPointIds().SetId(5, 5)

aWedgeGrid = vtk.vtkUnstructuredGrid()
aWedgeGrid.Allocate(1, 1)
aWedgeGrid.InsertNextCell(aWedge.GetCellType(), aWedge.GetPointIds())
aWedgeGrid.SetPoints(wedgePoints)

aWedgeMapper = vtk.vtkDataSetMapper()
aWedgeMapper.SetInputData(aWedgeGrid)

aWedgeActor = vtk.vtkActor()
aWedgeActor.SetMapper(aWedgeMapper)
aWedgeActor.AddPosition(6, 0, 0)
aWedgeActor.GetProperty().BackfaceCullingOn()

# Pyramid
pyramidPoints = vtk.vtkPoints()
pyramidPoints.SetNumberOfPoints(5)
pyramidPoints.InsertPoint(0, 0, 0, 0)
pyramidPoints.InsertPoint(1, 1, 0, 0)
pyramidPoints.InsertPoint(2, 1, 1, 0)
pyramidPoints.InsertPoint(3, 0, 1, 0)
pyramidPoints.InsertPoint(4, .5, .5, 1)

aPyramid = vtk.vtkPyramid()
aPyramid.GetPointIds().SetId(0, 0)
aPyramid.GetPointIds().SetId(1, 1)
aPyramid.GetPointIds().SetId(2, 2)
aPyramid.GetPointIds().SetId(3, 3)
aPyramid.GetPointIds().SetId(4, 4)

aPyramidGrid = vtk.vtkUnstructuredGrid()
aPyramidGrid.Allocate(1, 1)
aPyramidGrid.InsertNextCell(aPyramid.GetCellType(), aPyramid.GetPointIds())
aPyramidGrid.SetPoints(pyramidPoints)

aPyramidMapper = vtk.vtkDataSetMapper()
aPyramidMapper.SetInputData(aPyramidGrid)

aPyramidActor = vtk.vtkActor()
aPyramidActor.SetMapper(aPyramidMapper)
aPyramidActor.AddPosition(8, 0, 0)
aPyramidActor.GetProperty().BackfaceCullingOn()

# Pixel
pixelPoints = vtk.vtkPoints()
pixelPoints.SetNumberOfPoints(4)
pixelPoints.InsertPoint(0, 0, 0, 0)
pixelPoints.InsertPoint(1, 1, 0, 0)
pixelPoints.InsertPoint(2, 0, 1, 0)
pixelPoints.InsertPoint(3, 1, 1, 0)

aPixel = vtk.vtkPixel()
aPixel.GetPointIds().SetId(0, 0)
aPixel.GetPointIds().SetId(1, 1)
aPixel.GetPointIds().SetId(2, 2)
aPixel.GetPointIds().SetId(3, 3)

aPixelGrid = vtk.vtkUnstructuredGrid()
aPixelGrid.Allocate(1, 1)
aPixelGrid.InsertNextCell(aPixel.GetCellType(), aPixel.GetPointIds())
aPixelGrid.SetPoints(pixelPoints)

aPixelMapper = vtk.vtkDataSetMapper()
aPixelMapper.SetInputData(aPixelGrid)

aPixelActor = vtk.vtkActor()
aPixelActor.SetMapper(aPixelMapper)
aPixelActor.AddPosition(0, 0, 2)
aPixelActor.GetProperty().BackfaceCullingOn()

# Quad
quadPoints = vtk.vtkPoints()
quadPoints.SetNumberOfPoints(4)
quadPoints.InsertPoint(0, 0, 0, 0)
quadPoints.InsertPoint(1, 1, 0, 0)
quadPoints.InsertPoint(2, 1, 1, 0)
quadPoints.InsertPoint(3, 0, 1, 0)

aQuad = vtk.vtkQuad()
aQuad.GetPointIds().SetId(0, 0)
aQuad.GetPointIds().SetId(1, 1)
aQuad.GetPointIds().SetId(2, 2)
aQuad.GetPointIds().SetId(3, 3)

aQuadGrid = vtk.vtkUnstructuredGrid()
aQuadGrid.Allocate(1, 1)
aQuadGrid.InsertNextCell(aQuad.GetCellType(), aQuad.GetPointIds())
aQuadGrid.SetPoints(quadPoints)

aQuadMapper = vtk.vtkDataSetMapper()
aQuadMapper.SetInputData(aQuadGrid)

aQuadActor = vtk.vtkActor()
aQuadActor.SetMapper(aQuadMapper)
aQuadActor.AddPosition(2, 0, 2)
aQuadActor.GetProperty().BackfaceCullingOn()

# Triangle
trianglePoints = vtk.vtkPoints()
trianglePoints.SetNumberOfPoints(3)
trianglePoints.InsertPoint(0, 0, 0, 0)
trianglePoints.InsertPoint(1, 1, 0, 0)
trianglePoints.InsertPoint(2, .5, .5, 0)

triangleTCoords = vtk.vtkFloatArray()
triangleTCoords.SetNumberOfComponents(2)
triangleTCoords.SetNumberOfTuples(3)
triangleTCoords.InsertTuple2(0, 1, 1)
triangleTCoords.InsertTuple2(1, 2, 2)
triangleTCoords.InsertTuple2(2, 3, 3)

aTriangle = vtk.vtkTriangle()
aTriangle.GetPointIds().SetId(0, 0)
aTriangle.GetPointIds().SetId(1, 1)
aTriangle.GetPointIds().SetId(2, 2)

aTriangleGrid = vtk.vtkUnstructuredGrid()
aTriangleGrid.Allocate(1, 1)
aTriangleGrid.InsertNextCell(aTriangle.GetCellType(), aTriangle.GetPointIds())
aTriangleGrid.SetPoints(trianglePoints)
aTriangleGrid.GetPointData().SetTCoords(triangleTCoords)

aTriangleMapper = vtk.vtkDataSetMapper()
aTriangleMapper.SetInputData(aTriangleGrid)

aTriangleActor = vtk.vtkActor()
aTriangleActor.SetMapper(aTriangleMapper)
aTriangleActor.AddPosition(4, 0, 2)
aTriangleActor.GetProperty().BackfaceCullingOn()

# Polygon
polygonPoints = vtk.vtkPoints()
polygonPoints.SetNumberOfPoints(4)
polygonPoints.InsertPoint(0, 0, 0, 0)
polygonPoints.InsertPoint(1, 1, 0, 0)
polygonPoints.InsertPoint(2, 1, 1, 0)
polygonPoints.InsertPoint(3, 0, 1, 0)

aPolygon = vtk.vtkPolygon()
aPolygon.GetPointIds().SetNumberOfIds(4)
aPolygon.GetPointIds().SetId(0, 0)
aPolygon.GetPointIds().SetId(1, 1)
aPolygon.GetPointIds().SetId(2, 2)
aPolygon.GetPointIds().SetId(3, 3)

aPolygonGrid = vtk.vtkUnstructuredGrid()
aPolygonGrid.Allocate(1, 1)
aPolygonGrid.InsertNextCell(aPolygon.GetCellType(), aPolygon.GetPointIds())
aPolygonGrid.SetPoints(polygonPoints)

aPolygonMapper = vtk.vtkDataSetMapper()
aPolygonMapper.SetInputData(aPolygonGrid)

aPolygonActor = vtk.vtkActor()
aPolygonActor.SetMapper(aPolygonMapper)
aPolygonActor.AddPosition(6, 0, 2)
aPolygonActor.GetProperty().BackfaceCullingOn()

# Triangle strip
triangleStripPoints = vtk.vtkPoints()
triangleStripPoints.SetNumberOfPoints(5)
triangleStripPoints.InsertPoint(0, 0, 1, 0)
triangleStripPoints.InsertPoint(1, 0, 0, 0)
triangleStripPoints.InsertPoint(2, 1, 1, 0)
triangleStripPoints.InsertPoint(3, 1, 0, 0)
triangleStripPoints.InsertPoint(4, 2, 1, 0)

triangleStripTCoords = vtk.vtkFloatArray()
triangleStripTCoords.SetNumberOfComponents(2)
triangleStripTCoords.SetNumberOfTuples(3)
triangleStripTCoords.InsertTuple2(0, 1, 1)
triangleStripTCoords.InsertTuple2(1, 2, 2)
triangleStripTCoords.InsertTuple2(2, 3, 3)
triangleStripTCoords.InsertTuple2(3, 4, 4)
triangleStripTCoords.InsertTuple2(4, 5, 5)

aTriangleStrip = vtk.vtkTriangleStrip()
aTriangleStrip.GetPointIds().SetNumberOfIds(5)
aTriangleStrip.GetPointIds().SetId(0, 0)
aTriangleStrip.GetPointIds().SetId(1, 1)
aTriangleStrip.GetPointIds().SetId(2, 2)
aTriangleStrip.GetPointIds().SetId(3, 3)
aTriangleStrip.GetPointIds().SetId(4, 4)

aTriangleStripGrid = vtk.vtkUnstructuredGrid()
aTriangleStripGrid.Allocate(1, 1)
aTriangleStripGrid.InsertNextCell(aTriangleStrip.GetCellType(), aTriangleStrip.GetPointIds())
aTriangleStripGrid.SetPoints(triangleStripPoints)
aTriangleStripGrid.GetPointData().SetTCoords(triangleStripTCoords)

aTriangleStripMapper = vtk.vtkDataSetMapper()
aTriangleStripMapper.SetInputData(aTriangleStripGrid)

aTriangleStripActor = vtk.vtkActor()
aTriangleStripActor.SetMapper(aTriangleStripMapper)
aTriangleStripActor.AddPosition(8, 0, 2)
aTriangleStripActor.GetProperty().BackfaceCullingOn()

# Line
linePoints = vtk.vtkPoints()
linePoints.SetNumberOfPoints(2)
linePoints.InsertPoint(0, 0, 0, 0)
linePoints.InsertPoint(1, 1, 1, 0)

aLine = vtk.vtkLine()
aLine.GetPointIds().SetId(0, 0)
aLine.GetPointIds().SetId(1, 1)

aLineGrid = vtk.vtkUnstructuredGrid()
aLineGrid.Allocate(1, 1)
aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds())
aLineGrid.SetPoints(linePoints)

aLineMapper = vtk.vtkDataSetMapper()
aLineMapper.SetInputData(aLineGrid)

aLineActor = vtk.vtkActor()
aLineActor.SetMapper(aLineMapper)
aLineActor.AddPosition(0, 0, 4)
aLineActor.GetProperty().BackfaceCullingOn()

# Polyline
polyLinePoints = vtk.vtkPoints()
polyLinePoints.SetNumberOfPoints(3)
polyLinePoints.InsertPoint(0, 0, 0, 0)
polyLinePoints.InsertPoint(1, 1, 1, 0)
polyLinePoints.InsertPoint(2, 1, 0, 0)

aPolyLine = vtk.vtkPolyLine()
aPolyLine.GetPointIds().SetNumberOfIds(3)
aPolyLine.GetPointIds().SetId(0, 0)
aPolyLine.GetPointIds().SetId(1, 1)
aPolyLine.GetPointIds().SetId(2, 2)

aPolyLineGrid = vtk.vtkUnstructuredGrid()
aPolyLineGrid.Allocate(1, 1)
aPolyLineGrid.InsertNextCell(aPolyLine.GetCellType(), aPolyLine.GetPointIds())
aPolyLineGrid.SetPoints(polyLinePoints)

aPolyLineMapper = vtk.vtkDataSetMapper()
aPolyLineMapper.SetInputData(aPolyLineGrid)

aPolyLineActor = vtk.vtkActor()
aPolyLineActor.SetMapper(aPolyLineMapper)
aPolyLineActor.AddPosition(2, 0, 4)
aPolyLineActor.GetProperty().BackfaceCullingOn()

# Vertex
vertexPoints = vtk.vtkPoints()
vertexPoints.SetNumberOfPoints(1)
vertexPoints.InsertPoint(0, 0, 0, 0)

aVertex = vtk.vtkVertex()
aVertex.GetPointIds().SetId(0, 0)

aVertexGrid = vtk.vtkUnstructuredGrid()
aVertexGrid.Allocate(1, 1)
aVertexGrid.InsertNextCell(aVertex.GetCellType(), aVertex.GetPointIds())
aVertexGrid.SetPoints(vertexPoints)

aVertexMapper = vtk.vtkDataSetMapper()
aVertexMapper.SetInputData(aVertexGrid)

aVertexActor = vtk.vtkActor()
aVertexActor.SetMapper(aVertexMapper)
aVertexActor.AddPosition(0, 0, 6)
aVertexActor.GetProperty().BackfaceCullingOn()

# Polyvertex
polyVertexPoints = vtk.vtkPoints()
polyVertexPoints.SetNumberOfPoints(3)
polyVertexPoints.InsertPoint(0, 0, 0, 0)
polyVertexPoints.InsertPoint(1, 1, 0, 0)
polyVertexPoints.InsertPoint(2, 1, 1, 0)

aPolyVertex = vtk.vtkPolyVertex()
aPolyVertex.GetPointIds().SetNumberOfIds(3)
aPolyVertex.GetPointIds().SetId(0, 0)
aPolyVertex.GetPointIds().SetId(1, 1)
aPolyVertex.GetPointIds().SetId(2, 2)

aPolyVertexGrid = vtk.vtkUnstructuredGrid()
aPolyVertexGrid.Allocate(1, 1)
aPolyVertexGrid.InsertNextCell(aPolyVertex.GetCellType(), aPolyVertex.GetPointIds())
aPolyVertexGrid.SetPoints(polyVertexPoints)

aPolyVertexMapper = vtk.vtkDataSetMapper()
aPolyVertexMapper.SetInputData(aPolyVertexGrid)

aPolyVertexActor = vtk.vtkActor()
aPolyVertexActor.SetMapper(aPolyVertexMapper)
aPolyVertexActor.AddPosition(2, 0, 6)
aPolyVertexActor.GetProperty().BackfaceCullingOn()

# Pentagonal prism
pentaPoints = vtk.vtkPoints()
pentaPoints.SetNumberOfPoints(10)
pentaPoints.InsertPoint(0, 0.25, 0.0, 0.0)
pentaPoints.InsertPoint(1, 0.75, 0.0, 0.0)
pentaPoints.InsertPoint(2, 1.0, 0.5, 0.0)
pentaPoints.InsertPoint(3, 0.5, 1.0, 0.0)
pentaPoints.InsertPoint(4, 0.0, 0.5, 0.0)
pentaPoints.InsertPoint(5, 0.25, 0.0, 1.0)
pentaPoints.InsertPoint(6, 0.75, 0.0, 1.0)
pentaPoints.InsertPoint(7, 1.0, 0.5, 1.0)
pentaPoints.InsertPoint(8, 0.5, 1.0, 1.0)
pentaPoints.InsertPoint(9, 0.0, 0.5, 1.0)

aPenta = vtk.vtkPentagonalPrism()
aPenta.GetPointIds().SetId(0, 0)
aPenta.GetPointIds().SetId(1, 1)
aPenta.GetPointIds().SetId(2, 2)
aPenta.GetPointIds().SetId(3, 3)
aPenta.GetPointIds().SetId(4, 4)
aPenta.GetPointIds().SetId(5, 5)
aPenta.GetPointIds().SetId(6, 6)
aPenta.GetPointIds().SetId(7, 7)
aPenta.GetPointIds().SetId(8, 8)
aPenta.GetPointIds().SetId(9, 9)

aPentaGrid = vtk.vtkUnstructuredGrid()
aPentaGrid.Allocate(1, 1)
aPentaGrid.InsertNextCell(aPenta.GetCellType(), aPenta.GetPointIds())
aPentaGrid.SetPoints(pentaPoints)

aPentaMapper = vtk.vtkDataSetMapper()
aPentaMapper.SetInputData(aPentaGrid)

aPentaActor = vtk.vtkActor()
aPentaActor.SetMapper(aPentaMapper)
aPentaActor.AddPosition(10, 0, 0)
aPentaActor.GetProperty().BackfaceCullingOn()

# Hexagonal prism
hexaPoints = vtk.vtkPoints()
hexaPoints.SetNumberOfPoints(12)
hexaPoints.InsertPoint(0, 0.0, 0.0, 0.0)
hexaPoints.InsertPoint(1, 0.5, 0.0, 0.0)
hexaPoints.InsertPoint(2, 1.0, 0.5, 0.0)
hexaPoints.InsertPoint(3, 1.0, 1.0, 0.0)
hexaPoints.InsertPoint(4, 0.5, 1.0, 0.0)
hexaPoints.InsertPoint(5, 0.0, 0.5, 0.0)
hexaPoints.InsertPoint(6, 0.0, 0.0, 1.0)
hexaPoints.InsertPoint(7, 0.5, 0.0, 1.0)
hexaPoints.InsertPoint(8, 1.0, 0.5, 1.0)
hexaPoints.InsertPoint(9, 1.0, 1.0, 1.0)
hexaPoints.InsertPoint(10, 0.5, 1.0, 1.0)
hexaPoints.InsertPoint(11, 0.0, 0.5, 1.0)

aHexa = vtk.vtkHexagonalPrism()
aHexa.GetPointIds().SetId(0, 0)
aHexa.GetPointIds().SetId(1, 1)
aHexa.GetPointIds().SetId(2, 2)
aHexa.GetPointIds().SetId(3, 3)
aHexa.GetPointIds().SetId(4, 4)
aHexa.GetPointIds().SetId(5, 5)
aHexa.GetPointIds().SetId(6, 6)
aHexa.GetPointIds().SetId(7, 7)
aHexa.GetPointIds().SetId(8, 8)
aHexa.GetPointIds().SetId(9, 9)
aHexa.GetPointIds().SetId(10, 10)
aHexa.GetPointIds().SetId(11, 11)

aHexaGrid = vtk.vtkUnstructuredGrid()
aHexaGrid.Allocate(1, 1)
aHexaGrid.InsertNextCell(aHexa.GetCellType(), aHexa.GetPointIds())
aHexaGrid.SetPoints(hexaPoints)

aHexaMapper = vtk.vtkDataSetMapper()
aHexaMapper.SetInputData(aHexaGrid)

aHexaActor = vtk.vtkActor()
aHexaActor.SetMapper(aHexaMapper)
aHexaActor.AddPosition(12, 0, 0)
aHexaActor.GetProperty().BackfaceCullingOn()

ren1.SetBackground(1, 1, 1)

ren1.AddActor(aVoxelActor)
aVoxelActor.GetProperty().SetDiffuseColor(1, 0, 0)

ren1.AddActor(aHexahedronActor)
aHexahedronActor.GetProperty().SetDiffuseColor(1, 1, 0)

ren1.AddActor(aTetraActor)
aTetraActor.GetProperty().SetDiffuseColor(0, 1, 0)

ren1.AddActor(aWedgeActor)
aWedgeActor.GetProperty().SetDiffuseColor(0, 1, 1)

ren1.AddActor(aPyramidActor)
aPyramidActor.GetProperty().SetDiffuseColor(1, 0, 1)

ren1.AddActor(aPixelActor)
aPixelActor.GetProperty().SetDiffuseColor(0, 1, 1)

ren1.AddActor(aQuadActor)
aQuadActor.GetProperty().SetDiffuseColor(1, 0, 1)

ren1.AddActor(aTriangleActor)
aTriangleActor.GetProperty().SetDiffuseColor(.3, 1, .5)

ren1.AddActor(aPolygonActor)
aPolygonActor.GetProperty().SetDiffuseColor(1, .4, .5)

ren1.AddActor(aTriangleStripActor)
aTriangleStripActor.GetProperty().SetDiffuseColor(.3, .7, 1)

ren1.AddActor(aLineActor)
aLineActor.GetProperty().SetDiffuseColor(.2, 1, 1)

ren1.AddActor(aPolyLineActor)
aPolyLineActor.GetProperty().SetDiffuseColor(1, 1, 1)

ren1.AddActor(aVertexActor)
aVertexActor.GetProperty().SetDiffuseColor(1, 1, 1)

ren1.AddActor(aPolyVertexActor)
aPolyVertexActor.GetProperty().SetDiffuseColor(1, 1, 1)

ren1.AddActor(aPentaActor)
aPentaActor.GetProperty().SetDiffuseColor(1, 1, 0)

ren1.AddActor(aHexaActor)
aHexaActor.GetProperty().SetDiffuseColor(1, 1, 0)

#
# get the cell center of each type and put a glyph there
#
ball = vtk.vtkSphereSource()
ball.SetRadius(.2)

cellType = ['aVoxel', 'aHexahedron', 'aWedge', 'aPyramid', 'aTetra',
              'aQuad', 'aTriangle', 'aTriangleStrip', 'aLine',
              'aPolyLine', 'aVertex', 'aPolyVertex', 'aPixel',
              'aPolygon', 'aPenta', 'aHexa']
for cell in cellType:
    N = eval(cell + 'Grid').GetNumberOfPoints()

    vn = cell + 'Scalar'
    exec(vn + ' = vtk.vtkFloatArray()')
    eval(vn).SetNumberOfTuples(N)
    eval(vn).SetNumberOfComponents(1)

    i = 0
    while i < N:
        eval(vn).SetValue(i, 0)
        i = i + 1

    eval(vn).SetValue(0, 4)

    eval(cell + 'Grid').GetPointData().SetScalars(eval(vn))

    for cell in cellType:
        exec(cell + 'derivs' + ' = vtk.vtkCellDerivatives()')
        eval(cell + 'derivs').SetInputData(eval(cell + 'Grid'))
        eval(cell + 'derivs').SetVectorModeToComputeGradient()

        exec(cell + 'Centers' + ' = vtk.vtkCellCenters()')
        eval(cell + 'Centers').SetInputConnection(eval(cell + 'derivs').GetOutputPort())
        eval(cell + 'Centers').VertexCellsOn()

        exec(cell + 'hog' + ' = vtk.vtkHedgeHog()')
        eval(cell + 'hog').SetInputConnection(eval(cell + 'Centers').GetOutputPort())

        exec(cell + 'mapHog' + ' = vtk.vtkPolyDataMapper()')
        eval(cell + 'mapHog').SetInputConnection(eval(cell + 'hog').GetOutputPort())
        eval(cell + 'mapHog').SetScalarModeToUseCellData()
        eval(cell + 'mapHog').ScalarVisibilityOff()

        exec(cell + 'hogActor' + ' = vtk.vtkActor()')
        eval(cell + 'hogActor').SetMapper(eval(cell + 'mapHog'))
        eval(cell + 'hogActor').GetProperty().SetColor(0, 1, 0)

        exec(cell + 'Glyph3D' + ' = vtk.vtkGlyph3D()')
        eval(cell + 'Glyph3D').SetInputConnection(eval(cell + 'Centers').GetOutputPort())
        eval(cell + 'Glyph3D').SetSourceData(ball.GetOutput())

        exec(cell + 'CentersMapper' + ' = vtk.vtkPolyDataMapper()')
        eval(cell + 'CentersMapper').SetInputConnection(eval(cell + 'Glyph3D').GetOutputPort())

        exec(cell + 'CentersActor' + ' = vtk.vtkActor()')
        eval(cell + 'CentersActor').SetMapper(eval(cell + 'CentersMapper'))

        eval(cell + 'hogActor').SetPosition(eval(cell + 'Actor').GetPosition())
        ren1.AddActor(eval(cell + 'hogActor'))
        eval(cell + 'hogActor').GetProperty().SetRepresentationToWireframe()


ren1.ResetCamera()
ren1.GetActiveCamera().Azimuth(30)
ren1.GetActiveCamera().Elevation(20)
ren1.GetActiveCamera().Dolly(3.0)
ren1.ResetCameraClippingRange()

renWin.SetSize(300, 150)

renWin.Render()

# render the image
#
iren.Initialize()
#iren.Start()

# -*- coding: utf-8 -*-
#
# Copyright: (c) 2017, F5 Networks Inc.
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os
import json
import pytest
import sys

from nose.plugins.skip import SkipTest
if sys.version_info < (2, 7):
    raise SkipTest("F5 Ansible modules require Python >= 2.7")

from units.compat import unittest
from units.compat.mock import Mock
from units.compat.mock import patch
from ansible.module_utils.basic import AnsibleModule

try:
    from library.modules.bigip_profile_persistence_src_addr import ApiParameters
    from library.modules.bigip_profile_persistence_src_addr import ModuleParameters
    from library.modules.bigip_profile_persistence_src_addr import ModuleManager
    from library.modules.bigip_profile_persistence_src_addr import ArgumentSpec
    from library.module_utils.network.f5.common import F5ModuleError
    from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
    from test.unit.modules.utils import set_module_args
except ImportError:
    try:
        from ansible.modules.network.f5.bigip_profile_persistence_src_addr import ApiParameters
        from ansible.modules.network.f5.bigip_profile_persistence_src_addr import ModuleParameters
        from ansible.modules.network.f5.bigip_profile_persistence_src_addr import ModuleManager
        from ansible.modules.network.f5.bigip_profile_persistence_src_addr import ArgumentSpec
        from ansible.module_utils.network.f5.common import F5ModuleError
        from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
        from units.modules.utils import set_module_args
    except ImportError:
        raise SkipTest("F5 Ansible modules require the f5-sdk Python library")

fixture_path = os.path.join(os.path.dirname(__file__), 'fixtures')
fixture_data = {}


def load_fixture(name):
    path = os.path.join(fixture_path, name)

    if path in fixture_data:
        return fixture_data[path]

    with open(path) as f:
        data = f.read()

    try:
        data = json.loads(data)
    except Exception:
        pass

    fixture_data[path] = data
    return data


class TestParameters(unittest.TestCase):
    def test_module_parameters(self):
        args = dict(
            name='foo',
            parent='bar',
            match_across_services=False,
            match_across_virtuals=True,
            match_across_pools=False,
            hash_algorithm='carp',
            entry_timeout=100,
            override_connection_limit=True
        )

        p = ModuleParameters(params=args)
        assert p.name == 'foo'
        assert p.parent == '/Common/bar'
        assert p.match_across_services == 'disabled'
        assert p.match_across_virtuals == 'enabled'
        assert p.match_across_pools == 'disabled'
        assert p.hash_algorithm == 'carp'
        assert p.entry_timeout == 100
        assert p.override_connection_limit == 'enabled'

    def test_api_parameters(self):
        args = load_fixture('load_ltm_profile_persistence_src_addr_1.json')
        p = ApiParameters(params=args)
        assert p.name == 'source_addr'
        assert p.match_across_pools == 'disabled'
        assert p.match_across_services == 'disabled'
        assert p.match_across_virtuals == 'disabled'


class TestManager(unittest.TestCase):

    def setUp(self):
        self.spec = ArgumentSpec()

    def test_create(self, *args):
        # Configure the arguments that would be sent to the Ansible module
        set_module_args(dict(
            name='foo',
            match_across_virtuals='yes',
            parent='bar',
            password='password',
            server='localhost',
            user='admin'
        ))

        module = AnsibleModule(
            argument_spec=self.spec.argument_spec,
            supports_check_mode=self.spec.supports_check_mode
        )
        mm = ModuleManager(module=module)

        # Override methods to force specific logic in the module to happen
        mm.exists = Mock(return_value=False)
        mm.create_on_device = Mock(return_value=True)

        results = mm.exec_module()

        assert results['changed'] is True
        assert results['match_across_virtuals'] == 'yes'

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import migrations, models


class Migration(migrations.Migration):

    dependencies = [
        ('custom_attributes', '0005_auto_20150505_1639'),
    ]

    operations = [
        migrations.AddField(
            model_name='issuecustomattribute',
            name='type',
            field=models.CharField(default='text', choices=[('text', 'Text'), ('multiline', 'Multi-Line Text'), ('date', 'Date')], verbose_name='type', max_length=16),
        ),
        migrations.AddField(
            model_name='taskcustomattribute',
            name='type',
            field=models.CharField(default='text', choices=[('text', 'Text'), ('multiline', 'Multi-Line Text'), ('date', 'Date')], verbose_name='type', max_length=16),
        ),
        migrations.AddField(
            model_name='userstorycustomattribute',
            name='type',
            field=models.CharField(default='text', choices=[('text', 'Text'), ('multiline', 'Multi-Line Text'), ('date', 'Date')], verbose_name='type', max_length=16),
        ),
    ]

# -*- coding: utf-8 -*-
# noqa: This is a backport from Odoo. OCA has no control over style here.
# flake8: noqa
from openerp.tests.common import TransactionCase
from openerp.modules.module import get_module_resource

class TestOfxFile(TransactionCase):
    """Tests for import bank statement ofx file format (account.bank.statement.import)
    """

    def setUp(self):
        super(TestOfxFile, self).setUp()
        self.statement_import_model = self.registry('account.bank.statement.import')
        self.bank_statement_model = self.registry('account.bank.statement')

    def test_ofx_file_import(self):
        try:
            from ofxparse import OfxParser as ofxparser
        except ImportError:
            #the Python library isn't installed on the server, the OFX import is unavailable and the test cannot be run
            return True
        cr, uid = self.cr, self.uid
        ofx_file_path = get_module_resource('account_bank_statement_import_ofx', 'test_ofx_file', 'test_ofx.ofx')
        ofx_file = open(ofx_file_path, 'rb').read().encode('base64')
        bank_statement_id = self.statement_import_model.create(cr, uid, dict(
                            file_type='ofx',
                            data_file=ofx_file,
                            ))
        self.statement_import_model.parse_file(cr, uid, [bank_statement_id])
        statement_id = self.bank_statement_model.search(cr, uid, [('name', '=', '000000123')])[0]
        bank_st_record = self.bank_statement_model.browse(cr, uid, statement_id)
        self.assertEquals(bank_st_record.balance_start, 2156.56)
        self.assertEquals(bank_st_record.balance_end_real, 1796.56)

#!/usr/bin/python

# (c) 2018, NetApp, Inc
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'certified'}


DOCUMENTATION = '''
module: na_ontap_export_policy
short_description: NetApp ONTAP manage export-policy
extends_documentation_fragment:
    - netapp.na_ontap
version_added: '2.6'
author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
description:
- Create or destroy or rename export-policies on ONTAP
options:
  state:
    description:
    - Whether the specified export policy should exist or not.
    choices: ['present', 'absent']
    default: present
  name:
    description:
    - The name of the export-policy to manage.
    required: true
  from_name:
    description:
    - The name of the export-policy to be renamed.
    version_added: '2.7'
  vserver:
    description:
    - Name of the vserver to use.
'''

EXAMPLES = """
    - name: Create Export Policy
      na_ontap_export_policy:
        state: present
        name: ansiblePolicyName
        vserver: vs_hack
        hostname: "{{ netapp_hostname }}"
        username: "{{ netapp_username }}"
        password: "{{ netapp_password }}"
    - name: Rename Export Policy
      na_ontap_export_policy:
        action: present
        from_name: ansiblePolicyName
        vserver: vs_hack
        name: newPolicyName
        hostname: "{{ netapp_hostname }}"
        username: "{{ netapp_username }}"
        password: "{{ netapp_password }}"
    - name: Delete Export Policy
      na_ontap_export_policy:
        state: absent
        name: ansiblePolicyName
        vserver: vs_hack
        hostname: "{{ netapp_hostname }}"
        username: "{{ netapp_username }}"
        password: "{{ netapp_password }}"
"""

RETURN = """
"""

import traceback
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils._text import to_native
import ansible.module_utils.netapp as netapp_utils

HAS_NETAPP_LIB = netapp_utils.has_netapp_lib()


class NetAppONTAPExportPolicy(object):
    """
    Class with export policy methods
    """

    def __init__(self):

        self.argument_spec = netapp_utils.na_ontap_host_argument_spec()
        self.argument_spec.update(dict(
            state=dict(required=False, type='str', choices=['present', 'absent'], default='present'),
            name=dict(required=True, type='str'),
            from_name=dict(required=False, type='str', default=None),
            vserver=dict(required=False, type='str')
        ))
        self.module = AnsibleModule(
            argument_spec=self.argument_spec,
            required_if=[
                ('state', 'present', ['vserver'])
            ],
            supports_check_mode=True
        )
        parameters = self.module.params
        # set up state variables
        self.state = parameters['state']
        self.name = parameters['name']
        self.from_name = parameters['from_name']
        self.vserver = parameters['vserver']

        if HAS_NETAPP_LIB is False:
            self.module.fail_json(msg="the python NetApp-Lib module is required")
        else:
            self.server = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=self.vserver)

    def get_export_policy(self, name=None):
        """
        Return details about the export-policy
        :param:
            name : Name of the export-policy
        :return: Details about the export-policy. None if not found.
        :rtype: dict
        """
        if name is None:
            name = self.name
        export_policy_iter = netapp_utils.zapi.NaElement('export-policy-get-iter')
        export_policy_info = netapp_utils.zapi.NaElement('export-policy-info')
        export_policy_info.add_new_child('policy-name', name)
        query = netapp_utils.zapi.NaElement('query')
        query.add_child_elem(export_policy_info)
        export_policy_iter.add_child_elem(query)
        result = self.server.invoke_successfully(export_policy_iter, True)
        return_value = None
        # check if query returns the expected export-policy
        if result.get_child_by_name('num-records') and \
                int(result.get_child_content('num-records')) == 1:

            export_policy = result.get_child_by_name('attributes-list').get_child_by_name('export-policy-info').get_child_by_name('policy-name')
            return_value = {
                'policy-name': export_policy
            }
        return return_value

    def create_export_policy(self):
        """
        Creates an export policy
        """
        export_policy_create = netapp_utils.zapi.NaElement.create_node_with_children(
            'export-policy-create', **{'policy-name': self.name})
        try:
            self.server.invoke_successfully(export_policy_create,
                                            enable_tunneling=True)
        except netapp_utils.zapi.NaApiError as error:
            self.module.fail_json(msg='Error creating export-policy %s: %s'
                                  % (self.name, to_native(error)),
                                  exception=traceback.format_exc())

    def delete_export_policy(self):
        """
        Delete export-policy
        """
        export_policy_delete = netapp_utils.zapi.NaElement.create_node_with_children(
            'export-policy-destroy', **{'policy-name': self.name, })
        try:
            self.server.invoke_successfully(export_policy_delete,
                                            enable_tunneling=True)
        except netapp_utils.zapi.NaApiError as error:
            self.module.fail_json(msg='Error deleting export-policy %s: %s'
                                  % (self.name,
                                     to_native(error)), exception=traceback.format_exc())

    def rename_export_policy(self):
        """
        Rename the export-policy.
        """
        export_policy_rename = netapp_utils.zapi.NaElement.create_node_with_children(
            'export-policy-rename', **{'policy-name': self.from_name,
                                       'new-policy-name': self.name})
        try:
            self.server.invoke_successfully(export_policy_rename,
                                            enable_tunneling=True)
        except netapp_utils.zapi.NaApiError as error:
            self.module.fail_json(msg='Error renaming export-policy %s:%s'
                                  % (self.name, to_native(error)),
                                  exception=traceback.format_exc())

    def apply(self):
        """
        Apply action to export-policy
        """
        changed = False
        export_policy_exists = False
        netapp_utils.ems_log_event("na_ontap_export_policy", self.server)
        rename_flag = False
        export_policy_details = self.get_export_policy()
        if export_policy_details:
            export_policy_exists = True
            if self.state == 'absent':  # delete
                changed = True
        else:
            if self.state == 'present':  # create or rename
                if self.from_name is not None:
                    if self.get_export_policy(self.from_name):
                        changed = True
                        rename_flag = True
                    else:
                        self.module.fail_json(msg='Error renaming export-policy %s: does not exists' % self.from_name)
                else:  # create
                    changed = True
        if changed:
            if self.module.check_mode:
                pass
            else:
                if self.state == 'present':  # execute create or rename_export_policy
                    if rename_flag:
                        self.rename_export_policy()
                    else:
                        self.create_export_policy()
                elif self.state == 'absent':  # execute delete
                    self.delete_export_policy()
        self.module.exit_json(changed=changed)


def main():
    """
    Execute action
    """
    export_policy = NetAppONTAPExportPolicy()
    export_policy.apply()


if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-
#
# This file is part of Invenio.
# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 CERN.
#
# Invenio is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of the
# License, or (at your option) any later version.
#
# Invenio is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Invenio; if not, write to the Free Software Foundation, Inc.,
# 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.

""" Test unit for the miscutil/sequtils module. """

from invenio.testutils import InvenioTestCase
try:
    from mock import patch
    HAS_MOCK = True
except ImportError:
    HAS_MOCK = False

from invenio.testutils import make_test_suite, run_test_suite
from invenio.dbquery import run_sql

from invenio.sequtils import SequenceGenerator
from invenio.sequtils_texkey import TexkeySeq, TexkeyNoAuthorError, \
                                    task_run_core, TexkeyNoYearError


def get_bibrecord_mock(_):
    return {'001': [([], ' ', ' ', '1086086', 1)],
            '111': [([('a',
            'Mock conference'),
            ('d', '14-16 Sep 2011'),
            ('x', '2050-09-14'),
            ('c', 'xxxxx')],
            ' ',
            ' ',
            '',
            3)],
            '270': [([('m', 'dummy@dummy.com')], ' ', ' ', '', 5)],
            '856': [([('u', 'http://dummy.com/')], '4', ' ', '', 6)],
            '970': [([('a', 'CONF-XXXXXX')], ' ', ' ', '', 2)],
            '980': [([('a', 'CONFERENCES')], ' ', ' ', '', 7)]}


def get_sample_texkey(num_test=0):
    sample_records = []
    xml = """
    <record>
        <datafield tag="100" ind1=" " ind2=" ">
            <subfield code="a">Boyle, P.A.</subfield>
        </datafield>
        <datafield tag="700" ind1=" " ind2=" ">
            <subfield code="a">Christ, N.H.</subfield>
        </datafield>
        <datafield tag="269" ind1=" " ind2=" ">
            <subfield code="c">2012-12-06</subfield>
        </datafield>
    </record>
    """
    sample_records.append(xml)

    xml = """
    <record>
        <datafield tag="100" ind1=" " ind2=" ">
            <subfield code="a">Broekhoven-Fiene, Hannah</subfield>
        </datafield>
        <datafield tag="700" ind1=" " ind2=" ">
            <subfield code="a">Matthews, Brenda C.</subfield>
        </datafield>
            <datafield tag="269" ind1=" " ind2=" ">
        <subfield code="c">2012-12-06</subfield>
        </datafield>
    </record>
    """
    sample_records.append(xml)

    xml = """
    <record>
        <datafield tag="269" ind1=" " ind2=" ">
            <subfield code="b">CERN</subfield>
            <subfield code="a">Geneva</subfield>
            <subfield code="c">2012-11-06</subfield>
        </datafield>
        <datafield tag="300" ind1=" " ind2=" ">
            <subfield code="a">16</subfield>
        </datafield>
        <datafield tag="710" ind1=" " ind2=" ">
            <subfield code="g">ATLAS Collaboration</subfield>
        </datafield>
    </record>
    """
    sample_records.append(xml)

    xml = """
    <record>
        <datafield tag="269" ind1=" " ind2=" ">
            <subfield code="b">CERN</subfield>
            <subfield code="a">Geneva</subfield>
            <subfield code="c">2012-11-06</subfield>
        </datafield>
        <datafield tag="300" ind1=" " ind2=" ">
            <subfield code="a">16</subfield>
        </datafield>
    </record>
    """
    sample_records.append(xml)


    xml = """
    <record>
        <datafield tag="100" ind1=" " ind2=" ">
            <subfield code="a">Broekhoven-Fiene, Hannah</subfield>
        </datafield>
        <datafield tag="700" ind1=" " ind2=" ">
            <subfield code="a">Matthews, Brenda C.</subfield>
        </datafield>
    </record>
    """
    sample_records.append(xml)

    return sample_records[num_test]


class IntSeq(SequenceGenerator):
    seq_name = 'test_int'

    def _next_value(self, x):
        return x + 1


class TestIntSequenceGeneratorClass(InvenioTestCase):

    def test_sequence_next_int(self):
        int_seq = IntSeq()
        next_int = int_seq.next_value(1)
        self.assertEqual(next_int, 2)

        # Check if the value was stored in the DB
        res = run_sql("""SELECT seq_value FROM seqSTORE
                         WHERE seq_value=%s AND seq_name=%s""",
                         (2, int_seq.seq_name))
        self.assertEqual(int(res[0][0]), 2)

        # Clean DB entries
        run_sql(""" DELETE FROM seqSTORE WHERE seq_name="test_int" """)


class TestCnumSequenceGeneratorClass(InvenioTestCase):

    if HAS_MOCK:
        @patch('invenio.bibedit_utils.get_bibrecord',
            get_bibrecord_mock)
        def test_get_next_cnum(self):
            from invenio.sequtils_cnum import CnumSeq

            cnum_seq = CnumSeq()
            res = cnum_seq.next_value('xx')
            self.assertEqual(res, 'C50-09-14')
            res = cnum_seq.next_value('xx')
            self.assertEqual(res, 'C50-09-14.1')

            # Clean DB entries
            run_sql(""" DELETE FROM seqSTORE
                        WHERE seq_name="cnum"
                        AND seq_value IN ("C50-09-14", "C50-09-14.1") """)


class TestTexkeySequenceGeneratorClass(InvenioTestCase):

    def setUp(self):
        self.texkey1 = ""
        self.texkey2 = ""
        self.texkey3 = ""

    def test_get_next_texkey1(self):
        """ Generate the first texkey """

        texkey_seq = TexkeySeq()
        self.texkey1 = texkey_seq.next_value(xml_record=get_sample_texkey(0))
        self.assertEqual(self.texkey1[:-3], 'Boyle:2012')

    def test_get_next_texkey2(self):
        """ Generate the second texkey """

        texkey_seq = TexkeySeq()
        self.texkey2 = texkey_seq.next_value(xml_record=get_sample_texkey(1))
        self.assertEqual(self.texkey2[:-3], 'Broekhoven-Fiene:2012')

    def test_get_next_texkey3(self):
        """ Generate the third texkey """

        texkey_seq = TexkeySeq()
        self.texkey3 = texkey_seq.next_value(xml_record=get_sample_texkey(2))
        self.assertEqual(self.texkey3[:-3], 'ATLAS:2012')

    def test_get_next_texkey_no_author(self):
        """ Generate an error while getting a texkey with no author """

        texkey_seq = TexkeySeq()
        self.assertRaises(TexkeyNoAuthorError,
            texkey_seq.next_value, xml_record=get_sample_texkey(3))

    def test_get_next_texkey_no_year(self):
        """ Generate an error while getting a texkey with no year """
        texkey_seq = TexkeySeq()
        self.assertRaises(TexkeyNoYearError,
            texkey_seq.next_value, xml_record=get_sample_texkey(4))


    def tearDown(self):
        # Clean DB entries
        run_sql(""" DELETE FROM seqSTORE
                    WHERE seq_name="texkey"
                    AND seq_value IN ("%s", "%s", "%s") """ % (self.texkey1,
                                                               self.texkey2,
                                                               self.texkey3))


class TestTexkeydaemonClass(InvenioTestCase):
    def test_task_run_core(self):
        """ Basic task_run_core check """
        task_run_core()


TEST_SUITE = make_test_suite(TestIntSequenceGeneratorClass,
                             TestCnumSequenceGeneratorClass,
                             TestTexkeySequenceGeneratorClass,
                             TestTexkeydaemonClass)


if __name__ == "__main__":
    run_test_suite(TEST_SUITE, warn_user=True)

r"""JSON (JavaScript Object Notation) <http://json.org> is a subset of
JavaScript syntax (ECMA-262 3rd edition) used as a lightweight data
interchange format.

:mod:`simplejson` exposes an API familiar to users of the standard library
:mod:`marshal` and :mod:`pickle` modules. It is the externally maintained
version of the :mod:`json` library contained in Python 2.6, but maintains
compatibility with Python 2.4 and Python 2.5 and (currently) has
significant performance advantages, even without using the optional C
extension for speedups.

Encoding basic Python object hierarchies::

    >>> import simplejson as json
    >>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
    '["foo", {"bar": ["baz", null, 1.0, 2]}]'
    >>> print json.dumps("\"foo\bar")
    "\"foo\bar"
    >>> print json.dumps(u'\u1234')
    "\u1234"
    >>> print json.dumps('\\')
    "\\"
    >>> print json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True)
    {"a": 0, "b": 0, "c": 0}
    >>> from StringIO import StringIO
    >>> io = StringIO()
    >>> json.dump(['streaming API'], io)
    >>> io.getvalue()
    '["streaming API"]'

Compact encoding::

    >>> import simplejson as json
    >>> json.dumps([1,2,3,{'4': 5, '6': 7}], separators=(',',':'))
    '[1,2,3,{"4":5,"6":7}]'

Pretty printing::

    >>> import simplejson as json
    >>> s = json.dumps({'4': 5, '6': 7}, sort_keys=True, indent='    ')
    >>> print '\n'.join([l.rstrip() for l in  s.splitlines()])
    {
        "4": 5,
        "6": 7
    }

Decoding JSON::

    >>> import simplejson as json
    >>> obj = [u'foo', {u'bar': [u'baz', None, 1.0, 2]}]
    >>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]') == obj
    True
    >>> json.loads('"\\"foo\\bar"') == u'"foo\x08ar'
    True
    >>> from StringIO import StringIO
    >>> io = StringIO('["streaming API"]')
    >>> json.load(io)[0] == 'streaming API'
    True

Specializing JSON object decoding::

    >>> import simplejson as json
    >>> def as_complex(dct):
    ...     if '__complex__' in dct:
    ...         return complex(dct['real'], dct['imag'])
    ...     return dct
    ...
    >>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
    ...     object_hook=as_complex)
    (1+2j)
    >>> from decimal import Decimal
    >>> json.loads('1.1', parse_float=Decimal) == Decimal('1.1')
    True

Specializing JSON object encoding::

    >>> import simplejson as json
    >>> def encode_complex(obj):
    ...     if isinstance(obj, complex):
    ...         return [obj.real, obj.imag]
    ...     raise TypeError(repr(o) + " is not JSON serializable")
    ...
    >>> json.dumps(2 + 1j, default=encode_complex)
    '[2.0, 1.0]'
    >>> json.JSONEncoder(default=encode_complex).encode(2 + 1j)
    '[2.0, 1.0]'
    >>> ''.join(json.JSONEncoder(default=encode_complex).iterencode(2 + 1j))
    '[2.0, 1.0]'


Using simplejson.tool from the shell to validate and pretty-print::

    $ echo '{"json":"obj"}' | python -m simplejson.tool
    {
        "json": "obj"
    }
    $ echo '{ 1.2:3.4}' | python -m simplejson.tool
    Expecting property name: line 1 column 2 (char 2)
"""
__version__ = '2.2.1'
__all__ = [
    'dump', 'dumps', 'load', 'loads',
    'JSONDecoder', 'JSONDecodeError', 'JSONEncoder',
    'OrderedDict',
]

__author__ = 'Bob Ippolito <bob@redivi.com>'

from decimal import Decimal

from decoder import JSONDecoder, JSONDecodeError
from encoder import JSONEncoder
def _import_OrderedDict():
    import collections
    try:
        return collections.OrderedDict
    except AttributeError:
        import ordered_dict
        return ordered_dict.OrderedDict
OrderedDict = _import_OrderedDict()

def _import_c_make_encoder():
    try:
        from simplejson._speedups import make_encoder
        return make_encoder
    except ImportError:
        return None

_default_encoder = JSONEncoder(
    skipkeys=False,
    ensure_ascii=True,
    check_circular=True,
    allow_nan=True,
    indent=None,
    separators=None,
    encoding='utf-8',
    default=None,
    use_decimal=True,
    namedtuple_as_object=True,
    tuple_as_array=True,
)

def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        encoding='utf-8', default=None, use_decimal=True,
        namedtuple_as_object=True, tuple_as_array=True,
        **kw):
    """Serialize ``obj`` as a JSON formatted stream to ``fp`` (a
    ``.write()``-supporting file-like object).

    If ``skipkeys`` is true then ``dict`` keys that are not basic types
    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
    will be skipped instead of raising a ``TypeError``.

    If ``ensure_ascii`` is false, then the some chunks written to ``fp``
    may be ``unicode`` instances, subject to normal Python ``str`` to
    ``unicode`` coercion rules. Unless ``fp.write()`` explicitly
    understands ``unicode`` (as in ``codecs.getwriter()``) this is likely
    to cause an error.

    If ``check_circular`` is false, then the circular reference check
    for container types will be skipped and a circular reference will
    result in an ``OverflowError`` (or worse).

    If ``allow_nan`` is false, then it will be a ``ValueError`` to
    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)
    in strict compliance of the JSON specification, instead of using the
    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

    If *indent* is a string, then JSON array elements and object members
    will be pretty-printed with a newline followed by that string repeated
    for each level of nesting. ``None`` (the default) selects the most compact
    representation without any newlines. For backwards compatibility with
    versions of simplejson earlier than 2.1.0, an integer is also accepted
    and is converted to a string with that many spaces.

    If ``separators`` is an ``(item_separator, dict_separator)`` tuple
    then it will be used instead of the default ``(', ', ': ')`` separators.
    ``(',', ':')`` is the most compact JSON representation.

    ``encoding`` is the character encoding for str instances, default is UTF-8.

    ``default(obj)`` is a function that should return a serializable version
    of obj or raise TypeError. The default simply raises TypeError.

    If *use_decimal* is true (default: ``True``) then decimal.Decimal
    will be natively serialized to JSON with full precision.

    If *namedtuple_as_object* is true (default: ``True``),
    :class:`tuple` subclasses with ``_asdict()`` methods will be encoded
    as JSON objects.
    
    If *tuple_as_array* is true (default: ``True``),
    :class:`tuple` (and subclasses) will be encoded as JSON arrays.

    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
    ``.default()`` method to serialize additional types), specify it with
    the ``cls`` kwarg.

    """
    # cached encoder
    if (not skipkeys and ensure_ascii and
        check_circular and allow_nan and
        cls is None and indent is None and separators is None and
        encoding == 'utf-8' and default is None and use_decimal
        and namedtuple_as_object and tuple_as_array and not kw):
        iterable = _default_encoder.iterencode(obj)
    else:
        if cls is None:
            cls = JSONEncoder
        iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,
            check_circular=check_circular, allow_nan=allow_nan, indent=indent,
            separators=separators, encoding=encoding,
            default=default, use_decimal=use_decimal,
            namedtuple_as_object=namedtuple_as_object,
            tuple_as_array=tuple_as_array,
            **kw).iterencode(obj)
    # could accelerate with writelines in some versions of Python, at
    # a debuggability cost
    for chunk in iterable:
        fp.write(chunk)


def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,
        allow_nan=True, cls=None, indent=None, separators=None,
        encoding='utf-8', default=None, use_decimal=True,
        namedtuple_as_object=True,
        tuple_as_array=True,
        **kw):
    """Serialize ``obj`` to a JSON formatted ``str``.

    If ``skipkeys`` is false then ``dict`` keys that are not basic types
    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``)
    will be skipped instead of raising a ``TypeError``.

    If ``ensure_ascii`` is false, then the return value will be a
    ``unicode`` instance subject to normal Python ``str`` to ``unicode``
    coercion rules instead of being escaped to an ASCII ``str``.

    If ``check_circular`` is false, then the circular reference check
    for container types will be skipped and a circular reference will
    result in an ``OverflowError`` (or worse).

    If ``allow_nan`` is false, then it will be a ``ValueError`` to
    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in
    strict compliance of the JSON specification, instead of using the
    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).

    If ``indent`` is a string, then JSON array elements and object members
    will be pretty-printed with a newline followed by that string repeated
    for each level of nesting. ``None`` (the default) selects the most compact
    representation without any newlines. For backwards compatibility with
    versions of simplejson earlier than 2.1.0, an integer is also accepted
    and is converted to a string with that many spaces.

    If ``separators`` is an ``(item_separator, dict_separator)`` tuple
    then it will be used instead of the default ``(', ', ': ')`` separators.
    ``(',', ':')`` is the most compact JSON representation.

    ``encoding`` is the character encoding for str instances, default is UTF-8.

    ``default(obj)`` is a function that should return a serializable version
    of obj or raise TypeError. The default simply raises TypeError.

    If *use_decimal* is true (default: ``True``) then decimal.Decimal
    will be natively serialized to JSON with full precision.

    If *namedtuple_as_object* is true (default: ``True``),
    :class:`tuple` subclasses with ``_asdict()`` methods will be encoded
    as JSON objects.
    
    If *tuple_as_array* is true (default: ``True``),
    :class:`tuple` (and subclasses) will be encoded as JSON arrays.

    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
    ``.default()`` method to serialize additional types), specify it with
    the ``cls`` kwarg.

    """
    # cached encoder
    if (not skipkeys and ensure_ascii and
        check_circular and allow_nan and
        cls is None and indent is None and separators is None and
        encoding == 'utf-8' and default is None and use_decimal
        and namedtuple_as_object and tuple_as_array and not kw):
        return _default_encoder.encode(obj)
    if cls is None:
        cls = JSONEncoder
    return cls(
        skipkeys=skipkeys, ensure_ascii=ensure_ascii,
        check_circular=check_circular, allow_nan=allow_nan, indent=indent,
        separators=separators, encoding=encoding, default=default,
        use_decimal=use_decimal,
        namedtuple_as_object=namedtuple_as_object,
        tuple_as_array=tuple_as_array,
        **kw).encode(obj)


_default_decoder = JSONDecoder(encoding=None, object_hook=None,
                               object_pairs_hook=None)


def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,
        parse_int=None, parse_constant=None, object_pairs_hook=None,
        use_decimal=False, namedtuple_as_object=True, tuple_as_array=True,
        **kw):
    """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing
    a JSON document) to a Python object.

    *encoding* determines the encoding used to interpret any
    :class:`str` objects decoded by this instance (``'utf-8'`` by
    default).  It has no effect when decoding :class:`unicode` objects.

    Note that currently only encodings that are a superset of ASCII work,
    strings of other encodings should be passed in as :class:`unicode`.

    *object_hook*, if specified, will be called with the result of every
    JSON object decoded and its return value will be used in place of the
    given :class:`dict`.  This can be used to provide custom
    deserializations (e.g. to support JSON-RPC class hinting).

    *object_pairs_hook* is an optional function that will be called with
    the result of any object literal decode with an ordered list of pairs.
    The return value of *object_pairs_hook* will be used instead of the
    :class:`dict`.  This feature can be used to implement custom decoders
    that rely on the order that the key and value pairs are decoded (for
    example, :func:`collections.OrderedDict` will remember the order of
    insertion). If *object_hook* is also defined, the *object_pairs_hook*
    takes priority.

    *parse_float*, if specified, will be called with the string of every
    JSON float to be decoded.  By default, this is equivalent to
    ``float(num_str)``. This can be used to use another datatype or parser
    for JSON floats (e.g. :class:`decimal.Decimal`).

    *parse_int*, if specified, will be called with the string of every
    JSON int to be decoded.  By default, this is equivalent to
    ``int(num_str)``.  This can be used to use another datatype or parser
    for JSON integers (e.g. :class:`float`).

    *parse_constant*, if specified, will be called with one of the
    following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``.  This
    can be used to raise an exception if invalid JSON numbers are
    encountered.

    If *use_decimal* is true (default: ``False``) then it implies
    parse_float=decimal.Decimal for parity with ``dump``.

    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
    kwarg.

    """
    return loads(fp.read(),
        encoding=encoding, cls=cls, object_hook=object_hook,
        parse_float=parse_float, parse_int=parse_int,
        parse_constant=parse_constant, object_pairs_hook=object_pairs_hook,
        use_decimal=use_decimal, **kw)


def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
        parse_int=None, parse_constant=None, object_pairs_hook=None,
        use_decimal=False, **kw):
    """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON
    document) to a Python object.

    *encoding* determines the encoding used to interpret any
    :class:`str` objects decoded by this instance (``'utf-8'`` by
    default).  It has no effect when decoding :class:`unicode` objects.

    Note that currently only encodings that are a superset of ASCII work,
    strings of other encodings should be passed in as :class:`unicode`.

    *object_hook*, if specified, will be called with the result of every
    JSON object decoded and its return value will be used in place of the
    given :class:`dict`.  This can be used to provide custom
    deserializations (e.g. to support JSON-RPC class hinting).

    *object_pairs_hook* is an optional function that will be called with
    the result of any object literal decode with an ordered list of pairs.
    The return value of *object_pairs_hook* will be used instead of the
    :class:`dict`.  This feature can be used to implement custom decoders
    that rely on the order that the key and value pairs are decoded (for
    example, :func:`collections.OrderedDict` will remember the order of
    insertion). If *object_hook* is also defined, the *object_pairs_hook*
    takes priority.

    *parse_float*, if specified, will be called with the string of every
    JSON float to be decoded.  By default, this is equivalent to
    ``float(num_str)``. This can be used to use another datatype or parser
    for JSON floats (e.g. :class:`decimal.Decimal`).

    *parse_int*, if specified, will be called with the string of every
    JSON int to be decoded.  By default, this is equivalent to
    ``int(num_str)``.  This can be used to use another datatype or parser
    for JSON integers (e.g. :class:`float`).

    *parse_constant*, if specified, will be called with one of the
    following strings: ``'-Infinity'``, ``'Infinity'``, ``'NaN'``.  This
    can be used to raise an exception if invalid JSON numbers are
    encountered.

    If *use_decimal* is true (default: ``False``) then it implies
    parse_float=decimal.Decimal for parity with ``dump``.

    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``
    kwarg.

    """
    if (cls is None and encoding is None and object_hook is None and
            parse_int is None and parse_float is None and
            parse_constant is None and object_pairs_hook is None
            and not use_decimal and not kw):
        return _default_decoder.decode(s)
    if cls is None:
        cls = JSONDecoder
    if object_hook is not None:
        kw['object_hook'] = object_hook
    if object_pairs_hook is not None:
        kw['object_pairs_hook'] = object_pairs_hook
    if parse_float is not None:
        kw['parse_float'] = parse_float
    if parse_int is not None:
        kw['parse_int'] = parse_int
    if parse_constant is not None:
        kw['parse_constant'] = parse_constant
    if use_decimal:
        if parse_float is not None:
            raise TypeError("use_decimal=True implies parse_float=Decimal")
        kw['parse_float'] = Decimal
    return cls(encoding=encoding, **kw).decode(s)


def _toggle_speedups(enabled):
    import simplejson.decoder as dec
    import simplejson.encoder as enc
    import simplejson.scanner as scan
    c_make_encoder = _import_c_make_encoder()
    if enabled:
        dec.scanstring = dec.c_scanstring or dec.py_scanstring
        enc.c_make_encoder = c_make_encoder
        enc.encode_basestring_ascii = (enc.c_encode_basestring_ascii or 
            enc.py_encode_basestring_ascii)
        scan.make_scanner = scan.c_make_scanner or scan.py_make_scanner
    else:
        dec.scanstring = dec.py_scanstring
        enc.c_make_encoder = None
        enc.encode_basestring_ascii = enc.py_encode_basestring_ascii
        scan.make_scanner = scan.py_make_scanner
    dec.make_scanner = scan.make_scanner
    global _default_decoder
    _default_decoder = JSONDecoder(
        encoding=None,
        object_hook=None,
        object_pairs_hook=None,
    )
    global _default_encoder
    _default_encoder = JSONEncoder(
       skipkeys=False,
       ensure_ascii=True,
       check_circular=True,
       allow_nan=True,
       indent=None,
       separators=None,
       encoding='utf-8',
       default=None,
   )

# -*- coding: utf-8 -*-
# (c) 2020 Matt Martz <matt@sivel.net>
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type

from units.compat.mock import MagicMock

import pytest

from ansible.module_utils.six import PY3
from ansible.utils.display import Display, get_text_width, initialize_locale


def test_get_text_width():
    initialize_locale()
    assert get_text_width(u'コンニチハ') == 10
    assert get_text_width(u'abコcd') == 6
    assert get_text_width(u'café') == 4
    assert get_text_width(u'four') == 4
    assert get_text_width(u'\u001B') == 0
    assert get_text_width(u'ab\u0000') == 2
    assert get_text_width(u'abコ\u0000') == 4
    assert get_text_width(u'🚀🐮') == 4
    assert get_text_width(u'\x08') == 0
    assert get_text_width(u'\x08\x08') == 0
    assert get_text_width(u'ab\x08cd') == 3
    assert get_text_width(u'ab\x1bcd') == 3
    assert get_text_width(u'ab\x7fcd') == 3
    assert get_text_width(u'ab\x94cd') == 3

    pytest.raises(TypeError, get_text_width, 1)
    pytest.raises(TypeError, get_text_width, b'four')


@pytest.mark.skipif(PY3, reason='Fallback only happens reliably on py2')
def test_get_text_width_no_locale():
    pytest.raises(EnvironmentError, get_text_width, u'🚀🐮')


def test_Display_banner_get_text_width(monkeypatch):
    initialize_locale()
    display = Display()
    display_mock = MagicMock()
    monkeypatch.setattr(display, 'display', display_mock)

    display.banner(u'🚀🐮', color=False, cows=False)
    args, kwargs = display_mock.call_args
    msg = args[0]
    stars = u' %s' % (75 * u'*')
    assert msg.endswith(stars)


@pytest.mark.skipif(PY3, reason='Fallback only happens reliably on py2')
def test_Display_banner_get_text_width_fallback(monkeypatch):
    display = Display()
    display_mock = MagicMock()
    monkeypatch.setattr(display, 'display', display_mock)

    display.banner(u'🚀🐮', color=False, cows=False)
    args, kwargs = display_mock.call_args
    msg = args[0]
    stars = u' %s' % (77 * u'*')
    assert msg.endswith(stars)

import pygtk
pygtk.require( '2.0' )
import gtk

import time

import common.Util.InstrumentDB as InstrumentDB
import common.Config as Config
from common.Util.ThemeWidgets import *
Tooltips = Config.Tooltips

class InstrumentPanel( gtk.EventBox ):
    def __init__(self,setInstrument = None, playInstrument = None, enterMode = False, micRec = None, synthRec = None, rowLen = 8, _instDic = None, force_load = True ):
        gtk.EventBox.__init__(self)

        self.instrumentDB = InstrumentDB.getRef()
        self.setInstrument = setInstrument
        self.playInstrument = playInstrument
        self.micRec = micRec
        self.synthRec = synthRec
        self.rowLen = rowLen
        self.enterMode = enterMode

        self.instDic = _instDic

        self.loaded = False
        self.loadData = {}
        self.loadStage = [0,0,0]
        if force_load: self.load()

    def configure( self, setInstrument = None, playInstrument = None, enterMode = False, micRec = None, synthRec = None, rowLen = 8 ):

        self.setInstrument = setInstrument
        self.playInstrument = playInstrument
        self.enterMode = enterMode
        self.micRec = micRec

        if self.rowLen != rowLen:
            self.rowLen = rowLen
            self.prepareInstrumentTable( self.category )
        else:
            self.rowLen = rowLen

    def load( self, timeout = -1 ):
        if self.loaded: return True
        if Config.DEBUG > 4: print "InstrumentPanel load", self.loadStage

        if self.loadStage[0] == 0:
            color = gtk.gdk.color_parse(Config.PANEL_BCK_COLOR)
            self.modify_bg(gtk.STATE_NORMAL, color)
            self.loadStage[0] = 1
            if timeout >= 0 and time.time() > timeout: return False

        if self.loadStage[0] == 1:
            self.tooltips = gtk.Tooltips()
            self.loadStage[0] = 2
            if timeout >= 0 and time.time() > timeout: return False

        if self.loadStage[0] == 2:
            self.instTable = None
            self.recstate = False
            self.lastInstrumentWidget = None

            self.mainVBox =  gtk.VBox()
            self.loadStage[0] = 3
            if timeout >= 0 and time.time() > timeout: return False

        if self.loadStage[0] == 3:
            if not self.loadInstrumentList( timeout, self.loadStage ):
                return False
            self.loadStage[0] = 4
            if timeout >= 0 and time.time() > timeout: return False

        if self.loadStage[0] == 4:
            if not self.loadToolbar( timeout, self.loadStage ):
                return False
            self.loadStage[0] = 5
            if timeout >= 0 and time.time() > timeout: return False

        if self.loadStage[0] == 5:
            if self.instDic == None:
                self.instDic = {}
                self.loadStage[0] = 5.1
            else:
                self.loadStage[0] = 6

        if self.loadStage[0] == 5.1:
            if not self.loadInstDic( self.instDic, timeout, self.loadStage ):
                return False
            self.loadStage[0] = 6
            if timeout >= 0 and time.time() > timeout: return False

        if self.loadStage[0] == 6:
            self.loadInstrumentViewport()
            self.loadStage[0] = 7
            if timeout >= 0 and time.time() > timeout: return False

        if self.loadStage[0] == 7:
            self.prepareInstrumentTable()
            self.loadStage[0] = 8
            if timeout >= 0 and time.time() > timeout: return False

        self.add(self.mainVBox)
        self.show_all()

        self.loaded = True
        return True

    def loadInstrumentList( self, timeout = -1, loadStage = [0,0,0] ):

        if loadStage[1] == 0:
            self.instrumentList = { "all": [], "all.enterMode": [], "percussions.enterMode": [], "lab": [], "mic": [], "kit": [] }
            for category in Config.CATEGORIES:
                self.instrumentList[category] = []
            loadStage[1] = 1
            if timeout >= 0 and time.time() > timeout: return False

        if loadStage[1] == 1:
            keys = self.instrumentDB.instNamed.keys()
            for i in range(loadStage[2], len(keys)):
                key = keys[i]
                instrument = self.instrumentDB.instNamed[key]
                if key[0:4] != 'drum' and key[0:4] != 'guid' and key[0:3] != 'mic' and key[0:3] != 'lab':
                    self.instrumentList["all"].append( key )
                if key[0:4] != 'drum' and key[0:4] != 'guid' and key[0:3] != 'mic' and key[0:3] != 'lab':
                    self.instrumentList["all.enterMode"].append( key )
                if key[0:4] != 'drum' and key[0:4] != 'guid':
                    self.instrumentList[instrument.category].append( key )
                    if instrument.category == "percussions":
                        self.instrumentList["percussions.enterMode"].append( key )
                if instrument.category == "kit":
                    self.instrumentList["kit"].append( key )
                loadStage[2] += 1
                if timeout >= 0 and time.time() > timeout: return False

            loadStage[1] = 2
            loadStage[2] = 0

        self.instrumentList["mic"].sort()
        self.instrumentList["lab"].sort()

        self.instrumentList["all"] += self.instrumentList["kit"] + self.instrumentList["mic"] + self.instrumentList["lab"]
        self.instrumentList["all.enterMode"] += self.instrumentList["mic"] + self.instrumentList["lab"]
        self.instrumentList["percussions"] += self.instrumentList["kit"]
        self.instrumentList["people"] += self.instrumentList["mic"]
        self.instrumentList["keyboard"] += self.instrumentList["lab"]

        loadStage[1] = 0
        return True

    def loadToolbar( self, timeout = -1, loadStage = [0,0,0] ):
        if loadStage[1] == 0:
            self.loadData["toolbarBox"] = gtk.HBox()
            self.firstTbBtn = None
            self.loadStage[1] = 1
            if timeout >= 0 and time.time() > timeout: return False

        for i in range(loadStage[1]-1, len(Config.CATEGORIES)):
            category = Config.CATEGORIES[i]
            if loadStage[2] == 0:
                self.loadData["btnBox"] = RoundVBox(fillcolor = Config.CATEGORY_BCK_COLOR, bordercolor = Config.PANEL_BCK_COLOR, radius = Config.PANEL_RADIUS)
                self.loadData["btnBox"].set_border_width(Config.PANEL_SPACING)
                loadStage[2] = 1
                if timeout >= 0 and time.time() > timeout: return False

            if loadStage[2] == 1:
                self.loadData["btn"] = ImageRadioButton(self.firstTbBtn,
                        category + '.png', category + 'sel.png',
                        category + 'sel.png')
                loadStage[2] = 2
                if timeout >= 0 and time.time() > timeout: return False

            if self.firstTbBtn == None:
                self.firstTbBtn = self.loadData["btn"]
            self.loadData["btn"].connect('clicked',self.handleToolbarBtnPress,category)
            self.loadData["btnBox"].add(self.loadData["btn"])
            self.loadData["toolbarBox"].pack_start(self.loadData["btnBox"],True,True)

            loadStage[2] = 0
            loadStage[1] += 1
            if timeout >= 0 and time.time() > timeout: return False

        self.mainVBox.pack_start(self.loadData["toolbarBox"],False,False)

        self.loadData.pop("btn")
        self.loadData.pop("btnBox")
        self.loadData.pop("toolbarBox")
        loadStage[1] = 0
        return True

    def loadInstDic( self, instDic, timeout = -1, loadStage = [0,0,0] ):

        if loadStage[1] == 0:
            self.firstInstButton = None
            self.loadData["len"] = len(self.instrumentList['all'])
            loadStage[1] = 1
            if timeout >= 0 and time.time() > timeout: return False


        for i in range( loadStage[1]-1, self.loadData["len"] ):
            instrument = self.instrumentList["all"][i]
            if loadStage[2] == 0:
                self.loadData["instBox"] = RoundVBox(fillcolor = Config.INST_BCK_COLOR, bordercolor = Config.INSTRUMENT_GRID_COLOR, radius = Config.PANEL_RADIUS)
                self.loadData["instBox"].set_border_width(Config.PANEL_SPACING)
                loadStage[2] = 1
                if timeout >= 0 and time.time() > timeout: return False

            if loadStage[2] == 1:
                try:
                    self.loadData["instButton"] = ImageRadioButton(
                            self.firstInstButton, instrument + '.png',
                            instrument + 'sel.png', instrument + 'sel.png')
                except:
                    self.loadData["instButton"] = ImageRadioButton(
                            self.firstInstButton, 'generic.png',
                            'genericsel.png', 'genericsel.png')
                loadStage[2] = 2
                if timeout >= 0 and time.time() > timeout: return False

            if loadStage[2] == 2:
                self.loadData["instButton"].clickedHandler = self.loadData["instButton"].connect('clicked',self.handleInstrumentButtonClick, instrument)
                self.loadData["instButton"].connect('enter',self.handleInstrumentButtonEnter, instrument)
                loadStage[2] = 3
                if timeout >= 0 and time.time() > timeout: return False

            self.loadData["instBox"].pack_start(self.loadData["instButton"],False,False)
            instDic[instrument] = self.loadData["instBox"]
            if self.firstInstButton == None:
                self.firstInstButton = self.loadData["instButton"]
            loadStage[2] = 0
            if timeout >= 0 and time.time() > timeout: return False

            loadStage[1] += 1

        self.loadData.pop("instBox")
        self.loadData.pop("instButton")
        self.loadData.pop("len")
        loadStage[1] = 0
        return True

    def loadInstrumentViewport( self ):
        self.instrumentBox = RoundHBox(fillcolor = Config.INSTRUMENT_GRID_COLOR, bordercolor = Config.PANEL_BCK_COLOR, radius = Config.PANEL_RADIUS)

        self.scrollWin = gtk.ScrolledWindow()
        self.scrollWin.set_policy(gtk.POLICY_NEVER,gtk.POLICY_AUTOMATIC)

        self.tableEventBox = gtk.EventBox()
        color = gtk.gdk.color_parse(Config.INSTRUMENT_GRID_COLOR)
        self.tableEventBox.modify_bg(gtk.STATE_NORMAL, color)

        self.scrollWin.add_with_viewport(self.tableEventBox)
        self.tableEventBox.get_parent().set_shadow_type( gtk.SHADOW_NONE )
        self.instrumentBox.pack_start(self.scrollWin,True,True,0)
        self.mainVBox.pack_start(self.instrumentBox)
        self.show_all()

    def prepareInstrumentTable(self,category = 'all'):

        self.category = category

        if self.enterMode:
            if category == "all": category = "all.enterMode"
            elif category == "percussions": category = "percussions.enterMode"

        if self.instTable != None:
            for child in self.instTable.get_children()[:]:
                self.instTable.remove(child)
            self.tableEventBox.remove(self.instTable)
            self.instTable.destroy()

        instrumentNum = len(self.instrumentList[category])
        instruments = self.instrumentList[category]

        cols = self.rowLen
        if instrumentNum < cols:
            cols = instrumentNum
        rows = (instrumentNum // cols)
        if instrumentNum % cols is not 0:    #S'il y a un reste
            rows = rows + 1

        self.instTable = gtk.Table(rows,cols,True)
        self.instTable.set_row_spacings(0)
        self.instTable.set_col_spacings(0)

        for row in range(rows):
            for col in range(cols):
                if row*cols+col >= instrumentNum:
                    break
                instBox = self.instDic[instruments[row*cols+col]]
                self.instTable.attach(instBox, col, col+1, row, row+1, gtk.SHRINK, gtk.SHRINK, 0, 0)

        self.tableEventBox.add(self.instTable)
        self.instTable.show_all()

    def selectFirstCat(self):
        self.firstTbBtn.set_active(True)

    def handleToolbarBtnPress(self, widget, category):
        if widget.get_active():
            self.prepareInstrumentTable(category)

    def handleInstrumentButtonClick(self,widget,instrument):
        if widget.get_active() is True and self.recstate == False:
            if self.setInstrument:
                widget.event( gtk.gdk.Event( gtk.gdk.LEAVE_NOTIFY )  ) # fake the leave event
                self.setInstrument(instrument)
            if self.playInstrument: self.playInstrument(instrument)
            if self.enterMode:
                pass #Close the window

    def handleInstrumentButtonEnter(self,widget,instrument):
        if self.enterMode and self.playInstrument:
            self.playInstrument(instrument)

    def handleMicRecButtonClick(self,widget,mic):
        self.recstate = False
        self.setInstrument(mic)
        if self.micRec: self.micRec(mic)

    def handleRecButtonPress(self,widget,btn):
        self.recstate = True
        btn.set_active(True)

    def set_activeInstrument(self,instrument, state):
        if len(self.instDic) > 0:
            for key in self.instDic:
                if key == instrument:
                    btn = self.instDic[key].get_children()[0]
                    btn.handler_block(btn.clickedHandler)
                    btn.set_active(state)
                    btn.handler_unblock(btn.clickedHandler)


class DrumPanel( gtk.EventBox ):
    def __init__(self, setDrum = None):
        gtk.EventBox.__init__(self)
        color = gtk.gdk.color_parse(Config.PANEL_BCK_COLOR)
        self.modify_bg(gtk.STATE_NORMAL, color)

        self.setDrum = setDrum
        self.instrumentList = []
        keys = self.instrumentDB.instNamed.keys()
        for key in self.instrumentDB.instNamed.keys():
            if self.instrumentDB.instNamed[key].category == "kit":
                self.instrumentList.append( key )
        self.instrumentList.sort()
        self.drawDrums()

    def drawDrums(self):
        firstBtn = None
        btnBox = RoundHBox(fillcolor = '#6F947B', bordercolor = Config.PANEL_BCK_COLOR, radius = Config.PANEL_RADIUS)
        btnBox.set_border_width(Config.PANEL_SPACING)
        self.drums = {}
        for drumkit in self.instrumentList:
            instBox = RoundVBox(fillcolor = Config.INST_BCK_COLOR, bordercolor = Config.PANEL_COLOR, radius = Config.PANEL_RADIUS)
            instBox.set_border_width(Config.PANEL_SPACING)
            self.drums[drumkit] = ImageRadioButton(firstBtn, drumkit + '.png',
                    drumkit + 'sel.png', drumkit + 'sel.png')
            self.drums[drumkit].clickedHandler = self.drums[drumkit].connect('clicked',self.setDrums,drumkit)
            if firstBtn == None:
                firstBtn = self.drums[drumkit]
            instBox.pack_start(self.drums[drumkit], False, False, 0)
            btnBox.pack_start(instBox, False, False, 0)
        self.add(btnBox)
        self.show_all()

    def setDrums(self,widget,data):
        if widget.get_active():
            if self.setDrum:
                widget.event( gtk.gdk.Event( gtk.gdk.LEAVE_NOTIFY )  ) # fake the leave event
                self.setDrum(data)

    def set_activeInstrument( self, instrument, state ):
        if instrument in self.instrumentList:
            btn = self.drums[instrument]
            btn.handler_block(btn.clickedHandler)
            btn.set_active(state)
            btn.handler_unblock(btn.clickedHandler)

if __name__ == "__main__":
    win = gtk.Window()
    wc = DrumPanel(None)
    win.add(wc)
    win.show()
    #start the gtk event loop
    gtk.main()

"""
Tools for generating forms based on SQLAlchemy models.
"""
from __future__ import unicode_literals

import inspect

from wtforms import fields as f
from wtforms import validators
from wtforms.form import Form
from wtforms.ext.sqlalchemy.fields import QuerySelectField
from wtforms.ext.sqlalchemy.fields import QuerySelectMultipleField
from wtforms.ext.sqlalchemy.validators import Unique

__all__ = (
    'model_fields', 'model_form',
)

def converts(*args):
    def _inner(func):
        func._converter_for = frozenset(args)
        return func
    return _inner

class ModelConverterBase(object):
    def __init__(self, converters, use_mro=True):
        self.use_mro = use_mro

        if not converters:
            converters = {}

        for name in dir(self):
            obj = getattr(self, name)
            if hasattr(obj, '_converter_for'):
                for classname in obj._converter_for:
                    converters[classname] = obj

        self.converters = converters

class ModelConverterBase(object):
    def __init__(self, converters, use_mro=True):
        self.use_mro = use_mro

        if not converters:
            converters = {}

        for name in dir(self):
            obj = getattr(self, name)
            if hasattr(obj, '_converter_for'):
                for classname in obj._converter_for:
                    converters[classname] = obj

        self.converters = converters

    def convert(self, model, mapper, prop, field_args, db_session=None):
        if not hasattr(prop, 'columns') and not hasattr(prop, 'direction'):
            return
        elif not hasattr(prop, 'direction') and len(prop.columns) != 1:
            raise TypeError('Do not know how to convert multiple-column '
                + 'properties currently')

        kwargs = {
            'validators': [],
            'filters': [],
            'default': None,
        }

        converter = None
        column = None

        if not hasattr(prop, 'direction'):
            column = prop.columns[0]
            # Support sqlalchemy.schema.ColumnDefault, so users can benefit
            # from  setting defaults for fields, e.g.:
            #   field = Column(DateTimeField, default=datetime.utcnow)

            default = getattr(column, 'default', None)

            if default is not None:
                # Only actually change default if it has an attribute named
                # 'arg' that's callable.
                callable_default = getattr(default, 'arg', None)

                if callable_default and callable(callable_default):
                    default = callable_default(None)
            kwargs['default'] = default

            if column.nullable:
                kwargs['validators'].append(validators.Optional())
            else:
                kwargs['validators'].append(validators.Required())

            if db_session and column.unique:
                kwargs['validators'].append(Unique(lambda: db_session, model,
                    column))

            if self.use_mro:
                types = inspect.getmro(type(column.type))
            else:
                types = [type(column.type)]

            for col_type in types:
                type_string = '%s.%s' % (col_type.__module__,
                    col_type.__name__)
                if type_string.startswith('sqlalchemy'):
                    type_string = type_string[11:]

                if type_string in self.converters:
                    converter = self.converters[type_string]
                    break
            else:
                for col_type in types:
                    if col_type.__name__ in self.converters:
                        converter = self.converters[col_type.__name__]
                        break
                else:
                    return

        if db_session and hasattr(prop, 'direction'):
            foreign_model = prop.mapper.class_

            nullable = True
            for pair in prop.local_remote_pairs:
                if not pair[0].nullable:
                    nullable = False

            kwargs.update({
                'allow_blank': nullable,
                'query_factory': lambda: db_session.query(foreign_model).all()
            })

            converter = self.converters[prop.direction.name]

        if field_args:
            kwargs.update(field_args)

        return converter(model=model, mapper=mapper, prop=prop, column=column,
            field_args=kwargs)


class ModelConverter(ModelConverterBase):
    def __init__(self, extra_converters=None):
        super(ModelConverter, self).__init__(extra_converters)

    @classmethod
    def _string_common(cls, column, field_args, **extra):
        if column.type.length:
            field_args['validators'].append(validators.Length(max=column.type.length))

    @converts('String', 'Unicode')
    def conv_String(self, field_args, **extra):
        self._string_common(field_args=field_args, **extra)
        return f.TextField(**field_args)

    @converts('Text', 'UnicodeText', 'types.LargeBinary', 'types.Binary')
    def conv_Text(self, field_args, **extra):
        self._string_common(field_args=field_args, **extra)
        return f.TextAreaField(**field_args)

    @converts('Boolean')
    def conv_Boolean(self, field_args, **extra):
        return f.BooleanField(**field_args)

    @converts('Date')
    def conv_Date(self, field_args, **extra):
        return f.DateField(**field_args)

    @converts('DateTime')
    def conv_DateTime(self, field_args, **extra):
        return f.DateTimeField(**field_args)

    @converts('Integer', 'SmallInteger')
    def handle_integer_types(self, column, field_args, **extra):
        unsigned = getattr(column.type, 'unsigned', False)
        if unsigned:
            field_args['validators'].append(validators.NumberRange(min=0))
        return f.IntegerField(**field_args)

    @converts('Numeric', 'Float')
    def handle_decimal_types(self, column, field_args, **extra):
        places = getattr(column.type, 'scale', 2)
        if places is not None:
            field_args['places'] = places
        return f.DecimalField(**field_args)

    @converts('databases.mysql.MSYear')
    def conv_MSYear(self, field_args, **extra):
        field_args['validators'].append(validators.NumberRange(min=1901, max=2155))
        return f.TextField(**field_args)

    @converts('databases.postgres.PGInet', 'dialects.postgresql.base.INET')
    def conv_PGInet(self, field_args, **extra):
        field_args.setdefault('label', 'IP Address')
        field_args['validators'].append(validators.IPAddress())
        return f.TextField(**field_args)

    @converts('dialects.postgresql.base.MACADDR')
    def conv_PGMacaddr(self, field_args, **extra):
        field_args.setdefault('label', 'MAC Address')
        field_args['validators'].append(validators.MacAddress())
        return f.TextField(**field_args)

    @converts('dialects.postgresql.base.UUID')
    def conv_PGUuid(self, field_args, **extra):
        field_args.setdefault('label', 'UUID')
        field_args['validators'].append(validators.UUID())
        return f.TextField(**field_args)

    @converts('MANYTOONE')
    def conv_ManyToOne(self, field_args, **extra):
        return QuerySelectField(**field_args)

    @converts('MANYTOMANY', 'ONETOMANY')
    def conv_ManyToMany(self, field_args, **extra):
        return QuerySelectMultipleField(**field_args)


def model_fields(model, db_session=None, only=None, exclude=None,
    field_args=None, converter=None):
    """
    Generate a dictionary of fields for a given SQLAlchemy model.

    See `model_form` docstring for description of parameters.
    """
    if not hasattr(model, '_sa_class_manager'):
        raise TypeError('model must be a sqlalchemy mapped model')

    mapper = model._sa_class_manager.mapper
    converter = converter or ModelConverter()
    field_args = field_args or {}

    properties = ((p.key, p) for p in mapper.iterate_properties)
    if only:
        properties = (x for x in properties if x[0] in only)
    elif exclude:
        properties = (x for x in properties if x[0] not in exclude)

    field_dict = {}
    for name, prop in properties:
        field = converter.convert(model, mapper, prop,
            field_args.get(name), db_session)
        if field is not None:
            field_dict[name] = field

    return field_dict


def model_form(model, db_session=None, base_class=Form, only=None,
    exclude=None, field_args=None, converter=None, exclude_pk=True,
    exclude_fk=True, type_name=None):
    """
    Create a wtforms Form for a given SQLAlchemy model class::

        from wtalchemy.orm import model_form
        from myapp.models import User
        UserForm = model_form(User)

    :param model:
        A SQLAlchemy mapped model class.
    :param db_session:
        An optional SQLAlchemy Session.
    :param base_class:
        Base form class to extend from. Must be a ``wtforms.Form`` subclass.
    :param only:
        An optional iterable with the property names that should be included in
        the form. Only these properties will have fields.
    :param exclude:
        An optional iterable with the property names that should be excluded
        from the form. All other properties will have fields.
    :param field_args:
        An optional dictionary of field names mapping to keyword arguments used
        to construct each field object.
    :param converter:
        A converter to generate the fields based on the model properties. If
        not set, ``ModelConverter`` is used.
    :param exclude_pk:
        An optional boolean to force primary key exclusion.
    :param exclude_fk:
        An optional boolean to force foreign keys exclusion.
    :param type_name:
        An optional string to set returned type name.
    """
    class ModelForm(base_class):
        """Sets object as form attribute."""
        def __init__(self, *args, **kwargs):
            if 'obj' in kwargs:
                self._obj = kwargs['obj']
            super(ModelForm, self).__init__(*args, **kwargs)

    if not exclude:
        exclude = []
    model_mapper = model.__mapper__
    for prop in model_mapper.iterate_properties:
        if not hasattr(prop, 'direction') and prop.columns[0].primary_key:
            if exclude_pk:
                exclude.append(prop.key)
        if hasattr(prop, 'direction') and  exclude_fk and \
                prop.direction.name != 'MANYTOMANY':
            for pair in prop.local_remote_pairs:
                exclude.append(pair[0].key)
    type_name = type_name or str(model.__name__ + 'Form')
    field_dict = model_fields(model, db_session, only, exclude, field_args,
        converter)
    return type(type_name, (ModelForm, ), field_dict)

#!/usr/bin/env python
import optparse
import subprocess
import signal
import traceback
import sys
import os

from twisted.internet import reactor
from twisted.web      import proxy, server, resource

# Monkey-patch twisted.web.http to avoid request.finish exceptions
# https://trac.zulip.net/ticket/1728
from twisted.web.http import Request
orig_finish = Request.finish
def patched_finish(self):
    if self._disconnected:
        return
    return orig_finish(self)
Request.finish = patched_finish

parser = optparse.OptionParser(r"""

Starts the app listening on localhost, for local development.

This script launches the Django and Tornado servers, then runs a reverse proxy
which serves to both of them.  After it's all up and running, browse to

    http://localhost:9991/

Note that, while runserver and runtornado have the usual auto-restarting
behavior, the reverse proxy itself does *not* automatically restart on changes
to this file.
""")

parser.add_option('--test',
    action='store_true', dest='test',
    help='Use the testing database and ports')

parser.add_option('--interface',
    action='store', dest='interface',
    default='127.0.0.1', help='Set the IP or hostname for the proxy to listen on')

(options, args) = parser.parse_args()

base_port   = 9991
manage_args = ''
if options.test:
    base_port   = 9981
    settings_module = "zproject.test_settings"
else:
    settings_module = "zproject.settings"

manage_args = ['--settings=%s' % (settings_module,)]
os.environ['DJANGO_SETTINGS_MODULE'] = settings_module

sys.path.append(os.path.join(os.path.dirname(__file__), '..'))

proxy_port   = base_port
django_port  = base_port+1
tornado_port = base_port+2

os.chdir(os.path.join(os.path.dirname(__file__), '..'))

# Clean up stale .pyc files etc.
subprocess.check_call('./tools/clean-repo')

# Set up a new process group, so that we can later kill run{server,tornado}
# and all of the processes they spawn.
os.setpgrp()

# Pass --nostatic because we configure static serving ourselves in
# zulip/urls.py.
cmds = [['./tools/compile-handlebars-templates', 'forever'],
        ['python', 'manage.py', 'runserver', '--nostatic'] +
          manage_args + ['localhost:%d' % (django_port,)],
        ['python', 'manage.py', 'runtornado'] +
          manage_args + ['localhost:%d' % (tornado_port,)],
        ['./tools/run-dev-queue-processors'] + manage_args,
        ['env', 'PGHOST=localhost', # Force password authentication using .pgpass
         './puppet/zulip/files/postgresql/process_fts_updates']]

for cmd in cmds:
    subprocess.Popen(cmd)

class Resource(resource.Resource):
    def getChild(self, name, request):
        # Assume an HTTP 1.1 request
        proxy_host = request.requestHeaders.getRawHeaders('Host')
        request.requestHeaders.setRawHeaders('X-Forwarded-Host', proxy_host)

        if (request.uri in ['/json/get_events'] or
            request.uri.startswith('/json/events') or
            request.uri.startswith('/api/v1/events') or
            request.uri.startswith('/sockjs')):
            return proxy.ReverseProxyResource('localhost', tornado_port, '/'+name)

        return proxy.ReverseProxyResource('localhost', django_port, '/'+name)

try:
    reactor.listenTCP(proxy_port, server.Site(Resource()), interface=options.interface)
    reactor.run()
except:
    # Print the traceback before we get SIGTERM and die.
    traceback.print_exc()
    raise
finally:
    # Kill everything in our process group.
    os.killpg(0, signal.SIGTERM)


from muntjac.demo.sampler.ExampleUtil import ExampleUtil

from muntjac.api import VerticalLayout, Table, Label
from muntjac.event.action import Action
from muntjac.event import action
from muntjac.terminal.theme_resource import ThemeResource
from muntjac.ui.table import ICellStyleGenerator
from muntjac.data.property import IValueChangeListener


ACTION_MARK = Action('Mark')
ACTION_UNMARK = Action('Unmark')
ACTION_LOG = Action('Save')
ACTIONS_UNMARKED = [ACTION_MARK, ACTION_LOG]
ACTIONS_MARKED = [ACTION_UNMARK, ACTION_LOG]


# FIXME: "Could not determine column collapsing state"

class TableMainFeaturesExample(VerticalLayout):

    def __init__(self):
        super(TableMainFeaturesExample, self).__init__()

        self._markedRows = set()

        self._table = Table('ISO-3166 Country Codes and flags')
        self.addComponent(self._table)

        # Label to indicate current selection
        selected = Label('No selection')
        self.addComponent(selected)

        # set a style name, so we can style rows and cells
        self._table.setStyleName('iso3166')

        # size
        self._table.setWidth('100%')
        self._table.setHeight('170px')

        # selectable
        self._table.setSelectable(True)
        self._table.setMultiSelect(True)
        # react at once when something is selected
        self._table.setImmediate(True)

        # connect data source
        self._table.setContainerDataSource(ExampleUtil.getISO3166Container())

        # turn on column reordering and collapsing
        self._table.setColumnReorderingAllowed(True)
        self._table.setColumnCollapsingAllowed(True)

        # set column headers
        self._table.setColumnHeaders(['Country', 'Code', 'Icon file'])

        # Icons for column headers
        self._table.setColumnIcon(ExampleUtil.iso3166_PROPERTY_FLAG,
                ThemeResource('../sampler/icons/action_save.gif'))
        self._table.setColumnIcon(ExampleUtil.iso3166_PROPERTY_NAME,
                ThemeResource('../sampler/icons/icon_get_world.gif'))
        self._table.setColumnIcon(ExampleUtil.iso3166_PROPERTY_SHORT,
                ThemeResource('../sampler/icons/page_code.gif'))

        # Column alignment
        self._table.setColumnAlignment(ExampleUtil.iso3166_PROPERTY_SHORT,
                Table.ALIGN_CENTER)

        # Column width
        self._table.setColumnExpandRatio(ExampleUtil.iso3166_PROPERTY_NAME, 1)
        self._table.setColumnWidth(ExampleUtil.iso3166_PROPERTY_SHORT, 70)

        # Collapse one column - the user can make it visible again
        self._table.setColumnCollapsed(ExampleUtil.iso3166_PROPERTY_FLAG, True)

        # show row header w/ icon
        self._table.setRowHeaderMode(Table.ROW_HEADER_MODE_ICON_ONLY)
        self._table.setItemIconPropertyId(ExampleUtil.iso3166_PROPERTY_FLAG)

        # Actions (a.k.a context menu)
        self._table.addActionHandler( TableActionHandler(self) )

        # style generator
        self._table.setCellStyleGenerator( TableStyleGenerator(self) )

        # listen for valueChange, a.k.a 'select' and update the label
        self._table.addListener(TableChangeListener(self, selected),
                IValueChangeListener)


class TableActionHandler(action.IHandler):

    def __init__(self, c):
        self._c = c

    def getActions(self, target, sender):
        if target in self._c._markedRows:
            return ACTIONS_MARKED
        else:
            return ACTIONS_UNMARKED

    def handleAction(self, a, sender, target):
        if ACTION_MARK == a:
            self._c._markedRows.add(target)
            self._c._table.requestRepaint()
        elif ACTION_UNMARK == a:
            self._c._markedRows.remove(target)
            self._c._table.requestRepaint()
        elif ACTION_LOG == a:
            item = self._c._table.getItem(target)
            self._c.addComponent(Label('Saved: ' + target + ', '
                    + item.getItemProperty(
                        ExampleUtil.iso3166_PROPERTY_NAME).getValue()))


class TableStyleGenerator(ICellStyleGenerator):

    def __init__(self, c):
        self._c = c

    def getStyle(self, itemId, propertyId):
        if propertyId is None:
            # no propertyId, styling row
            return 'marked' if itemId in self._c._markedRows else None
        elif ExampleUtil.iso3166_PROPERTY_NAME == propertyId:
            return 'bold'
        else:
            return None  # no style


class TableChangeListener(IValueChangeListener):

    def __init__(self, c, selected):
        self._c = c
        self._selected = selected

    def valueChange(self, event):
        value = event.getProperty().getValue()
        if (None is value) or (len(value) == 0):
            # in multiselect mode, a Set of itemIds is returned,
            self._selected.setValue('No selection')
        else:
            # in singleselect mode the itemId is returned directly
            self._selected.setValue('Selected: %s' %
                    list(self._c._table.getValue()))

# SPDX-License-Identifier: AGPL-3.0-or-later
# lint: pylint
# pylint: disable=missing-function-docstring
"""The XPath engine is a *generic* engine with which it is possible to configure
engines in the settings.

Here is a simple example of a XPath engine configured in the
:ref:`settings engine` section, further read :ref:`engines-dev`.

.. code:: yaml

  - name : bitbucket
    engine : xpath
    paging : True
    search_url : https://bitbucket.org/repo/all/{pageno}?name={query}
    url_xpath : //article[@class="repo-summary"]//a[@class="repo-link"]/@href
    title_xpath : //article[@class="repo-summary"]//a[@class="repo-link"]
    content_xpath : //article[@class="repo-summary"]/p

"""

from urllib.parse import urlencode

from lxml import html
from searx.utils import extract_text, extract_url, eval_xpath, eval_xpath_list
from searx import logger

logger = logger.getChild('XPath engine')

search_url = None
"""
Search URL of the engine. Example::

    https://example.org/?search={query}&page={pageno}{time_range}{safe_search}

Replacements are:

``{query}``:
  Search terms from user.

``{pageno}``:
  Page number if engine supports pagging :py:obj:`paging`

``{lang}``:
  ISO 639-1 language code (en, de, fr ..)

``{time_range}``:
  :py:obj:`URL parameter <time_range_url>` if engine :py:obj:`supports time
  range <time_range_support>`.  The value for the parameter is taken from
  :py:obj:`time_range_map`.

``{safe_search}``:
  Safe-search :py:obj:`URL parameter <safe_search_map>` if engine
  :py:obj:`supports safe-search <safe_search_support>`.  The ``{safe_search}``
  replacement is taken from the :py:obj:`safes_search_map`.  Filter results::

      0: none, 1: moderate, 2:strict

  If not supported, the URL paramter is an empty string.

"""

lang_all='en'
'''Replacement ``{lang}`` in :py:obj:`search_url` if language ``all`` is
selected.
'''

soft_max_redirects = 0
'''Maximum redirects, soft limit. Record an error but don't stop the engine'''

results_xpath = ''
'''XPath selector for the list of result items'''

url_xpath = None
'''XPath selector of result's ``url``.'''

content_xpath = None
'''XPath selector of result's ``content``.'''

title_xpath = None
'''XPath selector of result's ``title``.'''

thumbnail_xpath = False
'''XPath selector of result's ``img_src``.'''

suggestion_xpath = ''
'''XPath selector of result's ``suggestion``.'''

cached_xpath = ''
cached_url = ''

paging = False
'''Engine supports paging [True or False].'''

page_size = 1
'''Number of results on each page.  Only needed if the site requires not a page
number, but an offset.'''

first_page_num = 1
'''Number of the first page (usually 0 or 1).'''

time_range_support = False
'''Engine supports search time range.'''

time_range_url = '&hours={time_range_val}'
'''Time range URL parameter in the in :py:obj:`search_url`.  If no time range is
requested by the user, the URL paramter is an empty string.  The
``{time_range_val}`` replacement is taken from the :py:obj:`time_range_map`.

.. code:: yaml

    time_range_url : '&days={time_range_val}'
'''

time_range_map = {
    'day': 24,
    'week': 24*7,
    'month': 24*30,
    'year': 24*365,
}
'''Maps time range value from user to ``{time_range_val}`` in
:py:obj:`time_range_url`.

.. code:: yaml

    time_range_map:
      day: 1
      week: 7
      month: 30
      year: 365
'''

safe_search_support = False
'''Engine supports safe-search.'''

safe_search_map = {
    0: '&filter=none',
    1: '&filter=moderate',
    2: '&filter=strict'
}
'''Maps safe-search value to ``{safe_search}`` in :py:obj:`search_url`.

.. code:: yaml

    safesearch: true
    safes_search_map:
      0: '&filter=none'
      1: '&filter=moderate'
      2: '&filter=strict'

'''

def request(query, params):
    '''Build request parameters (see :ref:`engine request`).

    '''
    lang = lang_all
    if params['language'] != 'all':
        lang = params['language'][:2]

    time_range = ''
    if params.get('time_range'):
        time_range_val = time_range_map.get(params.get('time_range'))
        time_range = time_range_url.format(time_range_val=time_range_val)

    safe_search = ''
    if params['safesearch']:
        safe_search = safe_search_map[params['safesearch']]

    fargs = {
        'query': urlencode({'q': query})[2:],
        'lang': lang,
        'pageno': (params['pageno'] - 1) * page_size + first_page_num,
        'time_range' : time_range,
        'safe_search' : safe_search,
    }

    params['url'] = search_url.format(**fargs)
    params['soft_max_redirects'] = soft_max_redirects
    logger.debug("query_url --> %s", params['url'])

    return params

def response(resp):
    '''Scrap *results* from the response (see :ref:`engine results`).

    '''
    results = []
    dom = html.fromstring(resp.text)
    is_onion = 'onions' in categories  # pylint: disable=undefined-variable

    if results_xpath:
        for result in eval_xpath_list(dom, results_xpath):

            url = extract_url(eval_xpath_list(result, url_xpath, min_len=1), search_url)
            title = extract_text(eval_xpath_list(result, title_xpath, min_len=1))
            content = extract_text(eval_xpath_list(result, content_xpath, min_len=1))
            tmp_result = {'url': url, 'title': title, 'content': content}

            # add thumbnail if available
            if thumbnail_xpath:
                thumbnail_xpath_result = eval_xpath_list(result, thumbnail_xpath)
                if len(thumbnail_xpath_result) > 0:
                    tmp_result['img_src'] = extract_url(thumbnail_xpath_result, search_url)

            # add alternative cached url if available
            if cached_xpath:
                tmp_result['cached_url'] = (
                    cached_url
                    + extract_text(eval_xpath_list(result, cached_xpath, min_len=1))
                )

            if is_onion:
                tmp_result['is_onion'] = True

            results.append(tmp_result)

    else:
        if cached_xpath:
            for url, title, content, cached in zip(
                (extract_url(x, search_url) for
                 x in eval_xpath_list(dom, url_xpath)),
                map(extract_text, eval_xpath_list(dom, title_xpath)),
                map(extract_text, eval_xpath_list(dom, content_xpath)),
                map(extract_text, eval_xpath_list(dom, cached_xpath))
            ):
                results.append({
                    'url': url,
                    'title': title,
                    'content': content,
                    'cached_url': cached_url + cached, 'is_onion': is_onion
                })
        else:
            for url, title, content in zip(
                (extract_url(x, search_url) for
                 x in eval_xpath_list(dom, url_xpath)),
                map(extract_text, eval_xpath_list(dom, title_xpath)),
                map(extract_text, eval_xpath_list(dom, content_xpath))
            ):
                results.append({
                    'url': url,
                    'title': title,
                    'content': content,
                    'is_onion': is_onion
                })

    if suggestion_xpath:
        for suggestion in eval_xpath(dom, suggestion_xpath):
            results.append({'suggestion': extract_text(suggestion)})

    logger.debug("found %s results", len(results))
    return results

'''
This file tests functions from model.py.
'''
import structcol as sc
from infer_structcol.model import *
from infer_structcol.main import Spectrum, Sample, find_close_indices
import numpy as np
from numpy.testing import assert_equal, assert_approx_equal
from pandas.util.testing import assert_frame_equal
from .test_inference import (ntrajectories, nevents, wavelength_sigma, sigma)

def test_calc_model_spect():
    wavelength = [500]
    sample = Sample(wavelength, 1.5, 1)
    theta = (0.5, 100, 200, 0, 0, 0, 0)
    
    wavelength_ind = find_close_indices(wavelength_sigma, sc.Quantity(wavelength,'nm'))
    sigma_test = sigma[np.array(wavelength_ind)]
    assert_frame_equal(calc_model_spect(sample, theta, (sigma_test, sigma_test), ntrajectories, nevents, 2), 
                       Spectrum(500, reflectance = 0.828595524325, sigma_r = 0.0193369922424, 
                       transmittance =0.171404475675, sigma_t = 0.0193369922424))

def test_calc_resid_spect():
    spect1=Spectrum(500, reflectance = 0.5, transmittance = 0.5, sigma_r = 0.1, 
                    sigma_t = 0.1)
    spect2=Spectrum(500, reflectance = 0.7, sigma_r = 0)
    expected_output = Spectrum(500, reflectance = 0.2, sigma_r = 0.1, 
                               transmittance = np.nan, sigma_t = np.nan)
    assert_frame_equal(calc_resid_spect(spect2, spect1), expected_output)

def test_log_prior():
    theta_range = {'min_phi':0.35, 'max_phi':0.74, 'min_radius':70, 'max_radius': 160, 
               'min_thickness':1, 'max_thickness':1000}

    # Test different conditions with only reflectance or transmittance 
    assert_approx_equal(calc_log_prior((0.5, 100, 100, 0, 1), theta_range), 0)
    assert_approx_equal(calc_log_prior((0.5, 100, 100, 1,-1), theta_range), 0)
    assert_equal(calc_log_prior((0.5, 100, 100, -0.5,1), theta_range), -np.inf)
    assert_equal(calc_log_prior((0.5, 100, 100, 0,1.5), theta_range), -np.inf)
    assert_equal(calc_log_prior((1.0, 100, 100, 1, 1), theta_range), -np.inf)
    assert_equal(calc_log_prior((0.5, 10, 100, 0, 1), theta_range), -np.inf)
    assert_equal(calc_log_prior((0.5, 300, 100, 0, 1), theta_range), -np.inf)
    assert_equal(calc_log_prior((0.5, 100, 100, 0, 1), theta_range), calc_log_prior((0.6, 100, 100, 0, 1), theta_range))
    assert_equal(calc_log_prior((0.5, 100, 1001, 0.5, 0.1), theta_range), -np.inf)
    
    # Tests for when there is both reflectance and transmittance 
    assert_approx_equal(calc_log_prior((0.5, 100, 100, 0, 0, 0, 1), theta_range), 0)
    assert_approx_equal(calc_log_prior((0.5, 100, 100, 0, 0, 1, -1), theta_range), 0)
    assert_equal(calc_log_prior((0.5, 100, 100, -0.5, 1, -0.5, 1), theta_range), -np.inf)
    assert_equal(calc_log_prior((0.5, 100, 100, 0, 1.5, 0, 1.5), theta_range), -np.inf)
    assert_equal(calc_log_prior((1.0, 100, 100, 1, 1, 1, 1), theta_range), -np.inf)
    assert_approx_equal(calc_log_prior((0.5, 10, 100, 0, 0, 0, 1), theta_range), -np.inf)
    assert_approx_equal(calc_log_prior((0.5, 300, 100, 0, 0, 1, -1), theta_range), -np.inf)
    assert_equal(calc_log_prior((0.5, 100, 100, 0, 1, 0, 1), theta_range), calc_log_prior((0.6, 100, 100, 0, 1, 0, 1), theta_range))
    assert_equal(calc_log_prior((0.5, 100, 1001, 0.5, 0.1, 0.1, 0.1), theta_range), -np.inf)
    
def test_likelihood():
    spect1=Spectrum(500, reflectance = 0.5, transmittance = 0.5, sigma_r = 0.1, sigma_t = 0.)
    spect2=Spectrum(500, reflectance = 0.7, transmittance = 0.3, sigma_r = 0., sigma_t = 0.1)
    expected_output = (1 / np.sqrt(2*np.pi*0.01) * np.exp(-2))**2
    assert_approx_equal(calc_likelihood(spect1, spect2), expected_output)

def test_log_posterior():
    wavelength = [500]
    spectrum=Spectrum(wavelength, reflectance = 0.5, sigma_r = 0.1)
    sample = Sample(wavelength, 1.5, 1)
    theta_range = {'min_phi':0.35, 'max_phi':0.74, 'min_radius':70, 'max_radius': 201, 
               'min_thickness':1, 'max_thickness':1000}
    wavelength_ind = find_close_indices(wavelength_sigma, sc.Quantity(wavelength,'nm'))
    sigma_test = sigma[np.array(wavelength_ind)]
    
    # When parameters are within prior range
    theta1 = (0.5, 200, 200, 0, 0)
    post1 = log_posterior(theta1, spectrum, sample, theta_range=theta_range, 
                          sigma=(sigma_test, sigma_test), ntrajectories=ntrajectories, nevents=nevents, seed=2)
    assert_approx_equal(post1, -6.0413752765269875)
    
    # When parameters are not within prior range
    theta2 = (0.3, 200, 200, 0, 0)
    post2 = log_posterior(theta2, spectrum, sample, theta_range=theta_range, 
                          sigma=(sigma_test, sigma_test), ntrajectories=ntrajectories, nevents=nevents, seed=2)
    assert_approx_equal(post2, -1e100)
    

# -*- coding: utf-8 -*-

#   Copyright(c) 2016-2020 Jonas Sjöberg <autonameow@jonasjberg.com>
#   Source repository: https://github.com/jonasjberg/autonameow
#
#   This file is part of autonameow.
#
#   autonameow is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation.
#
#   autonameow is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with autonameow.  If not, see <http://www.gnu.org/licenses/>.

import logging

from core import constants as C
from extractors import ExtractorError
from extractors.text.base import BaseTextExtractor
from util import encoding as enc


log = logging.getLogger(__name__)


class PlainTextExtractor(BaseTextExtractor):
    def _extract_text(self, fileobject):
        return read_entire_text_file(fileobject.abspath)

    @classmethod
    def dependencies_satisfied(cls):
        return True

    @classmethod
    def can_handle(cls, fileobject):
        if fileobject.mime_type != 'text/plain':
            return False

        if fileobject.basename_suffix in C.MARKDOWN_BASENAME_SUFFIXES:
            # Prefer the 'MarkdownTextExtractor' to handle this file.
            from extractors.text.extractor_markdown import MarkdownTextExtractor
            if MarkdownTextExtractor.can_handle(fileobject):
                return False

        return True


def read_entire_text_file(filepath):
    contents = None
    try:
        with open(filepath, 'r', encoding=C.DEFAULT_ENCODING) as fh:
            contents = fh.readlines()
    except FileNotFoundError as e:
        raise ExtractorError(e)
    except UnicodeDecodeError as e:
        log.debug(str(e))
        log.debug(
            'Failed with text encoding %s. Attempting encoding detection.',
            C.DEFAULT_ENCODING
        )
        contents = _read_entire_text_file_autodetect_encoding(filepath)

    if not contents:
        log.debug('Read NOTHING from file "%s"', filepath)
        return ''

    log.debug('Read %s lines from file "%s"', len(contents), filepath)
    text = ''.join(contents)
    return text


def _read_entire_text_file_autodetect_encoding(filepath):
    detected_encoding = enc.detect_encoding(filepath)
    if detected_encoding:
        log.debug('Detected text encoding %s', detected_encoding)
        try:
            with open(filepath, 'r', encoding=detected_encoding) as fh:
                return fh.readlines()
        except (UnicodeDecodeError, ValueError) as e:
            raise ExtractorError(
                'Detected text encoding %s :: {!s}'.format(detected_encoding, e)
            )
    return None

# -*- coding: utf-8 -*-
#
# pyqtgraph documentation build configuration file, created by
# sphinx-quickstart on Fri Nov 18 19:33:12 2011.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.

import sys, os

# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
path = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(path, '..', '..'))
sys.path.insert(0, os.path.join(path, '..', 'extensions'))

# -- General configuration -----------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'

# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode']

# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']

# The suffix of source filenames.
source_suffix = '.rst'

# The encoding of source files.
#source_encoding = 'utf-8-sig'

# The master toctree document.
master_doc = 'index'

# General information about the project.
project = 'pyqtgraph'
copyright = '2011, Luke Campagnola'

# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '0.9.10'
# The full version, including alpha/beta/rc tags.
release = '0.9.10'

# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None

# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'

# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = []

# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None

# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True

# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True

# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False

# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'

# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []


# -- Options for HTML output ---------------------------------------------------

# The theme to use for HTML and HTML Help pages.  See the documentation for
# a list of builtin themes.
html_theme = 'default'

# Theme options are theme-specific and customize the look and feel of a theme
# further.  For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}

# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []

# The name for this set of Sphinx documents.  If None, it defaults to
# "<project> v<release> documentation".
#html_title = None

# A shorter title for the navigation bar.  Default is the same as html_title.
#html_short_title = None

# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None

# The name of an image file (within the static path) to use as favicon of the
# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None

# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']

# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'

# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True

# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}

# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}

# If false, no module index is generated.
#html_domain_indices = True

# If false, no index is generated.
#html_use_index = True

# If true, the index is split into individual pages for each letter.
#html_split_index = False

# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True

# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True

# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True

# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it.  The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''

# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None

# Output file base name for HTML help builder.
htmlhelp_basename = 'pyqtgraphdoc'


# -- Options for LaTeX output --------------------------------------------------

# The paper size ('letter' or 'a4').
#latex_paper_size = 'letter'

# The font size ('10pt', '11pt' or '12pt').
#latex_font_size = '10pt'

# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
  ('index', 'pyqtgraph.tex', 'pyqtgraph Documentation',
   'Luke Campagnola', 'manual'),
]

# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None

# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False

# If true, show page references after internal links.
#latex_show_pagerefs = False

# If true, show URL addresses after external links.
#latex_show_urls = False

# Additional stuff for the LaTeX preamble.
#latex_preamble = ''

# Documents to append as an appendix to all manuals.
#latex_appendices = []

# If false, no module index is generated.
#latex_domain_indices = True


# -- Options for manual page output --------------------------------------------

# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
    ('index', 'pyqtgraph', 'pyqtgraph Documentation',
     ['Luke Campagnola'], 1)
]


# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import os

from pylib import cmd_helper
from pylib import constants

class JavaTestRunner(object):
  """Runs java tests on the host."""

  def __init__(self, options):
    self._package_filter = options.package_filter
    self._runner_filter = options.runner_filter
    self._sdk_version = options.sdk_version
    self._test_filter = options.test_filter
    self._test_suite = options.test_suite

  def SetUp(self):
    pass

  def RunTest(self, _test):
    """Runs junit tests from |self._test_suite|."""
    command = ['java',
               '-jar', os.path.join(constants.GetOutDirectory(), 'lib.java',
                                    '%s.jar' % self._test_suite)]
    if self._test_filter:
      command.extend(['-gtest-filter', self._test_filter])
    if self._package_filter:
      command.extend(['-package-filter', self._package_filter])
    if self._runner_filter:
      command.extend(['-runner-filter', self._runner_filter])
    if self._sdk_version:
      command.extend(['-sdk-version', self._sdk_version])
    return cmd_helper.RunCmd(command)

  def TearDown(self):
    pass


# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.

import os
import shutil
import sys
import uuid

from .. import testloader

from base import Step, StepRunner
from tree import Commit

here = os.path.abspath(os.path.split(__file__)[0])

bsd_license = """W3C 3-clause BSD License

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:

* Redistributions of works must retain the original copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the original copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution.

* Neither the name of the W3C nor the names of its contributors may be
  used to endorse or promote products derived from this work without
  specific prior written permission.


THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
"""


def copy_wpt_tree(tree, dest):
    """Copy the working copy of a Tree to a destination directory.

    :param tree: The Tree to copy.
    :param dest: The destination directory"""
    if os.path.exists(dest):
        assert os.path.isdir(dest)

    shutil.rmtree(dest)
    os.mkdir(dest)

    for tree_path in tree.paths():
        source_path = os.path.join(tree.root, tree_path)
        dest_path = os.path.join(dest, tree_path)

        dest_dir = os.path.split(dest_path)[0]
        if not os.path.isdir(source_path):
            if not os.path.exists(dest_dir):
                os.makedirs(dest_dir)
            shutil.copy2(source_path, dest_path)

    for source, destination in [("testharness_runner.html", ""),
                                ("testharnessreport.js", "resources/")]:
        source_path = os.path.join(here, os.pardir, source)
        dest_path = os.path.join(dest, destination, os.path.split(source)[1])
        shutil.copy2(source_path, dest_path)

    add_license(dest)


def add_license(dest):
    """Write the bsd license string to a LICENSE file.

    :param dest: Directory in which to place the LICENSE file."""
    with open(os.path.join(dest, "LICENSE"), "w") as f:
        f.write(bsd_license)

class UpdateCheckout(Step):
    """Pull changes from upstream into the local sync tree."""

    provides = ["local_branch"]

    def create(self, state):
        sync_tree = state.sync_tree
        state.local_branch = uuid.uuid4().hex
        sync_tree.update(state.sync["remote_url"],
                         state.sync["branch"],
                         state.local_branch)
        sync_path = os.path.abspath(sync_tree.root)
        if not sync_path in sys.path:
            from update import setup_paths
            setup_paths(sync_path)

    def restore(self, state):
        assert os.path.abspath(state.sync_tree.root) in sys.path
        Step.restore(self, state)


class GetSyncTargetCommit(Step):
    """Find the commit that we will sync to."""

    provides = ["sync_commit"]

    def create(self, state):
        if state.target_rev is None:
            #Use upstream branch HEAD as the base commit
            state.sync_commit = state.sync_tree.get_remote_sha1(state.sync["remote_url"],
                                                                state.sync["branch"])
        else:
            state.sync_commit = Commit(state.sync_tree, state.rev)

        state.sync_tree.checkout(state.sync_commit.sha1, state.local_branch, force=True)
        self.logger.debug("New base commit is %s" % state.sync_commit.sha1)


class LoadManifest(Step):
    """Load the test manifest"""

    provides = ["test_manifest"]

    def create(self, state):
        state.test_manifest = testloader.ManifestLoader(state.tests_path).load_manifest(
            state.tests_path, state.metadata_path,
        )


class UpdateManifest(Step):
    """Update the manifest to match the tests in the sync tree checkout"""

    provides = ["initial_rev"]
    def create(self, state):
        from manifest import manifest, update
        test_manifest = state.test_manifest
        state.initial_rev = test_manifest.rev
        update.update(state.sync["path"], "/", test_manifest)
        manifest.write(test_manifest, os.path.join(state.metadata_path, "MANIFEST.json"))


class CopyWorkTree(Step):
    """Copy the sync tree over to the destination in the local tree"""

    def create(self, state):
        copy_wpt_tree(state.sync_tree,
                      state.tests_path)


class CreateSyncPatch(Step):
    """Add the updated test files to a commit/patch in the local tree."""

    def create(self, state):
        if state.no_patch:
            return

        local_tree = state.local_tree
        sync_tree = state.sync_tree

        local_tree.create_patch("web-platform-tests_update_%s" % sync_tree.rev,
                                "Update %s to revision %s" % (state.suite_name, sync_tree.rev))
        local_tree.add_new(os.path.relpath(state.tests_path,
                                           local_tree.root))
        updated = local_tree.update_patch(include=[state.tests_path,
                                                   state.metadata_path])
        local_tree.commit_patch()

        if not updated:
            self.logger.info("Nothing to sync")


class SyncFromUpstreamRunner(StepRunner):
    """(Sub)Runner for doing an upstream sync"""
    steps = [UpdateCheckout,
             GetSyncTargetCommit,
             LoadManifest,
             UpdateManifest,
             CopyWorkTree,
             CreateSyncPatch]

class AlreadyThere(Exception):
    pass


class CantFollowYourself(Exception):
    pass


class DirectedGraph:

    def __init__(self):
        self.nodes = {}

    def add_node(self, node):
        if node in self.nodes.keys():
            raise AlreadyThere
        self.nodes[node] = set()

    def add_edge(self, node_a, node_b):
        if node_a not in self.nodes.keys():
            self.add_node(node_a)
        if node_b not in self.nodes.keys():
            self.add_node(node_b)
        if node_a == node_b:
            raise CantFollowYourself
        self.nodes[node_a].add(node_b)

    def get_neighbours_for(self, node):
        return self.nodes[node]

    def path_between(self, node_a, node_b):
        return self.are_connected(node_a, node_b, self.nodes)

    def edge_between(self, node_a, node_b):
        return node_b in self.nodes[node_a]

    @staticmethod
    def are_connected(start, end, graph):
        visited = set()
        queue = []
        path_to = {}
        queue.append(start)
        visited.add(start)
        path_to[start] = None
        found = False

        while len(queue) != 0:
            current_node = queue.pop(0)
            if current_node == end:
                found = True
                return found

            for neighbour in graph[current_node]:
                if neighbour not in visited:
                    path_to[neighbour] = current_node
                    visited.add(neighbour)
                    queue.append(neighbour)

        return False

#!/usr/bin/env python3

###############################################################################
# Copyright 2018 The Apollo Authors. All Rights Reserved.
#
# 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.
###############################################################################

import copy
import logging
import sys

from google.protobuf.internal import decoder
from google.protobuf.internal import encoder
import google.protobuf.text_format as text_format

from modules.prediction.proto import feature_pb2
from modules.prediction.proto import offline_features_pb2


def readVarint32(stream):
    """
    read block size from file stream
    """
    mask = 0x80  # (1 << 7)
    raw_varint32 = []
    while 1:
        b = stream.read(1)
        if b == "":
            break
        raw_varint32.append(b)
        if not (ord(b) & mask):
            break
    return raw_varint32


def load_protobuf(filename):
    """
    read a file in protobuf binary
    """
    offline_features = offline_features_pb2.Features()
    with open(filename, 'rb') as file_in:
        offline_features.ParseFromString(file_in.read())
    return offline_features.feature


def load_label_feature(filename):
    features = []
    with open(filename, 'rb') as f:
        size = readVarint32(f)
        while size:
            read_bytes, _ = decoder._DecodeVarint32(size, 0)
            data = f.read(read_bytes)
            if len(data) < read_bytes:
                print("Failed to load protobuf")
                break
            fea = feature_pb2.Feature()
            fea.ParseFromString(data)
            features.append(fea)
            size = readVarint32(f)
    return features


def save_protobuf(filename, feature_trajectories):
    """
    save a features in the given filename
    """
    with open(filename, 'wb') as f:
        for features in feature_trajectories:
            for fea in features:
                serializedMessage = fea.SerializeToString()
                delimiter = encoder._VarintBytes(len(serializedMessage))
                f.write(delimiter + serializedMessage)


def build_trajectory(features):
    """
    classify features by id and build trajectories of feature
    """
    fea_dict = dict()
    for fea in features:
        if fea.id in fea_dict.keys():
            fea_dict[fea.id].append(fea)
        else:
            fea_dict[fea.id] = [fea]

    for k in fea_dict.keys():
        if len(fea_dict[k]) < 2:
            del fea_dict[k]
            continue
        fea_dict[k].sort(key=lambda x: x.timestamp)

    return fea_dict

"""Helper functions

Consists of functions to typically be used within templates, but also
available to Controllers. This module is available to both as 'h'.
"""
from genshi.core import Markup
from webhelpers import *
import webhelpers.html.tags as html_tags
from pylons import config, url
from pylons import session
from webhelpers.pylonslib.flash import Flash as _Flash
from joj.utils import constants
from joj.utils import utils as utils


#Flash area for errors
error_flash = _Flash("errors")

# Flash area for success messages
success_flash = _Flash("success")

# Flash area for warning messages
warning_flash = _Flash("warning")


def jsonParseIfNotEmpty(var):
    if var is not None and var != "":
        return 'JSON.parse("%s")' % var
    else:
        return 'null'


def getOpenLayersImportPath():
    return config.get('openlayers_js_path', config['serverurl'] + '/js/OpenLayers.js')


def display_date(date, format):
    """
    Return the date as a string or none if the date isn't set
    :param date: date
    :param format: format for the date
    :return: formatted date or "" if the date isn't set
    """
    if date is None:
        return ""
    return date.strftime(format)


def wrap_helpers(localdict):
    def helper_wrapper(func):
        def wrapped_helper(*args, **kw):
            if not callable(func(*args, **kw)):
                return Markup(func(*args, **kw))
            else:
                return Markup(func(*args, **kw)())
        wrapped_helper.__name__ = func.__name__
        return wrapped_helper
    for name, func in localdict.iteritems():
        if not callable(func) or not func.__module__.startswith('webhelpers.rails'):
            continue
        localdict[name] = helper_wrapper(func)
wrap_helpers(locals())


def get_progress_bar_class_name(storage_percent_used):
    """
    Get the class to use for a storage allocation bar
    :param storage_percent_used: the percentage of storage used
    """
    if storage_percent_used < constants.QUOTA_WARNING_LIMIT_PERCENT:
        return "success"
    elif storage_percent_used < constants.QUOTA_ABSOLUTE_LIMIT_PERCENT:
        return "warning"
    else:
        return "danger"

from struct import Struct, unpack_from
from .. import dataformat
from ..util import dbg, zstr

from .empiresdat import endianness
from . import unit


class Civ(dataformat.Exportable):
    name_struct        = "civilisation"
    name_struct_file   = name_struct
    struct_description = "describes one a civilisation."

    data_format = (
        (dataformat.READ, "enabled", "int8_t"),
        (dataformat.READ_EXPORT, "name", "char[20]"),
        (dataformat.READ, "ressources_count", "uint16_t"),
        (dataformat.READ_EXPORT, "tech_tree_id",  "int16_t"),             #links to tech id (to apply its effects)
        (dataformat.READ_EXPORT, "team_bonus_id", "int16_t"),             #links to tech id as well
        (dataformat.READ, "ressources", "float[ressources_count]"),
        (dataformat.READ, "icon_set", "int8_t"),                          #building icon set, trade cart graphics, changes no other graphics
        (dataformat.READ_EXPORT, "unit_count", "uint16_t"),
        (dataformat.READ, "unit_offsets", "int32_t[unit_count]"),

        (dataformat.READ_EXPORT, "units", dataformat.MultisubtypeMember(
            type_name          = "unit_types",
            subtype_definition = (dataformat.READ, "unit_type", dataformat.EnumLookupMember(
                type_name      = "unit_type_id",
                lookup_dict    = unit.unit_type_lookup,
                raw_type       = "int8_t",
            )),
            class_lookup       = unit.unit_type_class_lookup,
            length             = "unit_count",
            offset_to          = ("unit_offsets", lambda o: o > 0),
        )),
    )

from math import log, sin, acos

print(" 1 - Вычислить функцию G\n " 
" 2 - Вычислить функцию F\n " 
" 3 - Вычислить функцию Y\n " 
" 0 - Выход из программы \n ") 
c = float(input('Значение\n')) 
if c == 0: 
print("До свидания!") 
else: 
a = float(input("Введите а: ")) 
min = float(input("Введите минимальное значение x: ")) 
max = float(input("Введите макимальное значение х: ")) 
step = int(input("Введите число шагов: ")) 
step = int 
step = (max - min) / (step - 1) 

if c == 1: 
while min <= max: 
m = (15*(a**2)+29*a*x+12*(x**2)) 
if m != 0: 
G = (4*(-18*(a**2)+3*a*x+10*(x**2))) / m 
print('Result: {0:.4f}'.format(G)) 
else: 
print("Введите корректное значение ") 
min += step 
elif c == 2: 
while min <= max: 
m =(cos(5*(a**2)+14*a*x-3*(x**2))) 
if m != 0: 
F = 1 / m 
print('Result: {0:.18f}'.format(F)) 
else: 
print("Введите корректное значение") 
min += step 
elif c == 3: 
while min <= max: 
Y = acos(9*(a**2)+42*a*x+40*(x**2)+1) 
print('Result: {0:.4f}'.format(Y)) 
min += step

# Copyright 2014 Cisco Systems, Inc.  All rights reserved.
#
#    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.
import sys

import datetime
import mock
from oslo_utils import uuidutils

sys.modules['ncclient'] = mock.MagicMock()
from networking_cisco.plugins.cisco.cfg_agent import device_status
from neutron.tests import base

import networking_cisco.plugins.cisco.common.cisco_constants as cc
_uuid = uuidutils.generate_uuid

TYPE_STRING = 'string'
TYPE_DATETIME = 'datetime'
NOW = 0
BOOT_TIME = 420
DEAD_TIME = 300
BELOW_BOOT_TIME = 100


def create_timestamp(seconds_from_now, type=TYPE_STRING):
    timedelta = datetime.timedelta(seconds=seconds_from_now)
    past_time = datetime.datetime.utcnow() - timedelta
    if type is TYPE_STRING:
        return past_time.strftime("%Y-%m-%dT%H:%M:%S.%f")
    if type is TYPE_DATETIME:
        return past_time


class TestHostingDevice(base.BaseTestCase):

    def setUp(self):
        super(TestHostingDevice, self).setUp()
        self.status = device_status.DeviceStatus()
        device_status._is_pingable = mock.MagicMock(return_value=True)

        self.hosting_device = {'id': 123,
                               'host_type': 'VM',
                               'management_ip_address': '10.0.0.1',
                               'protcol_port': '22',
                               'booting_time': 420}
        self.created_at_str = datetime.datetime.utcnow().strftime(
            "%Y-%m-%d %H:%M:%S")
        self.hosting_device['created_at'] = self.created_at_str

        # if is_pingable, then hd_state is 'Active'
        self.hosting_device['hd_state'] = cc.HD_ACTIVE
        self.router_id = _uuid()
        self.router = {id: self.router_id,
                       'hosting_device': self.hosting_device}

    def test_hosting_devices_object(self):
        self.assertEqual({}, self.status.hosting_devices_backlog)

    def test_is_hosting_device_reachable_positive(self):
        self.assertTrue(self.status.is_hosting_device_reachable(
            self.hosting_device))

    def test_is_hosting_device_reachable_positive_heartbeat_disabled(self):
        self.status.enable_heartbeat = False
        self.assertTrue(self.status.is_hosting_device_reachable(
            self.hosting_device))
        self.assertEqual(0, len(self.status.get_backlogged_hosting_devices()))

    def test_is_hosting_device_reachable_positive_heartbeat_enabled(self):
        self.status.enable_heartbeat = True
        self.assertTrue(self.status.is_hosting_device_reachable(
            self.hosting_device))
        self.assertEqual(1, len(self.status.get_backlogged_hosting_devices()))
        self.assertTrue(123 in self.status.get_backlogged_hosting_devices())
        self.assertEqual(self.status.hosting_devices_backlog[123]['hd'],
                         self.hosting_device)

    def test_is_hosting_device_reachable_negative(self):
        self.assertEqual(0, len(self.status.hosting_devices_backlog))
        self.hosting_device['created_at'] = self.created_at_str  # Back to str
        device_status._is_pingable.return_value = False
        self.hosting_device['hd_state'] = cc.HD_NOT_RESPONDING

        self.assertFalse(device_status._is_pingable('1.2.3.4'))
        self.assertFalse(self.status.is_hosting_device_reachable(
            self.hosting_device))
        self.assertEqual(1, len(self.status.get_backlogged_hosting_devices()))
        self.assertTrue(123 in self.status.get_backlogged_hosting_devices())
        self.assertEqual(self.status.hosting_devices_backlog[123]['hd'],
                         self.hosting_device)

    def test_is_hosting_device_reachable_negative_heartbeat_disabled(self):
        """
        Even if heartbeat is disabled, unreachable hosting device should
        still be backlogged
        """
        self.status.enable_heartbeat = False

        self.assertEqual(0, len(self.status.hosting_devices_backlog))
        self.hosting_device['created_at'] = self.created_at_str  # Back to str
        device_status._is_pingable.return_value = False
        self.hosting_device['hd_state'] = cc.HD_NOT_RESPONDING

        self.assertFalse(device_status._is_pingable('1.2.3.4'))
        self.assertFalse(self.status.is_hosting_device_reachable(
            self.hosting_device))
        self.assertEqual(1, len(self.status.get_backlogged_hosting_devices()))
        self.assertTrue(123 in self.status.get_backlogged_hosting_devices())
        self.assertEqual(self.status.hosting_devices_backlog[123]['hd'],
                         self.hosting_device)

    def test_test_is_hosting_device_reachable_negative_exisiting_hd(self):
        self.status.hosting_devices_backlog.clear()
        self.status.hosting_devices_backlog[123] = {'hd': self.hosting_device}

        self.assertEqual(1, len(self.status.hosting_devices_backlog))
        self.assertEqual(True, self.status.is_hosting_device_reachable(
            self.hosting_device))
        self.assertEqual(1, len(self.status.get_backlogged_hosting_devices()))
        self.assertTrue(123 in self.status.hosting_devices_backlog.keys())
        self.assertEqual(self.status.hosting_devices_backlog[123]['hd'],
                         self.hosting_device)

    def test_is_hosting_device_reachable_negative_dead_hd(self):
        self.status.hosting_devices_backlog.clear()
        self.hosting_device['hd_state'] = cc.HD_DEAD
        self.status.hosting_devices_backlog = {
            self.hosting_device['id']: {'hd': self.hosting_device}
        }
        self.assertEqual(False, self.status.is_hosting_device_reachable(
            self.hosting_device))
        self.hosting_device['hd_state'] = cc.HD_ACTIVE
        self.status.hosting_devices_backlog.clear()


class TestBacklogHostingDevice(base.BaseTestCase):
    """
    This test class covers test cases pertaining to hosting device backlog
    handling in the DeviceStatus class.  The "backlog" represents a set
    of hosting-devices that should be monitored for liveness and is used
    to retry router update scenarios and for heartbeat / device syncing.
    """

    def setUp(self):
        super(TestBacklogHostingDevice, self).setUp()

        self.status = device_status.DeviceStatus()
        device_status._is_pingable = mock.MagicMock(return_value=True)
        self.can_connect_mock = mock.MagicMock(return_value=True)
        device_status._can_connect = self.can_connect_mock

        self.hosting_device = {'id': 123,
                               'host_type': 'VM',
                               'management_ip_address': '10.0.0.1',
                               'protocol_port': '22',
                               'booting_time': 420}
        self.created_at_str = datetime.datetime.utcnow().strftime(
            "%Y-%m-%d %H:%M:%S")
        self.hosting_device['created_at'] = self.created_at_str

        # if is_pingable, then hd_state is 'Active'
        self.hosting_device['hd_state'] = cc.HD_ACTIVE
        self.router_id = _uuid()
        self.router = {id: self.router_id,
                       'hosting_device': self.hosting_device}

        # mock out drv_mgr
        self.drv_mgr = mock.MagicMock()
        self.drv_mock = mock.MagicMock()
        self.drv_mgr.get_driver_for_hosting_device.return_value = self.drv_mock

    def test_check_backlog_empty(self):

        expected = {'reachable': [],
                    'revived': [],
                    'dead': []}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.can_connect_mock.call_count)

    def test_check_backlog_below_booting_time(self):
        expected = {'reachable': [],
                    'revived': [],
                    'dead': []}

        self.hosting_device['created_at'] = create_timestamp(NOW)
        hd = self.hosting_device
        hd_id = hd['id']
        hd['hd_state'] = cc.HD_NOT_RESPONDING
        self.status.hosting_devices_backlog[hd_id] = {
            'hd': hd,
            'routers': [self.router_id]}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.can_connect_mock.call_count)

        # Simulate 20 seconds before boot time finishes
        self.hosting_device['created_at'] = create_timestamp(BOOT_TIME - 20)
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.can_connect_mock.call_count)

        # Simulate 1 second before boot time
        self.hosting_device['created_at'] = create_timestamp(BOOT_TIME - 1)
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))

    def test_check_backlog_above_booting_time_pingable(self):
        """Test for backlog processing after booting.

        Simulates a hosting device which has passed the created time.
        The device should now be pingable.
        """
        self.hosting_device['created_at'] = create_timestamp(BOOT_TIME + 10)
        hd = self.hosting_device
        hd_id = hd['id']
        device_status._is_pingable.return_value = True
        # assumption in this scenario was that reachability to the
        # hosting-device was unknown
        hd['hd_state'] = cc.HD_NOT_RESPONDING
        self.status.hosting_devices_backlog[hd_id] = {
            'hd': hd,
            'routers': [self.router_id]}
        expected = {'reachable': [hd_id],
                    'revived': [],
                    'dead': []}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.drv_mgr.call_count)

    def test_check_backlog_above_BT_not_pingable_below_deadtime(self):
        """Test for backlog processing in dead time interval.

        This test simulates a hosting device which has passed the created
        time but less than the 'declared dead' time.
        Hosting device is still not pingable.
        """
        hd = self.hosting_device
        hd['created_at'] = create_timestamp(BOOT_TIME + 10)
        #Inserted in backlog now
        hd['backlog_insertion_ts'] = create_timestamp(NOW, type=TYPE_DATETIME)
        hd_id = hd['id']
        device_status._is_pingable.return_value = False
        hd['hd_state'] = cc.HD_NOT_RESPONDING
        self.status.hosting_devices_backlog[hd_id] = {
            'hd': hd,
            'routers': [self.router_id]}
        expected = {'reachable': [],
                    'revived': [],
                    'dead': []}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.can_connect_mock.call_count)

    def test_check_backlog_above_BT_not_pingable_aboveDeadTime(self):
        """Test for backlog processing after dead time interval.

        This test simulates a hosting device which has passed the
        created time but greater than the 'declared dead' time.
        Hosting device is still not pingable.
        """
        hd = self.hosting_device
        hd['created_at'] = create_timestamp(BOOT_TIME + DEAD_TIME + 10)
        #Inserted in backlog 5 seconds after booting time
        hd['backlog_insertion_ts'] = create_timestamp(BOOT_TIME + 5,
                                                      type=TYPE_DATETIME)

        hd_id = hd['id']
        device_status._is_pingable.return_value = False
        hd['hd_state'] = cc.HD_NOT_RESPONDING
        self.status.hosting_devices_backlog[hd_id] = {
            'hd': hd,
            'routers': [self.router_id]}
        expected = {'reachable': [],
                    'revived': [],
                    'dead': [hd_id]}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.can_connect_mock.call_count)
        post_hd_state = (
            self.status.hosting_devices_backlog[hd_id]['hd']['hd_state'])
        self.assertEqual(cc.HD_DEAD, post_hd_state)

    def test_check_backlog_above_BT_revived_hosting_device(self):
        """
        Test reviving a hosting device after it's been deemed dead

        This test simulates a hosting device which has died is now
        reachable again.
        """
        hd = self.hosting_device
        hd['created_at'] = create_timestamp(BOOT_TIME + DEAD_TIME + 10)
        hd['backlog_insertion_ts'] = create_timestamp(BOOT_TIME + 5,
                                                      type=TYPE_DATETIME)
        hd_id = hd['id']
        device_status._is_pingable.return_value = False
        hd['hd_state'] = cc.HD_NOT_RESPONDING
        self.status.hosting_devices_backlog[hd_id] = {
            'hd': hd,
            'routers': [self.router_id]}
        expected = {'reachable': [],
                    'revived': [],
                    'dead': [hd_id]}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.can_connect_mock.call_count)

        post_hd_state = (
            self.status.hosting_devices_backlog[hd_id]['hd']['hd_state'])
        self.assertEqual(cc.HD_DEAD, post_hd_state)

        # now simulate that the hosting device is resurrected
        self.assertEqual(1, len(self.status.get_backlogged_hosting_devices()))
        device_status._is_pingable.return_value = True

        expected = {'reachable': [],
                    'revived': [hd_id],
                    'dead': []}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(1, self.can_connect_mock.call_count)

        post_hd_state = (
            self.status.hosting_devices_backlog[hd_id]['hd']['hd_state'])
        self.assertEqual(cc.HD_ACTIVE, post_hd_state)

    def test_check_backlog_above_BT_reachable_hosting_device(self):
        """
        Test reviving a hosting device after it's been deemed
        unresponsive and then becomes pingable before it's deemed
        dead.
        """
        hd = self.hosting_device
        hd['created_at'] = create_timestamp(BOOT_TIME + DEAD_TIME + 10)
        hd['backlog_insertion_ts'] = create_timestamp(BOOT_TIME + 5,
                                                      type=TYPE_DATETIME)
        hd_id = hd['id']
        device_status._is_pingable.return_value = True
        hd['hd_state'] = cc.HD_NOT_RESPONDING
        self.status.hosting_devices_backlog[hd_id] = {
            'hd': hd,
            'routers': [self.router_id]}

        expected = {'reachable': [hd_id],
                    'revived': [],
                    'dead': []}
        self.assertEqual(
            expected,
            self.status.check_backlogged_hosting_devices(self.drv_mgr))
        self.assertEqual(0, self.can_connect_mock.call_count)

        post_hd_state = (
            self.status.hosting_devices_backlog[hd_id]['hd']['hd_state'])
        self.assertEqual(cc.HD_ACTIVE, post_hd_state)

# -*- coding: utf-8 -*-
#
# test_rate_instantaneous_and_delayed.py
#
# This file is part of NEST.
#
# Copyright (C) 2004 The NEST Initiative
#
# NEST is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 2 of the License, or
# (at your option) any later version.
#
# NEST is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with NEST.  If not, see <http://www.gnu.org/licenses/>.

import nest
import unittest
import numpy as np


@nest.ll_api.check_stack
class RateInstantaneousAndDelayedTestCase(unittest.TestCase):

    '''
    Test whether delayed rate connections have same properties as
    instantaneous connections but with the correct delay
    '''

    def test_rate_instantaneous_and_delayed(self):

        # neuron parameters
        neuron_params = {'tau': 5., 'sigma': 0.}
        drive = 1.5
        delay = 2.
        weight = 0.5

        # simulation parameters
        simtime = 100.
        dt = 0.001

        nest.set_verbosity('M_WARNING')
        nest.ResetKernel()
        nest.SetKernelStatus(
            {'resolution': dt, 'use_wfr': True, 'print_time': False})

        # set up rate neuron network
        rate_neuron_drive = nest.Create(
            'lin_rate_ipn', params={'mu': drive, 'sigma': 0.})

        rate_neuron_1 = nest.Create(
            'lin_rate_ipn', params=neuron_params)
        rate_neuron_2 = nest.Create(
            'lin_rate_ipn', params=neuron_params)

        multimeter = nest.Create(
            'multimeter', params={
                'record_from': ['rate'],
                'interval': dt})

        # record rates and connect neurons
        neurons = rate_neuron_1 + rate_neuron_2

        nest.Connect(
            multimeter, neurons, 'all_to_all', {'delay': 10.})

        nest.Connect(rate_neuron_drive, rate_neuron_1,
                     'all_to_all',
                     {'synapse_model': 'rate_connection_instantaneous',
                      'weight': weight})

        nest.Connect(rate_neuron_drive, rate_neuron_2,
                     'all_to_all', {'synapse_model': 'rate_connection_delayed',
                                    'delay': delay,
                                    'weight': weight})

        # simulate
        nest.Simulate(simtime)

        # make sure shifted rates are identical
        events = nest.GetStatus(multimeter)[0]['events']
        senders = events['senders']

        rate_1 = np.array(events['rate'][
            np.where(senders == rate_neuron_1.get('global_id'))])
        times_2 = np.array(events['times'][
            np.where(senders == rate_neuron_2.get('global_id'))])
        rate_2 = np.array(events['rate'][
            np.where(senders == rate_neuron_2.get('global_id'))])

        # get shifted rate_2
        rate_2 = rate_2[times_2 > delay]
        # adjust length of rate_1 to be able to substract
        rate_1 = rate_1[:len(rate_2)]

        assert(np.sum(np.abs(rate_2 - rate_1)) < 1e-12)


def suite():

    # makeSuite is sort of obsolete http://bugs.python.org/issue2721
    # using loadTestsFromTestCase instead.
    suite1 = unittest.TestLoader().loadTestsFromTestCase(
        RateInstantaneousAndDelayedTestCase)
    return unittest.TestSuite([suite1])


def run():
    runner = unittest.TextTestRunner(verbosity=2)
    runner.run(suite())


if __name__ == '__main__':
    run()

# coding: utf-8
from __future__ import unicode_literals

from django.test import TestCase


class URLHandling(TestCase):
    """
    Tests for URL handling in views and responses.
    """
    urls = 'view_tests.generic_urls'
    redirect_target = "/%E4%B8%AD%E6%96%87/target/"

    def test_combining_redirect(self):
        """
        Tests that redirecting to an IRI, requiring encoding before we use it
        in an HTTP response, is handled correctly. In this case the arg to
        HttpRedirect is ASCII but the current request path contains non-ASCII
        characters so this test ensures the creation of the full path with a
        base non-ASCII part is handled correctly.
        """
        response = self.client.get('/中文/')
        self.assertRedirects(response, self.redirect_target)

    def test_nonascii_redirect(self):
        """
        Tests that a non-ASCII argument to HttpRedirect is handled properly.
        """
        response = self.client.get('/nonascii_redirect/')
        self.assertRedirects(response, self.redirect_target)

    def test_permanent_nonascii_redirect(self):
        """
        Tests that a non-ASCII argument to HttpPermanentRedirect is handled
        properly.
        """
        response = self.client.get('/permanent_nonascii_redirect/')
        self.assertRedirects(response, self.redirect_target, status_code=301)


# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for tensorflow.ops.argmax_op."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import numpy as np

from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.ops import gradients_impl
from tensorflow.python.ops import math_ops
from tensorflow.python.platform import test


class GradientCorrectnessTest(test.TestCase):

  def testMultipleOutputChainedGradients(self):
    with self.test_session() as sess:
      x = constant_op.constant(1.0, dtype=dtypes.float32)
      yexp = math_ops.exp(x)
      yexplog = math_ops.log(yexp)
      grads = gradients_impl.gradients([yexp, yexplog], [x])
      grad_vals = sess.run(grads)
      exp1_plus_one = (1.0 + np.exp(1.0)).astype(np.float32)
      # [dexp(x)/dx + d(log(exp(x)))/dx] @ x=1 == exp(1) + 1
      self.assertAllClose(grad_vals[0], exp1_plus_one)


if __name__ == '__main__':
  test.main()

# Copyright (c) 2011, Willow Garage, Inc.
# All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# 
#     * Redistributions of source code must retain the above copyright
#       notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above copyright
#       notice, this list of conditions and the following disclaimer in the
#       documentation and/or other materials provided with the distribution.
#     * Neither the name of the Willow Garage, Inc. nor the names of its
#       contributors may be used to endorse or promote products derived from
#       this software without specific prior written permission.
# 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.

# Author Ken Conley/kwc@willowgarage.com

import os
import traceback
from mock import Mock, patch

def get_test_dir():
    return os.path.abspath(os.path.join(os.path.dirname(__file__), 'pip'))

def test_pip_detect():
    from rosdep2.platforms.pip import pip_detect
    
    m = Mock()

    # test behavior with empty freeze
    m.return_value = ''
    val = pip_detect([], exec_fn=m)
    assert val == [], val

    val = pip_detect(['paramiko'], exec_fn=m)
    assert val == [], val

    # read freeze output into mock exec_fn
    with open(os.path.join(get_test_dir(), 'freeze_output'), 'r') as f:
        m.return_value = f.read()
    val = pip_detect(['paramiko'], exec_fn=m)
    assert val == ['paramiko'], val

    val = pip_detect(['paramiko', 'fakito', 'pycrypto'], exec_fn=m)
    assert val == ['paramiko', 'pycrypto'], val


def test_PipInstaller_get_depends():
    # make sure PipInstaller supports depends
    from rosdep2.platforms.pip import PipInstaller
    installer = PipInstaller()
    assert ['foo'] == installer.get_depends(dict(depends=['foo']))
    
def test_PipInstaller():
    from rosdep2 import InstallFailed
    from rosdep2.platforms.pip import PipInstaller

    @patch('rosdep2.platforms.pip.is_pip_installed')
    def test_no_pip(mock_method):
        mock_method.return_value = False
        try:
            installer = PipInstaller()
            installer.get_install_command(['whatever'])
            assert False, "should have raised"
        except InstallFailed: pass
    
    test_no_pip()
    
    @patch('rosdep2.platforms.pip.is_pip_installed')
    @patch.object(PipInstaller, 'get_packages_to_install')
    def test(mock_method, mock_is_pip_installed):
        mock_is_pip_installed.return_value = True
        installer = PipInstaller()
        mock_method.return_value = []
        assert [] == installer.get_install_command(['fake'])

        # no interactive option with PIP
        mock_method.return_value = ['a', 'b']
        expected = [['sudo', '-H', 'pip', 'install', '-U', 'a'],
                    ['sudo', '-H', 'pip', 'install', '-U', 'b']]
        val = installer.get_install_command(['whatever'], interactive=False)
        assert val == expected, val
        expected = [['sudo', '-H', 'pip', 'install', '-U', 'a'],
                    ['sudo', '-H', 'pip', 'install', '-U', 'b']]
        val = installer.get_install_command(['whatever'], interactive=True)
        assert val == expected, val
    try:
        test()
    except AssertionError:
        traceback.print_exc()
        raise
    

#!/usr/bin/python
#
# Copyright 2014 Google Inc. All Rights Reserved.
#
# 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.

"""This code example updates a single placement to allow for AdSense targeting.

To determine which placements exist, run get_all_placements.py.
"""

__author__ = ('Nicholas Chen',
              'Joseph DiLallo')

# Import appropriate modules from the client library.
from googleads import dfp

PLACEMENT_ID = 'INSERT_PLACEMENT_ID_HERE'


def main(client, placement_id):
  # Initialize appropriate service.
  placement_service = client.GetService('PlacementService', version='v201408')
# Create query.
  values = [{
      'key': 'placementId',
      'value': {
          'xsi_type': 'NumberValue',
          'value': placement_id
      }
  }]
  query = 'WHERE id = :placementId'
  statement = dfp.FilterStatement(query, values, 1)

  # Get placements by statement.
  placements = placement_service.getPlacementsByStatement(
      statement.ToStatement())

  for placement in placements:
    if not placement['targetingDescription']:
      placement['targetingDescription'] = 'Generic description'
    placement['targetingAdLocation'] = 'All images on sports pages.'
    placement['targetingSiteName'] = 'http://code.google.com'
    placement['isAdSenseTargetingEnabled'] = 'true'

  # Update placements remotely.
  placements = placement_service.updatePlacements(placements)

  for placement in placements:
    print ('Placement with id \'%s\', name \'%s\', and AdSense targeting '
           'enabled \'%s\' was updated.'
           % (placement['id'], placement['name'],
              placement['isAdSenseTargetingEnabled']))

if __name__ == '__main__':
  # Initialize client object.
  dfp_client = dfp.DfpClient.LoadFromStorage()
  main(dfp_client, PLACEMENT_ID)

"""Generate and work with PEP 425 Compatibility Tags."""

import distutils.util
import platform
import sys
import os
import sysconfig
import warnings

from .macosx_libfile import extract_macosx_min_system_version


try:
    from importlib.machinery import all_suffixes as get_all_suffixes
except ImportError:
    from imp import get_suffixes

    def get_all_suffixes():
        return [suffix[0] for suffix in get_suffixes()]


def get_config_var(var):
    try:
        return sysconfig.get_config_var(var)
    except IOError as e:  # pip Issue #1074
        warnings.warn("{0}".format(e), RuntimeWarning)
        return None


def get_abbr_impl():
    """Return abbreviated implementation name."""
    impl = platform.python_implementation()
    if impl == 'PyPy':
        return 'pp'
    elif impl == 'Jython':
        return 'jy'
    elif impl == 'IronPython':
        return 'ip'
    elif impl == 'CPython':
        return 'cp'

    raise LookupError('Unknown Python implementation: ' + impl)


def get_impl_ver():
    """Return implementation version."""
    impl_ver = get_config_var("py_version_nodot")
    if not impl_ver:
        impl_ver = ''.join(map(str, get_impl_version_info()))
    return impl_ver


def get_impl_version_info():
    """Return sys.version_info-like tuple for use in decrementing the minor
    version."""
    return sys.version_info[0], sys.version_info[1]


def get_flag(var, fallback, expected=True, warn=True):
    """Use a fallback method for determining SOABI flags if the needed config
    var is unset or unavailable."""
    val = get_config_var(var)
    if val is None:
        if warn:
            warnings.warn("Config variable '{0}' is unset, Python ABI tag may "
                          "be incorrect".format(var), RuntimeWarning, 2)
        return fallback()
    return val == expected


def get_abi_tag():
    """Return the ABI tag based on SOABI (if available) or emulate SOABI
    (CPython 2, PyPy)."""
    soabi = get_config_var('SOABI')
    impl = get_abbr_impl()
    if not soabi and impl in ('cp', 'pp') and hasattr(sys, 'maxunicode'):
        d = ''
        m = ''
        u = ''
        if get_flag('Py_DEBUG',
                    lambda: hasattr(sys, 'gettotalrefcount'),
                    warn=(impl == 'cp')):
            d = 'd'
        if get_flag('WITH_PYMALLOC',
                    lambda: impl == 'cp',
                    warn=(impl == 'cp' and
                          sys.version_info < (3, 8))) \
                and sys.version_info < (3, 8):
            m = 'm'
        if get_flag('Py_UNICODE_SIZE',
                    lambda: sys.maxunicode == 0x10ffff,
                    expected=4,
                    warn=(impl == 'cp' and
                          sys.version_info < (3, 3))) \
                and sys.version_info < (3, 3):
            u = 'u'
        abi = '%s%s%s%s%s' % (impl, get_impl_ver(), d, m, u)
    elif soabi and soabi.startswith('cpython-'):
        abi = 'cp' + soabi.split('-')[1]
    elif soabi:
        abi = soabi.replace('.', '_').replace('-', '_')
    else:
        abi = None
    return abi


def calculate_macosx_platform_tag(archive_root, platform_tag):
    """
    Calculate proper macosx platform tag basing on files which are included to wheel

    Example platform tag `macosx-10.14-x86_64`
    """
    prefix, base_version, suffix = platform_tag.split('-')
    base_version = tuple([int(x) for x in base_version.split(".")])
    if len(base_version) >= 2:
        base_version = base_version[0:2]

    assert len(base_version) == 2
    if "MACOSX_DEPLOYMENT_TARGET" in os.environ:
        deploy_target = tuple([int(x) for x in os.environ[
            "MACOSX_DEPLOYMENT_TARGET"].split(".")])
        if len(deploy_target) >= 2:
            deploy_target = deploy_target[0:2]
        if deploy_target < base_version:
            sys.stderr.write(
                 "[WARNING] MACOSX_DEPLOYMENT_TARGET is set to a lower value ({}) than the "
                 "version on which the Python interpreter was compiled ({}), and will be "
                 "ignored.\n".format('.'.join(str(x) for x in deploy_target),
                                     '.'.join(str(x) for x in base_version))
                )
        else:
            base_version = deploy_target

    assert len(base_version) == 2
    start_version = base_version
    versions_dict = {}
    for (dirpath, dirnames, filenames) in os.walk(archive_root):
        for filename in filenames:
            if filename.endswith('.dylib') or filename.endswith('.so'):
                lib_path = os.path.join(dirpath, filename)
                min_ver = extract_macosx_min_system_version(lib_path)
                if min_ver is not None:
                    versions_dict[lib_path] = min_ver[0:2]

    if len(versions_dict) > 0:
        base_version = max(base_version, max(versions_dict.values()))

    # macosx platform tag do not support minor bugfix release
    fin_base_version = "_".join([str(x) for x in base_version])
    if start_version < base_version:
        problematic_files = [k for k, v in versions_dict.items() if v > start_version]
        problematic_files = "\n".join(problematic_files)
        if len(problematic_files) == 1:
            files_form = "this file"
        else:
            files_form = "these files"
        error_message = \
            "[WARNING] This wheel needs a higher macOS version than {}  " \
            "To silence this warning, set MACOSX_DEPLOYMENT_TARGET to at least " +\
            fin_base_version + " or recreate " + files_form + " with lower " \
            "MACOSX_DEPLOYMENT_TARGET:  \n" + problematic_files

        if "MACOSX_DEPLOYMENT_TARGET" in os.environ:
            error_message = error_message.format("is set in MACOSX_DEPLOYMENT_TARGET variable.")
        else:
            error_message = error_message.format(
                "the version your Python interpreter is compiled against.")

        sys.stderr.write(error_message)

    platform_tag = prefix + "_" + fin_base_version + "_" + suffix
    return platform_tag


def get_platform(archive_root):
    """Return our platform name 'win32', 'linux_x86_64'"""
    # XXX remove distutils dependency
    result = distutils.util.get_platform()
    if result.startswith("macosx") and archive_root is not None:
        result = calculate_macosx_platform_tag(archive_root, result)
    result = result.replace('.', '_').replace('-', '_')
    if result == "linux_x86_64" and sys.maxsize == 2147483647:
        # pip pull request #3497
        result = "linux_i686"

    return result


def get_supported(archive_root, versions=None, supplied_platform=None):
    """Return a list of supported tags for each version specified in
    `versions`.

    :param versions: a list of string versions, of the form ["33", "32"],
        or None. The first version will be assumed to support our ABI.
    """
    supported = []

    # Versions must be given with respect to the preference
    if versions is None:
        versions = []
        version_info = get_impl_version_info()
        major = version_info[:-1]
        # Support all previous minor Python versions.
        for minor in range(version_info[-1], -1, -1):
            versions.append(''.join(map(str, major + (minor,))))

    impl = get_abbr_impl()

    abis = []

    abi = get_abi_tag()
    if abi:
        abis[0:0] = [abi]

    abi3s = set()
    for suffix in get_all_suffixes():
        if suffix.startswith('.abi'):
            abi3s.add(suffix.split('.', 2)[1])

    abis.extend(sorted(list(abi3s)))

    abis.append('none')

    platforms = []
    if supplied_platform:
        platforms.append(supplied_platform)
    platforms.append(get_platform(archive_root))

    # Current version, current API (built specifically for our Python):
    for abi in abis:
        for arch in platforms:
            supported.append(('%s%s' % (impl, versions[0]), abi, arch))

    # abi3 modules compatible with older version of Python
    for version in versions[1:]:
        # abi3 was introduced in Python 3.2
        if version in ('31', '30'):
            break
        for abi in abi3s:   # empty set if not Python 3
            for arch in platforms:
                supported.append(("%s%s" % (impl, version), abi, arch))

    # No abi / arch, but requires our implementation:
    for i, version in enumerate(versions):
        supported.append(('%s%s' % (impl, version), 'none', 'any'))
        if i == 0:
            # Tagged specifically as being cross-version compatible
            # (with just the major version specified)
            supported.append(('%s%s' % (impl, versions[0][0]), 'none', 'any'))

    # Major Python version + platform; e.g. binaries not using the Python API
    for arch in platforms:
        supported.append(('py%s' % (versions[0][0]), 'none', arch))

    # No abi / arch, generic Python
    for i, version in enumerate(versions):
        supported.append(('py%s' % (version,), 'none', 'any'))
        if i == 0:
            supported.append(('py%s' % (version[0]), 'none', 'any'))

    return supported

# The plot server must be running
# Go to http://localhost:5006/bokeh to view this plot

from __future__ import division

import numpy as np

from bokeh.plotting import figure, show, output_server, vplot

def streamlines(x, y, u, v, density=1):
    '''Returns streamlines of a vector flow.

    * x and y are 1d arrays defining an *evenly spaced* grid.
    * u and v are 2d arrays (shape [y,x]) giving velocities.
    * density controls the closeness of the streamlines. For different
      densities in each direction, use a tuple or list [densityx, densityy].

     '''

    ## Set up some constants - size of the grid used.
    NGX = len(x)
    NGY = len(y)

    ## Constants used to convert between grid index coords and user coords.
    DX = x[1]-x[0]
    DY = y[1]-y[0]
    XOFF = x[0]
    YOFF = y[0]

    ## Now rescale velocity onto axes-coordinates
    u = u / (x[-1]-x[0])
    v = v / (y[-1]-y[0])
    speed = np.sqrt(u*u+v*v)
    ## s (path length) will now be in axes-coordinates, but we must
    ## rescale u for integrations.
    u *= NGX
    v *= NGY
    ## Now u and v in grid-coordinates.

    NBX = int(30*density)
    NBY = int(30*density)
    blank = np.zeros((NBY,NBX))

    bx_spacing = NGX/float(NBX-1)
    by_spacing = NGY/float(NBY-1)

    def blank_pos(xi, yi):
        return int((xi / bx_spacing) + 0.5), \
               int((yi / by_spacing) + 0.5)

    def value_at(a, xi, yi):
        if type(xi) == np.ndarray:
            x = xi.astype(np.int)
            y = yi.astype(np.int)
        else:
            x = np.int(xi)
            y = np.int(yi)
        a00 = a[y,x]
        a01 = a[y,x+1]
        a10 = a[y+1,x]
        a11 = a[y+1,x+1]
        xt = xi - x
        yt = yi - y
        a0 = a00*(1-xt) + a01*xt
        a1 = a10*(1-xt) + a11*xt
        return a0*(1-yt) + a1*yt

    def rk4_integrate(x0, y0):
        ## This function does RK4 forward and back trajectories from
        ## the initial conditions, with the odd 'blank array'
        ## termination conditions. TODO tidy the integration loops.

        def f(xi, yi):
            dt_ds = 1./value_at(speed, xi, yi)
            ui = value_at(u, xi, yi)
            vi = value_at(v, xi, yi)
            return ui*dt_ds, vi*dt_ds

        def g(xi, yi):
            dt_ds = 1./value_at(speed, xi, yi)
            ui = value_at(u, xi, yi)
            vi = value_at(v, xi, yi)
            return -ui*dt_ds, -vi*dt_ds

        check = lambda xi, yi: xi>=0 and xi<NGX-1 and yi>=0 and yi<NGY-1

        bx_changes = []
        by_changes = []

        ## Integrator function
        def rk4(x0, y0, f):
            ds = 0.01 #min(1./NGX, 1./NGY, 0.01)
            stotal = 0
            xi = x0
            yi = y0
            xb, yb = blank_pos(xi, yi)
            xf_traj = []
            yf_traj = []
            while check(xi, yi):
                # Time step. First save the point.
                xf_traj.append(xi)
                yf_traj.append(yi)
                # Next, advance one using RK4
                try:
                    k1x, k1y = f(xi, yi)
                    k2x, k2y = f(xi + .5*ds*k1x, yi + .5*ds*k1y)
                    k3x, k3y = f(xi + .5*ds*k2x, yi + .5*ds*k2y)
                    k4x, k4y = f(xi + ds*k3x, yi + ds*k3y)
                except IndexError:
                    # Out of the domain on one of the intermediate steps
                    break
                xi += ds*(k1x+2*k2x+2*k3x+k4x) / 6.
                yi += ds*(k1y+2*k2y+2*k3y+k4y) / 6.
                # Final position might be out of the domain
                if not check(xi, yi): break
                stotal += ds
                # Next, if s gets to thres, check blank.
                new_xb, new_yb = blank_pos(xi, yi)
                if new_xb != xb or new_yb != yb:
                    # New square, so check and colour. Quit if required.
                    if blank[new_yb,new_xb] == 0:
                        blank[new_yb,new_xb] = 1
                        bx_changes.append(new_xb)
                        by_changes.append(new_yb)
                        xb = new_xb
                        yb = new_yb
                    else:
                        break
                if stotal > 2:
                    break
            return stotal, xf_traj, yf_traj

        integrator = rk4

        sf, xf_traj, yf_traj = integrator(x0, y0, f)
        sb, xb_traj, yb_traj = integrator(x0, y0, g)
        stotal = sf + sb
        x_traj = xb_traj[::-1] + xf_traj[1:]
        y_traj = yb_traj[::-1] + yf_traj[1:]

        ## Tests to check length of traj. Remember, s in units of axes.
        if len(x_traj) < 1: return None
        if stotal > .2:
            initxb, inityb = blank_pos(x0, y0)
            blank[inityb, initxb] = 1
            return x_traj, y_traj
        else:
            for xb, yb in zip(bx_changes, by_changes):
                blank[yb, xb] = 0
            return None

    ## A quick function for integrating trajectories if blank==0.
    trajectories = []
    def traj(xb, yb):
        if xb < 0 or xb >= NBX or yb < 0 or yb >= NBY:
            return
        if blank[yb, xb] == 0:
            t = rk4_integrate(xb*bx_spacing, yb*by_spacing)
            if t != None:
                trajectories.append(t)

    ## Now we build up the trajectory set. I've found it best to look
    ## for blank==0 along the edges first, and work inwards.
    for indent in range((max(NBX,NBY))//2):
        for xi in range(max(NBX,NBY)-2*indent):
            traj(xi+indent, indent)
            traj(xi+indent, NBY-1-indent)
            traj(indent, xi+indent)
            traj(NBX-1-indent, xi+indent)

    xs = [np.array(t[0])*DX+XOFF for t in trajectories]
    ys = [np.array(t[1])*DY+YOFF for t in trajectories]

    return xs, ys

xx = np.linspace(-3, 3, 100)
yy = np.linspace(-3, 3, 100)

Y, X = np.meshgrid(xx, yy)
U = -1 - X**2 + Y
V = 1 + X - Y**2
speed = np.sqrt(U*U + V*V)
theta = np.arctan(V/U)

x0 = X[::2, ::2].flatten()
y0 = Y[::2, ::2].flatten()
length = speed[::2, ::2].flatten()/40
angle = theta[::2, ::2].flatten()
x1 = x0 + length * np.cos(angle)
y1 = y0 + length * np.sin(angle)

xs, ys = streamlines(xx, yy, U.T, V.T, density=2)

cm = np.array(["#C7E9B4", "#7FCDBB", "#41B6C4", "#1D91C0", "#225EA8", "#0C2C84"])
ix = ((length-length.min())/(length.max()-length.min())*5).astype('int')
colors = cm[ix]

output_server("vector")

p1 = figure()
p1.segment(x0, y0, x1, y1, color=colors, line_width=2)

p2 = figure()
p2.multi_line(xs, ys, color="#ee6666", line_width=2, line_alpha=0.8)

show(vplot(p1,p2))  # open a browser

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#
#    Copyright (C) 2007  Manuel Vázquez Acosta <mva.led@gmail.com>
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#

# $Id$

"""
This module is a high-level front-end for the iDTD algorithm.
It provides objects that take XML samples and infer the DTD
"""


import types
from Rewrite import rewrite
from AutomataInferrer import infer_automata
from InferDTD import infer_soa
from threading import RLock
from DOM import Document, mergedocs

def inter_dtd(samples):
    for sample in samples:
        pass
    pass

from __future__ import absolute_import, print_function, unicode_literals

import functools
import collections

def save_method_args(method):
    """
    Wrap a method such that when it is called, we save the args and
    kwargs with which it was called.

    >>> class MyClass(object):
    ...     @save_method_args
    ...     def method(self, a, b):
    ...         print(a, b)
    >>> my_ob = MyClass()
    >>> my_ob.method(1, 2)
    1 2
    >>> my_ob._saved_method.args
    (1, 2)
    >>> my_ob._saved_method.kwargs
    {}
    >>> my_ob.method(a=3, b='foo')
    3 foo
    >>> my_ob._saved_method.args
    ()
    >>> my_ob._saved_method.kwargs == dict(a=3, b='foo')
    True
    """
    args_and_kwargs = collections.namedtuple('args_and_kwargs', 'args kwargs')
    @functools.wraps(method)
    def wrapper(self, *args, **kwargs):
        attr_name = '_saved_' + method.func_name
        attr = args_and_kwargs(args, kwargs)
        setattr(self, attr_name, attr)
        return method(self, *args, **kwargs)
    return wrapper

# Copyright 2014 OpenStack Foundation
#
# 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.

import mock

from neutron.common import constants
from neutron.common import topics
from neutron import context
from neutron.db import agents_db
from neutron.db import agentschedulers_db
from neutron.db import models_v2
from neutron.openstack.common import timeutils
from neutron.scheduler import dhcp_agent_scheduler
from neutron.tests.unit import testlib_api


class DhcpSchedulerTestCase(testlib_api.SqlTestCase):

    def setUp(self):
        super(DhcpSchedulerTestCase, self).setUp()
        self.ctx = context.get_admin_context()
        self.network_id = 'foo_network_id'
        self._save_networks([self.network_id])

    def _get_agents(self, hosts):
        return [
            agents_db.Agent(
                binary='neutron-dhcp-agent',
                host=host,
                topic=topics.DHCP_AGENT,
                configurations="",
                agent_type=constants.AGENT_TYPE_DHCP,
                created_at=timeutils.utcnow(),
                started_at=timeutils.utcnow(),
                heartbeat_timestamp=timeutils.utcnow())
            for host in hosts
        ]

    def _save_agents(self, agents):
        for agent in agents:
            with self.ctx.session.begin(subtransactions=True):
                self.ctx.session.add(agent)

    def _save_networks(self, networks):
        for network_id in networks:
            with self.ctx.session.begin(subtransactions=True):
                self.ctx.session.add(models_v2.Network(id=network_id))

    def _test_schedule_bind_network(self, agents, network_id):
        scheduler = dhcp_agent_scheduler.ChanceScheduler()
        scheduler._schedule_bind_network(self.ctx, agents, network_id)
        results = (
            self.ctx.session.query(agentschedulers_db.NetworkDhcpAgentBinding).
            filter_by(network_id=network_id).all())
        self.assertEqual(len(agents), len(results))
        for result in results:
            self.assertEqual(network_id, result.network_id)

    def test_schedule_bind_network_single_agent(self):
        agents = self._get_agents(['host-a'])
        self._save_agents(agents)
        self._test_schedule_bind_network(agents, self.network_id)

    def test_schedule_bind_network_multi_agents(self):
        agents = self._get_agents(['host-a', 'host-b'])
        self._save_agents(agents)
        self._test_schedule_bind_network(agents, self.network_id)

    def test_schedule_bind_network_multi_agent_fail_one(self):
        agents = self._get_agents(['host-a'])
        self._save_agents(agents)
        self._test_schedule_bind_network(agents, self.network_id)
        with mock.patch.object(dhcp_agent_scheduler.LOG, 'info') as fake_log:
            self._test_schedule_bind_network(agents, self.network_id)
            self.assertEqual(1, fake_log.call_count)

    def test_auto_schedule_networks_no_networks(self):
        plugin = mock.MagicMock()
        plugin.get_networks.return_value = []
        scheduler = dhcp_agent_scheduler.ChanceScheduler()
        self.assertFalse(scheduler.auto_schedule_networks(plugin,
                                                          self.ctx, "host-a"))

    def test_auto_schedule_networks(self):
        plugin = mock.MagicMock()
        plugin.get_subnets.return_value = [{"network_id": self.network_id,
                                            "enable_dhcp": True}]
        agents = self._get_agents(['host-a'])
        self._save_agents(agents)
        scheduler = dhcp_agent_scheduler.ChanceScheduler()

        self.assertTrue(scheduler.auto_schedule_networks(plugin,
                                                         self.ctx, "host-a"))
        results = (
            self.ctx.session.query(agentschedulers_db.NetworkDhcpAgentBinding)
            .all())
        self.assertEqual(1, len(results))

    def test_auto_schedule_networks_network_already_scheduled(self):
        plugin = mock.MagicMock()
        plugin.get_subnets.return_value = [{"network_id": self.network_id,
                                            "enable_dhcp": True}]
        agents = self._get_agents(['host-a'])
        self._save_agents(agents)
        scheduler = dhcp_agent_scheduler.ChanceScheduler()
        self._test_schedule_bind_network(agents, self.network_id)
        self.assertTrue(scheduler.auto_schedule_networks(plugin,
                                                         self.ctx, "host-a"))
        results = (
            self.ctx.session.query(agentschedulers_db.NetworkDhcpAgentBinding)
            .all())
        self.assertEqual(1, len(results))

from couchpotato.core.helpers.encoding import toUnicode
from elixir.entity import Entity
from elixir.fields import Field
from elixir.options import options_defaults, using_options
from elixir.relationships import ManyToMany, OneToMany, ManyToOne
from sqlalchemy.types import Integer, Unicode, UnicodeText, Boolean, String, \
    TypeDecorator
import json
import time

options_defaults["shortnames"] = True

# We would like to be able to create this schema in a specific database at
# will, so we can test it easily.
# Make elixir not bind to any session to make this possible.
#
# http://elixir.ematia.de/trac/wiki/Recipes/MultipleDatabasesOneMetadata
__session__ = None

class SetEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, set):
            return list(obj)
        return json.JSONEncoder.default(self, obj)


class JsonType(TypeDecorator):
    impl = UnicodeText

    def process_bind_param(self, value, dialect):
        try:
            return toUnicode(json.dumps(value, cls = SetEncoder))
        except:
            try:
                return toUnicode(json.dumps(value, cls = SetEncoder, encoding = 'latin-1'))
            except:
                raise

    def process_result_value(self, value, dialect):
        return json.loads(value if value else '{}')


class Movie(Entity):
    """Movie Resource a movie could have multiple releases
    The files belonging to the movie object are global for the whole movie
    such as trailers, nfo, thumbnails"""

    last_edit = Field(Integer, default = lambda: int(time.time()), index = True)

    library = ManyToOne('Library', cascade = 'delete, delete-orphan', single_parent = True)
    status = ManyToOne('Status')
    profile = ManyToOne('Profile')
    releases = OneToMany('Release', cascade = 'all, delete-orphan')
    files = ManyToMany('File', cascade = 'all, delete-orphan', single_parent = True)


class Library(Entity):
    """"""

    year = Field(Integer)
    identifier = Field(String(20), index = True)

    plot = Field(UnicodeText)
    tagline = Field(UnicodeText(255))
    info = Field(JsonType)

    status = ManyToOne('Status')
    movies = OneToMany('Movie', cascade = 'all, delete-orphan')
    titles = OneToMany('LibraryTitle', cascade = 'all, delete-orphan')
    files = ManyToMany('File', cascade = 'all, delete-orphan', single_parent = True)


class LibraryTitle(Entity):
    """"""
    using_options(order_by = '-default')

    title = Field(Unicode)
    simple_title = Field(Unicode, index = True)
    default = Field(Boolean, default = False, index = True)

    language = OneToMany('Language')
    libraries = ManyToOne('Library')


class Language(Entity):
    """"""

    identifier = Field(String(20), index = True)
    label = Field(Unicode)

    titles = ManyToOne('LibraryTitle')


class Release(Entity):
    """Logically groups all files that belong to a certain release, such as
    parts of a movie, subtitles."""

    last_edit = Field(Integer, default = lambda: int(time.time()), index = True)
    identifier = Field(String(100), index = True)

    movie = ManyToOne('Movie')
    status = ManyToOne('Status')
    quality = ManyToOne('Quality')
    files = ManyToMany('File')
    info = OneToMany('ReleaseInfo', cascade = 'all, delete-orphan')

    def to_dict(self, deep = {}, exclude = []):
        orig_dict = super(Release, self).to_dict(deep = deep, exclude = exclude)

        new_info = {}
        for info in orig_dict.get('info', []):

            value = info['value']
            try: value = int(info['value'])
            except: pass

            new_info[info['identifier']] = value

        orig_dict['info'] = new_info

        return orig_dict


class ReleaseInfo(Entity):
    """Properties that can be bound to a file for off-line usage"""

    identifier = Field(String(50), index = True)
    value = Field(Unicode(255), nullable = False)

    release = ManyToOne('Release')


class Status(Entity):
    """The status of a release, such as Downloaded, Deleted, Wanted etc"""

    identifier = Field(String(20), unique = True)
    label = Field(Unicode(20))

    releases = OneToMany('Release')
    movies = OneToMany('Movie')


class Quality(Entity):
    """Quality name of a release, DVD, 720p, DVD-Rip etc"""
    using_options(order_by = 'order')

    identifier = Field(String(20), unique = True)
    label = Field(Unicode(20))
    order = Field(Integer, default = 0, index = True)

    size_min = Field(Integer)
    size_max = Field(Integer)

    releases = OneToMany('Release')
    profile_types = OneToMany('ProfileType')


class Profile(Entity):
    """"""
    using_options(order_by = 'order')

    label = Field(Unicode(50))
    order = Field(Integer, default = 0, index = True)
    core = Field(Boolean, default = False)
    hide = Field(Boolean, default = False)

    movie = OneToMany('Movie')
    types = OneToMany('ProfileType', cascade = 'all, delete-orphan')

    def to_dict(self, deep = {}, exclude = []):
        orig_dict = super(Profile, self).to_dict(deep = deep, exclude = exclude)
        orig_dict['core'] = orig_dict.get('core') or False
        orig_dict['hide'] = orig_dict.get('hide') or False

        return orig_dict

class ProfileType(Entity):
    """"""
    using_options(order_by = 'order')

    order = Field(Integer, default = 0, index = True)
    finish = Field(Boolean, default = True)
    wait_for = Field(Integer, default = 0)

    quality = ManyToOne('Quality')
    profile = ManyToOne('Profile')


class File(Entity):
    """File that belongs to a release."""

    path = Field(Unicode(255), nullable = False, unique = True)
    part = Field(Integer, default = 1)
    available = Field(Boolean, default = True)

    type = ManyToOne('FileType')
    properties = OneToMany('FileProperty')

    history = OneToMany('RenameHistory')
    movie = ManyToMany('Movie')
    release = ManyToMany('Release')
    library = ManyToMany('Library')


class FileType(Entity):
    """Types could be trailer, subtitle, movie, partial movie etc."""

    identifier = Field(String(20), unique = True)
    type = Field(Unicode(20))
    name = Field(Unicode(50), nullable = False)

    files = OneToMany('File')


class FileProperty(Entity):
    """Properties that can be bound to a file for off-line usage"""

    identifier = Field(String(20), index = True)
    value = Field(Unicode(255), nullable = False)

    file = ManyToOne('File')


class RenameHistory(Entity):
    """Remembers from where to where files have been moved."""

    old = Field(Unicode(255))
    new = Field(Unicode(255))

    file = ManyToOne('File')


class Notification(Entity):
    using_options(order_by = 'added')

    added = Field(Integer, default = lambda: int(time.time()))
    read = Field(Boolean, default = False)
    message = Field(Unicode(255))
    data = Field(JsonType)


class Folder(Entity):
    """Renamer destination folders."""

    path = Field(Unicode(255))
    label = Field(Unicode(255))


class Properties(Entity):

    identifier = Field(String(50), index = True)
    value = Field(Unicode(255), nullable = False)


def setup():
    """Setup the database and create the tables that don't exists yet"""
    from elixir import setup_all, create_all
    from couchpotato.environment import Env

    engine = Env.getEngine()

    setup_all()
    create_all(engine)

    try:
        engine.execute("PRAGMA journal_mode = WAL")
        engine.execute("PRAGMA temp_store = MEMORY")
    except:
        pass

#!/usr/bin/env python
# -*- coding: utf-8; py-indent-offset:4 -*-
################################################################################
# 
#  Copyright (C) 2012-2014 Daniel Rodriguez
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
################################################################################
from BaseHTTPServer import HTTPServer
from collections import defaultdict, deque
from socket import SHUT_RDWR
from SocketServer import ThreadingMixIn

from hppconfig import HPPConfig
from hpphandler import HPPHandler


class HPPServer(ThreadingMixIn, HTTPServer):

    def __init__(self, handlerclass=HPPHandler, controller=None, **kwargs):

        self.config = controller.config if controller else HPPConfig(**kwargs)
        HTTPServer.__init__(self, (self.config.host, self.config.port), handlerclass)

        self.ldesc = deque()
        self.connq = defaultdict(deque)
        self.controller = controller


    def process_request_thread(self, request, client_address):
        """Same as in BaseServer but as a thread.

        In addition, exception handling is done here.

        """
        try:
            self.finish_request(request, client_address)
            self.shutdown_request(request)
        except Exception, e:
            self.handle_error(request, client_address, exc=e)
            self.shutdown_request(request)


    def handle_error(self, request, client_address, exc=None):
        if False and exc:
            print 'Exception happened: %s' % str(exc)
        else:
            HTTPServer.handle_error(self, request, client_address)


    def setproxy(self, **kwargs):
        self.config.setproxy(**kwargs)


    def postMsg(self, action, **kwargs):
        if self.controller:
            self.controller.postMsg(action, **kwargs)


    def hppstop(self):
        self.shutdown()
        # Close the descriptor of threads to force them out
        # of the loop and die - this allows full restart of the server
        for desc in self.ldesc:
            if hasattr(desc, 'shutdown'):
                # close a socket properly
                try:
                    desc.shutdown(SHUT_RDWR)
                except:
                    pass
            try:
                desc.close()
            except Exception, e:
                pass





# vim: tabstop=4 shiftwidth=4 softtabstop=4

# Copyright 2012 NEC Corporation
#
#    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.

from django.conf.urls.defaults import include  # noqa
from django.conf.urls.defaults import patterns  # noqa
from django.conf.urls.defaults import url  # noqa

from openstack_dashboard.dashboards.project.networks.ports \
    import urls as port_urls
from openstack_dashboard.dashboards.project.networks.ports \
    import views as port_views
from openstack_dashboard.dashboards.project.networks.subnets \
    import urls as subnet_urls
from openstack_dashboard.dashboards.project.networks.subnets \
    import views as subnet_views
from openstack_dashboard.dashboards.project.networks import views


NETWORKS = r'^(?P<network_id>[^/]+)/%s$'


urlpatterns = patterns('',
    url(r'^$', views.IndexView.as_view(), name='index'),
    url(r'^create$', views.CreateView.as_view(), name='create'),
    url(NETWORKS % 'detail', views.DetailView.as_view(), name='detail'),
    url(NETWORKS % 'update', views.UpdateView.as_view(), name='update'),
    url(NETWORKS % 'subnets/create', subnet_views.CreateView.as_view(),
        name='addsubnet'),
    url(r'^(?P<network_id>[^/]+)/subnets/(?P<subnet_id>[^/]+)/update$',
        subnet_views.UpdateView.as_view(), name='editsubnet'),
    url(r'^(?P<network_id>[^/]+)/ports/(?P<port_id>[^/]+)/update$',
        port_views.UpdateView.as_view(), name='editport'),
    url(r'^subnets/', include(subnet_urls, namespace='subnets')),
    url(r'^ports/', include(port_urls, namespace='ports')))

#!/usr/bin/python

# (c) 2016, NetApp, Inc
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}

DOCUMENTATION = """
---
module: netapp_e_drive_firmware
version_added: "2.9"
short_description: NetApp E-Series manage drive firmware
description:
    - Ensure drive firmware version is activated on specified drive model.
author:
    - Nathan Swartz (@ndswartz)
extends_documentation_fragment:
    - netapp.eseries
options:
    firmware:
        description:
            - list of drive firmware file paths.
            - NetApp E-Series drives require special firmware which can be downloaded from https://mysupport.netapp.com/NOW/download/tools/diskfw_eseries/
        type: list
        required: True
    wait_for_completion:
        description:
            - This flag will cause module to wait for any upgrade actions to complete.
        type: bool
        default: false
    ignore_inaccessible_drives:
        description:
            - This flag will determine whether drive firmware upgrade should fail if any affected drives are inaccessible.
        type: bool
        default: false
    upgrade_drives_online:
        description:
            - This flag will determine whether drive firmware can be upgrade while drives are accepting I/O.
            - When I(upgrade_drives_online==False) stop all I/O before running task.
        type: bool
        default: true
"""
EXAMPLES = """
- name: Ensure correct firmware versions
  nac_santricity_drive_firmware:
    ssid: "1"
    api_url: "https://192.168.1.100:8443/devmgr/v2"
    api_username: "admin"
    api_password: "adminpass"
    validate_certs: true
    firmware: "path/to/drive_firmware"
    wait_for_completion: true
    ignore_inaccessible_drives: false
"""
RETURN = """
msg:
    description: Whether any drive firmware was upgraded and whether it is in progress.
    type: str
    returned: always
    sample:
        { changed: True, upgrade_in_process: True }
"""
import os
import re

from time import sleep
from ansible.module_utils.netapp import NetAppESeriesModule, create_multipart_formdata
from ansible.module_utils._text import to_native, to_text, to_bytes


class NetAppESeriesDriveFirmware(NetAppESeriesModule):
    WAIT_TIMEOUT_SEC = 60 * 15

    def __init__(self):
        ansible_options = dict(
            firmware=dict(type="list", required=True),
            wait_for_completion=dict(type="bool", default=False),
            ignore_inaccessible_drives=dict(type="bool", default=False),
            upgrade_drives_online=dict(type="bool", default=True))

        super(NetAppESeriesDriveFirmware, self).__init__(ansible_options=ansible_options,
                                                         web_services_version="02.00.0000.0000",
                                                         supports_check_mode=True)

        args = self.module.params
        self.firmware_list = args["firmware"]
        self.wait_for_completion = args["wait_for_completion"]
        self.ignore_inaccessible_drives = args["ignore_inaccessible_drives"]
        self.upgrade_drives_online = args["upgrade_drives_online"]

        self.upgrade_list_cache = None

        self.upgrade_required_cache = None
        self.upgrade_in_progress = False
        self.drive_info_cache = None

    def upload_firmware(self):
        """Ensure firmware has been upload prior to uploaded."""
        for firmware in self.firmware_list:
            firmware_name = os.path.basename(firmware)
            files = [("file", firmware_name, firmware)]
            headers, data = create_multipart_formdata(files)
            try:
                rc, response = self.request("/files/drive", method="POST", headers=headers, data=data)
            except Exception as error:
                self.module.fail_json(msg="Failed to upload drive firmware [%s]. Array [%s]. Error [%s]." % (firmware_name, self.ssid, to_native(error)))

    def upgrade_list(self):
        """Determine whether firmware is compatible with the specified drives."""
        if self.upgrade_list_cache is None:
            self.upgrade_list_cache = list()
            try:
                rc, response = self.request("storage-systems/%s/firmware/drives" % self.ssid)

                # Create upgrade list, this ensures only the firmware uploaded is applied
                for firmware in self.firmware_list:
                    filename = os.path.basename(firmware)

                    for uploaded_firmware in response["compatibilities"]:
                        if uploaded_firmware["filename"] == filename:

                            # Determine whether upgrade is required
                            drive_reference_list = []
                            for drive in uploaded_firmware["compatibleDrives"]:
                                try:
                                    rc, drive_info = self.request("storage-systems/%s/drives/%s" % (self.ssid, drive["driveRef"]))

                                    # Add drive references that are supported and differ from current firmware
                                    if (drive_info["firmwareVersion"] != uploaded_firmware["firmwareVersion"] and
                                            uploaded_firmware["firmwareVersion"] in uploaded_firmware["supportedFirmwareVersions"]):

                                        if self.ignore_inaccessible_drives or (not drive_info["offline"] and drive_info["available"]):
                                            drive_reference_list.append(drive["driveRef"])

                                        if not drive["onlineUpgradeCapable"] and self.upgrade_drives_online:
                                            self.module.fail_json(msg="Drive is not capable of online upgrade. Array [%s]. Drive [%s]."
                                                                      % (self.ssid, drive["driveRef"]))

                                except Exception as error:
                                    self.module.fail_json(msg="Failed to retrieve drive information. Array [%s]. Drive [%s]. Error [%s]."
                                                              % (self.ssid, drive["driveRef"], to_native(error)))

                            if drive_reference_list:
                                self.upgrade_list_cache.extend([{"filename": filename, "driveRefList": drive_reference_list}])

            except Exception as error:
                self.module.fail_json(msg="Failed to complete compatibility and health check. Array [%s]. Error [%s]." % (self.ssid, to_native(error)))

        return self.upgrade_list_cache

    def wait_for_upgrade_completion(self):
        """Wait for drive firmware upgrade to complete."""
        drive_references = [reference for drive in self.upgrade_list() for reference in drive["driveRefList"]]
        last_status = None
        for attempt in range(int(self.WAIT_TIMEOUT_SEC / 5)):
            try:
                rc, response = self.request("storage-systems/%s/firmware/drives/state" % self.ssid)

                # Check drive status
                for status in response["driveStatus"]:
                    last_status = status
                    if status["driveRef"] in drive_references:
                        if status["status"] == "okay":
                            continue
                        elif status["status"] in ["inProgress", "inProgressRecon", "pending", "notAttempted"]:
                            break
                        else:
                            self.module.fail_json(msg="Drive firmware upgrade failed. Array [%s]. Drive [%s]. Status [%s]."
                                                      % (self.ssid, status["driveRef"], status["status"]))
                else:
                    self.upgrade_in_progress = False
                    break
            except Exception as error:
                self.module.fail_json(msg="Failed to retrieve drive status. Array [%s]. Error [%s]." % (self.ssid, to_native(error)))

            sleep(5)
        else:
            self.module.fail_json(msg="Timed out waiting for drive firmware upgrade. Array [%s]. Status [%s]." % (self.ssid, last_status))

    def upgrade(self):
        """Apply firmware to applicable drives."""
        try:
            rc, response = self.request("storage-systems/%s/firmware/drives/initiate-upgrade?onlineUpdate=%s"
                                        % (self.ssid, "true" if self.upgrade_drives_online else "false"), method="POST", data=self.upgrade_list())
            self.upgrade_in_progress = True
        except Exception as error:
            self.module.fail_json(msg="Failed to upgrade drive firmware. Array [%s]. Error [%s]." % (self.ssid, to_native(error)))

        if self.wait_for_completion:
            self.wait_for_upgrade_completion()

    def apply(self):
        """Apply firmware policy has been enforced on E-Series storage system."""
        self.upload_firmware()

        if self.upgrade_list() and not self.module.check_mode:
            self.upgrade()

        self.module.exit_json(changed=True if self.upgrade_list() else False,
                              upgrade_in_process=self.upgrade_in_progress)


def main():
    drive_firmware = NetAppESeriesDriveFirmware()
    drive_firmware.apply()


if __name__ == '__main__':
    main()

# Copyright 2012 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

'''
Blocks and utilities for trellis coding and related.
'''

# The presence of this file turns this directory into a Python package
import os

try:
    from trellis_swig import *
except ImportError:
    dirname, filename = os.path.split(os.path.abspath(__file__))
    __path__.append(os.path.join(dirname, "..", "..", "swig"))
    from trellis_swig import *

# import any pure python here

"""Tests for the Cast config flow."""
from unittest.mock import patch

from homeassistant import config_entries, data_entry_flow
from homeassistant.setup import async_setup_component
from homeassistant.components import cast

from tests.common import MockDependency, mock_coro


async def test_creating_entry_sets_up_media_player(hass):
    """Test setting up Cast loads the media player."""
    with patch('homeassistant.components.media_player.cast.async_setup_entry',
               return_value=mock_coro(True)) as mock_setup, \
            MockDependency('pychromecast', 'discovery'), \
            patch('pychromecast.discovery.discover_chromecasts',
                  return_value=True):
        result = await hass.config_entries.flow.async_init(
            cast.DOMAIN, context={'source': config_entries.SOURCE_USER})

        # Confirmation form
        assert result['type'] == data_entry_flow.RESULT_TYPE_FORM

        result = await hass.config_entries.flow.async_configure(
            result['flow_id'], {})
        assert result['type'] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY

        await hass.async_block_till_done()

    assert len(mock_setup.mock_calls) == 1


async def test_configuring_cast_creates_entry(hass):
    """Test that specifying config will create an entry."""
    with patch('homeassistant.components.cast.async_setup_entry',
               return_value=mock_coro(True)) as mock_setup, \
            MockDependency('pychromecast', 'discovery'), \
            patch('pychromecast.discovery.discover_chromecasts',
                  return_value=True):
        await async_setup_component(hass, cast.DOMAIN, {
            'cast': {
                'some_config': 'to_trigger_import'
            }
        })
        await hass.async_block_till_done()

    assert len(mock_setup.mock_calls) == 1


async def test_not_configuring_cast_not_creates_entry(hass):
    """Test that no config will not create an entry."""
    with patch('homeassistant.components.cast.async_setup_entry',
               return_value=mock_coro(True)) as mock_setup, \
            MockDependency('pychromecast', 'discovery'), \
            patch('pychromecast.discovery.discover_chromecasts',
                  return_value=True):
        await async_setup_component(hass, cast.DOMAIN, {})
        await hass.async_block_till_done()

    assert len(mock_setup.mock_calls) == 0

import json
import sys

from ansible.compat.tests import unittest
from ansible.compat.tests.mock import patch, MagicMock

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.six.moves import builtins
from ansible.module_utils._text import to_native
from units.mock.procenv import swap_stdin_and_argv


import pprint

realimport = builtins.__import__


class TestPostgres(unittest.TestCase):
    def clear_modules(self, mods):
        for mod in mods:
            if mod in sys.modules:
                del sys.modules[mod]

    @patch.object(builtins, '__import__')
    def test_postgres_pg2_missing_ensure_libs(self, mock_import):
        def _mock_import(name, *args, **kwargs):
            if name == 'psycopg2':
                raise ImportError
            return realimport(name, *args, **kwargs)

        self.clear_modules(['psycopg2', 'ansible.module_utils.postgres'])
        mock_import.side_effect = _mock_import
        mod = builtins.__import__('ansible.module_utils.postgres')

        self.assertFalse(mod.module_utils.postgres.HAS_PSYCOPG2)

        with self.assertRaises(mod.module_utils.postgres.LibraryError) as context:
            mod.module_utils.postgres.ensure_libs(sslrootcert=None)
        self.assertIn('psycopg2 is not installed', to_native(context.exception))

    @patch.object(builtins, '__import__')
    def test_postgres_pg2_found_ensure_libs(self, mock_import):
        def _mock_import(name, *args, **kwargs):
            if 'psycopg2' in name:
                return MagicMock()
            return realimport(name, *args, **kwargs)

        self.clear_modules(['psycopg2', 'ansible.module_utils.postgres'])
        mock_import.side_effect = _mock_import
        mod = builtins.__import__('ansible.module_utils.postgres')

        self.assertTrue(mod.module_utils.postgres.HAS_PSYCOPG2)

        ensure_ret = mod.module_utils.postgres.ensure_libs(sslrootcert=None)
        self.assertFalse(ensure_ret)
        pprint.pprint(ensure_ret)

    @patch.object(builtins, '__import__')
    def test_postgres_pg2_found_ensure_libs_old_version(self, mock_import):
        def _mock_import(name, *args, **kwargs):
            if 'psycopg2' in name:
                m = MagicMock()
                m.__version__ = '2.4.1'
                return m
            return realimport(name, *args, **kwargs)

        self.clear_modules(['psycopg2', 'ansible.module_utils.postgres'])
        mock_import.side_effect = _mock_import
        mod = builtins.__import__('ansible.module_utils.postgres')

        self.assertTrue(mod.module_utils.postgres.HAS_PSYCOPG2)

        with self.assertRaises(mod.module_utils.postgres.LibraryError) as context:
            mod.module_utils.postgres.ensure_libs(sslrootcert='yes')
        self.assertIn('psycopg2 must be at least 2.4.3 in order to use', to_native(context.exception))

import copy
import re

from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
from django.db import connection
from django.db.models import Q
from django.db.models.sql.query import AND, OR
from django.utils.tree import Node


ORDER_PATTERN = re.compile(r'^[-+]?[a-zA-Z0-9_]+$')
FIELD_PATTERN = re.compile(r'^[a-zA-Z0-9_\.]+$')
RAW_FILTER_PATTERN = re.compile(
    r'^(?P<field>[a-zA-Z0-9_\.]+)\s*(?P<op>=|>|<|>=|<=|!=|IN|LIKE|ILIKE)\s*$',
    re.I)


class LazyRawSQLManager(object):
    """A deferred manager to work around metaclass lameness."""

    def __init__(self, sql_model_class):
        self.__sql_model_class = sql_model_class
        self.__manager = None

    def __getattr__(self, name):
        if not self.__manager:
            self.__manager = RawSQLManager(self.__sql_model_class())
        return getattr(self.__manager, name)


class RawSQLManager(object):
    """Raw SQL Manager for a Raw SQL Model.

    This provides a very minimal set of features in the Query Set API.
    """

    def __init__(self, sql_model, base_query=None):
        self.sql_model = sql_model
        if not base_query:
            base_query = copy.deepcopy(sql_model.base_query())
        self.base_query = base_query
        if 'where' not in self.base_query:
            self.base_query['where'] = []
        if 'having' not in self.base_query:
            self.base_query['having'] = []
        if 'order_by' not in self.base_query:
            self.base_query['order_by'] = []
        if 'limit' not in self.base_query:
            self.base_query['limit'] = []
        if '_args' not in self.base_query:
            self.base_query['_args'] = {}
        self._cursor = None
        self._record_set = []

    def __iter__(self):
        self._build_cursor()
        for row in self._iter_cursor_results():
            yield row

    def __getitem__(self, key):
        if isinstance(key, slice):
            if key.start and key.stop:
                # Translate slice into LIMIT, e.g.
                # [0:2] ->
                #          LIMIT 0, 2
                # [10:15] ->
                #          LIMIT 10, 5
                offset = self._check_limit(key.start)
                end = self._check_limit(key.stop)
                row_count = max(0, end - offset)
                self.base_query['limit'] = [offset, row_count]
            elif key.start:
                self.base_query['limit'] = [self._check_limit(key.start)]
            elif key.stop:
                self.base_query['limit'] = [0, self._check_limit(key.stop)]
            self._build_cursor()
            self._build_record_set()
            return self._record_set
        elif isinstance(key, int):
            if not len(self._record_set):
                # Get all rows!  Better to use a limit with slices.
                self._build_cursor()
                self._build_record_set()
            return self._record_set[key]
        else:
            raise TypeError('Key must be a slice or integer.')

    def all(self):
        return self._clone()

    def count(self):
        """Count of all results, preserving aggregate grouping."""
        self._execute('SELECT count(*) from (%s) as q' % self.as_sql())
        return self._cursor.fetchone()[0]

    def get(self, **kw):
        clone = self._clone()
        if kw:
            clone = clone.filter(**kw)
        cnt = clone.count()
        if cnt > 1:
            raise clone.sql_model.MultipleObjectsReturned(
                'get() returned more than one row -- it returned %s!' % cnt)
        elif cnt == 0:
            raise clone.sql_model.DoesNotExist(
                '%s matching query does not exist.' %
                self.sql_model.__class__.__name__)
        else:
            return clone[0:1][0]

    def exclude(self, *args, **kw):
        raise NotImplementedError()

    def filter(self, *args, **kw):
        """Adds a where clause with keyword args.

        Example::

            qs = qs.filter(category='trees')
            qs = qs.filter(Q(type=1) | Q(name='foo'))

        """
        clone = self._clone()
        for arg in args:
            if isinstance(arg, Q):
                clone.base_query['where'].append(
                    '(%s)' % (clone._flatten_q(arg, clone._kw_clause_from_q)))
            else:
                raise TypeError(
                    'non keyword args should be Q objects, got %r' % arg)
        for field, val in kw.items():
            clone.base_query['where'].append(clone._kw_filter_to_clause(field,
                                                                        val))
        return clone

    def filter_raw(self, *args):
        """Adds a where clause in limited SQL.

        Examples::

            qs = qs.filter_raw('total >', 1)
            qs = qs.filter_raw('total >=', 1)
            qs = qs.filter_raw(Q('name LIKE', '%foo%') |
                               Q('status IN', [1, 2, 3]))

        The field on the leftside can be a key in the select dictionary.
        That is, it will be replaced with the actual expression when the
        query is built.
        """
        clone = self._clone()
        specs = []
        for arg in args:
            if isinstance(arg, Q):
                clone.base_query['where'].append(
                    '(%s)' % (clone._flatten_q(arg, clone._filter_to_clause)))
            else:
                specs.append(arg)
        if len(specs):
            clone.base_query['where'].append(clone._filter_to_clause(*specs))
        return clone

    def having(self, spec, val):
        """Adds a having clause in limited SQL.

        Examples::

            qs = qs.having('total >', 1)
            qs = qs.having('total >=', 1)

        The field on the leftside can be a key in the select dictionary.
        That is, it will be replaced with the actual expression when the
        query is built.
        """
        clone = self._clone()
        clone.base_query['having'].append(clone._filter_to_clause(spec, val))
        return clone

    def latest(self, column):
        """Return the latest item, based on the given column."""

        clone = self._clone()
        clone.order_by('-%s' % column)
        if clone.count() == 0:
            raise clone.sql_model.DoesNotExist(
                '%s matching query does not exist.' %
                self.sql_model.__class__.__name__)
        return clone[0]

    def order_by(self, spec):
        """Order by column (ascending) or -column (descending)."""
        if not ORDER_PATTERN.match(spec):
            raise ValueError('Invalid order by value: %r' % spec)
        if spec.startswith('-'):
            dir = 'DESC'
            field = spec[1:]
        else:
            dir = 'ASC'
            field = spec
        clone = self._clone()
        clone.base_query['order_by'].append('%s %s' %
                                            (clone._resolve_alias(field), dir))
        return clone

    def as_sql(self):
        stmt = self._compile(self.base_query)
        return stmt

    def _clone(self):
        return self.__class__(self.sql_model,
                              base_query=copy.deepcopy(self.base_query))

    def _flatten_q(self, q_object, join_specs, stack=None):
        """Makes a WHERE clause out of a Q object (supports nested Q objects).

        Pass in join_specs(*specs) based on what kind of arguments you think
        the Q object will have.  filter() Qs are different from
        filter_raw() Qs.
        """
        specs = []
        if stack is None:
            stack = [None]
        # TODO(Kumar): construct NOT clause:
        if q_object.negated:
            raise NotImplementedError('negated Q objects')
        connector = q_object.connector

        def add(specs):
            c = join_specs(*specs, connector=connector)
            if stack[-1] in (AND, OR):
                c = u'(%s)' % (c)
            elif stack[-1] is not None:
                stack.append(connector)
            if c:
                stack.append(c)

        for child in q_object.children:
            if isinstance(child, Node):
                add(specs)
                specs[:] = []
                self._flatten_q(child, join_specs, stack=stack)
            else:
                specs.append(child)
        if len(specs):
            add(specs)
        return u' '.join([c for c in stack if c])

    def _kw_clause_from_q(self, *pairs, **kw):
        """Makes a WHERE clause out of pairs of (key, val) from Q objects."""
        connector = kw.get('connector', AND)
        stmt = []
        for field, val in pairs:
            stmt.append(self._kw_filter_to_clause(field, val))
        return (u' %s ' % connector).join(stmt)

    def _kw_filter_to_clause(self, field, val):
        """Makes a WHERE clause out of field = val."""
        if not FIELD_PATTERN.match(field):
            raise ValueError('Not a valid field for where clause: %r' % field)
        param_k = self._param(val)
        field = self._resolve_alias(field)
        return u'%s = %%(%s)s' % (field, param_k)

    def _filter_to_clause(self, *specs, **kw):
        """Makes a WHERE clause out of filter_raw() arguments."""
        connector = kw.get('connector', AND)
        specs = list(specs)
        if (len(specs) % 2) != 0:
            raise TypeError(
                "Expected pairs of 'spec =', 'val'. Got: %r" % specs)
        full_clause = []
        while len(specs):
            spec, val = specs.pop(0), specs.pop(0)
            clause = RAW_FILTER_PATTERN.match(spec)
            if not clause:
                raise ValueError(
                    'This is not a valid clause: %r; must match: %s' % (
                        spec, RAW_FILTER_PATTERN.pattern))
            field = clause.group('field')
            field = self._resolve_alias(field)
            if clause.group('op').lower() == 'in':
                # eg. WHERE foo IN (%(param_0)s, %(param_1)s, %(param_2)s)
                #     WHERE foo IN (1, 2, 3)
                parts = ['%(' + self._param(p) + ')s' for p in iter(val)]
                param = '(%s)' % ', '.join(parts)
            else:
                param = '%%(%s)s' % self._param(val)
            full_clause.append('%s %s %s' % (field, clause.group('op'), param))
        c = (u' %s ' % connector).join(full_clause)
        if len(full_clause) > 1:
            # Protect OR clauses
            c = u'(%s)' % c
        return c

    def _resolve_alias(self, field):
        """Access a field (or expression) by alias, similar to how a view works.
        """
        if field in self.base_query['select']:
            field = self.base_query['select'][field]
        return field

    def _compile(self, parts):
        sep = u",\n"
        and_ = u' %s\n' % AND
        select = [u'%s AS `%s`' % (v, k) for k, v in parts['select'].items()]
        stmt = u"SELECT\n%s\nFROM\n%s" % (sep.join(select),
                                          u"\n".join(parts['from']))
        if parts.get('where'):
            stmt = u"%s\nWHERE\n%s" % (stmt, and_.join(parts['where']))
        if parts.get('group_by'):
            stmt = u"%s\nGROUP BY\n%s" % (stmt, parts['group_by'])
        if parts.get('having'):
            stmt = u"%s\nHAVING\n%s" % (stmt, and_.join(parts['having']))
        if parts.get('order_by'):
            stmt = u"%s\nORDER BY\n%s" % (stmt, sep.join(parts['order_by']))
        if len(parts['limit']):
            stmt = u"%s\nLIMIT %s" % (stmt, ', '.join([str(i) for i in
                                                       parts['limit']]))
        return stmt

    def _execute(self, sql):
        self._record_set = []
        self._cursor = connection.cursor()
        self._cursor.execute(sql, self.base_query['_args'])

    def _param(self, val):
        param_k = 'param_%s' % len(self.base_query['_args'].keys())
        self.base_query['_args'][param_k] = val
        return param_k

    def _build_cursor(self):
        self._execute(self.as_sql())

    def _build_record_set(self):
        self._record_set = []
        for row in self._iter_cursor_results():
            self._record_set.append(row)

    def _iter_cursor_results(self):
        col_names = [c[0] for c in self._cursor.description]
        while 1:
            row = self._cursor.fetchone()
            if row is None:
                break
            yield self._make_row(row, col_names)

    def _make_row(self, row, col_names):
        values = dict(zip(col_names, row))
        return self.sql_model.__class__(**values)

    def _check_limit(self, i):
        i = int(i)
        if i < 0:
            raise IndexError("Negative indexing is not supported")
        return i


class RawSQLModelMeta(type):

    def __new__(cls, name, bases, attrs):
        super_new = super(RawSQLModelMeta, cls).__new__
        cls = super_new(cls, name, bases, attrs)
        cls.objects = LazyRawSQLManager(cls)
        return cls


class RawSQLModel(object):
    """Very minimal model-like object based on a SQL query.

    It supports barely enough for django-tables and the Django paginator.

    Why not use database views and Meta.managed=False?  Good question!
    This is for rare cases when you need the speed and optimization of
    building a query with many different types of where clauses.
    """
    __metaclass__ = RawSQLModelMeta

    class DoesNotExist(ObjectDoesNotExist):
        pass

    MultipleObjectsReturned = MultipleObjectsReturned

    def __init__(self, **kwargs):
        for key, val in kwargs.items():
            field = getattr(self.__class__, key, None)
            if field is None:
                raise TypeError(
                    'Field %r returned from raw SQL query does not have '
                    'a column defined in the model' % key)
            setattr(self, field.get_attname() or key, field.to_python(val))

    def base_query(self):
        """Returns a dict with parts of the raw SQL query.

        Example::

            def base_query(self):
                return {
                    'select': {
                        'category': 'c.name',
                        'total': 'count(*)',
                        'latest_product_date': 'max(p.created)'
                    },
                    'from': [
                        'product p',
                        'join product_cat x on x.product_id=p.id',
                        'join category c on x.category_id=c.id'],
                    'where': [],
                    'group_by': 'category',
                    'having': []
                }
        """
        return {}

    def _explode_concat(self, value, sep=',', cast=int):
        """Returns list of IDs in a MySQL GROUP_CONCAT(field) result."""
        if value is None:
            # for NULL fields, ala left joins
            return []
        # Cope with a value like ...1261530,1261530, which occurs because of:
        # 1 line(s) were cut by GROUP_CONCAT()
        return [cast(i) for i in value.split(sep) if i]

"""
Master Boot Record
The first sector on disk, contains the partition table, bootloader, et al.

http://www.win.tue.nl/~aeb/partitions/partition_types-1.html
"""
from construct import *
from binascii import unhexlify
import six


mbr = Struct("mbr",
    HexDumpAdapter(Bytes("bootloader_code", 446)),
    Array(4,
        Struct("partitions",
            Enum(Byte("state"),
                INACTIVE = 0x00,
                ACTIVE = 0x80,
            ),
            BitStruct("beginning",
                Octet("head"),
                Bits("sect", 6),
                Bits("cyl", 10),
            ),
            Enum(UBInt8("type"),
                Nothing = 0x00,
                FAT12 = 0x01,
                XENIX_ROOT = 0x02,
                XENIX_USR = 0x03,
                FAT16_old = 0x04,
                Extended_DOS = 0x05,
                FAT16 = 0x06,
                FAT32 = 0x0b,
                FAT32_LBA = 0x0c,
                NTFS = 0x07,
                LINUX_SWAP = 0x82,
                LINUX_NATIVE = 0x83,
                _default_ = Pass,
            ),
            BitStruct("ending",
                Octet("head"),
                Bits("sect", 6),
                Bits("cyl", 10),
            ),
            UBInt32("sector_offset"), # offset from MBR in sectors
            UBInt32("size"), # in sectors
        )
    ),
    Const(Bytes("signature", 2), six.b("\x55\xAA")),
)



if __name__ == "__main__":
    cap1 = unhexlify(six.b(
    "33C08ED0BC007CFB5007501FFCBE1B7CBF1B065057B9E501F3A4CBBDBE07B104386E00"
    "7C09751383C510E2F4CD188BF583C610497419382C74F6A0B507B4078BF0AC3C0074FC"
    "BB0700B40ECD10EBF2884E10E84600732AFE4610807E040B740B807E040C7405A0B607"
    "75D2804602068346080683560A00E821007305A0B607EBBC813EFE7D55AA740B807E10"
    "0074C8A0B707EBA98BFC1E578BF5CBBF05008A5600B408CD1372238AC1243F988ADE8A"
    "FC43F7E38BD186D6B106D2EE42F7E239560A77237205394608731CB80102BB007C8B4E"
    "028B5600CD1373514F744E32E48A5600CD13EBE48A560060BBAA55B441CD13723681FB"
    "55AA7530F6C101742B61606A006A00FF760AFF76086A0068007C6A016A10B4428BF4CD"
    "136161730E4F740B32E48A5600CD13EBD661F9C3496E76616C69642070617274697469"
    "6F6E207461626C65004572726F72206C6F6164696E67206F7065726174696E67207379"
    "7374656D004D697373696E67206F7065726174696E672073797374656D000000000000"
    "0000000000000000000000000000000000000000000000000000000000000000000000"
    "00000000000000000000000000000000002C4463B7BDB7BD00008001010007FEFFFF3F"
    "000000371671020000C1FF0FFEFFFF761671028A8FDF06000000000000000000000000"
    "000000000000000000000000000000000000000055AA"))
    
    print(mbr.parse(cap1))







import functools

class GridComputeError(StandardError):
    pass

class NoSuchAxisError(StandardError):
    pass

def permute_row(values, row_length):
    if not values:
        return []

    required_length = sum(values) + len(values) - 1
    if row_length < required_length :
        raise ValueError
    permutes = []
    if len(values) == 1:
        value = values[0]
        bit_field = set_n_bits(value)
        permutes = [bit_field << i for i in reversed(xrange(0,row_length-value+1))]
        return permutes

    space_for_head = values[0] + 1
    tail = values[1:]
    min_space_for_tail = sum(tail) + len(tail) - 1
    while (space_for_head + min_space_for_tail -1 < row_length):
        tail_perms = permute_row(tail, row_length - space_for_head)
        head_perm = set_n_bits(values[0]) << (row_length-space_for_head+1)
        permutes += [head_perm | tail_perm for tail_perm in tail_perms]
        space_for_head += 1
    return permutes


def filter_out_permute(permutes, permute_filter):
    return [permute for permute in permutes if (permute & permute_filter) == permute_filter]


def set_n_bits(n):
    bit_field = 0
    for i in xrange(0,n):
        bit_field |= (1<<i)
    return bit_field

def get_filtered_column(grid,index,row_length):
    bit_mask = 1 << (row_length-1-index)
    column_length = len(grid)
    iter_mask = 1 << (column_length-1)
    value = 0
    for filtered_row in grid:
        if filtered_row & bit_mask:
            value |= iter_mask
        iter_mask >>= 1
    return value

def set_filtered_column(row_length,value,index,grid):
    formatter = "#0{}b".format(row_length + 2)
    bit_mask = 1 << (row_length-1-index)
    column_length = len(grid)
    iter_mask = 1 << (column_length-1)
    for i in xrange(0, len(grid)):
        filtered_row = grid[i]
        if iter_mask & value:
            filtered_row |= bit_mask
        grid[i] = filtered_row
        iter_mask >>= 1
    return 

def permute_values(permuted_values, value_length, values):
    return [permute_row(row_value, value_length) for row_value in values]

def get_unique_permuted_values(values):
    return [i for i in xrange(0,len(values)) if len(values[i])==1]

def get_axis_value(value, length):
    mask_bit = 1 << (length-1)
    separated_values = []
    last_bit_set=False
    formatter = "#0{}b".format(length + 2)
    while mask_bit:
        if mask_bit & value:
            if not last_bit_set:
                separated_values += [1]
            else:
                separated_values[-1]+=1
            last_bit_set=True
                
        else:
            last_bit_set=False
        mask_bit >>=1
    return separated_values
            
ROW=0
COLUMN=1

class Grid(object):
    def __init__(self,row_values,column_values,filtered_grid):
        self.row_values = row_values
        self.column_values = column_values
        self.filtered_grid = filtered_grid
        self.row_length = len(column_values)
        self.column_length = len(row_values)
        self.permuted_columns = [[]for i in xrange(self.row_length)]
        self.permuted_rows = [[] for i in xrange(self.column_length)]
        self.formatter = "#0{}b".format(self.row_length + 2)

    def get_filter_row(self,index,grid=None):
        grid = grid if grid else self.filtered_grid
        return grid[index]

    def print_value(self, value):
        print format(value, self.formatter)
        
    def get_filter_column(self, index,grid=None):
        grid = grid if grid else self.filtered_grid        
        return get_filtered_column(grid,index,self.row_length)

    def permute_row(self,index):
        permuted_row = permute_row(self.row_values[index], self.row_length)
        self.permuted_rows[index] = permuted_row
        return permuted_row

    def permute_column(self,index):
        permuted_column = permute_row(self.column_values[index], self.column_length)
        self.permuted_columns[index] = permuted_column
        return permuted_column

    def permute_rows(self):
        [self.permute_row(i) for i in xrange(0,len(self.row_values))]
        return self.permuted_rows

    def permute_columns(self):
        [self.permute_column(i) for i in xrange(0,len(self.column_values))]
        return self.permuted_columns

    def get_unique_axis(self,axis):
        if axis == ROW:
            return get_unique_permuted_values(self.permuted_rows)
        elif axis == COLUMN:
            return get_unique_permuted_values(self.permuted_columns)
        raise NoSuchAxisError
        
    def filter_rows(self, row_indices):
        for i in row_indices:
            filter = self.get_filter_row(i)
            filtered_row = filter_out_permute(self.permuted_rows[i],filter)
            self.permuted_rows[i] = filtered_row
        return self.permuted_rows
    
    def filter_columns(self, column_indices):
        for i in column_indices:
            filter = self.get_filter_column(i)
            filtered_row = filter_out_permute(self.permuted_columns[i],filter)
            self.permuted_columns[i] = filtered_row
        return self.permuted_columns

    def calculate(self):
        before_unique_columns = self.get_unique_axis(COLUMN)
        before_unique_rows = self.get_unique_axis(ROW)
        self.permute_rows()
        self.permute_columns()
        invalidated_rows = xrange(0,self.column_length)
        self.filter_unique_rows(invalidated_rows, before_unique_rows, before_unique_columns)
        self.print_filtered_grid()
        permuted_values = [([(permuted_row, False) for permuted_row in  self.permuted_rows[i]], i, ROW) for i in xrange(0,len(self.permuted_rows)) if len(self.permuted_rows[i]) != 1]
        permuted_values += [([(permuted_column, False) for permuted_column in self.permuted_columns[i]], i, COLUMN) for i in xrange(0,len(self.permuted_columns)) if len(self.permuted_columns[i]) != 1]
        permuted_values.sort(key=lambda arg: len(arg[0]))
        for permuted_value in permuted_values:
            print "no of permuted values {0} i {1} axis {2}".format(len(permuted_value[0]),permuted_value[1],permuted_value[2])
        self.print_filtered_grid()
        for permuted_pair,index,axis in permuted_values:
            for permuted_value,checked in permuted_pair:
                if not checked:
                    permuted_pair = True
                    filtered_grid = self.filtered_grid[:]
                    if axis == ROW:
                        self.set_filtered_row(permuted_value,index,filtered_grid)
                    elif axis == COLUMN:
                        self.set_filtered_column(permuted_value,index,filtered_grid)
                    try:
                        pass
#                        grid = Grid(self.row_values, self.column_values,filtered_grid)
#                        grid.calculate()
                    except GridComputeError:
                        "print try again"
                        
        
            
        
    def filter_unique_rows(self, invalidated_rows, before_unique_rows, before_unique_columns):
        permuted_rows_before = self.permuted_rows[:]
        self.filter_rows(invalidated_rows)
        unique_rows = self.get_unique_axis(ROW)
        before_filtered_grid = self.filtered_grid[:]
        for i in xrange(0,len(self.permuted_rows)):
            permute_row = self.permuted_rows[i]
            agg = ~0
            for value in permute_row:
                agg &= value
            new_value = self.get_filter_row(i) | agg
            self.set_filtered_row(new_value,i)

        get_filter_row = functools.partial(Grid.get_filter_row, self)
        invalidated_columns = self.get_invalidated_axes(xrange(0,self.row_length), before_filtered_grid, self.row_length, get_filter_row)
        if not invalidated_columns:
            return
        before_unique_rows = self.get_unique_axis(ROW)
        self.filter_unique_columns(invalidated_columns, before_unique_columns, before_unique_rows)
        for unique_column in self.get_unique_axis(COLUMN):
            if get_axis_value(self.get_filter_column(unique_column), self.column_length) != self.column_values[unique_column]:
                raise GridComputeError                
            
            

    def filter_unique_columns(self, invalidated_columns, before_unique_columns, before_unique_rows):
        self.filter_columns(invalidated_columns)
        unique_columns = self.get_unique_axis(COLUMN)
        before_filtered_grid = self.filtered_grid[:]
        for i in xrange(0,len(self.permuted_columns)):
            permute_column = self.permuted_columns[i]
            agg = ~0
            for value in permute_column:
                agg &= value
            new_value = self.get_filter_column(i) | agg
            self.set_filtered_column(new_value,i)

        get_filter_column = functools.partial(Grid.get_filter_column, self)
        invalidated_rows = self.get_invalidated_axes(xrange(0,self.column_length), before_filtered_grid, self.column_length, get_filter_column)
        if not invalidated_rows:
            return
        before_unique_columns = self.get_unique_axis(COLUMN)
        self.filter_unique_rows(invalidated_rows, before_unique_rows, before_unique_columns)
        for unique_row in self.get_unique_axis(ROW):
            if get_axis_value(self.get_filter_row(unique_row), self.row_length) != self.row_values[unique_row]:
                raise GridComputeError                
        
    def get_invalidated_axes(self, flipped_alt_axes, before_filtered_grid, alt_axis_length,get_filter_alt_axis):
        invalidated_axes = set()
        for flipped_alt_axis in flipped_alt_axes:
            before_alt_axis = get_filter_alt_axis(flipped_alt_axis,before_filtered_grid)
            after_alt_axis = get_filter_alt_axis(flipped_alt_axis,self.filtered_grid)
            if before_alt_axis & after_alt_axis != before_alt_axis:
                raise GridComputeError

            invalidated_bits = (~before_alt_axis & after_alt_axis)
            bit_mask = 1 << (alt_axis_length-1)
            index = 0
            while bit_mask:
                if bit_mask & invalidated_bits:
                    invalidated_axes.add(index)
                index += 1
                bit_mask >>= 1
        return invalidated_axes
    
    def print_filtered_grid(self):
        print "\n"
        for row in self.filtered_grid:
            print format(row, self.formatter)
    def set_filtered_row(self,value,index,grid=None):
        grid = grid if grid else self.filtered_grid
        grid[index]=value

    def set_filtered_column(self,value,index,grid=None):
        grid = grid if grid else self.filtered_grid
        set_filtered_column(self.row_length,value,index,grid)

# Copyright 2013 Red Hat, Inc.
#
#    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.

"""Provides thread-related generators

This module defines classes for threading-related
generators for generating the models in
:mod:`openstack.common.report.models.threading`.
"""

from __future__ import absolute_import

import sys
import threading

import greenlet

from nova.openstack.common.report.models import threading as tm
from nova.openstack.common.report.models import with_default_views as mwdv
from nova.openstack.common.report import utils as rutils
from nova.openstack.common.report.views.text import generic as text_views


class ThreadReportGenerator(object):
    """A Thread Data Generator

    This generator returns a collection of
    :class:`openstack.common.report.models.threading.ThreadModel`
    objects by introspecting the current python state using
    :func:`sys._current_frames()` .  Its constructor may optionally
    be passed a frame object.  This frame object will be interpreted
    as the actual stack trace for the current thread, and, come generation
    time, will be used to replace the stack trace of the thread in which
    this code is running.
    """

    def __init__(self, curr_thread_traceback=None):
        self.traceback = curr_thread_traceback

    def __call__(self):
        threadModels = dict(
            (thread_id, tm.ThreadModel(thread_id, stack))
            for thread_id, stack in sys._current_frames().items()
        )

        if self.traceback is not None:
            curr_thread_id = threading.current_thread().ident
            threadModels[curr_thread_id] = tm.ThreadModel(curr_thread_id,
                                                          self.traceback)

        return mwdv.ModelWithDefaultViews(threadModels,
                                          text_view=text_views.MultiView())


class GreenThreadReportGenerator(object):
    """A Green Thread Data Generator

    This generator returns a collection of
    :class:`openstack.common.report.models.threading.GreenThreadModel`
    objects by introspecting the current python garbage collection
    state, and sifting through for :class:`greenlet.greenlet` objects.

    .. seealso::

        Function :func:`openstack.common.report.utils._find_objects`
    """

    def __call__(self):
        threadModels = [
            tm.GreenThreadModel(gr.gr_frame)
            for gr in rutils._find_objects(greenlet.greenlet)
        ]

        return mwdv.ModelWithDefaultViews(threadModels,
                                          text_view=text_views.MultiView())

def func1():
    try:
        return "it worked"
    finally:
        print("finally 1")

print(func1())


def func2():
    try:
        return "it worked"
    finally:
        print("finally 2")

def func3():
    try:
        s = func2()
        return s + ", did this work?"
    finally:
        print("finally 3")

print(func3())

# for loop within try-finally
def f():
    try:
        for i in [1, 2]:
            return i
    finally:
        print('finally')
print(f())

# multiple for loops within try-finally
def f():
    try:
        for i in [1, 2]:
            for j in [3, 4]:
                return (i, j)
    finally:
        print('finally')
print(f())

# multiple for loops and nested try-finally's
def f():
    try:
        for i in [1, 2]:
            for j in [3, 4]:
                try:
                    for k in [5, 6]:
                        for l in [7, 8]:
                            return (i, j, k, l)
                finally:
                    print('finally 2')
    finally:
        print('finally 1')
print(f())

# multiple for loops that are optimised, and nested try-finally's
def f():
    try:
        for i in range(1, 3):
            for j in range(3, 5):
                try:
                    for k in range(5, 7):
                        for l in range(7, 9):
                            return (i, j, k, l)
                finally:
                    print('finally 2')
    finally:
        print('finally 1')
print(f())

#!/usr/bin/python

# unpkg 4.5
# http://www.timdoug.com/unpkg/
# by timdoug[.com|@gmail.com]
# 
# version notes:
#
# 4.5 -- 2010-08-26
# - get rid of ternary conditionals for compatibility with 10.4/2.3 (grr.)
# - rip out AppleScript & use Platypus' progress bar instead
# - minor refactoring and menial fixes
#
# 4.5-beta -- 2010-08-24
# - finally: metapackage extraction!
# - use new ``droplet'' Platypus type
# - lots of behind-the-scenes changes
# - compile xar for 10.4/ppc, 10.4/i386, and 10.5/x86_64 from Apple's 10.6.4 version
#   (http://opensource.apple.com/tarballs/xar/xar-36.1.tar.gz)
# - do the same with cpio
# - (http://www.opensource.apple.com/tarballs/libarchive/libarchive-14.tar.gz)
# - be more explicit about BSD licensed software
# 
# 4.0 (final. really, this time!) -- 2009-01-15
# - 10.4 doesn't have "xar" and 10.5 has 1.4, which is really
#   outdated. bundle a CVS snapshot r223 (further unmodified).
# - menial fixes and edits
#
# 4.0-pre (internal only) -- 2009-01-14
# - deals with errors much more gracefully
# - create temp folders properly
# - 10.4 has Python 2.3, which doesn't have subprocess (grr!)
#   use os.system instead
# - other little interface changes here and there
# - new (and prettier!) icon
#
# 4.0-beta (internal-only release) -- 2009-01-13
# - competely re-written in Python
# - now works with multiple packages and new, 10.5-style packages
# - ripped out CocoaDialog, simplifying the interface
# - upgraded to the (much improved) Platypus 4.0, and its Web View
# (what happened to 3.0? it's what I called a few unreleased
#  hack jobs in Cocoa/Python/Objective C...)
# 
# Copyright (C) 2009-10 timdoug
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 of the License. (NOT
# any later version!)
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.


import os
import sys
import shutil
import tempfile

XAR_PATH = '/usr/bin/xar'
CPIO_PATH = '/usr/bin/cpio'

def get_extract_dir(pkg_path):
	enclosing_path, pkg_name = os.path.split(os.path.splitext(pkg_path)[0])

	# if the enclosing path is not writable, extract to Desktop
	if not os.access(enclosing_path, os.W_OK):
		enclosing_path = os.path.join(os.environ['HOME'], 'Desktop')
	
	extract_dir = os.path.join(enclosing_path, pkg_name)
	
	if os.path.exists(extract_dir):
		orig_extract_dir = extract_dir
		for i in xrange(1, 1000):
			extract_dir = '%s-%s' % (orig_extract_dir, str(i))
			if not os.path.exists(extract_dir): break
			if i == 999: # I sure hope this never happens...
				print 'Cannot establish appropriate extraction directory.'
				sys.exit()
	
	return extract_dir

# Python 2.3 on OS X 10.4 doesn't have subprocess, so use this function instead
def run_in_path(cmd, path):
	os.chdir(path)
	os.system(cmd)

def find_pax(pkg_path):
	for root, dirs, files in os.walk(pkg_path):
		for file in files:
			if file.endswith('.pax') or file.endswith('.pax.gz'):
				return os.path.join(root, file)
	return None

def extract_package(pkg_path, extract_dir):
	
	# old style packages
	if os.path.isdir(pkg_path):
		pax_path = find_pax(pkg_path)
		if not pax_path:
			print 'Cannot find pax file. (not a valid package?)'
			return False
		os.mkdir(extract_dir)
		extract_prog = '/bin/pax -r < "%s"'
		if pax_path[-3:] == '.gz':
			extract_prog = '/usr/bin/gzcat "%s" | /bin/pax -r'
		run_in_path(extract_prog % pax_path, extract_dir)
		return True
	
	# new (10.5) style packages
	else:
		# no 'with' for compatibility with python 2.3 (10.4)
		try:
			f = open(pkg_path, 'r')
			if f.read(4) != 'xar!':
				print 'Not a valid package.'
				return False
		except IOError:
			print 'Cannot read package.'
			return False
		else:
			f.close()
		
		temp_dir = tempfile.mkdtemp()
		run_in_path('"%s" -xf "%s"' % (XAR_PATH, pkg_path), temp_dir)
		
		payloads = []
		for root, dirs, files in os.walk(temp_dir):
			for file in filter(lambda x: x == 'Payload', files):
				payloads.append(os.path.join(root, file))

		os.mkdir(extract_dir)
		extract_prog = '/usr/bin/gzcat "%s" | "' + CPIO_PATH + '" -i --quiet'
		
		if len(payloads) == 0:
			print 'No payloads found.'
			return False
		elif len(payloads) == 1:
			run_in_path(extract_prog % payloads[0], extract_dir)
		else:
			for payload in payloads:
				subpack_name = os.path.splitext(os.path.basename(os.path.dirname(payload)))[0]
				subpack_path = os.path.join(extract_dir, subpack_name)
				os.mkdir(subpack_path)
				run_in_path(extract_prog % payload, subpack_path)
		
		shutil.rmtree(temp_dir)
		return True


def main():
	for pkg_path in sys.argv[1:]:
		pkg_path = os.path.abspath(pkg_path)
		print 'Extracting "%s"...' % os.path.splitext(os.path.basename(pkg_path))[0]
		sys.stdout.flush()
		
		if not os.access(pkg_path, os.R_OK):
			print 'Cannot read package.'
			continue
		
		extract_dir = get_extract_dir(pkg_path)
		
		if pkg_path.endswith('.mpkg'):
			os.mkdir(extract_dir)
			count = 0
			for root, dirs, files in os.walk(pkg_path):
				for file in files + dirs:
					if file.endswith('.pkg'):
						subpkg_extract_dir = os.path.join(extract_dir, os.path.splitext(file)[0])
						if extract_package(os.path.join(root, file), subpkg_extract_dir):
							count += 1
			if count > 0:
				print 'Extracted %d internal package%s to "%s".' % \
					(count, ('', 's')[count > 1], extract_dir)
			else:
				shutil.rmtree(extract_dir)
				print 'No packages found within the metapackage.'
		elif pkg_path.endswith('.pkg'):
			if extract_package(pkg_path, extract_dir):
				print 'Extracted to "%s".' % extract_dir
		else:
			print 'Not a package.'
			
		print '----------------------'
	
	print 'Done!'

if __name__ == '__main__':
	main()


# This file is part of the MapProxy project.
# Copyright (C) 2010 Omniscale <http://omniscale.de>
#
# 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.

import os

import pytest

from mapproxy.client.http import HTTPClient
from mapproxy.script.wms_capabilities import wms_capabilities_command
from mapproxy.test.http import mock_httpd
from mapproxy.test.helper import capture


TESTSERVER_ADDRESS = ("127.0.0.1", 56413)
TESTSERVER_URL = "http://%s:%s" % TESTSERVER_ADDRESS
CAPABILITIES111_FILE = os.path.join(
    os.path.dirname(__file__), "fixture", "util_wms_capabilities111.xml"
)
CAPABILITIES130_FILE = os.path.join(
    os.path.dirname(__file__), "fixture", "util_wms_capabilities130.xml"
)
SERVICE_EXCEPTION_FILE = os.path.join(
    os.path.dirname(__file__), "fixture", "util_wms_capabilities_service_exception.xml"
)


class TestUtilWMSCapabilities(object):

    def setup(self):
        self.client = HTTPClient()
        self.args = ["command_dummy", "--host", TESTSERVER_URL + "/service"]

    def test_http_error(self):
        self.args = ["command_dummy", "--host", "http://foo.doesnotexist"]
        with capture() as (out, err):
            with pytest.raises(SystemExit):
                wms_capabilities_command(self.args)
        assert err.getvalue().startswith("ERROR:")

        self.args[2] = "/no/valid/url"
        with capture() as (out, err):
            with pytest.raises(SystemExit):
                wms_capabilities_command(self.args)
        assert err.getvalue().startswith("ERROR:")

    def test_request_not_parsable(self):
        with mock_httpd(
            TESTSERVER_ADDRESS,
            [
                (
                    {
                        "path": "/service?request=GetCapabilities&version=1.1.1&service=WMS",
                        "method": "GET",
                    },
                    {"status": "200", "body": ""},
                )
            ],
        ):
            with capture() as (out, err):
                with pytest.raises(SystemExit):
                    wms_capabilities_command(self.args)
            error_msg = err.getvalue().rsplit("-" * 80, 1)[1].strip()
            assert error_msg.startswith("Could not parse the document")

    def test_service_exception(self):
        self.args = [
            "command_dummy",
            "--host",
            TESTSERVER_URL + "/service?request=GetCapabilities",
        ]
        with open(SERVICE_EXCEPTION_FILE, "rb") as fp:
            capabilities_doc = fp.read()
            with mock_httpd(
                TESTSERVER_ADDRESS,
                [
                    (
                        {
                            "path": "/service?request=GetCapabilities&version=1.1.1&service=WMS",
                            "method": "GET",
                        },
                        {"status": "200", "body": capabilities_doc},
                    )
                ],
            ):
                with capture() as (out, err):
                    with pytest.raises(SystemExit):
                        wms_capabilities_command(self.args)
                error_msg = err.getvalue().rsplit("-" * 80, 1)[1].strip()
                assert "Not a capabilities document" in error_msg

    def test_parse_capabilities(self):
        self.args = [
            "command_dummy",
            "--host",
            TESTSERVER_URL + "/service?request=GetCapabilities",
            "--version",
            "1.1.1",
        ]
        with open(CAPABILITIES111_FILE, "rb") as fp:
            capabilities_doc = fp.read()
            with mock_httpd(
                TESTSERVER_ADDRESS,
                [
                    (
                        {
                            "path": "/service?request=GetCapabilities&version=1.1.1&service=WMS",
                            "method": "GET",
                        },
                        {"status": "200", "body": capabilities_doc},
                    )
                ],
            ):
                with capture() as (out, err):
                    wms_capabilities_command(self.args)
                lines = out.getvalue().split("\n")
                assert lines[1].startswith("Capabilities Document Version 1.1.1")

    def test_parse_130capabilities(self):
        self.args = [
            "command_dummy",
            "--host",
            TESTSERVER_URL + "/service?request=GetCapabilities",
            "--version",
            "1.3.0",
        ]
        with open(CAPABILITIES130_FILE, "rb") as fp:
            capabilities_doc = fp.read()
            with mock_httpd(
                TESTSERVER_ADDRESS,
                [
                    (
                        {
                            "path": "/service?request=GetCapabilities&version=1.3.0&service=WMS",
                            "method": "GET",
                        },
                        {"status": "200", "body": capabilities_doc},
                    )
                ],
            ):
                with capture() as (out, err):
                    wms_capabilities_command(self.args)
                lines = out.getvalue().split("\n")
                assert lines[1].startswith("Capabilities Document Version 1.3.0")

    def test_key_error(self):
        self.args = [
            "command_dummy",
            "--host",
            TESTSERVER_URL + "/service?request=GetCapabilities",
        ]
        with open(CAPABILITIES111_FILE, "rb") as fp:
            capabilities_doc = fp.read()
            capabilities_doc = capabilities_doc.replace(b"minx", b"foo")
            with mock_httpd(
                TESTSERVER_ADDRESS,
                [
                    (
                        {
                            "path": "/service?request=GetCapabilities&version=1.1.1&service=WMS",
                            "method": "GET",
                        },
                        {"status": "200", "body": capabilities_doc},
                    )
                ],
            ):
                with capture() as (out, err):
                    with pytest.raises(SystemExit):
                        wms_capabilities_command(self.args)

                assert err.getvalue().startswith("XML-Element has no such attribute")

# (c) 2014 Michael DeHaan, <michael@ansible.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

# Make coding more python3-ish
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os

from ansible.errors import AnsibleParserError, AnsibleError
from ansible.module_utils._text import to_native
from ansible.module_utils.six import string_types
from ansible.playbook.attribute import FieldAttribute
from ansible.playbook.base import Base
from ansible.playbook.collectionsearch import CollectionSearch
from ansible.playbook.helpers import load_list_of_roles
from ansible.playbook.role.requirement import RoleRequirement

__all__ = ['RoleMetadata']


class RoleMetadata(Base, CollectionSearch):
    '''
    This class wraps the parsing and validation of the optional metadata
    within each Role (meta/main.yml).
    '''

    _allow_duplicates = FieldAttribute(isa='bool', default=False)
    _dependencies = FieldAttribute(isa='list', default=list)
    _galaxy_info = FieldAttribute(isa='GalaxyInfo')

    def __init__(self, owner=None):
        self._owner = owner
        super(RoleMetadata, self).__init__()

    @staticmethod
    def load(data, owner, variable_manager=None, loader=None):
        '''
        Returns a new RoleMetadata object based on the datastructure passed in.
        '''

        if not isinstance(data, dict):
            raise AnsibleParserError("the 'meta/main.yml' for role %s is not a dictionary" % owner.get_name())

        m = RoleMetadata(owner=owner).load_data(data, variable_manager=variable_manager, loader=loader)
        return m

    def _load_dependencies(self, attr, ds):
        '''
        This is a helper loading function for the dependencies list,
        which returns a list of RoleInclude objects
        '''

        roles = []
        if ds:
            if not isinstance(ds, list):
                raise AnsibleParserError("Expected role dependencies to be a list.", obj=self._ds)

            for role_def in ds:
                if isinstance(role_def, string_types) or 'role' in role_def or 'name' in role_def:
                    roles.append(role_def)
                    continue
                try:
                    # role_def is new style: { src: 'galaxy.role,version,name', other_vars: "here" }
                    def_parsed = RoleRequirement.role_yaml_parse(role_def)
                    if def_parsed.get('name'):
                        role_def['name'] = def_parsed['name']
                    roles.append(role_def)
                except AnsibleError as exc:
                    raise AnsibleParserError(to_native(exc), obj=role_def, orig_exc=exc)

        current_role_path = None
        collection_search_list = None

        if self._owner:
            current_role_path = os.path.dirname(self._owner._role_path)

            # if the calling role has a collections search path defined, consult it
            collection_search_list = self._owner.collections[:] or []

            # if the calling role is a collection role, ensure that its containing collection is searched first
            owner_collection = self._owner._role_collection
            if owner_collection:
                collection_search_list = [c for c in collection_search_list if c != owner_collection]
                collection_search_list.insert(0, owner_collection)
            # ensure fallback role search works
            if 'ansible.legacy' not in collection_search_list:
                collection_search_list.append('ansible.legacy')

        try:
            return load_list_of_roles(roles, play=self._owner._play, current_role_path=current_role_path,
                                      variable_manager=self._variable_manager, loader=self._loader,
                                      collection_search_list=collection_search_list)
        except AssertionError as e:
            raise AnsibleParserError("A malformed list of role dependencies was encountered.", obj=self._ds, orig_exc=e)

    def _load_galaxy_info(self, attr, ds):
        '''
        This is a helper loading function for the galaxy info entry
        in the metadata, which returns a GalaxyInfo object rather than
        a simple dictionary.
        '''

        return ds

    def serialize(self):
        return dict(
            allow_duplicates=self._allow_duplicates,
            dependencies=self._dependencies
        )

    def deserialize(self, data):
        setattr(self, 'allow_duplicates', data.get('allow_duplicates', False))
        setattr(self, 'dependencies', data.get('dependencies', []))

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models, migrations


class Migration(migrations.Migration):

    dependencies = [
        ('harvest', '0003_activejob_failjob'),
    ]

    operations = [
        migrations.DeleteModel(
            name='ActiveJob',
        ),
        migrations.DeleteModel(
            name='FailJob',
        ),
        migrations.CreateModel(
            name='EffectiveJob',
            fields=[
            ],
            options={
                'verbose_name': 'Job (Effective)',
                'proxy': True,
                'verbose_name_plural': 'Jobs (Effective)',
            },
            bases=('harvest.job',),
        ),
        migrations.CreateModel(
            name='FailingJob',
            fields=[
            ],
            options={
                'verbose_name': 'Job (Failing)',
                'proxy': True,
                'verbose_name_plural': 'Jobs (Failing)',
            },
            bases=('harvest.job',),
        ),
        migrations.CreateModel(
            name='RunningJob',
            fields=[
            ],
            options={
                'verbose_name': 'Job (Running)',
                'proxy': True,
                'verbose_name_plural': 'Jobs (Running)',
            },
            bases=('harvest.job',),
        ),
    ]

# Copyright 2011 OpenStack Foundation
# Copyright 2011 Grid Dynamics
# Copyright 2011 Eldar Nugaev, Kirill Shileev, Ilya Alekseyev
#
#    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.

import re

import webob

from nova.api.openstack import common
from nova.api.openstack import extensions
from nova.api.openstack import wsgi
from nova import compute
from nova import exception
from nova.i18n import _


authorize = extensions.extension_authorizer('compute', 'console_output')


class ConsoleOutputController(wsgi.Controller):
    def __init__(self, *args, **kwargs):
        super(ConsoleOutputController, self).__init__(*args, **kwargs)
        self.compute_api = compute.API()

    @wsgi.action('os-getConsoleOutput')
    def get_console_output(self, req, id, body):
        """Get text console output."""
        context = req.environ['nova.context']
        authorize(context)

        instance = common.get_instance(self.compute_api, context, id)
        try:
            length = body['os-getConsoleOutput'].get('length')
        except (TypeError, KeyError):
            raise webob.exc.HTTPBadRequest(_('os-getConsoleOutput malformed '
                                             'or missing from request body'))

        if length is not None:
            try:
                # NOTE(maurosr): cast length into a string before cast into an
                # integer to avoid thing like: int(2.5) which is 2 instead of
                # raise ValueError like it would when we try int("2.5"). This
                # can be removed once we have api validation landed.
                int(str(length))
            except ValueError:
                raise webob.exc.HTTPBadRequest(_('Length in request body must '
                                                 'be an integer value'))

        try:
            output = self.compute_api.get_console_output(context,
                                                         instance,
                                                         length)
        except exception.NotFound:
            msg = _('Unable to get console')
            raise webob.exc.HTTPNotFound(explanation=msg)
        except exception.InstanceNotReady as e:
            raise webob.exc.HTTPConflict(explanation=e.format_message())
        except NotImplementedError:
            msg = _("Unable to get console log, functionality not implemented")
            raise webob.exc.HTTPNotImplemented(explanation=msg)

        # XML output is not correctly escaped, so remove invalid characters
        remove_re = re.compile('[\x00-\x08\x0B-\x1F]')
        output = remove_re.sub('', output)

        return {'output': output}


class Console_output(extensions.ExtensionDescriptor):
    """Console log output support, with tailing ability."""

    name = "ConsoleOutput"
    alias = "os-console-output"
    namespace = ("http://docs.openstack.org/compute/ext/"
                 "os-console-output/api/v2")
    updated = "2011-12-08T00:00:00Z"

    def get_controller_extensions(self):
        controller = ConsoleOutputController()
        extension = extensions.ControllerExtension(self, 'servers', controller)
        return [extension]

# -*- coding: utf-8 -*-

##################################################################
#	pyHTTPd
#	$Id$
#	(c) 2006 by Tim Taubert
##################################################################

import socket, sys, os, threading

class pHTTPServer:
	
	address_family = socket.AF_INET
	socket_type = socket.SOCK_STREAM
	request_queue_size = 5
	allow_reuse_address = False
	daemon_threads = False
	
	def __init__(self, server_address, RequestHandlerClass):
		self.server_address = server_address
		self.RequestHandlerClass = RequestHandlerClass
	
		self.socket = socket.socket(self.address_family, self.socket_type)
		self.server_bind()
		self.server_activate()
	
	def server_bind(self):
		if self.allow_reuse_address:
			self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
		self.socket.bind(self.server_address)
	
		host, port = self.socket.getsockname()[:2]
		self.server_name = socket.getfqdn(host)
		self.server_port = port
	
	def server_activate(self):
		self.socket.listen(self.request_queue_size)
	
	def serve_forever(self):
		while 1:
			self.handle_request()
	
	def get_request(self):
		return self.socket.accept()
	
	def handle_request(self):
		try:
			request, client_address = self.get_request()
		except socket.error:
			return
		if self.verify_request(request, client_address):
			try:
				self.process_request(request, client_address)
			except:
				self.handle_error(request, client_address)
				self.close_request(request)
	
	def verify_request(self, request, client_address):
		return True
	
	def process_request_thread(self, request, client_address):
		try:
			self.finish_request(request, client_address)
			self.close_request(request)
		except:
			self.handle_error(request, client_address)
			self.close_request(request)
	
	def process_request(self, request, client_address):
		t = threading.Thread(target = self.process_request_thread,
								args = (request, client_address))
		if self.daemon_threads:
			t.setDaemon (1)
		t.start()
	
	def server_close(self):
		self.socket.close()
	
	def finish_request(self, request, client_address):
		self.RequestHandlerClass(request, client_address, self)
	
	def close_request(self, request):
		request.close()
	
	def fileno(self):
		return self.socket.fileno()
	
	def handle_error(self, request, client_address):
		print '-'*40
		print 'Exception happened during processing of request from',
		print client_address
		import traceback
		traceback.print_exc() # XXX But this goes to stderr!
		print '-'*40

# -*- coding: utf-8 -*-
r'''
    werkzeug.script
    ~~~~~~~~~~~~~~~

    .. admonition:: Deprecated Functionality

       ``werkzeug.script`` is deprecated without replacement functionality.
       Python's command line support improved greatly with :mod:`argparse`
       and a bunch of alternative modules.

    Most of the time you have recurring tasks while writing an application
    such as starting up an interactive python interpreter with some prefilled
    imports, starting the development server, initializing the database or
    something similar.

    For that purpose werkzeug provides the `werkzeug.script` module which
    helps you writing such scripts.


    Basic Usage
    -----------

    The following snippet is roughly the same in every werkzeug script::

        #!/usr/bin/env python
        # -*- coding: utf-8 -*-
        from werkzeug import script

        # actions go here

        if __name__ == '__main__':
            script.run()

    Starting this script now does nothing because no actions are defined.
    An action is a function in the same module starting with ``"action_"``
    which takes a number of arguments where every argument has a default.  The
    type of the default value specifies the type of the argument.

    Arguments can then be passed by position or using ``--name=value`` from
    the shell.

    Because a runserver and shell command is pretty common there are two
    factory functions that create such commands::

        def make_app():
            from yourapplication import YourApplication
            return YourApplication(...)

        action_runserver = script.make_runserver(make_app, use_reloader=True)
        action_shell = script.make_shell(lambda: {'app': make_app()})


    Using The Scripts
    -----------------

    The script from above can be used like this from the shell now:

    .. sourcecode:: text

        $ ./manage.py --help
        $ ./manage.py runserver localhost 8080 --debugger --no-reloader
        $ ./manage.py runserver -p 4000
        $ ./manage.py shell

    As you can see it's possible to pass parameters as positional arguments
    or as named parameters, pretty much like Python function calls.


    :copyright: (c) 2014 by the Werkzeug Team, see AUTHORS for more details.
    :license: BSD, see LICENSE for more details.
'''
from __future__ import print_function

import sys
import inspect
import getopt
from warnings import warn
from os.path import basename
from werkzeug._compat import iteritems


argument_types = {
    bool:       'boolean',
    str:        'string',
    int:        'integer',
    float:      'float'
}


converters = {
    'boolean': lambda x: x.lower() in ('1', 'true', 'yes', 'on'),
    'string':   str,
    'integer':  int,
    'float':    float
}


def _deprecated():
    warn(DeprecationWarning('werkzeug.script is deprecated and '
                            'will be removed soon'), stacklevel=2)


def run(namespace=None, action_prefix='action_', args=None):
    """Run the script.  Participating actions are looked up in the caller's
    namespace if no namespace is given, otherwise in the dict provided.
    Only items that start with action_prefix are processed as actions.  If
    you want to use all items in the namespace provided as actions set
    action_prefix to an empty string.

    :param namespace: An optional dict where the functions are looked up in.
                      By default the local namespace of the caller is used.
    :param action_prefix: The prefix for the functions.  Everything else
                          is ignored.
    :param args: the arguments for the function.  If not specified
                 :data:`sys.argv` without the first argument is used.
    """
    _deprecated()
    if namespace is None:
        namespace = sys._getframe(1).f_locals
    actions = find_actions(namespace, action_prefix)

    if args is None:
        args = sys.argv[1:]
    if not args or args[0] in ('-h', '--help'):
        return print_usage(actions)
    elif args[0] not in actions:
        fail('Unknown action \'%s\'' % args[0])

    arguments = {}
    types = {}
    key_to_arg = {}
    long_options = []
    formatstring = ''
    func, doc, arg_def = actions[args.pop(0)]
    for idx, (arg, shortcut, default, option_type) in enumerate(arg_def):
        real_arg = arg.replace('-', '_')
        if shortcut:
            formatstring += shortcut
            if not isinstance(default, bool):
                formatstring += ':'
            key_to_arg['-' + shortcut] = real_arg
        long_options.append(isinstance(default, bool) and arg or arg + '=')
        key_to_arg['--' + arg] = real_arg
        key_to_arg[idx] = real_arg
        types[real_arg] = option_type
        arguments[real_arg] = default

    try:
        optlist, posargs = getopt.gnu_getopt(args, formatstring, long_options)
    except getopt.GetoptError as e:
        fail(str(e))

    specified_arguments = set()
    for key, value in enumerate(posargs):
        try:
            arg = key_to_arg[key]
        except IndexError:
            fail('Too many parameters')
        specified_arguments.add(arg)
        try:
            arguments[arg] = converters[types[arg]](value)
        except ValueError:
            fail('Invalid value for argument %s (%s): %s' % (key, arg, value))

    for key, value in optlist:
        arg = key_to_arg[key]
        if arg in specified_arguments:
            fail('Argument \'%s\' is specified twice' % arg)
        if types[arg] == 'boolean':
            if arg.startswith('no_'):
                value = 'no'
            else:
                value = 'yes'
        try:
            arguments[arg] = converters[types[arg]](value)
        except ValueError:
            fail('Invalid value for \'%s\': %s' % (key, value))

    newargs = {}
    for k, v in iteritems(arguments):
        newargs[k.startswith('no_') and k[3:] or k] = v
    arguments = newargs
    return func(**arguments)


def fail(message, code=-1):
    """Fail with an error."""
    _deprecated()
    print('Error: %s' % message, file=sys.stderr)
    sys.exit(code)


def find_actions(namespace, action_prefix):
    """Find all the actions in the namespace."""
    _deprecated()
    actions = {}
    for key, value in iteritems(namespace):
        if key.startswith(action_prefix):
            actions[key[len(action_prefix):]] = analyse_action(value)
    return actions


def print_usage(actions):
    """Print the usage information.  (Help screen)"""
    _deprecated()
    actions = sorted(iteritems(actions))
    print('usage: %s <action> [<options>]' % basename(sys.argv[0]))
    print('       %s --help' % basename(sys.argv[0]))
    print()
    print('actions:')
    for name, (func, doc, arguments) in actions:
        print('  %s:' % name)
        for line in doc.splitlines():
            print('    %s' % line)
        if arguments:
            print()
        for arg, shortcut, default, argtype in arguments:
            if isinstance(default, bool):
                print('    %s' % (
                    (shortcut and '-%s, ' % shortcut or '') + '--' + arg
                ))
            else:
                print('    %-30s%-10s%s' % (
                    (shortcut and '-%s, ' % shortcut or '') + '--' + arg,
                    argtype, default
                ))
        print()


def analyse_action(func):
    """Analyse a function."""
    _deprecated()
    description = inspect.getdoc(func) or 'undocumented action'
    arguments = []
    args, varargs, kwargs, defaults = inspect.getargspec(func)
    if varargs or kwargs:
        raise TypeError('variable length arguments for action not allowed.')
    if len(args) != len(defaults or ()):
        raise TypeError('not all arguments have proper definitions')

    for idx, (arg, definition) in enumerate(zip(args, defaults or ())):
        if arg.startswith('_'):
            raise TypeError('arguments may not start with an underscore')
        if not isinstance(definition, tuple):
            shortcut = None
            default = definition
        else:
            shortcut, default = definition
        argument_type = argument_types[type(default)]
        if isinstance(default, bool) and default is True:
            arg = 'no-' + arg
        arguments.append((arg.replace('_', '-'), shortcut,
                          default, argument_type))
    return func, description, arguments


def make_shell(init_func=None, banner=None, use_ipython=True):
    """Returns an action callback that spawns a new interactive
    python shell.

    :param init_func: an optional initialization function that is
                      called before the shell is started.  The return
                      value of this function is the initial namespace.
    :param banner: the banner that is displayed before the shell.  If
                   not specified a generic banner is used instead.
    :param use_ipython: if set to `True` ipython is used if available.
    """
    _deprecated()
    if banner is None:
        banner = 'Interactive Werkzeug Shell'
    if init_func is None:
        init_func = dict

    def action(ipython=use_ipython):
        """Start a new interactive python session."""
        namespace = init_func()
        if ipython:
            try:
                try:
                    from IPython.frontend.terminal.embed import InteractiveShellEmbed
                    sh = InteractiveShellEmbed(banner1=banner)
                except ImportError:
                    from IPython.Shell import IPShellEmbed
                    sh = IPShellEmbed(banner=banner)
            except ImportError:
                pass
            else:
                sh(global_ns={}, local_ns=namespace)
                return
        from code import interact
        interact(banner, local=namespace)
    return action


def make_runserver(app_factory, hostname='localhost', port=5000,
                   use_reloader=False, use_debugger=False, use_evalex=True,
                   threaded=False, processes=1, static_files=None,
                   extra_files=None, ssl_context=None):
    """Returns an action callback that spawns a new development server.

    .. versionadded:: 0.5
       `static_files` and `extra_files` was added.

    ..versionadded:: 0.6.1
       `ssl_context` was added.

    :param app_factory: a function that returns a new WSGI application.
    :param hostname: the default hostname the server should listen on.
    :param port: the default port of the server.
    :param use_reloader: the default setting for the reloader.
    :param use_evalex: the default setting for the evalex flag of the debugger.
    :param threaded: the default threading setting.
    :param processes: the default number of processes to start.
    :param static_files: optional dict of static files.
    :param extra_files: optional list of extra files to track for reloading.
    :param ssl_context: optional SSL context for running server in HTTPS mode.
    """
    _deprecated()
    def action(hostname=('h', hostname), port=('p', port),
               reloader=use_reloader, debugger=use_debugger,
               evalex=use_evalex, threaded=threaded, processes=processes):
        """Start a new development server."""
        from werkzeug.serving import run_simple
        app = app_factory()
        run_simple(hostname, port, app,
                   use_reloader=reloader, use_debugger=debugger,
                   use_evalex=evalex, extra_files=extra_files,
                   reloader_interval=1, threaded=threaded, processes=processes,
                   static_files=static_files, ssl_context=ssl_context)
    return action

#!/usr/bin/env python

"""
Copyright (c) 2006-2013 sqlmap developers (http://sqlmap.org/)
See the file 'doc/COPYING' for copying permission
"""

import os
import re

from lib.core.common import singleTimeWarnMessage
from lib.core.data import kb
from lib.core.enums import DBMS
from lib.core.enums import PRIORITY
from lib.core.settings import IGNORE_SPACE_AFFECTED_KEYWORDS

__priority__ = PRIORITY.HIGHER

def dependencies():
    singleTimeWarnMessage("tamper script '%s' is only meant to be run against %s < 5.1" % (os.path.basename(__file__).split(".")[0], DBMS.MYSQL))

def tamper(payload, **kwargs):
    """
    Adds versioned MySQL comment before each keyword

    Requirement:
        * MySQL < 5.1

    Tested against:
        * MySQL 4.0.18, 5.0.22

    Notes:
        * Useful to bypass several web application firewalls when the
          back-end database management system is MySQL
        * Used during the ModSecurity SQL injection challenge,
          http://modsecurity.org/demo/challenge.html

    >>> tamper("value' UNION ALL SELECT CONCAT(CHAR(58,107,112,113,58),IFNULL(CAST(CURRENT_USER() AS CHAR),CHAR(32)),CHAR(58,97,110,121,58)), NULL, NULL# AND 'QDWa'='QDWa")
    "value'/*!0UNION/*!0ALL/*!0SELECT/*!0CONCAT(/*!0CHAR(58,107,112,113,58),/*!0IFNULL(CAST(/*!0CURRENT_USER()/*!0AS/*!0CHAR),/*!0CHAR(32)),/*!0CHAR(58,97,110,121,58)),/*!0NULL,/*!0NULL#/*!0AND 'QDWa'='QDWa"
    """

    def process(match):
        word = match.group('word')
        if word.upper() in kb.keywords and word.upper() not in IGNORE_SPACE_AFFECTED_KEYWORDS:
            return match.group().replace(word, "/*!0%s" % word)
        else:
            return match.group()

    retVal = payload

    if payload:
        retVal = re.sub(r"(?<=\W)(?P<word>[A-Za-z_]+)(?=\W|\Z)", lambda match: process(match), retVal)
        retVal = retVal.replace(" /*!0", "/*!0")

    return retVal

import os
import time
from subprocess import Popen, PIPE
import re
import os
import socket

if os.name != "nt":
    import fcntl
    import struct

    def get_interface_ip(ifname):
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        return socket.inet_ntoa(fcntl.ioctl(s.fileno(), 0x8915, struct.pack('256s',
                                ifname[:15]))[20:24])

def get_lan_ip():
    ip = socket.gethostbyname(socket.gethostname())
    if ip.startswith("127.") and os.name != "nt":
        interfaces = [
            "eth0",
            "eth1",
            "eth2",
            "wlan0",
            "wlan1",
            "wifi0",
            "ath0",
            "ath1",
            "ppp0",
            ]
        for ifname in interfaces:
            try:
                ip = get_interface_ip(ifname)
                break
            except IOError:
                pass
    return ip
os.system("clear")
uip=[]
macar=[]
lanip=get_lan_ip()
notorm=re.search(r"([1-9])\d+$", lanip)
notorm=notorm.group(0)
lanip=lanip.replace(str(notorm),"")
knowmac={"":""}
def rescan():
 devnull = open(os.devnull, 'wb')
 
 p = [] # ip -> process
 for n in range(1, 100): # start ping processes
    ip = str(lanip) + "%d" % n
    p.append((ip, Popen(['ping', '-c', '3', ip], stdout=devnull)))
    #NOTE: you could set stderr=subprocess.STDOUT to ignore stderr also
 os.system("clear")
 while p:
     for i, (ip, proc) in enumerate(p[:]):
         if proc.poll() is not None: # ping finished
             p.remove((ip, proc)) # this makes it O(n**2)
             if proc.returncode == 0:
                 uip.append(ip)
 devnull.close()
 os.system("clear")
 for ipaddr in uip:
  pid = Popen(["arp", "-n", ipaddr], stdout=PIPE)
  s = pid.communicate()[0]
  mac = re.search(r"(([a-f\d]{1,2}\:){5}[a-f\d]{1,2})", s)
  macar.append(mac.group(0) if mac else "")
while True:
 os.system("clear")
 rescan()
 for dev in macar:
  if str(dev) in knowmac:
   print knowmac[dev], "is on the network"
   del macar[:]
 time.sleep(30)
 os.system("clear")
 print "Refreshing"

#!/usr/bin/env python
# vim: set fileencoding=utf-8 :
# Andre Anjos <andre.anjos@idiap.ch>
# Wed 16 Apr 09:35:37 2014 CEST

"""Tests for flandmark python bindings
"""

import os
import numpy
import functools
import pkg_resources
import nose.tools
import bob.io.base
import bob.io.image
import bob.ip.color

from . import Flandmark

def F(f):
  """Returns the test file on the "data" subdirectory"""
  return pkg_resources.resource_filename(__name__, os.path.join('data', f))

LENA = F('lena.jpg')
LENA_BBX = [
    [214, 202, 183, 183]
    ]

MULTI = F('multi.jpg')
MULTI_BBX = [
    [326, 20, 31, 31],
    [163, 25, 34, 34],
    [253, 42, 28, 28],
    ]


def pnpoly(point, vertices):
  """Python translation of the C algorithm taken from:
  http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
  """

  (x, y) = point
  j = vertices[-1]
  c = False
  for i in vertices:
    if ( (i[1] > y) != (j[1] > y) ) and \
        ( x < (((j[0]-i[0]) * (y-i[1]) / (j[1]-i[1])) + i[0]) ):
      c = not c
    j = i

  return c

def is_inside(point, box, eps=1e-5):
  """Calculates if a point lies inside a bounding box"""

  (y, x, height, width) = box
  #note: vertices must be organized clockwise
  vertices = numpy.array([
    (x-eps, y-eps),
    (x+width+eps, y-eps),
    (x+width+eps, y+height+eps),
    (x-eps, y+height+eps),
    ], dtype=float)
  return pnpoly((point[1], point[0]), vertices)


def test_is_inside():

  box = (0, 0, 1, 1)

  # really inside
  assert is_inside((0.5, 0.5), box, eps=1e-10)

  # on the limit of the box
  assert is_inside((0.0, 0.0), box, eps=1e-10)
  assert is_inside((1.0, 1.0), box, eps=1e-10)
  assert is_inside((1.0, 0.0), box, eps=1e-10)
  assert is_inside((0.0, 1.0), box, eps=1e-10)

def test_is_outside():

  box = (0, 0, 1, 1)

  # really outside the box
  assert not is_inside((1.5, 1.0), box, eps=1e-10)
  assert not is_inside((0.5, 1.5), box, eps=1e-10)
  assert not is_inside((1.5, 1.5), box, eps=1e-10)
  assert not is_inside((-0.5, -0.5), box, eps=1e-10)


def test_lena():

  img = bob.io.base.load(LENA)
  gray = bob.ip.color.rgb_to_gray(img)
  (x, y, width, height) = LENA_BBX[0]

  flm = Flandmark()
  keypoints = flm.locate(gray, y, x, height, width)
  nose.tools.eq_(keypoints.shape, (8, 2))
  nose.tools.eq_(keypoints.dtype, 'float64')
  for k in keypoints:
    assert is_inside(k, (y, x, height, width), eps=1)

def test_full_image():

  img = bob.io.base.load(LENA)
  gray = bob.ip.color.rgb_to_gray(img)

  flm = Flandmark()
  lm1 = flm.locate(gray, 0, 0, gray.shape[0], gray.shape[1])
  lm2 = flm.locate(gray)
  assert all(numpy.allclose(lm1[i],lm2[i]) for i in range(len(lm1)))



def test_multi():

  img = bob.io.base.load(MULTI)
  gray = bob.ip.color.rgb_to_gray(img)

  flm = Flandmark()
  for (x, y, width, height) in MULTI_BBX:
    keypoints = flm.locate(gray, y, x, height, width)
    nose.tools.eq_(keypoints.shape, (8, 2))
    nose.tools.eq_(keypoints.dtype, 'float64')
    for k in keypoints:
      assert is_inside(k, (y, x, height, width), eps=1)

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Business Applications
#    Copyright (c) 2012-TODAY OpenERP S.A. <http://openerp.com>
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from . import test_multicompany

checks = [
    test_multicompany,
]

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

#!/usr/bin/env python
#
# Copyright 2012-2013 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

from gnuradio import gr, gr_unittest, blocks

class test_probe_signal(gr_unittest.TestCase):

    def setUp(self):
        self.tb = gr.top_block()

    def tearDown(self):
        self.tb = None

    def test_001(self):
        value = 12.3
        repeats = 100
        src_data = [value] * repeats

        src = blocks.vector_source_f(src_data)
        dst = blocks.probe_signal_f()

        self.tb.connect(src, dst)
        self.tb.run()
        output = dst.level()
        self.assertAlmostEqual(value, output, places=6)

    def test_002(self):
        vector_length = 10
        repeats = 10
        value = [0.5+i for i in range(0, vector_length)]
        src_data = value * repeats

        src = blocks.vector_source_f(src_data)
        s2v = blocks.stream_to_vector(gr.sizeof_float, vector_length)
        dst = blocks.probe_signal_vf(vector_length)

        self.tb.connect(src, s2v, dst)
        self.tb.run()
        output = dst.level()
        self.assertEqual(len(output), vector_length)
        self.assertAlmostEqual(value[3], output[3], places=6)

if __name__ == '__main__':
    gr_unittest.run(test_probe_signal, "test_probe_signal.xml")

# -*- coding: utf-8 -*-
from .Qt import QtCore
from .ptime import time
from . import ThreadsafeTimer
import weakref

__all__ = ['SignalProxy']

class SignalProxy(QtCore.QObject):
    """Object which collects rapid-fire signals and condenses them
    into a single signal or a rate-limited stream of signals. 
    Used, for example, to prevent a SpinBox from generating multiple 
    signals when the mouse wheel is rolled over it.
    
    Emits sigDelayed after input signals have stopped for a certain period of time.
    """
    
    sigDelayed = QtCore.Signal(object)
    
    def __init__(self, signal, delay=0.3, rateLimit=0, slot=None):
        """Initialization arguments:
        signal - a bound Signal or pyqtSignal instance
        delay - Time (in seconds) to wait for signals to stop before emitting (default 0.3s)
        slot - Optional function to connect sigDelayed to.
        rateLimit - (signals/sec) if greater than 0, this allows signals to stream out at a 
                    steady rate while they are being received.
        """
        
        QtCore.QObject.__init__(self)
        signal.connect(self.signalReceived)
        self.signal = signal
        self.delay = delay
        self.rateLimit = rateLimit
        self.args = None
        self.timer = ThreadsafeTimer.ThreadsafeTimer()
        self.timer.timeout.connect(self.flush)
        self.block = False
        self.slot = weakref.ref(slot)
        self.lastFlushTime = None
        if slot is not None:
            self.sigDelayed.connect(slot)
        
    def setDelay(self, delay):
        self.delay = delay
        
    def signalReceived(self, *args):
        """Received signal. Cancel previous timer and store args to be forwarded later."""
        if self.block:
            return
        self.args = args
        if self.rateLimit == 0:
            self.timer.stop()
            self.timer.start((self.delay*1000)+1)
        else:
            now = time()
            if self.lastFlushTime is None:
                leakTime = 0
            else:
                lastFlush = self.lastFlushTime
                leakTime = max(0, (lastFlush + (1.0 / self.rateLimit)) - now)
                
            self.timer.stop()
            self.timer.start((min(leakTime, self.delay)*1000)+1)
            
        
    def flush(self):
        """If there is a signal queued up, send it now."""
        if self.args is None or self.block:
            return False
        #self.emit(self.signal, *self.args)
        self.sigDelayed.emit(self.args)
        self.args = None
        self.timer.stop()
        self.lastFlushTime = time()
        return True
        
    def disconnect(self):
        self.block = True
        try:
            self.signal.disconnect(self.signalReceived)
        except:
            pass
        try:
            self.sigDelayed.disconnect(self.slot())
        except:
            pass
   
   

#def proxyConnect(source, signal, slot, delay=0.3):
    #"""Connect a signal to a slot with delay. Returns the SignalProxy
    #object that was created. Be sure to store this object so it is not
    #garbage-collected immediately."""
    #sp = SignalProxy(source, signal, delay)
    #if source is None:
        #sp.connect(sp, QtCore.SIGNAL('signal'), slot)
    #else:
        #sp.connect(sp, signal, slot)
    #return sp
    
    
if __name__ == '__main__':
    from .Qt import QtGui
    app = QtGui.QApplication([])
    win = QtGui.QMainWindow()
    spin = QtGui.QSpinBox()
    win.setCentralWidget(spin)
    win.show()
    
    def fn(*args):
        print("Raw signal:", args)
    def fn2(*args):
        print("Delayed signal:", args)
    
    
    spin.valueChanged.connect(fn)
    #proxy = proxyConnect(spin, QtCore.SIGNAL('valueChanged(int)'), fn)
    proxy = SignalProxy(spin.valueChanged, delay=0.5, slot=fn2)
        
from __future__ import absolute_import, division, print_function

from .common import Benchmark

import numpy as np

from six.moves import xrange


class LaplaceInplace(Benchmark):
    params = ['inplace', 'normal']
    param_names = ['update']

    def setup(self, update):
        N = 150
        Niter = 1000
        dx = 0.1
        dy = 0.1
        dx2 = (dx * dx)
        dy2 = (dy * dy)

        def num_update(u, dx2, dy2):
            u[1:(-1), 1:(-1)] = ((((u[2:, 1:(-1)] + u[:(-2), 1:(-1)]) * dy2) +
                                  ((u[1:(-1), 2:] + u[1:(-1), :(-2)]) * dx2))
                                 / (2 * (dx2 + dy2)))

        def num_inplace(u, dx2, dy2):
            tmp = u[:(-2), 1:(-1)].copy()
            np.add(tmp, u[2:, 1:(-1)], out=tmp)
            np.multiply(tmp, dy2, out=tmp)
            tmp2 = u[1:(-1), 2:].copy()
            np.add(tmp2, u[1:(-1), :(-2)], out=tmp2)
            np.multiply(tmp2, dx2, out=tmp2)
            np.add(tmp, tmp2, out=tmp)
            np.multiply(tmp, (1.0 / (2.0 * (dx2 + dy2))),
                        out=u[1:(-1), 1:(-1)])

        def laplace(N, Niter=100, func=num_update, args=()):
            u = np.zeros([N, N], order='C')
            u[0] = 1
            for i in range(Niter):
                func(u, *args)
            return u

        func = {'inplace': num_inplace, 'normal': num_update}[update]

        def run():
            laplace(N, Niter, func, args=(dx2, dy2))

        self.run = run

    def time_it(self, update):
        self.run()


class MaxesOfDots(Benchmark):
    def setup(self):
        np.random.seed(1)
        nsubj = 5
        nfeat = 100
        ntime = 200

        self.arrays = [np.random.normal(size=(ntime, nfeat))
                       for i in xrange(nsubj)]

    def maxes_of_dots(self, arrays):
        """
        A magical feature score for each feature in each dataset
        :ref:`Haxby et al., Neuron (2011) <HGC+11>`.
        If arrays are column-wise zscore-d before computation it
        results in characterizing each column in each array with
        sum of maximal correlations of that column with columns
        in other arrays.

        Arrays must agree only on the first dimension.

        For numpy it a join benchmark of dot products and max()
        on a set of arrays.
        """
        feature_scores = ([0] * len(arrays))
        for (i, sd) in enumerate(arrays):
            for (j, sd2) in enumerate(arrays[(i + 1):]):
                corr_temp = np.dot(sd.T, sd2)
                feature_scores[i] += np.max(corr_temp, axis=1)
                feature_scores[((j + i) + 1)] += np.max(corr_temp, axis=0)
        return feature_scores

    def time_it(self):
        self.maxes_of_dots(self.arrays)

# This build on top of test6 by adding overrides for libs in the application

expected_results = {
   "base": {
        "desc": "override values based on labels with libs (no labels)",
        "app.app1": "v_app1",
        "app.app2": "v_app2",
        "lib1.p1": "v_p1_lib1_app",
        "lib1.p2": "v_p2_lib1",
        "lib1.p3": "v_p3_lib1_app",
        "lib2.p1": "v_p1_lib2_app",
        "lib2.p2": "v_p2_lib2"
    },
    "b1": {
        "desc": "override values based on labels with libs (first label)",
        "app.app1": "v_app1[b1_label]",
        "app.app2": "v_app2",
        "lib1.p1": "v_p1_lib1_app",
        "lib1.p2": "v_p2_lib1",
        "lib1.p3": "v_p3_lib1_app",
        "lib2.p1": "v_p1_lib2_app",
        "lib2.p2": "v_p2_lib2[b1_label]"
    },
    "b2": {
        "desc": "override values based on labels with libs (second label)",
        "app.app1": "v_app1",
        "app.app2": "v_app2[b2_label]",
        "lib1.p1": "v_p1_lib1_app",
        "lib1.p2": "v_p2_lib1[b2_label]",
        "lib1.p3": "v_p3_lib1_app",
        "lib2.p1": "v_p1_lib2_app",
        "lib2.p2": "v_p2_lib2[b2_label]"
    },
    # The values for lib2.p1 and lib2.p2 illustrate how overriding on multiple
    # labels work. In lib2, both lib2.p1 and lib2.p2 are overriden for both
    # labels (b1_label and b2_label). However, since "b2_label" is specified
    # after "b1_label", it sets the final values of the overrides.
    "both": {
        "desc": "override values based on labels with libs (both labels)",
        "app.app1": "v_app1[b1_label]",
        "app.app2": "v_app2[b2_label]",
        "lib1.p1": "v_p1_lib1_app",
        "lib1.p2": "v_p2_lib1[b2_label]",
        "lib1.p3": "v_p3_lib1_app",
        "lib2.p1": "v_p1_lib2_app",
        "lib2.p2": "v_p2_lib2[b2_label]"
    }
}

# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Methods to allow dict of numpy arrays."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import collections
from tensorflow.python.estimator.inputs.queues import feeding_functions

# Key name to pack the target into dict of `features`. See
# `_get_unique_target_key` for details.
_TARGET_KEY = '__target_key__'


def _get_unique_target_key(features):
  """Returns a key not existed in the input dict `features`.

  Caller of `input_fn` usually provides `features` (dict of numpy arrays) and
  `target`, but the underlying feeding module expects a single dict of numpy
  arrays as input. So, the `target` needs to be packed into the `features`
  temporarily and unpacked after calling the feeding function. Toward this goal,
  this function returns a key not existed in the `features` to pack the
  `target`.
  """
  target_key = _TARGET_KEY
  while target_key in features:
    target_key += '_n'
  return target_key


def numpy_input_fn(x,
                   y=None,
                   batch_size=128,
                   num_epochs=1,
                   shuffle=None,
                   queue_capacity=1000,
                   num_threads=1):
  """Returns input function that would feed dict of numpy arrays into the model.

  This returns a function outputting `features` and `target` based on the dict
  of numpy arrays. The dict `features` has the same keys as the `x`.

  Example:
  ```python
  age = np.arange(4) * 1.0
  height = np.arange(32, 36)
  x = {'age': age, 'height': height}
  y = np.arange(-32, -28)

  with tf.Session() as session:
    input_fn = numpy_io.numpy_input_fn(
        x, y, batch_size=2, shuffle=False, num_epochs=1)
  ```

  Args:
    x: dict of numpy array object.
    y: numpy array object. `None` if absent.
    batch_size: Integer, size of batches to return.
    num_epochs: Integer, number of epochs to iterate over data. If `None` will
      run forever.
    shuffle: Boolean, if True shuffles the queue. Avoid shuffle at prediction
      time.
    queue_capacity: Integer, size of queue to accumulate.
    num_threads: Integer, number of threads used for reading and enqueueing. In
      order to have predicted and repeatable order of reading and enqueueing,
      such as in prediction and evaluation mode, `num_threads` should be 1.

  Returns:
    Function, that has signature of ()->(dict of `features`, `target`)

  Raises:
    ValueError: if the shape of `y` mismatches the shape of values in `x` (i.e.,
      values in `x` have same shape).
    TypeError: `x` is not a dict or `shuffle` is not bool.
  """

  if not isinstance(shuffle, bool):
    raise TypeError('shuffle must be explicitly set as boolean; '
                    'got {}'.format(shuffle))

  def input_fn():
    """Numpy input function."""
    if not isinstance(x, dict):
      raise TypeError('x must be dict; got {}'.format(type(x).__name__))

    # Make a shadow copy and also ensure the order of iteration is consistent.
    ordered_dict_x = collections.OrderedDict(
        sorted(x.items(), key=lambda t: t[0]))

    unique_target_key = _get_unique_target_key(ordered_dict_x)
    if y is not None:
      ordered_dict_x[unique_target_key] = y

    if len(set(v.shape[0] for v in ordered_dict_x.values())) != 1:
      shape_dict_of_x = {k: ordered_dict_x[k].shape
                         for k in ordered_dict_x.keys()}
      shape_of_y = None if y is None else y.shape
      raise ValueError('Length of tensors in x and y is mismatched. All '
                       'elements in x and y must have the same length.\n'
                       'Shapes in x: {}\n'
                       'Shape for y: {}\n'.format(shape_dict_of_x, shape_of_y))

    queue = feeding_functions._enqueue_data(  # pylint: disable=protected-access
        ordered_dict_x,
        queue_capacity,
        shuffle=shuffle,
        num_threads=num_threads,
        enqueue_size=batch_size,
        num_epochs=num_epochs)

    features = (queue.dequeue_many(batch_size) if num_epochs is None
                else queue.dequeue_up_to(batch_size))

    # Remove the first `Tensor` in `features`, which is the row number.
    if len(features) > 0:
      features.pop(0)

    features = dict(zip(ordered_dict_x.keys(), features))
    if y is not None:
      target = features.pop(unique_target_key)
      return features, target
    return features

  return input_fn

class BaseSpatialOperations(object):
    """
    This module holds the base `BaseSpatialBackend` object, which is
    instantiated by each spatial database backend with the features
    it has.
    """
    truncate_params = {}

    # Quick booleans for the type of this spatial backend, and
    # an attribute for the spatial database version tuple (if applicable)
    postgis = False
    spatialite = False
    mysql = False
    oracle = False
    spatial_version = None

    # How the geometry column should be selected.
    select = None

    # Does the spatial database have a geometry or geography type?
    geography = False
    geometry = False

    area = False
    bounding_circle = False
    centroid = False
    difference = False
    distance = False
    distance_sphere = False
    distance_spheroid = False
    envelope = False
    force_rhr = False
    mem_size = False
    num_geom = False
    num_points = False
    perimeter = False
    perimeter3d = False
    point_on_surface = False
    polygonize = False
    reverse = False
    scale = False
    snap_to_grid = False
    sym_difference = False
    transform = False
    translate = False
    union = False

    # Aggregates
    disallowed_aggregates = ()

    geom_func_prefix = ''

    # Mapping between Django function names and backend names, when names do not
    # match; used in spatial_function_name().
    function_names = {}

    # Blacklist/set of known unsupported functions of the backend
    unsupported_functions = {
        'Area', 'AsGeoJSON', 'AsGML', 'AsKML', 'AsSVG',
        'BoundingCircle', 'Centroid', 'Difference', 'Distance', 'Envelope',
        'ForceRHR', 'GeoHash', 'Intersection', 'IsValid', 'Length', 'MakeValid',
        'MemSize', 'NumGeometries', 'NumPoints', 'Perimeter', 'PointOnSurface',
        'Reverse', 'Scale', 'SnapToGrid', 'SymDifference', 'Transform',
        'Translate', 'Union',
    }

    # Serialization
    geohash = False
    geojson = False
    gml = False
    kml = False
    svg = False

    # Constructors
    from_text = False
    from_wkb = False

    # Default conversion functions for aggregates; will be overridden if implemented
    # for the spatial backend.
    def convert_extent(self, box, srid):
        raise NotImplementedError('Aggregate extent not implemented for this spatial backend.')

    def convert_extent3d(self, box, srid):
        raise NotImplementedError('Aggregate 3D extent not implemented for this spatial backend.')

    # For quoting column values, rather than columns.
    def geo_quote_name(self, name):
        return "'%s'" % name

    # GeometryField operations
    def geo_db_type(self, f):
        """
        Returns the database column type for the geometry field on
        the spatial backend.
        """
        raise NotImplementedError('subclasses of BaseSpatialOperations must provide a geo_db_type() method')

    def get_distance(self, f, value, lookup_type):
        """
        Returns the distance parameters for the given geometry field,
        lookup value, and lookup type.
        """
        raise NotImplementedError('Distance operations not available on this spatial backend.')

    def get_geom_placeholder(self, f, value, compiler):
        """
        Returns the placeholder for the given geometry field with the given
        value.  Depending on the spatial backend, the placeholder may contain a
        stored procedure call to the transformation function of the spatial
        backend.
        """
        raise NotImplementedError('subclasses of BaseSpatialOperations must provide a geo_db_placeholder() method')

    def check_expression_support(self, expression):
        if isinstance(expression, self.disallowed_aggregates):
            raise NotImplementedError(
                "%s spatial aggregation is not supported by this database backend." % expression.name
            )
        super(BaseSpatialOperations, self).check_expression_support(expression)

    def spatial_aggregate_name(self, agg_name):
        raise NotImplementedError('Aggregate support not implemented for this spatial backend.')

    def spatial_function_name(self, func_name):
        if func_name in self.unsupported_functions:
            raise NotImplementedError("This backend doesn't support the %s function." % func_name)
        return self.function_names.get(func_name, self.geom_func_prefix + func_name)

    # Routines for getting the OGC-compliant models.
    def geometry_columns(self):
        raise NotImplementedError('Subclasses of BaseSpatialOperations must provide a geometry_columns() method.')

    def spatial_ref_sys(self):
        raise NotImplementedError('subclasses of BaseSpatialOperations must a provide spatial_ref_sys() method')

# coding=utf-8
# Copyright 2019 Google LLC
# 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.

"""Shared constants for Touchdown problem.

The remainder of constants is defined streetview_common subdir.
"""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from valan.streetview_common import streetview_constants


TD_BASELINE_AGENT_PARAMS = streetview_constants.BaselineAgentParams(
    # Actual vocab size is 4280, we add 1 as vocab_id=0 can not be used since we
    # are masking for RNN performance.
    VOCAB_SIZE=4280 + 1,
    INSTRUCTION_LSTM_DIM=256,
    TEXT_EMBED_DIM=32,
    TIMESTEP_EMBED_DIM=32,
    ACTION_EMBED_DIM=16,
    MAX_AGENT_ACTIONS=55,
    L2_SCALE=0.0,
    )


TD_PANO_AGENT_PARAMS = streetview_constants.PanoramicAgentParams(
    VOCAB_SIZE=4280 + 1,
    INSTRUCTION_LSTM_DIM=256,
    GROUNDING_EMBEDDING_DIM=256,  # Unused in Touchdown
    FEATURE_H=3,
    FEATURE_W=18,
    # FEATURE_C=64,  # Starburst v4
    FEATURE_C=606,  # Bottleneck v7
    # FEATURE_H=1,
    # FEATURE_W=8,
    # FEATURE_C=2048,  # ResNet50
    LINGUNET_H=64,
    LINGUNET_G=16,
    TIME_LSTM_DIM=32,
    TEXT_EMBED_DIM=32,
    TIMESTEP_EMBED_DIM=32,
    ACTION_EMBED_DIM=16,
    MAX_AGENT_ACTIONS=55,
    L2_SCALE=0.0,
    )

TD_PANO_AGENT_PARAMS_BIG = streetview_constants.PanoramicAgentParams(
    VOCAB_SIZE=30522+1,
    INSTRUCTION_LSTM_DIM=256,
    GROUNDING_EMBEDDING_DIM=256,
    FEATURE_H=3,
    FEATURE_W=18,
    FEATURE_C=606,
    LINGUNET_H=128,
    LINGUNET_G=64,
    TIME_LSTM_DIM=32,
    TEXT_EMBED_DIM=32,
    TIMESTEP_EMBED_DIM=32,
    ACTION_EMBED_DIM=16,
    MAX_AGENT_ACTIONS=55,
    L2_SCALE=0.0,
    )



#!/usr/bin/python
# coding: utf-8 -*-

# (c) 2017, Wayne Witzel III <wayne@riotousliving.com>
#
# This module is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This software is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this software.  If not, see <http://www.gnu.org/licenses/>.

ANSIBLE_METADATA = {'metadata_version': '1.0',
                    'status': ['preview'],
                    'supported_by': 'community'}


DOCUMENTATION = '''
---
module: tower_organization
version_added: "2.3"
author: "Wayne Witzel III (@wwitzel3)"
short_description: create, update, or destroy Ansible Tower organizations
description:
    - Create, update, or destroy Ansible Tower organizations. See
      U(https://www.ansible.com/tower) for an overview.
options:
    name:
      description:
        - Name to use for the organization.
      required: True
    description:
      description:
        - The description to use for the organization.
      required: False
      default: null
    state:
      description:
        - Desired state of the resource.
      required: False
      default: "present"
      choices: ["present", "absent"]
    tower_host:
      description:
        - URL to your Tower instance.
      required: False
      default: null
    tower_username:
        description:
          - Username for your Tower instance.
        required: False
        default: null
    tower_password:
        description:
          - Password for your Tower instance.
        required: False
        default: null
    tower_verify_ssl:
        description:
          - Dis/allow insecure connections to Tower. If C(no), SSL certificates will not be validated.
            This should only be used on personally controlled sites using self-signed certificates.
        required: False
        default: True
    tower_config_file:
      description:
        - Path to the Tower config file. See notes.
      required: False
      default: null


requirements:
  - "python >= 2.6"
  - "ansible-tower-cli >= 3.0.3"

notes:
  - If no I(tower_config_file) is provided we will attempt to use the tower-cli library
    defaults to find your Tower host information.
  - I(tower_config_file) should contain Tower configuration in the following format
      host=hostname
      username=username
      password=password
'''


EXAMPLES = '''
- name: Create tower organization
  tower_organization:
    name: "Foo"
    description: "Foo bar organization"
    state: present
    tower_config_file: "~/tower_cli.cfg"
'''

try:
    import tower_cli
    import tower_cli.utils.exceptions as exc

    from tower_cli.conf import settings
    from ansible.module_utils.ansible_tower import tower_auth_config, tower_check_mode

    HAS_TOWER_CLI = True
except ImportError:
    HAS_TOWER_CLI = False


def main():
    module = AnsibleModule(
        argument_spec=dict(
            name=dict(required=True),
            description=dict(),
            tower_host=dict(),
            tower_username=dict(),
            tower_password=dict(no_log=True),
            tower_verify_ssl=dict(type='bool', default=True),
            tower_config_file=dict(type='path'),
            state=dict(choices=['present', 'absent'], default='present'),
        ),
        supports_check_mode=True
    )

    if not HAS_TOWER_CLI:
        module.fail_json(msg='ansible-tower-cli required for this module')

    name = module.params.get('name')
    description = module.params.get('description')
    state = module.params.get('state')

    json_output = {'organization': name, 'state': state}

    tower_auth = tower_auth_config(module)
    with settings.runtime_values(**tower_auth):
        tower_check_mode(module)
        organization = tower_cli.get_resource('organization')
        try:
            if state == 'present':
                result = organization.modify(name=name, description=description, create_on_missing=True)
                json_output['id'] = result['id']
            elif state == 'absent':
                result = organization.delete(name=name)
        except (exc.ConnectionError, exc.BadRequest) as excinfo:
            module.fail_json(msg='Failed to update the organization: {0}'.format(excinfo), changed=False)

    json_output['changed'] = result['changed']
    module.exit_json(**json_output)


from ansible.module_utils.basic import AnsibleModule
if __name__ == '__main__':
    main()

# -*- coding: utf-8 -*-
import unittest

from analyzer import needleman_wunsch as nw
from analyzer.needleman_wunsch import AdaptiveGapPenalty, GapPenalty, Weighting
from analyzer.script_entity import ScriptEntity
from analyzer.subtitles_parser import Subtitle
from analyzer.logger import Logger


def test_gap_filter():
	s1 = "millegeeee"
	s2 = "mille_asde"

	fs1, fs2 = nw.filter_gaps(s1, s2)
	assert len(fs1) == 9
	assert len(fs2) == 9
	assert fs1[5] == "e"
	assert fs2[5] == "a"


def test_gap_filter_only_gaps():
	s1 = "millegeeee"
	s2 = "__________"

	fs1, fs2 = nw.filter_gaps(s1, s2)
	assert len(fs1) == 0
	assert len(fs2) == 0


class NeedlemanWunschMergerTest(unittest.TestCase):
	"""Some test case"""

	def setUp(self):
		self._sut = nw.perform
		self._logger = Logger(None)

	def test_bio_string(self):
		subtitles = [
			Subtitle(0, 0, "GCATGCU"),
		]

		script_entities = [
			ScriptEntity(**{"character": "CHAR0", "text": "GATTACA", "type": "speech"}),
		]

		alignment = self._sut(script_entities, subtitles, logger=self._logger)
		nw.pretty_print_grid(alignment)

	def test_bio_string_2(self):
		subtitles = [
			Subtitle(0, 0, "CNJRQCLU"),
		]

		script_entities = [
			ScriptEntity(**{"character": "CHAR0", "text": "CJRQDLN", "type": "speech"}),
		]

		alignment = self._sut(script_entities, subtitles, Weighting(1, -1, AdaptiveGapPenalty(-5, -1)), logger=self._logger)
		nw.pretty_print_grid(alignment)

	def test_character_detection(self):
		subtitles = [
			Subtitle(0, 0, "Hello sir"),
			Subtitle(0, 0, "my name is micha"),
		]

		script_entities = [
			ScriptEntity(**{"character": "CHAR0", "text": "Hallo Mr", "type": "speech"}),
			ScriptEntity(**{"character": "CHAR1", "text": "my name is michi", "type": "speech"}),
		]

		alignment = self._sut(script_entities, subtitles, logger=self._logger)
		nw.pretty_print_grid(alignment)

		assert len(alignment.subtitles) == 2
		assert alignment.subtitles[0].character == "CHAR0"
		assert alignment.subtitles[1].character == "CHAR1"

	def test_gap_penalty_alignment_adaptive(self):
		s1 = "GAAAAAAT"
		s1_index = [(s, None) for s in list(s1)]

		s2 = "GAAT"
		s2_index = [(s, None) for s in list(s2)]

		grid, traceback = nw.nw(s1_index, s2_index, Weighting(1, -1, AdaptiveGapPenalty(-5, -1)))
		alignment = nw.calculate_backtrace(grid, traceback, s1_index, s2_index)

		nw.pretty_print_grid(alignment)
		s1_string = "".join([char for char, _ in alignment.vertical_index])
		s2_string = "".join([char for char, _ in alignment.horizontal_index])
		print(s1_string)
		print(s2_string)

		assert s2_string == "GAA____T"

	def test_gap_penalty_alignment_linear(self):
		s1 = "GAAAAAAT"
		s1_index = [(s, None) for s in list(s1)]

		s2 = "GAAT"
		s2_index = [(s, None) for s in list(s2)]

		grid, traceback = nw.nw(s1_index, s2_index, Weighting(1, -1, GapPenalty(-2)))
		alignment = nw.calculate_backtrace(grid, traceback, s1_index, s2_index)

		nw.pretty_print_grid(alignment)
		s1_string = "".join([char for char, _ in alignment.vertical_index])
		s2_string = "".join([char for char, _ in alignment.horizontal_index])
		print(s1_string)
		print(s2_string)

		assert s2_string == "GAA____T"

	def test_split_words(self):
		subtitles = [
			Subtitle(0, 0, "Millage Ville, Georgia."),
		]

		script_entities = [
			ScriptEntity(**{"character": "CHAR0", "text": "Milledgeville, Georgia", "type": "speech"}),
		]

		alignment = self._sut(script_entities, subtitles, logger=self._logger)

		assert alignment.subtitles[0].character == "CHAR0"

	def test_punctuation_removal(self):
		s1 = [Subtitle(0, 0, "m.")]
		s2 = [ScriptEntity(**{"character": "CHAR0", "text": ".m", "type": "speech"})]

		alignment = self._sut(s1, s2, logger=self._logger)

		assert len(alignment.vertical_index) == 1
		assert len(alignment.horizontal_index) == 1

"""
Fixer that changes zip(seq0, seq1, ...) into list(zip(seq0, seq1, ...)
unless there exists a 'from future_builtins import zip' statement in the
top-level namespace.

We avoid the transformation if the zip() call is directly contained in
iter(<>), list(<>), tuple(<>), sorted(<>), ...join(<>), or for V in <>:.
"""

# Local imports
from .. import fixer_base
from ..pytree import Node
from ..pygram import python_symbols as syms
from ..fixer_util import Name, ArgList, in_special_context


class FixZip(fixer_base.ConditionalFix):

    BM_compatible = True
    PATTERN = """
    power< 'zip' args=trailer< '(' [any] ')' > [trailers=trailer*]
    >
    """

    skip_on = "future_builtins.zip"

    def transform(self, node, results):
        if self.should_skip(node):
            return

        if in_special_context(node):
            return None

        args = results['args'].clone()
        args.prefix = ""

        trailers = []
        if 'trailers' in results:
            trailers = [n.clone() for n in results['trailers']]
            for n in trailers:
                n.prefix = ""

        new = Node(syms.power, [Name("zip"), args], prefix="")
        new = Node(syms.power, [Name("list"), ArgList([new])] + trailers)
        new.prefix = node.prefix
        return new

import pyfits as pyf
from glob import glob
import os
from astLib.astStats import clippedMedianStdev
from numpy import average, delete

import numpy as np


def skySubtract(data):
    sums = [sum(data[i, :]) for i in range(data.shape[0])]
    med = clippedMedianStdev(sums)
    med = med['clippedMedian']
    skyfibers = [i for i in range(data.shape[0]) if sum(data[i, :]) <= med]
    skydata = data.take(skyfibers, axis=0)
    skyflux = [average(skydata[:, i]) for i in range(skydata.shape[1])]

    return skyflux


files = glob('bcs*.fits')

for f in files:
    oimg = pyf.open(f)
    obj = oimg[1].header['object'].split('_')
    print f, obj
    field, dither, num = obj[1].split()
    # Correct for a typo in the naming.
    if obj[0] == 'c203p83+41p00':
        obj[0] = 'c203p83+41p0'

    # load data and skysubtract
    data = oimg[1].data
    dataHDR = oimg[1].header

    sky = skySubtract(data)

    if not os.path.isfile(obj[0] + '_' + field + '_' + num + '.fits'):
        # rewriting the whole file because that is easy to update
        oimg.writeto(obj[0] + '_' + field + '_' + num + '.fits')
        # update with sky subtraction
        pyf.update(obj[0] + '_' + field + '_' + num + '.fits', data - sky,
                   dataHDR, 1)
    else:
        # Here's the data we are going to add to
        img = pyf.open(obj[0] + '_' + field + '_' + num + '.fits')
        data1 = img[1].data
        dataHDR1 = img[1].header
        try:
            pyf.update(obj[0] + '_' + field + '_' + num + '.fits',
                       data1 + data, dataHDR, 1)
        except ValueError:
            # Make sure all of the arrays are the same length
            if data.shape[1] > data1.shape[1]:
                sky.pop(-1 * (data.shape[1] - data1.shape[1]))
                data = delete(data, -1 * (data.shape[1] - data1.shape[1]), 1)
            elif data.shape[1] < data1.shape[1]:
                data1 = delete(data1, -1 * (data1.shape[1] - data.shape[1]), 1)
            else:
                print "I don't know what to do!"

            # UPDATE!!!
            pyf.update(obj[0] + '_' + field + '_' + num + '.fits',
                       data1 + data, dataHDR, 1)

        img.close()
    oimg.close()

"""
Unit tests for serialization

'Tale' mud driver, mudlib and interactive fiction framework
Copyright by Irmen de Jong (irmen@razorvine.net)
"""
from __future__ import print_function, division, unicode_literals, absolute_import
import unittest
import pickle
from tale import mud_context, races, base, npc, soul, player, util, hints
from tale.driver import StoryConfig
from tests.supportstuff import TestDriver


def serializecycle(obj):
    ser = pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
    return pickle.loads(ser)


class TestSerializing(unittest.TestCase):
    def setUp(self):
        mud_context.driver = TestDriver()

    def assert_base_attrs(self, obj):
        self.assertEqual("name", obj.name)
        self.assertEqual("title", obj.title)
        self.assertEqual("description", obj.description)
        self.assertEqual("n", obj.gender)

    def test_basic(self):
        o = serializecycle(races.races)
        self.assertEqual(races.races, o)
        o = base.MudObject("name", "title", "description")
        o.aliases = ["alias"]
        x = serializecycle(o)
        self.assert_base_attrs(x)
        self.assertEqual(["alias"], x.aliases)

    def test_items_and_container(self):
        o = base.Item("name", "title", "description")
        o.aliases = ["alias"]
        bag = base.Container("name", "title", "description")
        bag.insert(o, None)
        x = serializecycle(bag)
        self.assert_base_attrs(x)
        self.assertEqual(1, x.inventory_size)
        y = list(x.inventory)[0]
        self.assertEqual(x, y.contained_in)
        o = base.Weapon("w")
        x = serializecycle(o)
        self.assertEqual("w", x.name)
        o = base.Armour("a")
        x = serializecycle(o)
        self.assertEqual("a", x.name)

    def test_location(self):
        room = base.Location("room", "description")
        x = serializecycle(room)
        self.assertEqual("room", x.name)
        self.assertEqual(set(), x.livings)
        self.assertEqual(set(), x.items)
        # now add some exits and a second location, and try again
        room2 = base.Location("room2", "description")
        exit1 = base.Exit("room2", room2, "to room2")
        exit2 = base.Exit("room", room, "back to room")
        room.add_exits([exit1])
        room2.add_exits([exit2])
        [r1, r2] = serializecycle([room, room2])
        self.assertEqual("room", r1.name)
        self.assertEqual("room2", r2.name)
        self.assertEqual(1, len(r1.exits))
        self.assertEqual(1, len(r2.exits))
        exit1 = r1.exits["room2"]
        exit2 = r2.exits["room"]
        self.assertEqual("to room2", exit1.short_description)
        self.assertEqual("back to room", exit2.short_description)
        self.assertEqual(r2, exit1.target)
        self.assertEqual(r1, exit2.target)

    def test_exits_and_doors(self):
        o = base.Exit("east", "target", "somewhere")
        x = serializecycle(o)
        self.assertFalse(x.bound)
        self.assertEqual("target", x.target)
        self.assertEqual("somewhere", x.short_description)
        self.assertEqual("east", x.name)
        o = base.Door("east", "target", "somewhere", locked=True, opened=False)
        self.assertEqual("somewhere It is closed and locked.", o.description)
        x = serializecycle(o)
        self.assertEqual("target", x.target)
        self.assertEqual("east", x.name)
        self.assertEqual("somewhere It is closed and locked.", x.description)

    def test_living_npc_monster(self):
        o = base.Living("name", "n", title="title", description="description", race="dragon")
        x = serializecycle(o)
        self.assert_base_attrs(x)
        o = npc.NPC("name", "n", title="title", description="description", race="dragon")
        x = serializecycle(o)
        self.assert_base_attrs(x)
        self.assertFalse(x.aggressive)

    def test_player_and_soul(self):
        o = soul.Soul()
        x = serializecycle(o)
        self.assertIsNotNone(x)
        p = player.Player("name", "n", description="description")
        p.title = "title"
        p.money = 42
        x = serializecycle(p)
        self.assert_base_attrs(x)
        self.assertEqual(42, x.money)

    def test_storyconfig(self):
        s = StoryConfig(**dict.fromkeys(StoryConfig.config_items))   # empty config
        s.server_mode = "if"
        s.display_gametime = True
        s.name = "test"
        x = serializecycle(s)
        self.assertEqual(s, x)

    def test_Context(self):
        c = util.Context(driver=1, clock=2, config=3, player_connection=4)
        x = serializecycle(c)
        self.assertEqual(c, x)
        self.assertEqual(vars(c), vars(x))

    def test_Hints(self):
        h = hints.HintSystem()
        h.init([hints.Hint("start", None, "first")])
        x = serializecycle(h)
        self.assertEqual(h.all_hints, x.all_hints)


if __name__ == '__main__':
    unittest.main()

#! python
#
# This module implements a special URL handler that uses the port listing to
# find ports by searching the string descriptions.
#
# This file is part of pySerial. https://github.com/pyserial/pyserial
# (C) 2011-2015 Chris Liechti <cliechti@gmx.net>
#
# SPDX-License-Identifier:    BSD-3-Clause
#
# URL format:    hwgrep://<regexp>&<option>
#
# where <regexp> is a Python regexp according to the re module
#
# violating the normal definition for URLs, the charachter `&` is used to
# separate parameters from the arguments (instead of `?`, but the question mark
# is heavily used in regexp'es)
#
# options:
# n=<N>     pick the N'th entry instead of the first one (numbering starts at 1)
# skip_busy tries to open port to check if it is busy, fails on posix as ports are not locked!

import serial
import serial.tools.list_ports

try:
    basestring
except NameError:
    basestring = str    # python 3  pylint: disable=redefined-builtin


class Serial(serial.Serial):
    """Just inherit the native Serial port implementation and patch the port property."""
    # pylint: disable=no-member

    @serial.Serial.port.setter
    def port(self, value):
        """translate port name before storing it"""
        if isinstance(value, basestring) and value.startswith('hwgrep://'):
            serial.Serial.port.__set__(self, self.from_url(value))
        else:
            serial.Serial.port.__set__(self, value)

    def from_url(self, url):
        """extract host and port from an URL string"""
        if url.lower().startswith("hwgrep://"):
            url = url[9:]
        n = 0
        test_open = False
        args = url.split('&')
        regexp = args.pop(0)
        for arg in args:
            if '=' in arg:
                option, value = arg.split('=', 1)
            else:
                option = arg
                value = None
            if option == 'n':
                # pick n'th element
                n = int(value) - 1
                if n < 1:
                    raise ValueError('option "n" expects a positive integer larger than 1: {!r}'.format(value))
            elif option == 'skip_busy':
                # open to test if port is available. not the nicest way..
                test_open = True
            else:
                raise ValueError('unknown option: {!r}'.format(option))
        # use a for loop to get the 1st element from the generator
        for port, desc, hwid in sorted(serial.tools.list_ports.grep(regexp)):
            if test_open:
                try:
                    s = serial.Serial(port)
                except serial.SerialException:
                    # it has some error, skip this one
                    continue
                else:
                    s.close()
            if n:
                n -= 1
                continue
            return port
        else:
            raise serial.SerialException('no ports found matching regexp {!r}'.format(url))

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
if __name__ == '__main__':
    s = Serial(None)
    s.port = 'hwgrep://ttyS0'
    print(s)

# Copyright 2013 OpenStack Foundation
# Copyright 2013 Spanish National Research Council.
# All Rights Reserved.
#
#    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.

# E0202: An attribute inherited from %s hide this method
# pylint: disable=E0202

########################################################################
#
# THIS MODULE IS DEPRECATED
#
# Please refer to
# https://etherpad.openstack.org/p/kilo-cloudpulseclient-library-proposals for
# the discussion leading to this deprecation.
#
# We recommend checking out the python-openstacksdk project
# (https://launchpad.net/python-openstacksdk) instead.
#
########################################################################

import abc
import argparse
import os

import six
from stevedore import extension

from cloudpulseclient.openstack.common.apiclient import exceptions


_discovered_plugins = {}


def discover_auth_systems():
    """Discover the available auth-systems.

    This won't take into account the old style auth-systems.
    """
    global _discovered_plugins
    _discovered_plugins = {}

    def add_plugin(ext):
        _discovered_plugins[ext.name] = ext.plugin

    ep_namespace = "cloudpulseclient.openstack.common.apiclient.auth"
    mgr = extension.ExtensionManager(ep_namespace)
    mgr.map(add_plugin)


def load_auth_system_opts(parser):
    """Load options needed by the available auth-systems into a parser.

    This function will try to populate the parser with options from the
    available plugins.
    """
    group = parser.add_argument_group("Common auth options")
    BaseAuthPlugin.add_common_opts(group)
    for name, auth_plugin in six.iteritems(_discovered_plugins):
        group = parser.add_argument_group(
            "Auth-system '%s' options" % name,
            conflict_handler="resolve")
        auth_plugin.add_opts(group)


def load_plugin(auth_system):
    try:
        plugin_class = _discovered_plugins[auth_system]
    except KeyError:
        raise exceptions.AuthSystemNotFound(auth_system)
    return plugin_class(auth_system=auth_system)


def load_plugin_from_args(args):
    """Load required plugin and populate it with options.

    Try to guess auth system if it is not specified. Systems are tried in
    alphabetical order.

    :type args: argparse.Namespace
    :raises: AuthPluginOptionsMissing
    """
    auth_system = args.os_auth_system
    if auth_system:
        plugin = load_plugin(auth_system)
        plugin.parse_opts(args)
        plugin.sufficient_options()
        return plugin

    for plugin_auth_system in sorted(six.iterkeys(_discovered_plugins)):
        plugin_class = _discovered_plugins[plugin_auth_system]
        plugin = plugin_class()
        plugin.parse_opts(args)
        try:
            plugin.sufficient_options()
        except exceptions.AuthPluginOptionsMissing:
            continue
        return plugin
    raise exceptions.AuthPluginOptionsMissing(["auth_system"])


@six.add_metaclass(abc.ABCMeta)
class BaseAuthPlugin(object):
    """Base class for authentication plugins.

    An authentication plugin needs to override at least the authenticate
    method to be a valid plugin.
    """

    auth_system = None
    opt_names = []
    common_opt_names = [
        "auth_system",
        "username",
        "password",
        "tenant_name",
        "token",
        "auth_url",
        "project_domain_name",
        "user_domain_name",
    ]

    def __init__(self, auth_system=None, **kwargs):
        self.auth_system = auth_system or self.auth_system
        self.opts = dict((name, kwargs.get(name))
                         for name in self.opt_names)

    @staticmethod
    def _parser_add_opt(parser, opt):
        """Add an option to parser in two variants.

        :param opt: option name (with underscores)
        """
        dashed_opt = opt.replace("_", "-")
        env_var = "OS_%s" % opt.upper()
        arg_default = os.environ.get(env_var, "")
        arg_help = "Defaults to env[%s]." % env_var
        parser.add_argument(
            "--os-%s" % dashed_opt,
            metavar="<%s>" % dashed_opt,
            default=arg_default,
            help=arg_help)
        parser.add_argument(
            "--os_%s" % opt,
            metavar="<%s>" % dashed_opt,
            help=argparse.SUPPRESS)

    @classmethod
    def add_opts(cls, parser):
        """Populate the parser with the options for this plugin.
        """
        for opt in cls.opt_names:
            # use `BaseAuthPlugin.common_opt_names` since it is never
            # changed in child classes
            if opt not in BaseAuthPlugin.common_opt_names:
                cls._parser_add_opt(parser, opt)

    @classmethod
    def add_common_opts(cls, parser):
        """Add options that are common for several plugins.
        """
        for opt in cls.common_opt_names:
            cls._parser_add_opt(parser, opt)

    @staticmethod
    def get_opt(opt_name, args):
        """Return option name and value.

        :param opt_name: name of the option, e.g., "username"
        :param args: parsed arguments
        """
        return (opt_name, getattr(args, "os_%s" % opt_name, None))

    def parse_opts(self, args):
        """Parse the actual auth-system options if any.

        This method is expected to populate the attribute `self.opts` with a
        dict containing the options and values needed to make authentication.
        """
        self.opts.update(dict(self.get_opt(opt_name, args)
                              for opt_name in self.opt_names))

    def authenticate(self, http_client):
        """Authenticate using plugin defined method.

        The method usually analyses `self.opts` and performs
        a request to authentication server.

        :param http_client: client object that needs authentication
        :type http_client: HTTPClient
        :raises: AuthorizationFailure
        """
        self.sufficient_options()
        self._do_authenticate(http_client)

    @abc.abstractmethod
    def _do_authenticate(self, http_client):
        """Protected method for authentication.
        """

    def sufficient_options(self):
        """Check if all required options are present.

        :raises: AuthPluginOptionsMissing
        """
        missing = [opt
                   for opt in self.opt_names
                   if not self.opts.get(opt)]
        if missing:
            raise exceptions.AuthPluginOptionsMissing(missing)

    @abc.abstractmethod
    def token_and_endpoint(self, endpoint_type, service_type):
        """Return token and endpoint.

        :param service_type: Service type of the endpoint
        :type service_type: string
        :param endpoint_type: Type of endpoint.
                              Possible values: public or publicURL,
                              internal or internalURL,
                              admin or adminURL
        :type endpoint_type: string
        :returns: tuple of token and endpoint strings
        :raises: EndpointException
        """

# coding=utf-8
"""
    内置数据源示例实现模块：

    所有数据接口仅供学习使用，以及最基本使用测试，如需进一步使用，请购买数据
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import logging
import os

import random
import math
import sqlite3 as sqlite

import pandas as pd

from ..CoreBu.ABuEnv import EMarketTargetType, EMarketSubType
from ..CoreBu import ABuEnv
from ..MarketBu import ABuNetWork
from ..MarketBu.ABuDataBase import StockBaseMarket, SupportMixin, FuturesBaseMarket, TCBaseMarket
from ..MarketBu.ABuDataParser import BDParser, TXParser, NTParser, SNUSParser
from ..MarketBu.ABuDataParser import SNFuturesParser, SNFuturesGBParser, HBTCParser
from ..UtilBu import ABuStrUtil, ABuDateUtil, ABuMd5
from ..UtilBu.ABuDTUtil import catch_error
from ..CoreBu.ABuDeprecated import AbuDeprecated
# noinspection PyUnresolvedReferences
from ..CoreBu.ABuFixes import xrange, range, filter

"""网络请求（连接10秒，接收60秒）超时时间"""
K_TIME_OUT = (10, 60)


def random_from_list(array):
    """从参数array中随机取一个元素"""
    # 在array长度短的情况下，测试比np.random.choice效率要高
    return array[random.randrange(0, len(array))]


@AbuDeprecated('only read old symbol db, miss update!!!')
def query_symbol_sub_market(symbol):
    path = TXApi.K_SYMBOLS_DB
    conn = sqlite.connect(path)
    cur = conn.cursor()
    symbol = symbol.lower()
    query = "select {} from {} where {} like \'{}.%\'".format(TXApi.K_DB_TABLE_SN, TXApi.K_DB_TABLE_NAME,
                                                              TXApi.K_DB_TABLE_SN, symbol)
    cur.execute(query)
    results = cur.fetchall()
    conn.close()
    sub_market = ''
    if results is not None and len(results) > 0:
        try:
            if results[0][0].find('.') > 0:
                sub_market = '.' + results[0][0].split('.')[1].upper()
        except:
            logging.info(results)
    return sub_market


@catch_error(return_val=None, log=False)
def query_symbol_from_pinyin(pinyin):
    """通过拼音对symbol进行模糊查询"""
    path = TXApi.K_SYMBOLS_DB
    conn = sqlite.connect(path)
    cur = conn.cursor()
    pinyin = pinyin.lower()
    query = "select stockCode from {} where pinyin=\'{}\'".format(TXApi.K_DB_TABLE_NAME, pinyin)
    cur.execute(query)
    results = cur.fetchall()
    conn.close()
    if len(results) > 0:
        code = results[0][0]
        # 查询到的stcok code eg：sh111111，usabcd.n
        start = 2
        end = len(code)
        if '.' in code:
            # 如果是美股要截取.
            end = code.find('.')
        return code[start:end]


class BDApi(StockBaseMarket, SupportMixin):
    """bd数据源，支持港股，美股，a股"""

    K_NET_CONNECT_START = '&start='
    K_NET_DAY = 'http://gp.baidu.com:80/stocks/stockkline?from=android&os_ver=21&format=json&vv=3.3.0' \
                '&uid=&BDUSS=&cuid=%s&channel=default_channel&device=%s&logid=%s&actionid=%s&device_net_type' \
                '=wifi&period=day&stock_code=%s&fq_type=front'

    MINUTE_NET_5D = 'http://gp.baidu.com:80/stocks/stocktimelinefive?from=android&os_ver=21&format=json' \
                    '&vv=3.3&uid=&BDUSS=&cuid=%s&channel=default_channel&device=%s&logid=%s&actionid=%s' \
                    '&device_net_type=wifi&stock_code=%s&step=10'

    def __init__(self, symbol):
        """
        :param symbol: Symbol类型对象
        """
        super(BDApi, self).__init__(symbol)
        self._action_id = int(ABuDateUtil.time_seconds())
        self._version2_log_cnt = 0
        self.data_parser_cls = BDParser

    def kline(self, n_folds=2, start=None, end=None):
        """日k线接口"""
        self._version2_log_cnt += 1
        log_id = self._action_id + self._version2_log_cnt * 66
        cuid = ABuStrUtil.create_random_with_num_low(40)
        device = random_from_list(StockBaseMarket.K_DEV_MODE_LIST)
        url = BDApi.K_NET_DAY % (cuid, device, str(log_id), str(self._action_id), self._symbol.value)
        # logging.info(url)
        next_start = None
        kl_df = None
        if start:
            # 需重新计算n_fold
            days = ABuDateUtil.diff(start, ABuDateUtil.current_str_date(), check_order=False)
            # 每次返回300条数据
            n_folds = int(days / 300.0)

        for _ in xrange(0, n_folds):
            if next_start:
                url = url + BDApi.K_NET_CONNECT_START + str(next_start)
            # logging.info(url)
            data = ABuNetWork.get(url=url, timeout=K_TIME_OUT)
            temp_df = None
            if data is not None:
                temp_df = self.data_parser_cls(self._symbol, data.json()).df

            if temp_df is not None:
                next_start = int(temp_df.loc[temp_df.index[0], ['date']].values[0])
            kl_df = temp_df if kl_df is None else pd.concat([temp_df, kl_df])
            # 因为是从前向后请求，且与时间无关，所以可以直接在for里面中断
            if kl_df is None:
                return None

            """由于每次放回300条>1年的数据，所以超出总数就不再请求下一组"""
            if kl_df.shape[0] > ABuEnv.g_market_trade_year * n_folds:
                break

        return StockBaseMarket._fix_kline_pd(kl_df, n_folds, start, end)

    def minute(self, n_folds=5, *args, **kwargs):
        self._version2_log_cnt += 1
        cuid = ABuStrUtil.create_random_with_num_low(40)
        log_id = self._action_id + self._version2_log_cnt * 66
        device = random_from_list(StockBaseMarket.K_DEV_MODE_LIST)
        url = BDApi.MINUTE_NET_5D % (cuid, device, str(log_id), str(self._action_id), self._symbol.value)

        return ABuNetWork.get(url=url, timeout=K_TIME_OUT).json()


class TXApi(StockBaseMarket, SupportMixin):
    """tx数据源，支持港股，美股，a股"""

    K_NET_BASE = "http://ifzq.gtimg.cn/appstock/app/%sfqkline/get?p=1&param=%s,day,,,%d," \
                 "qfq&_appName=android&_dev=%s&_devId=%s&_mid=%s&_md5mid=%s&_appver=4.2.2&_ifChId=303&_screenW=%d" \
                 "&_screenH=%d&_osVer=%s&_uin=10000&_wxuin=20000&__random_suffix=%d"

    K_NET_HK_MNY = 'http://proxy.finance.qq.com/ifzqgtimg/stock/corp/hkmoney/sumary?' \
                   'symbol=%s&type=sum&jianjie=1&_appName=android' \
                   '&_dev=%s&_devId=%s&_mid=%s&_md5mid=%s&_appver=5.5.0&_ifChId=277' \
                   '&_screenW=%d&_screenH=%d&_osVer=%s&_uin=10000&_wxuin=20000&_net=WIFI&__random_suffix=%d'

    K_DB_TABLE_NAME = "values_table"
    K_DB_TABLE_SN = "stockCode"
    p_dir = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.path.pardir))
    K_SYMBOLS_DB = os.path.join(p_dir, 'RomDataBu/symbols_db.db')

    def __init__(self, symbol):
        """
        :param symbol: Symbol类型对象
        """
        super(TXApi, self).__init__(symbol)
        # 设置数据源解析对象类
        self.data_parser_cls = TXParser

    def kline(self, n_folds=2, start=None, end=None):
        """日k线接口"""
        cuid = ABuStrUtil.create_random_with_num_low(40)
        cuid_md5 = ABuMd5.md5_from_binary(cuid)
        random_suffix = ABuStrUtil.create_random_with_num(5)
        dev_mod = random_from_list(StockBaseMarket.K_DEV_MODE_LIST)
        os_ver = random_from_list(StockBaseMarket.K_OS_VERSION_LIST)
        screen = random_from_list(StockBaseMarket.K_PHONE_SCREEN)

        days = ABuEnv.g_market_trade_year * n_folds + 1
        # start 不为空时计算 获取天数，获取的数据肯定比预期的数据多，因为同一时间内，交易日的天数一定不比实际的天数多
        if start:
            temp_end = ABuDateUtil.current_str_date()
            days = ABuDateUtil.diff(start, temp_end, check_order=False)

        sub_market = None
        if self._symbol.market == EMarketTargetType.E_MARKET_TARGET_US:
            # sub_market = self.query_symbol_sub_market(self._symbol.value)
            market = self._symbol.market.value
            if '.' in self._symbol.value:
                # 如果已经有.了说明是大盘，大盘不需要子市场，eg：us.IXIC
                sub_market = ''
            else:
                # 这里tx的source不支持US_PINK, US_OTC, US_PREIPO
                sub_market_map = {EMarketSubType.US_N.value: 'n',

                                  EMarketSubType.US_PINK.value: 'n',
                                  EMarketSubType.US_OTC.value: 'n',
                                  EMarketSubType.US_PREIPO.value: 'n',
                                  EMarketSubType.US_AMEX.value: 'n',

                                  EMarketSubType.US_OQ.value: 'oq'}
                sub_market = '.{}'.format(sub_market_map[self._symbol.sub_market.value])
            url = TXApi.K_NET_BASE % (
                market, self._symbol.value + sub_market, days,
                dev_mod, cuid, cuid, cuid_md5, screen[0], screen[1], os_ver, int(random_suffix, 10))
        elif self._symbol.market == EMarketTargetType.E_MARKET_TARGET_HK:
            market = self._symbol.market.value
            url = TXApi.K_NET_BASE % (
                market, self._symbol.value, days,
                dev_mod, cuid, cuid, cuid_md5, screen[0], screen[1], os_ver, int(random_suffix, 10))
        else:
            market = ''
            url = TXApi.K_NET_BASE % (
                market, self._symbol.value, days,
                dev_mod, cuid, cuid, cuid_md5, screen[0], screen[1], os_ver, int(random_suffix, 10))

        data = ABuNetWork.get(url, timeout=K_TIME_OUT)
        if data is not None:
            kl_pd = self.data_parser_cls(self._symbol, sub_market, data.json()).df
        else:
            return None

        return StockBaseMarket._fix_kline_pd(kl_pd, n_folds, start, end)

    def hkmoney(self):
        """港股概要信息接口"""
        if self._symbol.market != EMarketTargetType.E_MARKET_TARGET_HK:
            raise TypeError('hkmoney only support hk!!')

        cuid = ABuStrUtil.create_random_with_num_low(40)
        cuid_md5 = ABuMd5.md5_from_binary(cuid)
        random_suffix = ABuStrUtil.create_random_with_num(5)
        dev_mod = random_from_list(StockBaseMarket.K_DEV_MODE_LIST)
        os_ver = random_from_list(StockBaseMarket.K_OS_VERSION_LIST)
        screen = random_from_list(StockBaseMarket.K_PHONE_SCREEN)

        url = TXApi.K_NET_HK_MNY % (self._symbol.value, dev_mod, cuid, cuid, cuid_md5, screen[0], screen[1], os_ver,
                                    int(random_suffix, 10))
        return ABuNetWork.get(url, timeout=K_TIME_OUT)

    def minute(self, n_fold=5, *args, **kwargs):
        """分钟k线接口"""
        raise NotImplementedError('TXApi minute NotImplementedError!')


class NTApi(StockBaseMarket, SupportMixin):
    """nt数据源，支持港股，美股，a股"""

    K_NET_BASE = "http://img1.money.126.net/data/%s/kline/day/history/%d/%s.json"

    def __init__(self, symbol):
        """
        :param symbol: Symbol类型对象
        """
        super(NTApi, self).__init__(symbol)
        # 设置数据源解析对象类
        self.data_parser_cls = NTParser

    def kline(self, n_folds=2, start=None, end=None):
        """日k线接口"""
        kl_df = None
        if start is None or end is None:
            end_year = int(ABuDateUtil.current_str_date()[:4])
            start_year = end_year - n_folds + 1
        else:
            start_year = int(start[:4])
            end_year = int(end[:4])
        req_year = list(range(start_year, end_year + 1))

        if self._symbol.market == EMarketTargetType.E_MARKET_TARGET_US:
            market = self._symbol.market.value
            symbol = self._symbol.symbol_code.upper()
            if self._symbol.is_us_index():
                # ntes 需要做映射匹配大盘symbol
                index_dict = {'.DJI': 'DOWJONES', '.IXIC': 'NASDAQ', '.INX': 'SP500'}
                symbol = index_dict[symbol]
        elif self._symbol.market == EMarketTargetType.E_MARKET_TARGET_HK:
            market = self._symbol.market.value
            symbol = self._symbol.symbol_code.upper()
        elif self._symbol.market == EMarketTargetType.E_MARKET_TARGET_CN:
            market = self._symbol.market.value
            symbol = self._symbol.symbol_code
            if self._symbol.is_sz_stock():
                symbol = '1{}'.format(symbol)
            else:
                symbol = '0{}'.format(symbol)
        else:
            raise TypeError('NTApi dt support {}'.format(self._symbol.market))

        for year in req_year:
            url = NTApi.K_NET_BASE % (market, year, symbol)
            data = ABuNetWork.get(url=url, retry=1, timeout=K_TIME_OUT)
            temp_df = None
            if data is not None:
                temp_df = self.data_parser_cls(self._symbol, data.json()).df
            if temp_df is not None:
                kl_df = temp_df if kl_df is None else kl_df.append(temp_df)
        if kl_df is None:
            return None
        return StockBaseMarket._fix_kline_pd(kl_df, n_folds, start, end)

    def minute(self, n_fold=5, *args, **kwargs):
        """分钟k线接口"""
        raise NotImplementedError('NTApi minute NotImplementedError!')


class SNUSApi(StockBaseMarket, SupportMixin):
    """snus数据源，支持美股"""
    K_NET_BASE = "http://stock.finance.sina.com.cn/usstock/api/json_v2.php/US_MinKService.getDailyK?" \
                 "symbol=%s&___qn=3n"

    def __init__(self, symbol):
        """
        :param symbol: Symbol类型对象
        """
        super(SNUSApi, self).__init__(symbol)
        # 设置数据源解析对象类
        self.data_parser_cls = SNUSParser

    def _support_market(self):
        """声明数据源支持美股"""
        return [EMarketTargetType.E_MARKET_TARGET_US]

    def kline(self, n_folds=2, start=None, end=None):
        """日k线接口"""
        url = SNUSApi.K_NET_BASE % self._symbol.symbol_code
        data = ABuNetWork.get(url=url, timeout=K_TIME_OUT).json()
        kl_df = self.data_parser_cls(self._symbol, data).df
        if kl_df is None:
            return None
        return StockBaseMarket._fix_kline_pd(kl_df, n_folds, start, end)

    def minute(self, n_fold=5, *args, **kwargs):
        """分钟k线接口"""
        raise NotImplementedError('SNUSApi minute NotImplementedError!')


class SNFuturesApi(FuturesBaseMarket, SupportMixin):
    """sn futures数据源，支持国内期货"""

    K_NET_BASE = "http://stock.finance.sina.com.cn/futures/api/json_v2.php/" \
                 "IndexService.getInnerFuturesDailyKLine?symbol=%s"

    def __init__(self, symbol):
        """
        :param symbol: Symbol类型对象
        """
        super(SNFuturesApi, self).__init__(symbol)
        # 设置数据源解析对象类
        self.data_parser_cls = SNFuturesParser

    def _support_market(self):
        """声明数据源支持期货数据"""
        return [EMarketTargetType.E_MARKET_TARGET_FUTURES_CN]

    def kline(self, n_folds=2, start=None, end=None):
        """日k线接口"""
        url = SNFuturesApi.K_NET_BASE % self._symbol.symbol_code
        data = ABuNetWork.get(url=url, timeout=K_TIME_OUT).json()
        kl_df = self.data_parser_cls(self._symbol, data).df
        if kl_df is None:
            return None
        return FuturesBaseMarket._fix_kline_pd(kl_df, n_folds, start, end)


class SNFuturesGBApi(FuturesBaseMarket, SupportMixin):
    """sn futures数据源，支持国际期货"""

    K_NET_BASE = "http://stock2.finance.sina.com.cn/futures/api/jsonp.php/" \
                 "var %s%s=/GlobalFuturesService.getGlobalFuturesDailyKLine?symbol=%s&_=%s"

    def __init__(self, symbol):
        """
        :param symbol: Symbol类型对象
        """
        super(SNFuturesGBApi, self).__init__(symbol)
        # 设置数据源解析对象类
        self.data_parser_cls = SNFuturesGBParser

    def _support_market(self):
        """声明数据源支持期货数据, 支持国际期货市场"""
        return [EMarketTargetType.E_MARKET_TARGET_FUTURES_GLOBAL]

    def kline(self, n_folds=2, start=None, end=None):
        """日k线接口"""
        today = ABuDateUtil.current_str_date().replace('-', '_')
        url = SNFuturesGBApi.K_NET_BASE % (self._symbol.symbol_code, today, self._symbol.symbol_code, today)
        data = ABuNetWork.get(url=url, timeout=(10, 60))
        text = data.text
        # 返回的是Javascript字符串解析出dict
        js_dict = ABuNetWork.parse_js(text[text.find('=(') + 2:text.rfind(')')])
        kl_df = self.data_parser_cls(self._symbol, js_dict).df
        if kl_df is None:
            return None
        return FuturesBaseMarket._fix_kline_pd(kl_df, n_folds, start, end)


class HBApi(TCBaseMarket, SupportMixin):
    """hb数据源，支持币类，比特币，莱特币"""

    K_NET_BASE = 'https://www.huobi.com/qt/staticmarket/%s_kline_100_json.js?length=%d'

    def __init__(self, symbol):
        """
        :param symbol: Symbol类型对象
        """
        super(HBApi, self).__init__(symbol)
        # 设置数据源解析对象类
        self.data_parser_cls = HBTCParser

    def _support_market(self):
        """只支持币类市场"""
        return [EMarketTargetType.E_MARKET_TARGET_TC]

    def kline(self, n_folds=2, start=None, end=None):
        """日k线接口"""
        req_cnt = n_folds * ABuEnv.g_market_trade_year
        if start is not None and end is not None:
            # 向上取整数，下面使用_fix_kline_pd再次进行剪裁, 要使用current_str_date不能是end
            folds = math.ceil(ABuDateUtil.diff(ABuDateUtil.date_str_to_int(start),
                                               ABuDateUtil.current_str_date()) / 365)
            req_cnt = folds * ABuEnv.g_market_trade_year

        url = HBApi.K_NET_BASE % (self._symbol.symbol_code, req_cnt)
        data = ABuNetWork.get(url=url, timeout=K_TIME_OUT).json()
        kl_df = self.data_parser_cls(self._symbol, data).df
        if kl_df is None:
            return None
        return TCBaseMarket._fix_kline_pd(kl_df, n_folds, start, end)

    def minute(self, *args, **kwargs):
        """分钟k线接口"""
        raise NotImplementedError('HBApi minute NotImplementedError!')

"""unit tests module for ndg.httpsclient.utils module

PyOpenSSL utility to make a httplib-like interface suitable for use with 
urllib2
"""
__author__ = "P J Kershaw (STFC)"
__date__ = "06/01/12"
__copyright__ = "(C) 2012 Science and Technology Facilities Council"
__license__ = "BSD - see LICENSE file in top-level directory"
__contact__ = "Philip.Kershaw@stfc.ac.uk"
__revision__ = '$Id$'
import unittest
import os

from OpenSSL import SSL

from ndg.httpsclient.test import Constants
from ndg.httpsclient.utils import (Configuration, fetch_from_url, open_url,
                                   _should_use_proxy)


class TestUtilsModule(unittest.TestCase):
    '''Test ndg.httpsclient.utils module'''

    def test01_configuration(self):
        config = Configuration(SSL.Context(SSL.SSLv3_METHOD), True)
        self.assert_(config.ssl_context)
        self.assertEquals(config.debug, True)

    def test02_fetch_from_url(self):
        config = Configuration(SSL.Context(SSL.SSLv3_METHOD), True)
        res = fetch_from_url(Constants.TEST_URI, config)
        self.assert_(res)
        
    def test03_open_url(self):
        config = Configuration(SSL.Context(SSL.SSLv3_METHOD), True)
        res = open_url(Constants.TEST_URI, config)
        self.assertEqual(res[0], 200, 
                         'open_url for %r failed' % Constants.TEST_URI)
        
    def test04__should_use_proxy(self):
        if 'no_proxy' in os.environ:
            no_proxy = os.environ['no_proxy']
            del os.environ['no_proxy']
        else:
            no_proxy = None
               
        self.assertTrue(_should_use_proxy(Constants.TEST_URI), 
                        'Expecting use proxy = True')
        
        os.environ['no_proxy'] = 'localhost,localhost.localdomain'
        self.assertFalse(_should_use_proxy(Constants.TEST_URI), 
                         'Expecting use proxy = False')
        
        if no_proxy is not None:
            os.environ['no_proxy'] = no_proxy
        else:
            del os.environ['no_proxy']
    
if __name__ == "__main__":
    unittest.main()
# coding=utf-8

"""
Collects all number values from the db.serverStatus() command, other
values are ignored.

#### Dependencies

 * pymongo

#### Example Configuration

MongoDBCollector.conf

```
    enabled = True
    hosts = localhost:27017, alias1@localhost:27018, etc
```
"""

import diamond.collector
from diamond.collector import str_to_bool
import re
import zlib

try:
    import pymongo
except ImportError:
    pymongo = None

try:
    from pymongo import ReadPreference
except ImportError:
    ReadPreference = None


class MongoDBCollector(diamond.collector.Collector):
    MAX_CRC32 = 4294967295

    def __init__(self, *args, **kwargs):
        self.__totals = {}
        super(MongoDBCollector, self).__init__(*args, **kwargs)

    def get_default_config_help(self):
        config_help = super(MongoDBCollector, self).get_default_config_help()
        config_help.update({
            'hosts': 'Array of hostname(:port) elements to get metrics from'
                     'Set an alias by prefixing host:port with alias@',
            'host': 'A single hostname(:port) to get metrics from'
                    ' (can be used instead of hosts and overrides it)',
            'user': 'Username for authenticated login (optional)',
            'passwd': 'Password for authenticated login (optional)',
            'databases': 'A regex of which databases to gather metrics for.'
                         ' Defaults to all databases.',
            'ignore_collections': 'A regex of which collections to ignore.'
                                  ' MapReduce temporary collections (tmp.mr.*)'
                                  ' are ignored by default.',
            'collection_sample_rate': 'Only send stats for a consistent subset '
            'of collections. This is applied after collections are ignored via'
            ' ignore_collections Sampling uses crc32 so it is consistent across'
            ' replicas. Value between 0 and 1. Default is 1',
            'network_timeout': 'Timeout for mongodb connection (in seconds).'
                               ' There is no timeout by default.',
            'simple': 'Only collect the same metrics as mongostat.',
            'translate_collections': 'Translate dot (.) to underscores (_)'
                                     ' in collection names.',
            'ssl': 'True to enable SSL connections to the MongoDB server.'
                    ' Default is False'
        })
        return config_help

    def get_default_config(self):
        """
        Returns the default collector settings
        """
        config = super(MongoDBCollector, self).get_default_config()
        config.update({
            'path':      'mongo',
            'hosts':     ['localhost'],
            'user':      None,
            'passwd':      None,
            'databases': '.*',
            'ignore_collections': '^tmp\.mr\.',
            'network_timeout': None,
            'simple': 'False',
            'translate_collections': 'False',
            'collection_sample_rate': 1,
            'ssl': False
        })
        return config

    def collect(self):
        """Collect number values from db.serverStatus()"""

        if pymongo is None:
            self.log.error('Unable to import pymongo')
            return

        hosts = self.config.get('hosts')

        # Convert a string config value to be an array
        if isinstance(hosts, basestring):
            hosts = [hosts]

        # we need this for backwards compatibility
        if 'host' in self.config:
            hosts = [self.config['host']]

        # convert network_timeout to integer
        if self.config['network_timeout']:
            self.config['network_timeout'] = int(
                self.config['network_timeout'])

        # convert collection_sample_rate to float
        if self.config['collection_sample_rate']:
            self.config['collection_sample_rate'] = float(
                self.config['collection_sample_rate'])

        # use auth if given
        if 'user' in self.config:
            user = self.config['user']
        else:
            user = None

        if 'passwd' in self.config:
            passwd = self.config['passwd']
        else:
            passwd = None

        for host in hosts:
            matches = re.search('((.+)\@)?(.+)?', host)
            alias = matches.group(2)
            host = matches.group(3)

            if alias is None:
                if len(hosts) == 1:
                    # one host only, no need to have a prefix
                    base_prefix = []
                else:
                    base_prefix = [re.sub('[:\.]', '_', host)]
            else:
                base_prefix = [alias]

            try:
                # Ensure that the SSL option is a boolean.
                if type(self.config['ssl']) is str:
                    self.config['ssl'] = str_to_bool(self.config['ssl'])

                if ReadPreference is None:
                    conn = pymongo.Connection(
                        host,
                        network_timeout=self.config['network_timeout'],
                        ssl=self.config['ssl'],
                        slave_okay=True
                    )
                else:
                    conn = pymongo.Connection(
                        host,
                        network_timeout=self.config['network_timeout'],
                        ssl=self.config['ssl'],
                        read_preference=ReadPreference.SECONDARY,
                    )
            except Exception, e:
                self.log.error('Couldnt connect to mongodb: %s', e)
                continue

            # try auth
            if user:
                try:
                    conn.admin.authenticate(user, passwd)
                except Exception, e:
                    self.log.error('User auth given, but could not autheticate'
                                   + ' with host: %s, err: %s' % (host, e))
                    return{}

            data = conn.db.command('serverStatus')
            self._publish_transformed(data, base_prefix)
            if str_to_bool(self.config['simple']):
                data = self._extract_simple_data(data)

            self._publish_dict_with_prefix(data, base_prefix)
            db_name_filter = re.compile(self.config['databases'])
            ignored_collections = re.compile(self.config['ignore_collections'])
            sample_threshold = self.MAX_CRC32 * self.config[
                'collection_sample_rate']
            for db_name in conn.database_names():
                if not db_name_filter.search(db_name):
                    continue
                db_stats = conn[db_name].command('dbStats')
                db_prefix = base_prefix + ['databases', db_name]
                self._publish_dict_with_prefix(db_stats, db_prefix)
                for collection_name in conn[db_name].collection_names():
                    if ignored_collections.search(collection_name):
                        continue
                    if (self.config['collection_sample_rate'] < 1 and (
                            zlib.crc32(collection_name) & 0xffffffff
                            ) > sample_threshold):
                        continue

                    collection_stats = conn[db_name].command('collstats',
                                                             collection_name)
                    if str_to_bool(self.config['translate_collections']):
                        collection_name = collection_name.replace('.', '_')
                    collection_prefix = db_prefix + [collection_name]
                    self._publish_dict_with_prefix(collection_stats,
                                                   collection_prefix)

    def _publish_transformed(self, data, base_prefix):
        """ Publish values of type: counter or percent """
        self._publish_dict_with_prefix(data.get('opcounters', {}),
                                       base_prefix + ['opcounters_per_sec'],
                                       self.publish_counter)
        self._publish_dict_with_prefix(data.get('opcountersRepl', {}),
                                       base_prefix + ['opcountersRepl_per_sec'],
                                       self.publish_counter)
        self._publish_metrics(base_prefix + ['backgroundFlushing_per_sec'],
                              'flushes',
                              data.get('backgroundFlushing', {}),
                              self.publish_counter)
        self._publish_dict_with_prefix(data.get('network', {}),
                                       base_prefix + ['network_per_sec'],
                                       self.publish_counter)
        self._publish_metrics(base_prefix + ['extra_info_per_sec'],
                              'page_faults',
                              data.get('extra_info', {}),
                              self.publish_counter)

        def get_dotted_value(data, key_name):
            key_name = key_name.split('.')
            for i in key_name:
                data = data.get(i, {})
                if not data:
                    return 0
            return data

        def compute_interval(data, total_name):
            current_total = get_dotted_value(data, total_name)
            total_key = '.'.join(base_prefix + [total_name])
            last_total = self.__totals.get(total_key, current_total)
            interval = current_total - last_total
            self.__totals[total_key] = current_total
            return interval

        def publish_percent(value_name, total_name, data):
            value = float(get_dotted_value(data, value_name) * 100)
            interval = compute_interval(data, total_name)
            key = '.'.join(base_prefix + ['percent', value_name])
            self.publish_counter(key, value, time_delta=bool(interval),
                                 interval=interval)

        publish_percent('globalLock.lockTime', 'globalLock.totalTime', data)
        publish_percent('indexCounters.btree.misses',
                        'indexCounters.btree.accesses', data)

        locks = data.get('locks')
        if locks:
            if '.' in locks:
                locks['_global_'] = locks['.']
                del (locks['.'])
            key_prefix = '.'.join(base_prefix + ['percent'])
            db_name_filter = re.compile(self.config['databases'])
            interval = compute_interval(data, 'uptimeMillis')
            for db_name in locks:
                if not db_name_filter.search(db_name):
                    continue
                r = get_dotted_value(
                    locks,
                    '%s.timeLockedMicros.r' % db_name)
                R = get_dotted_value(
                    locks,
                    '.%s.timeLockedMicros.R' % db_name)
                value = float(r + R) / 10
                if value:
                    self.publish_counter(
                        key_prefix + '.locks.%s.read' % db_name,
                        value, time_delta=bool(interval),
                        interval=interval)
                w = get_dotted_value(
                    locks,
                    '%s.timeLockedMicros.w' % db_name)
                W = get_dotted_value(
                    locks,
                    '%s.timeLockedMicros.W' % db_name)
                value = float(w + W) / 10
                if value:
                    self.publish_counter(
                        key_prefix + '.locks.%s.write' % db_name,
                        value, time_delta=bool(interval), interval=interval)

    def _publish_dict_with_prefix(self, dict, prefix, publishfn=None):
        for key in dict:
            self._publish_metrics(prefix, key, dict, publishfn)

    def _publish_metrics(self, prev_keys, key, data, publishfn=None):
        """Recursively publish keys"""
        if key not in data:
            return
        value = data[key]
        keys = prev_keys + [key]
        if not publishfn:
            publishfn = self.publish
        if isinstance(value, dict):
            for new_key in value:
                self._publish_metrics(keys, new_key, value)
        elif isinstance(value, int) or isinstance(value, float):
            publishfn('.'.join(keys), value)
        elif isinstance(value, long):
            publishfn('.'.join(keys), float(value))

    def _extract_simple_data(self, data):
        return {
            'connections': data.get('connections'),
            'globalLock': data.get('globalLock'),
            'indexCounters': data.get('indexCounters')
        }

#!/usr/bin/python
#
# Copyright (C) 2007 Google Inc.
#
# 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.

__author__ = 'api.lliabraa@google.com (Lane LiaBraaten)'

import unittest
try:
  from xml.etree import ElementTree
except ImportError:
  from elementtree import ElementTree
import atom
import gdata.calendar
import gdata.calendar.service
import gdata.service
import random
import getpass
from gdata import test_data

username = ''
password = ''

class CalendarServiceAclUnitTest(unittest.TestCase):
  _aclFeedUri = "/calendar/feeds/default/acl/full"
  _aclEntryUri = "%s/user:%s" % (_aclFeedUri, "user@gmail.com",)
  
  def setUp(self):
    self.cal_client = gdata.calendar.service.CalendarService()
    self.cal_client.email = username 
    self.cal_client.password = password
    self.cal_client.source = 'GCalendarClient ACL "Unit" Tests'

  def tearDown(self):
    # No teardown needed
    pass  

  def _getRandomNumber(self):
    """Return a random number as a string for testing"""
    r = random.Random()
    r.seed()
    return str(r.randint(100000,1000000))

  def _generateAclEntry(self, role="owner", scope_type="user", scope_value=None):
    """Generates a ACL rule from parameters or makes a random user an owner by default"""
    if (scope_type=="user" and scope_value is None):
      scope_value = "user%s@gmail.com" % (self._getRandomNumber())
    rule = gdata.calendar.CalendarAclEntry()
    rule.title = atom.Title(text=role)
    rule.scope = gdata.calendar.Scope(value=scope_value, type="user")
    rule.role = gdata.calendar.Role(value="http://schemas.google.com/gCal/2005#%s" % (role))
    return rule

  def assertEqualAclEntry(self, expected, actual):
    """Compares the values of two ACL entries"""
    self.assertEqual(expected.role.value, actual.role.value)
    self.assertEqual(expected.scope.value, actual.scope.value)
    self.assertEqual(expected.scope.type, actual.scope.type)

  def testGetAclFeedUnauthenticated(self):
    """Fiendishly try to get an ACL feed without authenticating"""
    try:
      self.cal_client.GetCalendarAclFeed(self._aclFeedUri)
      self.fail("Unauthenticated request should fail")
    except gdata.service.RequestError, error:
      self.assertEqual(error[0]['status'], 401)
      self.assertEqual(error[0]['reason'], "Authorization required")

  def testGetAclFeed(self):
    """Get an ACL feed"""
    self.cal_client.ProgrammaticLogin()
    feed = self.cal_client.GetCalendarAclFeed(self._aclFeedUri)
    self.assertNotEqual(0,len(feed.entry))

  def testGetAclEntryUnauthenticated(self):
    """Fiendishly try to get an ACL entry without authenticating"""
    try:
      self.cal_client.GetCalendarAclEntry(self._aclEntryUri)
      self.fail("Unauthenticated request should fail");
    except gdata.service.RequestError, error:
      self.assertEqual(error[0]['status'], 401)
      self.assertEqual(error[0]['reason'], "Authorization required")
  
  def testGetAclEntry(self):
    """Get an ACL entry"""
    self.cal_client.ProgrammaticLogin()
    self.cal_client.GetCalendarAclEntry(self._aclEntryUri)
    
  def testCalendarAclFeedFromString(self):
    """Create an ACL feed from a hard-coded string"""
    aclFeed = gdata.calendar.CalendarAclFeedFromString(test_data.ACL_FEED)
    self.assertEqual("Elizabeth Bennet's access control list", aclFeed.title.text)
    self.assertEqual(2,len(aclFeed.entry))
    
  def testCalendarAclEntryFromString(self):
    """Create an ACL entry from a hard-coded string"""
    aclEntry = gdata.calendar.CalendarAclEntryFromString(test_data.ACL_ENTRY)
    self.assertEqual("owner", aclEntry.title.text)
    self.assertEqual("user", aclEntry.scope.type)
    self.assertEqual("liz@gmail.com", aclEntry.scope.value)
    self.assertEqual("http://schemas.google.com/gCal/2005#owner", aclEntry.role.value)

  def testCreateAndDeleteAclEntry(self):
    """Add an ACL rule and verify that is it returned in the ACL feed.  Then delete the rule and 
       verify that the rule is no longer included in the ACL feed."""
    # Get the current number of ACL rules   
    self.cal_client.ProgrammaticLogin()
    aclFeed = self.cal_client.GetCalendarAclFeed(self._aclFeedUri)
    original_rule_count = len(aclFeed.entry)
 
    # Insert entry 
    rule = self._generateAclEntry()
    returned_rule = self.cal_client.InsertAclEntry(rule, self._aclFeedUri)

    # Verify rule was added with correct ACL values
    aclFeed = self.cal_client.GetCalendarAclFeed(self._aclFeedUri)
    self.assertEqual(original_rule_count+1, len(aclFeed.entry))
    self.assertEqualAclEntry(rule, returned_rule)

    # Delete the event
    self.cal_client.DeleteAclEntry(returned_rule.GetEditLink().href)
    aclFeed = self.cal_client.GetCalendarAclFeed(self._aclFeedUri)
    self.assertEquals(original_rule_count, len(aclFeed.entry))

  def testUpdateAclChangeScopeValue(self):
    """Fiendishly try to insert a test ACL rule and attempt to change the scope value (i.e. username).
       Verify that an exception is thrown, then delete the test rule."""
    # Insert a user-scoped owner role ot random user
    aclEntry = self._generateAclEntry("owner","user");
    self.cal_client.ProgrammaticLogin()
    rule = self._generateAclEntry()
    returned_rule = self.cal_client.InsertAclEntry(rule, self._aclFeedUri)

    # Change the scope value (i.e. what user is the owner) and update the entry
    updated_rule = returned_rule
    updated_rule.scope.value = "user_%s@gmail.com" % (self._getRandomNumber())
    try:
      returned_rule = self.cal_client.UpdateAclEntry(returned_rule.GetEditLink().href, updated_rule)
    except gdata.service.RequestError, error:
      self.assertEqual(error[0]['status'], 403)
      self.assertEqual(error[0]['reason'], "Forbidden")

    self.cal_client.DeleteAclEntry(updated_rule.GetEditLink().href)

  
  def testUpdateAclChangeScopeType(self):
    """Fiendishly try to insert a test ACL rule and attempt to change the scope type (i.e. from 'user' to 'domain').
       Verify that an exception is thrown, then delete the test rule."""
    # Insert a user-scoped owner role ot random user
    aclEntry = self._generateAclEntry("owner","user");
    self.cal_client.ProgrammaticLogin()
    rule = self._generateAclEntry()
    returned_rule = self.cal_client.InsertAclEntry(rule, self._aclFeedUri)

    # Change the scope value (i.e. what user is the owner) and update the entry
    updated_rule = returned_rule
    updated_rule.scope.type = "domain"
    try:
      returned_rule = self.cal_client.UpdateAclEntry(returned_rule.GetEditLink().href, updated_rule)
    except gdata.service.RequestError, error:
      self.assertEqual(error[0]['status'], 403)
      self.assertEqual(error[0]['reason'], "Forbidden")

    self.cal_client.DeleteAclEntry(updated_rule.GetEditLink().href)

    
  def testUpdateAclChangeRoleValue(self):
    """Insert a test ACL rule and attempt to change the scope type (i.e. from 'owner' to 'editor').
       Verify that an exception is thrown, then delete the test rule."""
    # Insert a user-scoped owner role ot random user
    aclEntry = self._generateAclEntry("owner","user");
    self.cal_client.ProgrammaticLogin()
    rule = self._generateAclEntry()
    returned_rule = self.cal_client.InsertAclEntry(rule, self._aclFeedUri)

    # Change the scope value (i.e. what user is the owner) and update the entry
    updated_rule = returned_rule
    updated_rule.role.value = "http://schemas.google.com/gCal/2005#editor"
    returned_rule = self.cal_client.UpdateAclEntry(returned_rule.GetEditLink().href, updated_rule)
    self.assertEqualAclEntry(updated_rule, returned_rule)
    
    self.cal_client.DeleteAclEntry(updated_rule.GetEditLink().href)
    
if __name__ == '__main__':
  print ('NOTE: Please run these tests only with a test account. ' +
      'The tests may delete or update your data.')
  username = raw_input('Please enter your username: ')
  password = getpass.getpass()
  unittest.main()


# coding=utf-8
# Copyright 2014 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).

from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
                        unicode_literals, with_statement)

import itertools
import os
import subprocess
import sys

from twitter.common.collections import OrderedSet

from pants.backend.codegen.targets.python_thrift_library import PythonThriftLibrary
from pants.backend.python.code_generator import CodeGenerator
from pants.base.build_environment import get_buildroot
from pants.util.dirutil import safe_walk
from pants.util.memo import memoized_property


class PythonThriftBuilder(CodeGenerator):
  """Generate Python code from thrift IDL files."""
  class UnknownPlatformException(CodeGenerator.Error):

    def __init__(self, platform):
      super(PythonThriftBuilder.UnknownPlatformException, self).__init__(
          'Unknown platform: {}!'.format(str(platform)))

  def __init__(self, thrift_binary_factory, workdir, target, root_dir, target_suffix=None):
    super(PythonThriftBuilder, self).__init__(workdir, target, root_dir,
                                              target_suffix=target_suffix)
    self._thrift_binary_factory = thrift_binary_factory

  @property
  def install_requires(self):
    return ['thrift']

  @memoized_property
  def _thrift_binary(self):
    return self._thrift_binary_factory().path

  def run_thrifts(self):
    """Generate Python thrift code."""
    bases = OrderedSet()

    def collect_bases(target):
      if isinstance(target, PythonThriftLibrary):
        bases.add(os.path.join(get_buildroot(), target.target_base))

    self.target.walk(collect_bases)

    for source in self.target.payload.sources.relative_to_buildroot():
      if not self._run_thrift(bases, os.path.join(get_buildroot(), source)):
        raise PythonThriftBuilder.CodeGenerationException(
          "Could not generate .py from {}!".format(source))

  def _run_thrift(self, bases, source):
    include_paths = list(itertools.chain.from_iterable(('-I', base) for base in bases))

    args = [
             self._thrift_binary,
             '--gen',
             'py:new_style',
             '-o', self.codegen_root] + include_paths + [source]

    po = subprocess.Popen(args, cwd=self.chroot.path())
    rv = po.wait()
    if rv != 0:
      comm = po.communicate()
      print('thrift generation failed!', file=sys.stderr)
      print('STDOUT', file=sys.stderr)
      print(comm[0], file=sys.stderr)
      print('STDERR', file=sys.stderr)
      print(comm[1], file=sys.stderr)
    return rv == 0

  @property
  def package_dir(self):
    return "gen-py"

  def generate(self):
    # auto-generate the python files that we bundle up
    self.run_thrifts()

    # Thrift generates code with all parent namespaces with empty __init__.py's. Generally
    # speaking we want to drop anything w/o an __init__.py, and for anything with an __init__.py,
    # we want to explicitly make it a namespace package, hence the hoops here.
    for root, _, files in safe_walk(os.path.normpath(self.package_root)):
      reldir = os.path.relpath(root, self.package_root)
      if reldir == '.':  # skip root
        continue
      if '__init__.py' not in files:  # skip non-packages
        continue
      init_py_abspath = os.path.join(root, '__init__.py')
      module_path = self.path_to_module(reldir)
      self.created_packages.add(module_path)
      if os.path.getsize(init_py_abspath) == 0:  # empty __init__, translate to namespace package
        with open(init_py_abspath, 'wb') as f:
          f.write(b"__import__('pkg_resources').declare_namespace(__name__)")
        self.created_namespace_packages.add(module_path)
      else:
        # non-empty __init__, this is a leaf package, usually with ttypes and constants, leave as-is
        pass

    if not self.created_packages:
      raise self.CodeGenerationException('No Thrift structures declared in {}!'.format(self.target))

from django.test import TestCase
from django.core.urlresolvers import reverse
from django.contrib.auth.models import Group
from django.contrib.auth.models import User

import json


class ThemeTestCase(TestCase):
    fixtures = ['test_fixtures']

    def setUp(self):
        user = User.objects.create_user(username='test', password='pass')
        admin_group = Group(name='Administration Users')
        admin_group.save()
        user.groups.add(admin_group)
        self.client.post(
            reverse('login'), {'username': 'test', 'password': 'pass'})

        self.maxDiff = None
        self.expected_theme = """
{
    "error": {
        "status": false,
        "name": null,
        "text": null,
        "debug": null,
        "level": null
    },
    "id": 1,
    "ext": {},
    "name": "Test Name",
    "background_color": "rgb(81, 114, 133)",
    "foreground_color": "rgb(81, 114, 133)",
    "header_color": "rgb(81, 114, 133)",
    "font_color": "rgb(81, 114, 133)",
    "logo": "/media/dog.jpg",
    "slogan": "Test Slogan",
    "site_title": "Oregon Catch",
    "vendors": "shopkeepers",
    "vendors_slug": "vendors",
    "products": "items",
    "products_slug": "products",
    "preparations": "preparations",
    "preparations_slug": "preparations",
    "stories": "stories",
    "stories_slug": "stories",
    "images": "media-image",
    "images_slug": "images",
    "videos": "media-video",
    "videos_slug": "videos",
    "active": "no"
}"""

    def test_url_endpoint(self):
        url = reverse('theme-details', kwargs={'id': '1'})
        self.assertEqual(url, '/1/themes/1')

    def test_theme_endpoint(self):
        response = self.client.get(
            reverse('theme-details', kwargs={'id': '1'})).content
        parsed_answer = json.loads(response)

        expected_answer = json.loads(self.expected_theme)
        self.assertEqual(parsed_answer, expected_answer)

# -*- test-case-name: txdav.carddav.datastore.test.test_file -*-
##
# Copyright (c) 2010-2014 Apple Inc. All rights reserved.
#
# 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.
##

"""
File addressbook store.
"""

__all__ = [
    "AddressBookStore",
    "AddressBookStoreTransaction",
    "AddressBookHome",
    "AddressBook",
    "AddressBookObject",
]

from errno import ENOENT

from txdav.xml.rfc2518 import GETContentType
from txweb2.dav.resource import TwistedGETContentMD5
from txweb2.http_headers import MimeType

from twisted.python import hashlib

from twistedcaldav.vcard import Component as VComponent, InvalidVCardDataError
from txdav.carddav.datastore.index_file import AddressBookIndex as OldIndex

from txdav.carddav.datastore.util import validateAddressBookComponent
from txdav.carddav.iaddressbookstore import IAddressBook, IAddressBookObject
from txdav.carddav.iaddressbookstore import IAddressBookHome

from txdav.common.datastore.file import CommonDataStore, CommonHome, \
    CommonStoreTransaction, CommonHomeChild, CommonObjectResource, \
    CommonStubResource
from txdav.common.icommondatastore import NoSuchObjectResourceError, InternalDataStoreError
from txdav.base.datastore.file import hidden, writeOperation
from txdav.base.propertystore.base import PropertyName

from twistedcaldav import customxml, carddavxml

from zope.interface import implements

contentTypeKey = PropertyName.fromElement(GETContentType)
md5key = PropertyName.fromElement(TwistedGETContentMD5)

AddressBookStore = CommonDataStore

AddressBookStoreTransaction = CommonStoreTransaction

class AddressBookHome(CommonHome):

    implements(IAddressBookHome)

    _topPath = "addressbooks"
    _notifierPrefix = "CardDAV"

    def __init__(self, uid, path, addressbookStore, transaction):
        super(AddressBookHome, self).__init__(uid, path, addressbookStore, transaction)

        self._childClass = AddressBook

    addressbooks = CommonHome.children
    listAddressbooks = CommonHome.listChildren
    loadAddressbooks = CommonHome.loadChildren
    addressbookWithName = CommonHome.childWithName
    createAddressBookWithName = CommonHome.createChildWithName
    removeAddressBookWithName = CommonHome.removeChildWithName

    @property
    def _addressbookStore(self):
        return self._dataStore


    def createdHome(self):
        self.createAddressBookWithName("addressbook")



class AddressBook(CommonHomeChild):
    """
    File-based implementation of L{IAddressBook}.
    """
    implements(IAddressBook)

    def __init__(self, name, addressbookHome, owned, realName=None):
        """
        Initialize an addressbook pointing at a path on disk.

        @param name: the subdirectory of addressbookHome where this addressbook
            resides.
        @type name: C{str}

        @param addressbookHome: the home containing this addressbook.
        @type addressbookHome: L{AddressBookHome}

        @param realName: If this addressbook was just created, the name which it
        will eventually have on disk.
        @type realName: C{str}
        """

        super(AddressBook, self).__init__(name, addressbookHome, owned, realName=realName)

        self._index = Index(self)
        self._objectResourceClass = AddressBookObject


    @property
    def _addressbookHome(self):
        return self._home

    ownerAddressBookHome = CommonHomeChild.ownerHome
    addressbookObjects = CommonHomeChild.objectResources
    listAddressbookObjects = CommonHomeChild.listObjectResources
    addressbookObjectWithName = CommonHomeChild.objectResourceWithName
    addressbookObjectWithUID = CommonHomeChild.objectResourceWithUID
    createAddressBookObjectWithName = CommonHomeChild.createObjectResourceWithName
    addressbookObjectsSinceToken = CommonHomeChild.objectResourcesSinceToken


    def initPropertyStore(self, props):
        # Setup peruser special properties
        props.setSpecialProperties(
            (
                PropertyName.fromElement(carddavxml.AddressBookDescription),
            ),
            (
                PropertyName.fromElement(customxml.GETCTag),
            ),
            (),
        )


    def contentType(self):
        """
        The content type of Addresbook objects is text/vcard.
        """
        return MimeType.fromString("text/vcard; charset=utf-8")



class AddressBookObject(CommonObjectResource):
    """
    """
    implements(IAddressBookObject)

    def __init__(self, name, addressbook, metadata=None):

        super(AddressBookObject, self).__init__(name, addressbook)


    @property
    def _addressbook(self):
        return self._parentCollection


    def addressbook(self):
        return self._addressbook


    @writeOperation
    def setComponent(self, component, inserting=False):

        validateAddressBookComponent(self, self._addressbook, component, inserting)

        self._addressbook.retrieveOldIndex().addResource(
            self.name(), component
        )

        componentText = str(component)
        self._objectText = componentText

        def do():
            # Mark all properties as dirty, so they can be added back
            # to the newly updated file.
            self.properties().update(self.properties())

            backup = None
            if self._path.exists():
                backup = hidden(self._path.temporarySibling())
                self._path.moveTo(backup)

            fh = self._path.open("w")
            try:
                # FIXME: concurrency problem; if this write is interrupted
                # halfway through, the underlying file will be corrupt.
                fh.write(componentText)
            finally:
                fh.close()

            md5 = hashlib.md5(componentText).hexdigest()
            self.properties()[md5key] = TwistedGETContentMD5.fromString(md5)

            # Now re-write the original properties on the updated file
            self.properties().flush()

            def undo():
                if backup:
                    backup.moveTo(self._path)
                else:
                    self._path.remove()
            return undo
        self._transaction.addOperation(do, "set addressbook component %r" % (self.name(),))

        self._addressbook.notifyChanged()


    def component(self):
        """
        Read address data and validate/fix it. Do not raise a store error here if there are unfixable
        errors as that could prevent the overall request to fail. Instead we will hand bad data off to
        the caller - that is not ideal but in theory we should have checked everything on the way in and
        only allowed in good data.
        """
        text = self._text()
        try:
            component = VComponent.fromString(text)
        except InvalidVCardDataError, e:
            # This is a really bad situation, so do raise
            raise InternalDataStoreError(
                "File corruption detected (%s) in file: %s"
                % (e, self._path.path)
            )

        # Fix any bogus data we can
        fixed, unfixed = component.validVCardData(doFix=True, doRaise=False)

        if unfixed:
            self.log.error("Address data at %s had unfixable problems:\n  %s" % (self._path.path, "\n  ".join(unfixed),))

        if fixed:
            self.log.error("Address data at %s had fixable problems:\n  %s" % (self._path.path, "\n  ".join(fixed),))

        return component


    def _text(self):
        if self._objectText is not None:
            return self._objectText

        try:
            fh = self._path.open()
        except IOError, e:
            if e[0] == ENOENT:
                raise NoSuchObjectResourceError(self)
            else:
                raise

        try:
            text = fh.read()
        finally:
            fh.close()

        if not (
            text.startswith("BEGIN:VCARD\r\n") or
            text.endswith("\r\nEND:VCARD\r\n")
        ):
            raise InternalDataStoreError(
                "File corruption detected (improper start) in file: %s"
                % (self._path.path,)
            )

        self._objectText = text
        return text


    def uid(self):
        if not hasattr(self, "_uid"):
            self._uid = self.component().resourceUID()
        return self._uid


    # IDataStoreObject
    def contentType(self):
        """
        The content type of Addressbook objects is text/x-vcard.
        """
        return MimeType.fromString("text/vcard; charset=utf-8")



class AddressBookStubResource(CommonStubResource):
    """
    Just enough resource to keep the addressbook's sql DB classes going.
    """

    def isAddressBookCollection(self):
        return True


    def getChild(self, name):
        addressbookObject = self.resource.addressbookObjectWithName(name)
        if addressbookObject:
            class ChildResource(object):
                def __init__(self, addressbookObject):
                    self.addressbookObject = addressbookObject

                def iAddressBook(self):
                    return self.addressbookObject.component()

            return ChildResource(addressbookObject)
        else:
            return None



class Index(object):
    #
    # OK, here's where we get ugly.
    # The index code needs to be rewritten also, but in the meantime...
    #
    def __init__(self, addressbook):
        self.addressbook = addressbook
        stubResource = AddressBookStubResource(addressbook)
        self._oldIndex = OldIndex(stubResource)


    def addressbookObjects(self):
        addressbook = self.addressbook
        for name, uid, componentType in self._oldIndex.bruteForceSearch():
            addressbookObject = addressbook.addressbookObjectWithName(name)

            # Precache what we found in the index
            addressbookObject._uid = uid
            addressbookObject._componentType = componentType

            yield addressbookObject

from enigma import eDVBResourceManager, Misc_Options
from Tools.Directories import fileExists, fileCheck
from Tools.HardwareInfo import HardwareInfo

from boxbranding import getMachineBuild, getBoxType

SystemInfo = { }

#FIXMEE...
def getNumVideoDecoders():
	idx = 0
	while fileExists("/dev/dvb/adapter0/video%d"% idx, 'f'):
		idx += 1
	return idx

SystemInfo["NumVideoDecoders"] = getNumVideoDecoders()
SystemInfo["PIPAvailable"] = SystemInfo["NumVideoDecoders"] > 1
SystemInfo["CanMeasureFrontendInputPower"] = eDVBResourceManager.getInstance().canMeasureFrontendInputPower()


def countFrontpanelLEDs():
	leds = 0
	if fileExists("/proc/stb/fp/led_set_pattern"):
		leds += 1
	while fileExists("/proc/stb/fp/led%d_pattern" % leds):
		leds += 1
	return leds

SystemInfo["12V_Output"] = Misc_Options.getInstance().detected_12V_output()
SystemInfo["ZapMode"] = fileCheck("/proc/stb/video/zapmode") or fileCheck("/proc/stb/video/zapping_mode")
SystemInfo["NumFrontpanelLEDs"] = countFrontpanelLEDs()
SystemInfo["FrontpanelDisplay"] = fileExists("/dev/dbox/oled0") or fileExists("/dev/dbox/lcd0")
SystemInfo["OledDisplay"] = fileExists("/dev/dbox/oled0")
SystemInfo["LcdDisplay"] = fileExists("/dev/dbox/lcd0")
SystemInfo["DeepstandbySupport"] = HardwareInfo().has_deepstandby()
SystemInfo["Fan"] = fileCheck("/proc/stb/fp/fan")
SystemInfo["FanPWM"] = SystemInfo["Fan"] and fileCheck("/proc/stb/fp/fan_pwm")
SystemInfo["StandbyLED"] = fileCheck("/proc/stb/power/standbyled")
SystemInfo["LEDButtons"] = getBoxType() == 'vuultimo'
SystemInfo["WakeOnLAN"] = fileCheck("/proc/stb/power/wol") or fileCheck("/proc/stb/fp/wol")
SystemInfo["HDMICEC"] = (fileExists("/dev/hdmi_cec") or fileExists("/dev/misc/hdmi_cec0")) and fileExists("/usr/lib/enigma2/python/Plugins/SystemPlugins/HdmiCEC/plugin.pyo")
SystemInfo["SABSetup"] = fileExists("/usr/lib/enigma2/python/Plugins/SystemPlugins/SABnzbd/plugin.pyo")
SystemInfo["Blindscan"] = fileExists("/usr/lib/enigma2/python/Plugins/SystemPlugins/Blindscan/plugin.pyo")
SystemInfo["Satfinder"] = fileExists("/usr/lib/enigma2/python/Plugins/SystemPlugins/Satfinder/plugin.pyo")
SystemInfo["HasExternalPIP"] = getMachineBuild() not in ('et9x00', 'et6x00', 'et5x00') and fileCheck("/proc/stb/vmpeg/1/external")
SystemInfo["VideoDestinationConfigurable"] = fileExists("/proc/stb/vmpeg/0/dst_left")
SystemInfo["hasPIPVisibleProc"] = fileCheck("/proc/stb/vmpeg/1/visible")
SystemInfo["LCDMiniTV"] = fileExists("/proc/stb/lcd/mode")
SystemInfo["LCDMiniTVPiP"] = SystemInfo["LCDMiniTV"] and getBoxType() != 'gb800ueplus'


from django.core.urlresolvers import reverse
from django.views.generic import View

from pulp.server import exceptions as pulp_exceptions
from pulp.server.auth import authorization
from pulp.server.managers import factory
from pulp.server.webservices.views.decorators import auth_required
from pulp.server.webservices.views.util import (generate_json_response,
                                                generate_json_response_with_pulp_encoder,
                                                generate_redirect_response,
                                                json_body_required)


class RolesView(View):
    """
    Views for roles.
    """

    @auth_required(authorization.READ)
    def get(self, request):
        """
        List all roles.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest

        :return: Response containing a list of roles
        :rtype: django.http.HttpResponse
        """
        role_query_manager = factory.role_query_manager()
        user_query_manager = factory.user_query_manager()
        permissions_manager = factory.permission_manager()
        roles = role_query_manager.find_all()
        for role in roles:
            role['users'] = [u['login'] for u in
                             user_query_manager.find_users_belonging_to_role(role['id'])]

            resource_permission = {}
            # isolate schema change
            if role['permissions']:
                for item in role['permissions']:
                    resource = item['resource']
                    operations = item.get('permission', [])
                    resource_permission[resource] = [permissions_manager.operation_value_to_name(o)
                                                     for o in operations]

            role['permissions'] = resource_permission

            link = {'_href': reverse('role_resource',
                    kwargs={'role_id': role['id']})}
            role.update(link)
        return generate_json_response_with_pulp_encoder(roles)

    @auth_required(authorization.CREATE)
    @json_body_required
    def post(self, request):
        """
        Create a new role.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest

        :return: Response containing the role
        :rtype: django.http.HttpResponse
        """
        role_data = request.body_as_json
        role_id = role_data.get('role_id', None)
        display_name = role_data.get('display_name', None)
        description = role_data.get('description', None)
        manager = factory.role_manager()
        role = manager.create_role(role_id, display_name, description)
        link = {'_href': reverse('role_resource',
                kwargs={'role_id': role['id']})}
        role.update(link)
        response = generate_json_response_with_pulp_encoder(role)
        redirect_response = generate_redirect_response(response, link['_href'])
        return redirect_response


class RoleResourceView(View):
    """
    Views for a single role.
    """

    @auth_required(authorization.READ)
    def get(self, request, role_id):
        """
        Retrieve a specific role.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param role_id: id for the requested role
        :type role_id: str

        :return: Response containing the role
        :rtype: django.http.HttpResponse
        :raises: MissingResource if role ID does not exist
        """
        role = factory.role_query_manager().find_by_id(role_id)
        if role is None:
            raise pulp_exceptions.MissingResource(role_id)
        role['users'] = [u['login'] for u in
                         factory.user_query_manager().find_users_belonging_to_role(role['id'])]
        permissions_manager = factory.permission_manager()
        # isolate schema change
        resource_permission = {}
        for item in role['permissions']:
            resource = item['resource']
            operations = item.get('permission', [])
            resource_permission[resource] = [permissions_manager.operation_value_to_name(o)
                                             for o in operations]
        role['permissions'] = resource_permission

        link = {'_href': reverse('role_resource',
                kwargs={'role_id': role['id']})}
        role.update(link)
        return generate_json_response_with_pulp_encoder(role)

    @auth_required(authorization.DELETE)
    def delete(self, request, role_id):
        """
        Delete a  role.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param role_id: id for the requested role
        :type role_id: str

        :return: An empty response
        :rtype: django.http.HttpResponse
        """
        manager = factory.role_manager()
        result = manager.delete_role(role_id)
        return generate_json_response(result)

    @auth_required(authorization.UPDATE)
    @json_body_required
    def put(self, request, role_id):
        """
        Update a specific role.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param role_id: id for the requested role
        :type role_id: str

        :return: Response containing the role
        :rtype: django.http.HttpResponse
        """
        role_data = request.body_as_json
        delta = role_data.get('delta', None)
        manager = factory.role_manager()
        role = manager.update_role(role_id, delta)
        link = {'_href': reverse('role_resource',
                kwargs={'role_id': role['id']})}
        role.update(link)
        return generate_json_response_with_pulp_encoder(role)


class RoleUsersView(View):
    """
    Views for user membership within a role
    """

    @auth_required(authorization.READ)
    def get(self, request, role_id):
        """
        List Users belonging to a role.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param role_id: id for the requested role
        :type role_id: str

        :return: Response containing the users
        :rtype: django.http.HttpResponse
        """
        user_query_manager = factory.user_query_manager()
        role_users = user_query_manager.find_users_belonging_to_role(role_id)
        return generate_json_response_with_pulp_encoder(role_users)

    @auth_required(authorization.UPDATE)
    @json_body_required
    def post(self, request, role_id):
        """
        Add user to a role.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param role_id: id for the requested role
        :type role_id: str

        :return: An empty response
        :rtype: django.http.HttpResponse
        :raises: InvalidValue some parameters are invalid
        """
        params = request.body_as_json
        login = params.get('login', None)
        if login is None:
            raise pulp_exceptions.InvalidValue(login)

        role_manager = factory.role_manager()
        add_user = role_manager.add_user_to_role(role_id, login)
        return generate_json_response(add_user)


class RoleUserView(View):
    """
    View for specific user membership within a role.
    """

    @auth_required(authorization.DELETE)
    def delete(self, request, role_id, login):
        """
        Remove user from a role.

        :param request: WSGI request object
        :type request: django.core.handlers.wsgi.WSGIRequest
        :param role_id: id for the requested role
        :type role_id: str
        :param login: id for the requested user
        :type login: str

        :return: An empty response
        :rtype: django.http.HttpResponse
        """
        role_manager = factory.role_manager()
        remove_user = role_manager.remove_user_from_role(role_id, login)
        return generate_json_response(remove_user)

# Copyright (c) 2006-2007 The Regents of The University of Michigan
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Korey Sewell

m5.util.addToPath('../configs/common')
from cpu2000 import mcf

workload = mcf(isa, opsys, 'smred')
root.system.cpu[0].workload = workload.makeLiveProcess()
root.system.physmem.range=AddrRange('256MB')

#Copyright (c) 2015 Microsoft Corp 

#Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

#The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


from azure import *
from azure.servicemanagement import *
import VMClusterSetupClasses
from VMClusterSetupClasses import XmlSerializerVMCluster, AzureHttpRequests
from collections import namedtuple
import json
import base64
from _io import open
from builtins import bytes
from azure import _encode_base64
from azure import _Base64String
from requests import Response
import time
from time import sleep
#from __builtin__ import bytes
#import paramiko
#from paramiko import SSHClient
#from paramiko.client import AutoAddPolicy


# Constant variables
subscription_id = "5c78935e-b33b-4b89-b627-b32fd08408f5"
certificate_path = "CURRENT_USER\\my\\AzureCertificate"
storage_location_name = ""
vnet_name = "mysqlvnetsg"
cs_name = "mysqlchefsg"
vnet_location = ""
svc = ServiceManagementService(subscription_id, certificate_path)     
isStorageAccCreated = False
isHostedServiceCreated = False
vm_image_name="debian-77-disk"

config_file_path = "C:\\Python_Files\\"


def Create_StorageAccount():
    storage_acc_name = ""    
    storage_replication = ""
    storage_location_name = ""
    #Standard_LRS, Standard_ZRS, Standard_GRS, Standard_RAGRS
    if storage_acc_name == "":
        storage_acc_name = str(input("Enter a storage account name. Storage account names must be between 3 and 24 characters in length and use numbers and lower-case letters only... "))
        isBoolStorageAccountNameUnique = False
        while isBoolStorageAccountNameUnique == False:
            res = svc.check_storage_account_name_availability(storage_acc_name)
            if res.result  == True:
                isBoolStorageAccountNameUnique = True
                if len(storage_location_name) <= 0: 
                    storage_location_name = str(input("Enter storage location... "))
                if len(storage_replication) <= 0:
                    storage_replication = str(input("Enter replication factor (Standard_LRS, Standard_ZRS, Standard_GRS, Standard_RAGRS)... "))
                    isBoolStorageReplicationValid = False
                    while isBoolStorageReplicationValid == False:
                        if storage_replication != "Standard_LRS" and storage_replication != "Standard_ZRS" and storage_replication != "Standard_GRS" and storage_replication != "Standard_RAGRS":
                            storage_replication = str(input("Invalid entry: Please re-enter replication factor (Standard_LRS, Standard_ZRS, Standard_GRS, Standard_RAGRS), press E if you want to exit"))
                            if storage_replication == "E" or storage_replication == "e":
                                isStorageAccCreated = False
                                break
                        else:
                            isBoolStorageReplicationValid = True
                if isBoolStorageReplicationValid == True:
                    svc.create_storage_account(storage_acc_name,storage_acc_name,storage_acc_name,None,storage_location_name,True,None)
                    isStorageAccCreated = True
            else:
                storage_acc_name = str(input("The storage account name entered is already in use, please re-enter another one, press E to exit.."))                            
                if storage_acc_name == "E" or storage_acc_name == "e":
                    isStorageAccCreated = False
                    break
        if isStorageAccCreated == True:
            print("Storage account..." + storage_acc_name + " has been created")
        else:
            print("Storage account could be created")

    return True

def Create_HostedService():
   
    cs_label = ""
    cs_description = ""
    cs_location = ""
    isHostedCSNameUnique = False
    
    if len(storage_location_name) > 0 and isStorageAccCreated == True:
        cs_location = storage_location_name
    if len(cs_name) <= 0:
        cs_name = str(input("Enter hosted service name. This name is the DNS prefix name and can be used to access the hosted service"))
        while isHostedCSNameUnique == False:            
            res_cs_Name = svc.check_hosted_service_name_availability(cs_name)
            if res_cs_Name.result == True:
                isHostedCSNameUnique = True
                if len(cs_label) <= 0:
                    cs_label = str(input("Enter hosted service label"))
                if len(cs_description) <= 0:
                    cs_description = str(input("Enter hosted service description"))
                if len(cs_location) <= 0:
                    cs_location = str(input("Enter hosted service location"))
                svc.create_hosted_service(cs_name, cs_label,cs_description,cs_location)
                isHostedServiceCreated = True
                
            else:    
                print(res_cs_Name.body)
                cs_name = str(input("The host service name entered is already in use, please another one or press E to exit"))
                if cs_name == "E" or cs_name == "e":
                    isHostedServiceCreated = False
                    break
    if isHostedServiceCreated == True:
        print("Hosted service... " + cs_name + " created")  
    else:
        print("Hosted service could not be created")
def Create_VNet():
    # Creating VNet
    input_option = str(input("Do you have a Vnet configured? Y for Yes, N for No..."))
    if input_option == "Y" or input_option == "y":
        vnet_name = str(input("Please enter vnet name..."))  
    else:
        # creating a vnet from existing file?
        is_vnet_file = str(input("Do you have a pre-created vnet configuration xml file? please enter Y for Yes, N for No..."))        
        if is_vnet_file == "Y" or is_vnet_file == "y":
            vnet_file = str(input("Please enter the complete/absolute file path..."))
            file_created_path = vnet_file
            vnet_rest_api_path = "https://management.core.windows.net/" + subscription_id + "/services/networking/media"
            AzureHttpRequests.create_vnet(vnet_rest_api_path,file_created_path)
        else:
            # Input from JSon - Version 2
            print("Requesting all parameters...")
            vnet_name = str(input("Please enter a vnet name you wish to create..."))
            if len(storage_location_name) <= 0:
                vnet_location = str(input("Please enter location you wish to create the vnet in..."))
            else:
                vnet_location = storage_location_name             
            
            ### check vnet name availability .... version 2
            is_dns = str(input("Do you have dns servers to create? Please enter Y for Yes and N for No.... "))
            is_more_dns = True
            dns = []
            while is_more_dns == True:
                dns_inp = str(input("Enter dns server name, IPAddress seperated by ','ex: (www.abc.com,111.23.45.66), or press E after entering all dns entries ..."))
                if dns_inp != "E" and dns_inp != "e":
                    dns_val = dns_inp.split(",")
                    if len(dns_val) == 2:
                        dns_name = dns_val[0]
                        dns_addr = dns_val[1]
                        # check if IP Address is valid - Version 2
                        dns.append({"name":dns_name,"IP_address":dns_addr})                                                
                else:
                    is_more_dns = False
                    break
            ### Version 2 : Local network site inputs
            ### Entering Address Space
            ### Entering Virtual network subnet entries
            ## Defaulting address space and subnet values (for version 1)
            addr_space = "10.0.0.0/8"
            subnet_det = {"name":"Subnet-1","addr":"10.0.0.0/11"}
            if len(config_file_path) <=0:
                config_file_path = str(input("Please enter the configuration save file path..."))
            file_created_path = XmlSerializerVMCluster.create_vnet_config_xml(vnet_name,vnet_location,dns,addr_space,subnet_det,config_file_path)
            vnet_rest_api_path = "https://management.core.windows.net/" + subscription_id + "/services/networking/media"
            AzureHttpRequests.post_request(vnet_rest_api_path,file_created_path)

def Get_Res_Ext_List():
    res_ext_ref = []
    res_exts = ResourceExtensionReferences()
    res = ResourceExtensionReference()
    
    res.reference_name="MyCustomScriptExtension"
    res.name = "CustomScriptForLinux"
    res.publisher = "Microsoft.OSTCExtensions"
    res.version =    "1.1"
    res.label= "MyCustomScriptExtension"
    #_encode_base64(
    res_chef_client_rb = ResourceExtensionParameterValue()
    

    res_chef_client_rb.key = "CustomScriptExtensionPublicConfigParameter"
    res_chef_client_rb.value = _encode_base64('{"fileUris":["http://<storage account name>.blob.core.windows.net/demo/install-chef.sh"],"commandToExecute":"sh install-chef.sh"}') 
    res_chef_client_rb.type = "Public"
    res_chef_client_validation = ResourceExtensionParameterValue()
    res_chef_client_validation.key = "CustomScriptExtensionPrivateConfigParameter"
    res_chef_client_validation.value = _encode_base64('{"storageAccountName":"<storage account name>","storageAccountKey":"<storage account key>"}')
    res_chef_client_validation.type = "Private"
    
    
    
    res.resource_extension_parameter_values.resource_extension_parameter_values.append(res_chef_client_rb)
    
    res.resource_extension_parameter_values.resource_extension_parameter_values.append(res_chef_client_validation)

    res_ext_ref.append(res)
  
    return res_ext_ref    

def Create_Virtual_Machine_Single(cs_name,deployment_name,label,role_name,system_config=None,os_hd=None,role_size="Small",resource_ext_refs=None,vnet_name=None,provision_guest_agent="true",network_config=None,add_role=False,vm_number=" "):
    # Creates a single VM based on parameters passed
    if add_role == False:
        result = svc.create_virtual_machine_deployment(service_name=cs_name,
        deployment_name=deployment_name,        
        deployment_slot='production',
        label=cs_name,
        role_name=role_name,
        system_config=system_config,
        os_virtual_hard_disk=os_hd,
        role_size='Small',
        resource_extension_references=resource_ext_refs,
        virtual_network_name=vnet_name,
        provision_guest_agent='true',
        network_config=network_config)
        return result
    else:
        result = svc.add_role(service_name=cs_name,deployment_name=deployment_name,role_name=role_name,system_config=system_config,os_virtual_hard_disk=os_hd,network_config=network_config,role_size=role_size,resource_extension_references=resource_ext_refs,provision_guest_agent=provision_guest_agent)
        return result

               
def Create_Virtual_Machine_New():
    
    ## Initializing cloud service and Vnet name

    cs_name = " "
    vnet_name = " "

    cs_name = input("Please enter the cloud service name")
    vnet_name = input("Please enter the vnet name")

    if len(cs_name) <= 0:
        Create_HostedService()
    vm_name = cs_name + "01"
    ### Modify the code to get Chef Extension

    res_ext_ref = Get_Res_Ext_List()
    #res_ext_ref = None   
    
    linux_config = LinuxConfigurationSet(host_name=vm_name,user_name="azureuser",user_password="MicrosoftDx1",disable_ssh_password_authentication="false")
    
    network = ConfigurationSet()
    network.configuration_set_type = "NetworkConfiguration"
    network.input_endpoints.input_endpoints.append(ConfigurationSetInputEndpoint('ssh', 'tcp', '22', '22'))
    network.input_endpoints.input_endpoints.append(ConfigurationSetInputEndpoint('http', 'tcp', '80', '80'))
    
        
    network_02 = ConfigurationSet()
    network_02.configuration_set_type = "NetworkConfiguration"
    network_02.input_endpoints.input_endpoints.append(ConfigurationSetInputEndpoint('ssh', 'tcp', '223', '22'))
    network_02.input_endpoints.input_endpoints.append(ConfigurationSetInputEndpoint('http', 'tcp', '8023', '8023'))
    
    network_03 = ConfigurationSet()
    network_03.configuration_set_type = "NetworkConfiguration"
    network_03.input_endpoints.input_endpoints.append(ConfigurationSetInputEndpoint('ssh', 'tcp', '224', '22'))
    network_03.input_endpoints.input_endpoints.append(ConfigurationSetInputEndpoint('http', 'tcp', '8024', '8024'))
    
        
    vm_number = " "
    
    #disk_name="debian77_01",
    #source_image_name="pipedriveimage"
    ### VM1
    os_hd = OSVirtualHardDisk(source_image_name="b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB",media_link="https://<storage account name>.blob.core.windows.net/vhds/" + cs_name + "pipedrivevhd010101sgvr01.vhd",os="Linux")
    os_hd_01 = OSVirtualHardDisk(source_image_name="b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB",media_link="https://<storage account name>.blob.core.windows.net/vhds/" + cs_name + "pipedrivevhd020202sgvr02.vhd",os="Linux")
    os_hd_02 = OSVirtualHardDisk(source_image_name="b39f27a8b8c64d52b05eac6a62ebad85__Ubuntu-14_04_1-LTS-amd64-server-20140927-en-us-30GB",media_link="https://<storage account name>.blob.core.windows.net/vhds/" + cs_name + "pipedrivevhd030303sgvr03.vhd",os="Linux")

    resvm_01 = Create_Virtual_Machine_Single(cs_name=cs_name+"01",
    deployment_name=cs_name+"01",    
    label=cs_name+"01",
    role_name=cs_name+"01",
    system_config=linux_config,
    os_hd=os_hd,
    role_size='Small',
    resource_ext_refs=res_ext_ref,
    vnet_name=vnet_name,
    provision_guest_agent="true",
    network_config=network,add_role=False,vm_number="01")
    

    # Install_Chef

    

    
    
    ## VM2

        
        
    linux_config_02 = LinuxConfigurationSet(host_name=cs_name+"02",user_name="azureuser",user_password="MicrosoftDx1",disable_ssh_password_authentication="false")

    resvm_02 = Create_Virtual_Machine_Single(cs_name=cs_name+"02",
    deployment_name=cs_name+"02",    
    label=cs_name+"02",
    role_name=cs_name+"02",
    system_config=linux_config_02,
    os_hd=os_hd_02,
    role_size='Small',
    resource_ext_refs=res_ext_ref,
    vnet_name=vnet_name,
    provision_guest_agent="true",
    network_config=network_02,add_role=False,vm_number="02")
    result_status_02 = False
    res_ops_status_02 = False

    
    
    
    linux_config_03 = LinuxConfigurationSet(host_name=cs_name+"03",user_name="azureuser",user_password="MicrosoftDx1",disable_ssh_password_authentication="false")

    resvm_03 = Create_Virtual_Machine_Single(cs_name=cs_name+"03",
    deployment_name=cs_name+"03",    
    label=cs_name+"03",
    role_name=cs_name+"03",
    system_config=linux_config_03,
    os_hd=os_hd_01,
    role_size='Small',
    resource_ext_refs=res_ext_ref,
    vnet_name=vnet_name,
    provision_guest_agent="true",
    network_config=network_03,add_role=False,vm_number="03")
    
    print("Submitted successfully...")    
    
        ## get the result status




  
        

  

               
if __name__ == "__main__":
    print("This script creates VM clusters, and also other Azure components. Enter 'vm' parameter to create VMs, 'cs' to create cloud service, 'sa' to create storage account")
    inp = input("Enter your choice")
    if inp == "vm":
        Create_Virtual_Machine_New()
    else:
        if inp == "cs":
            Create_HostedService()
        else:
            if inp == "sa":
                Create_StorageAccount()
            else:
                print("Invalid parameter exiting code") 

    
import datetime

from django.conf import settings
from django.db import backend, connection, transaction, DEFAULT_DB_ALIAS
from django.test import TestCase, TransactionTestCase

from models import Book, Award, AwardNote, Person, Child, Toy, PlayedWith, PlayedWithNote

# Can't run this test under SQLite, because you can't
# get two connections to an in-memory database.
if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.sqlite3':
    class DeleteLockingTest(TransactionTestCase):
        def setUp(self):
            # Create a second connection to the default database
            conn_settings = settings.DATABASES[DEFAULT_DB_ALIAS]
            self.conn2 = backend.DatabaseWrapper({
                'HOST': conn_settings['HOST'],
                'NAME': conn_settings['NAME'],
                'OPTIONS': conn_settings['OPTIONS'],
                'PASSWORD': conn_settings['PASSWORD'],
                'PORT': conn_settings['PORT'],
                'USER': conn_settings['USER'],
                'TIME_ZONE': settings.TIME_ZONE,
            })

            # Put both DB connections into managed transaction mode
            transaction.enter_transaction_management()
            transaction.managed(True)
            self.conn2._enter_transaction_management(True)

        def tearDown(self):
            # Close down the second connection.
            transaction.leave_transaction_management()
            self.conn2.close()

        def test_concurrent_delete(self):
            "Deletes on concurrent transactions don't collide and lock the database. Regression for #9479"

            # Create some dummy data
            b1 = Book(id=1, pagecount=100)
            b2 = Book(id=2, pagecount=200)
            b3 = Book(id=3, pagecount=300)
            b1.save()
            b2.save()
            b3.save()

            transaction.commit()

            self.assertEquals(3, Book.objects.count())

            # Delete something using connection 2.
            cursor2 = self.conn2.cursor()
            cursor2.execute('DELETE from delete_regress_book WHERE id=1')
            self.conn2._commit();

            # Now perform a queryset delete that covers the object
            # deleted in connection 2. This causes an infinite loop
            # under MySQL InnoDB unless we keep track of already
            # deleted objects.
            Book.objects.filter(pagecount__lt=250).delete()
            transaction.commit()
            self.assertEquals(1, Book.objects.count())

class DeleteCascadeTests(TestCase):
    def test_generic_relation_cascade(self):
        """
        Test that Django cascades deletes through generic-related
        objects to their reverse relations.

        This might falsely succeed if the database cascades deletes
        itself immediately; the postgresql_psycopg2 backend does not
        give such a false success because ForeignKeys are created with
        DEFERRABLE INITIALLY DEFERRED, so its internal cascade is
        delayed until transaction commit.

        """
        person = Person.objects.create(name='Nelson Mandela')
        award = Award.objects.create(name='Nobel', content_object=person)
        note = AwardNote.objects.create(note='a peace prize',
                                        award=award)
        self.assertEquals(AwardNote.objects.count(), 1)
        person.delete()
        self.assertEquals(Award.objects.count(), 0)
        # first two asserts are just sanity checks, this is the kicker:
        self.assertEquals(AwardNote.objects.count(), 0)

    def test_fk_to_m2m_through(self):
        """
        Test that if a M2M relationship has an explicitly-specified
        through model, and some other model has an FK to that through
        model, deletion is cascaded from one of the participants in
        the M2M, to the through model, to its related model.

        Like the above test, this could in theory falsely succeed if
        the DB cascades deletes itself immediately.

        """
        juan = Child.objects.create(name='Juan')
        paints = Toy.objects.create(name='Paints')
        played = PlayedWith.objects.create(child=juan, toy=paints,
                                           date=datetime.date.today())
        note = PlayedWithNote.objects.create(played=played,
                                             note='the next Jackson Pollock')
        self.assertEquals(PlayedWithNote.objects.count(), 1)
        paints.delete()
        self.assertEquals(PlayedWith.objects.count(), 0)
        # first two asserts just sanity checks, this is the kicker:
        self.assertEquals(PlayedWithNote.objects.count(), 0)

class LargeDeleteTests(TestCase):
    def test_large_deletes(self):
        "Regression for #13309 -- if the number of objects > chunk size, deletion still occurs"
        for x in range(300):
            track = Book.objects.create(pagecount=x+100)
        Book.objects.all().delete()
        self.assertEquals(Book.objects.count(), 0)

# -*- coding: utf-8 -*-
# This file is part of Shuup.
#
# Copyright (c) 2012-2016, Shoop Ltd. All rights reserved.
#
# This source code is licensed under the AGPLv3 license found in the
# LICENSE file in the root directory of this source tree.
from django.utils.timezone import now
from rest_framework import serializers, status
from rest_framework.decorators import detail_route
from rest_framework.response import Response
from rest_framework.viewsets import ModelViewSet

from shuup.core.models import (
    MutableAddress, Order, OrderLine, OrderStatus, Payment
)
from shuup.utils.money import Money


class OrderLineSerializer(serializers.ModelSerializer):
    class Meta:
        model = OrderLine


class AddressSerializer(serializers.ModelSerializer):
    class Meta:
        model = MutableAddress


class PaymentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Payment
        fields = ("payment_identifier", "amount_value", "description")


class OrderSerializer(serializers.ModelSerializer):
    lines = OrderLineSerializer(many=True, read_only=True)
    billing_address = AddressSerializer(read_only=True)
    shipping_address = AddressSerializer(read_only=True)
    payments = PaymentSerializer(many=True, read_only=True)

    def get_fields(self):
        fields = super(OrderSerializer, self).get_fields()
        for name, field in fields.items():
            if name in ("status", "key", "label"):
                field.required = False
            if name == "order_date":
                field.default = lambda: now()
        return fields

    def create(self, validated_data):
        if not validated_data.get("status"):
            validated_data["status"] = OrderStatus.objects.get_default_initial()
        return super(OrderSerializer, self).create(validated_data)

    class Meta:
        model = Order


class OrderViewSet(ModelViewSet):
    serializer_class = OrderSerializer
    queryset = Order.objects.all()

    @detail_route(methods=['post'])
    def create_payment(self, request, pk=None):
        return _handle_payment_creation(request, self.get_object())

    @detail_route(methods=['post'])
    def set_fully_paid(self, request, pk=None):
        order = self.get_object()
        if order.is_paid():
            return Response({"status": "order is already fully paid"})

        request.data["currency"] = order.currency
        request.data["amount_value"] = (order.taxful_total_price_value - order.get_total_paid_amount().value)
        return _handle_payment_creation(request, order)


def _handle_payment_creation(request, order):
    serializer = PaymentSerializer(data=request.data)
    if serializer.is_valid():
        data = serializer.validated_data
        order.create_payment(
            Money(data["amount_value"], order.currency),
            data["payment_identifier"],
            data.get("description", "")
        )
        return Response({'status': 'payment created'}, status=status.HTTP_201_CREATED)
    else:
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.
#

# This example uses text8 file from http://mattmahoney.net/dc/text8.zip
# The file was downloaded, unzipped and split into multiple lines using
#
# wget http://mattmahoney.net/dc/text8.zip
# unzip text8.zip
# grep -o -E '\w+(\W+\w+){0,15}' text8 > text8_lines
# This was done so that the example can be run in local mode

from __future__ import print_function

import sys

from pyspark import SparkContext
from pyspark.mllib.feature import Word2Vec

USAGE = ("bin/spark-submit --driver-memory 4g "
         "examples/src/main/python/mllib/word2vec.py text8_lines")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(USAGE)
        sys.exit("Argument for file not provided")
    file_path = sys.argv[1]
    sc = SparkContext(appName='Word2Vec')
    inp = sc.textFile(file_path).map(lambda row: row.split(" "))

    word2vec = Word2Vec()
    model = word2vec.fit(inp)

    synonyms = model.findSynonyms('china', 40)

    for word, cosine_distance in synonyms:
        print("{}: {}".format(word, cosine_distance))
    sc.stop()

#!/usr/bin/python
# -*- coding: utf-8 -*-

import __init__
import settings
from time import time
from settings import _obj
from bson import ObjectId

class Event(settings.BaseObj):

	data = {
		'type': 0,
	    'author': '',
	    'guild_run': False,
	    'target': 0,
	    'start_date': 0,
	    'finish_date': 0,
	    'create_date': 0,
	    'desc': '',
	    'faction': -1,
	    'lvl_min': 1,
	    'lvl_max': 60,
	    'active': False,
	    'people': [],
	    'promoted_hashtag': False,
	    'activity': [],
	    'status': ''  # active — скоро случится; progress — идет сейчас; complete — завершено удачно; fail — провалено
	}

class ModelEvents():

	col_events = settings.database.cols['col_events']
	col_dungeons = settings.database.cols['col_dungeons']
	col_players = settings.database.cols['players']

	def __init__(self, connection):
		self.mongo = connection
		self.balance = settings.balance

	# GET

	def getRaidDungeons(self, lvl = False):
		record = {'type': 1}
		if lvl:
			record.update({'lvl_min': {'$lte': lvl}, 'lvl_max': {'$gte': lvl}})

		return self.mongo.getu(self.col_dungeons, record, sort={'lvl_min':-1})

	def getRaidDungeonById(self, uid, only_max_people = False):
		fields = {}
		if only_max_people:
			fields = {'max_players': 1}

		return self.mongo.find(self.col_dungeons, {'UID': uid}, fields)

	def getEvents(self, query={}, player_id=None, guild='', fields = {}):

		datedelta = 86400
		sort = {'start_date': 1}

		if 'finished' in query:
			search = {'$or': [{'status':'complete'}, {'status': 'fail'}], 'finish_date': {'$gte': time()-datedelta }}
			sort = {'finish_date': -1}
		elif 'only_active' in query:
			search = {'status': 'active'}
		elif 'upcoming' in query:
			search = {'$or': [{'status':'active'}, {'status': 'progress'}]}
		else:
			search = {}

		if 'raids' in query:
			search.update({'type': 'raid'})

		if 'wars' in query:
			search.update({'type': 'war'})

		if 'gruns' in query:
			if guild:
				search.update({'guild_run': True, 'guild_side_name': guild})

		if player_id:
			search.update({'people':{'$all':[player_id]}})

		return self.mongo.getu(self.col_events, search=search, sort=sort, fields=fields)

	def getEventData(self, event_id, full = False):
		if not isinstance(event_id, ObjectId):
			event_id = ObjectId(event_id)

		if full:
			fields = {}
		else:
			fields = {
				'target':1,
			    'type': 1,
				'people': 1,
				'start_date':1,
				'finish_date':1,
				'lvl_min':1,
			    'sides':1,
			    'position':1,
			    'guild_side_name':1,
			    'target_name':1
			}

		return self.mongo.find(self.col_events, {'_id': event_id}, fields)

	def _getEventMembers(self, event_id):
		try:
			event = self.mongo.find(self.col_events, {'_id': ObjectId(event_id)}, {'people': 1, 'author': 1})
		except Exception:
			event = None

		if event:
			event_members = event['people']
			players = self.mongo.findSomeIDs(self.col_players, event_members, sort={'lvl':1}, fields={
				'name': 1,
				'class': 1,
				'lvl':1,
				'avatar': 1,
				'race': 1,
				'faction': 1,
			    '_id': 1,
			    '_guild_name':1,
			    'stat.lead.current':1
			})

			return players

		else:
			return False

	def getJustFinishedEvents(self):
		return self.mongo.getu(self.col_events, {
			'$and': [
				{'status': {'$ne': 'complete'}},
				{'status': {'$ne': 'fail'}},
			    {'finish_date': {'$lte': time()}}
			]
		})

	def getEventID(self, author_id, create_date):
		event = self.mongo.find(self.col_events, {'author': author_id, 'create_date':create_date}, {'_id':1})
		if event:
			return event['_id']
		else:
			return False

	def getPlayersRawEvents(self, player_id):
		return self.mongo.getu(self.col_events, {'people':{'$all':[player_id]}, 'start_date': {'$gte': time()}}, sort={'start_date': 1}, limit=1)

	def getGvGEvents(self, player_id = False, fields = {}):
		if player_id:
			return self.mongo.getu(self.col_events, {'people':{'$all':[player_id]}, 'type': 'war'}, fields = fields)
		else:
			return self.mongo.getu(self.col_events, {'type': 'war'}, fields = fields)

	# ADD

	def addNewEvent(self, event):
		if '_id' in event:
			del event['_id']

		self.mongo.insert(self.col_events, event)

	def updateEvent(self, event_id, event_info):
		self.mongo.update(self.col_events, {'_id': event_id}, event_info)

	# MISC

	def removeGvGEventsByGuild(self, guild_id):
		self.mongo.remove(self.col_events, {
			'$or': [ {'guild_side': guild_id}, {'target': guild_id} ]
		})

	def joinEvent(self, event_id, player_id):
		self.mongo.raw_update(self.col_events, {'_id': _obj(event_id).id}, {'$push':{'people': player_id}})

	def leaveEvent(self, event_id, creator_id):
		if not isinstance(event_id, ObjectId):
			event_id = ObjectId(event_id)

		event = self.mongo.find(self.col_events, {'_id': event_id}, {'people': 1, 'author': 1})

		if event:
			# если автор хочет покинуть событие...
			if 'author' in event and event['author'] == creator_id:

				# ... если он один, то просто удалим эвекнт
				if len(event['people']) == 1:
					self.mongo.remove(self.col_events, {'_id': event_id})

				# ... иначе, назначим первого попавшегося новым автором
				else:
					for player_id in event['people']:
						if player_id != creator_id:
							self.mongo.raw_update(self.col_events, {'_id': event_id}, {'$pull':{'people': creator_id}, '$set': {'author': player_id} })

			else:
				for player in event['people']:
					if player == creator_id:
						self.mongo.raw_update(self.col_events, {'_id': event_id}, {'$pull':{'people': creator_id}})

	def markJustFinishedAsFinished(self, events):
		for event in events:
			try:
				record = {
					'status': event['status'],
					'combat_log': event['combat']
				}

				if event['type'] == 'raid':
					record.update({'result_points': event['result_points']})
				elif event['type'] == 'war':
					record.update({
						'winner': event['winner'],
					    'winner_id': event['winner_id']
					})
			except Exception:

				if not 'status' in event:
					event['status'] = 'fail'

				if not 'combat' in event:
					event['combat'] = []

				record = {
					'status': event['status'],
					'combat_log': event['combat']
				}

			self.mongo.update(self.col_events, {'_id': event['_id']}, record)

	def getEventInThisTime(self, start_time, player_id):
		event = self.mongo.find(self.col_events, {'start_date':{'$lte':start_time}, 'finish_date':{'$gt':start_time}, 'people':{'$all':[player_id]}}, {'_id':1})
		if event:
			return True

		return False

	def getGuildEventsByID(self, guild_smth, limit = 0, fields = {}):
		if isinstance(guild_smth, ObjectId):
			query = [ { 'target': guild_smth } , { 'guild_side' : guild_smth } ]
		else:
			query = [ { 'target_name': guild_smth } , { 'guild_side_name' : guild_smth } ]

		return self.mongo.getu(
			self.col_events,
			{
				'$or' : query,
			    'status' : {'$in': ['active', 'progress']}
			},
			fields=fields,
			sort={'start_date': 1},
			limit=limit
		)

	def getFactionEventsByID(self, faction_id, limit = 0, fields = {}):
		return self.mongo.getu(
			self.col_events,
				{
				'sides' : {'$all': [faction_id]},
				'status' : {'$in': ['active', 'progress']}
			},
			fields=fields,
			sort={'start_date': 1},
			limit=limit
		)

	def getPlayerActiveEventsCount(self, player_id):
		return self.mongo.count(self.col_events, { '$or' : [ { 'status': 'active' } , { 'status' : 'progress' } ], 'people':{'$all':[player_id]}})

	def getPlayerCreatedGuildEventsCount(self, player_id):
		return self.mongo.count(self.col_events, { 'type': 'war', '$or' : [ { 'status': 'active' } , { 'status' : 'progress' } ], 'author': player_id})

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from openerp.osv import fields, osv
from openerp.tools.translate import _

class stock_move(osv.osv):
    _inherit = 'stock.move'
    _columns = {
        'sale_line_id': fields.many2one('sale.order.line', 'Sales Order Line', ondelete='set null', select=True, readonly=True),
    }

    def _prepare_chained_picking(self, cr, uid, picking_name, picking, picking_type, moves_todo, context=None):
        values = super(stock_move, self)._prepare_chained_picking(cr, uid, picking_name, picking, picking_type, moves_todo, context=context)
        if picking.sale_id:
            values['sale_id'] = picking.sale_id.id
        return values

class stock_picking(osv.osv):
    _inherit = 'stock.picking'
    _columns = {
        'sale_id': fields.many2one('sale.order', 'Sales Order', ondelete='set null', select=True),
    }
    _defaults = {
        'sale_id': False
    }

    def get_currency_id(self, cursor, user, picking):
        if picking.sale_id:
            return picking.sale_id.pricelist_id.currency_id.id
        else:
            return super(stock_picking, self).get_currency_id(cursor, user, picking)

    def _get_partner_to_invoice(self, cr, uid, picking, context=None):
        """ Inherit the original function of the 'stock' module
            We select the partner of the sales order as the partner of the customer invoice
        """
        if picking.sale_id:
            return picking.sale_id.partner_invoice_id
        return super(stock_picking, self)._get_partner_to_invoice(cr, uid, picking, context=context)

    def _get_comment_invoice(self, cursor, user, picking):
        if picking.note or (picking.sale_id and picking.sale_id.note):
            return picking.note or picking.sale_id.note
        return super(stock_picking, self)._get_comment_invoice(cursor, user, picking)

    def _prepare_invoice_group(self, cr, uid, picking, partner, invoice, context=None):
        """ Inherit the original function of the 'stock' module in order to override name field
            to pass the customer reference form the sales order
        """
        invoice_vals = super(stock_picking, self)._prepare_invoice_group(cr, uid, picking, partner, invoice, context)
        if picking.sale_id:
            invoice_vals['name'] = (invoice.name or '') + ', ' + (picking.sale_id.client_order_ref or '')
        return invoice_vals

    def _prepare_invoice(self, cr, uid, picking, partner, inv_type, journal_id, context=None):
        """ Inherit the original function of the 'stock' module in order to override some
            values if the picking has been generated by a sales order
        """
        invoice_vals = super(stock_picking, self)._prepare_invoice(cr, uid, picking, partner, inv_type, journal_id, context=context)
        if picking.sale_id:
            invoice_vals['fiscal_position'] = picking.sale_id.fiscal_position.id
            invoice_vals['payment_term'] = picking.sale_id.payment_term.id
            invoice_vals['user_id'] = picking.sale_id.user_id.id
            invoice_vals['name'] = picking.sale_id.client_order_ref or ''
        return invoice_vals

    def _prepare_invoice_line(self, cr, uid, group, picking, move_line, invoice_id, invoice_vals, context=None):
        invoice_vals = super(stock_picking, self)._prepare_invoice_line(cr, uid, group, picking, move_line, invoice_id, invoice_vals, context=context)
        if picking.sale_id:
            if move_line.sale_line_id:
                invoice_vals['account_analytic_id'] = self._get_account_analytic_invoice(cr, uid, picking, move_line)
        return invoice_vals

    def _get_price_unit_invoice(self, cursor, user, move_line, type):
        if move_line.sale_line_id and move_line.sale_line_id.product_id.id == move_line.product_id.id:
            uom_id = move_line.product_id.uom_id.id
            uos_id = move_line.product_id.uos_id and move_line.product_id.uos_id.id or False
            price = move_line.sale_line_id.price_unit
            coeff = move_line.product_id.uos_coeff
            if uom_id != uos_id  and coeff != 0:
                price_unit = price / coeff
                return price_unit
            return move_line.sale_line_id.price_unit
        return super(stock_picking, self)._get_price_unit_invoice(cursor, user, move_line, type)

    def _get_discount_invoice(self, cursor, user, move_line):
        if move_line.sale_line_id:
            return move_line.sale_line_id.discount
        return super(stock_picking, self)._get_discount_invoice(cursor, user, move_line)

    def _get_taxes_invoice(self, cursor, user, move_line, type):
        if move_line.sale_line_id and move_line.sale_line_id.product_id.id == move_line.product_id.id:
            return [x.id for x in move_line.sale_line_id.tax_id]
        return super(stock_picking, self)._get_taxes_invoice(cursor, user, move_line, type)

    def _get_account_analytic_invoice(self, cursor, user, picking, move_line):
        if picking.sale_id:
            return picking.sale_id.project_id.id
        return super(stock_picking, self)._get_account_analytic_invoice(cursor, user, picking, move_line)

    def _invoice_line_hook(self, cursor, user, move_line, invoice_line_id):
        if move_line.sale_line_id:
            move_line.sale_line_id.write({'invoice_lines': [(4, invoice_line_id)]})
        return super(stock_picking, self)._invoice_line_hook(cursor, user, move_line, invoice_line_id)

    def _invoice_hook(self, cursor, user, picking, invoice_id):
        sale_obj = self.pool.get('sale.order')
        order_line_obj = self.pool.get('sale.order.line')
        invoice_obj = self.pool.get('account.invoice')
        invoice_line_obj = self.pool.get('account.invoice.line')
        if picking.sale_id:
            sale_obj.write(cursor, user, [picking.sale_id.id], {
                'invoice_ids': [(4, invoice_id)],
            })
            for sale_line in picking.sale_id.order_line:
                if sale_line.product_id.type == 'service' and not sale_line.invoiced:
                    vals = order_line_obj._prepare_order_line_invoice_line(cursor, user, sale_line, False)
                    vals['invoice_id'] = invoice_id
                    invoice_line_id = invoice_line_obj.create(cursor, user, vals)
                    order_line_obj.write(cursor, user, [sale_line.id], {
                        'invoice_lines': [(6, 0, [invoice_line_id])],
                    })
                    invoice_obj.button_compute(cursor, user, [invoice_id])
        return super(stock_picking, self)._invoice_hook(cursor, user, picking, invoice_id)
    
    def action_done(self, cr, uid, ids, context=None):
        """ Changes picking state to done. This method is called at the end of
            the workflow by the activity "done".
        """
        for record in self.browse(cr, uid, ids, context):
            if record.type == "out" and record.sale_id:
                self.pool.get('sale.order').message_post(cr, uid, [record.sale_id.id], body=_("Products delivered"), context=context)
        return super(stock_picking, self).action_done(cr, uid, ids, context=context)

# Redefinition of the new field in order to update the model stock.picking.out in the orm
# FIXME: this is a temporary workaround because of a framework bug (ref: lp996816). It should be removed as soon as
#        the bug is fixed
class stock_picking_out(osv.osv):
    _inherit = 'stock.picking.out'
    _columns = {
        'sale_id': fields.many2one('sale.order', 'Sale Order',
            ondelete='set null', select=True),
    }
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

from books.karelians.extraction.extractors.baseExtractor import BaseExtractor
from books.karelians.extractionkeys import KEYS
from interface.valuewrapper import ValueWrapper
from books.karelians.extraction.extractionExceptions import OtherLocationException
from books.karelians.extraction.extractionExceptions import KarelianLocationException
from shared import regexUtils
import re
from shared.geo.geocoding import GeoCoder, LocationNotFound
from books.karelians.extraction.extractors.bnf_parsers import migration_parser
from names import location_name_white_list

MAX_PLACE_NAME_LENGTH = 15
MIN_PLACE_NAME_LENGTH = 4


def validate_location_name(entry_name, geocoordinates):
    if len(entry_name) > MAX_PLACE_NAME_LENGTH and geocoordinates['latitude'] == '' and geocoordinates['longitude'] == '':
        name_is_ok = False

        # Check if there is white list pattern which matches to current name
        for pattern in location_name_white_list.WHITE_LIST['patterns']:
            result = pattern['find'].subn(pattern['replace'], entry_name)

            if result[1] > 0:  # Replace success, end loop
                entry_name = result[0]
                name_is_ok = True
                break

        if not name_is_ok:
            raise InvalidLocationException(entry_name)

    if len(entry_name) < MIN_PLACE_NAME_LENGTH:
        name_is_ok = False
        ln = entry_name.lower()
        if ln in location_name_white_list.WHITE_LIST['names']:
            # The name is in white list, so it is ok to use!
            # Also check if there is known alias for it
            name_is_ok = True
            if 'alias' in location_name_white_list.WHITE_LIST['names'][ln]:
                entry_name = location_name_white_list.WHITE_LIST['names'][ln]['alias']

        if not name_is_ok:
            raise InvalidLocationException(entry_name)

    return entry_name


def validate_village_name(village_name):
    if village_name is not None and (len(village_name) > MAX_PLACE_NAME_LENGTH or len(village_name) < MIN_PLACE_NAME_LENGTH):
        return None
    else:
        return village_name


class FinnishLocationsExtractor(BaseExtractor):
    """
    Tries to extract the locations of the person in oter places than karelia
    """
    geocoder = GeoCoder()

    OTHER_REGION_ID = 'other'

    def extract(self, text):
        self.LOCATION_PATTERN = r"Muut\.?,?\s?(?:asuinp(\.|,)?){i<=1}(?::|;)?(?P<asuinpaikat>[A-ZÄ-Öa-zä-ö\s\.,0-9——-]*—)" #r"Muut\.?,?\s?(?:asuinp(\.|,)?){i<=1}(?::|;)?(?P<asuinpaikat>[A-ZÄ-Öa-zä-ö\s\.,0-9——-]*?)(?=[A-Za-zÄ-Öä-ö\s\.]{30,50})" # #r"Muut\.?,?\s?(?:asuinp(\.|,)){i<=1}(?::|;)?(?P<asuinpaikat>[A-ZÄ-Öa-zä-ö\s\.,0-9——-])*(?=—\D\D\D)"
        self.LOCATION_OPTIONS = (re.UNICODE | re.IGNORECASE)
        self.locations = ""
        self.location_listing = []
        self.location_error = False

        try:
            self._find_locations(text)
        except LocationThresholdException:
            pass

        return self._constructReturnDict()

    def _find_locations(self, text):
        # Replace all weird invisible white space characters with regular space
        text = re.sub(r"\s", r" ", text)

        try:
            found_locations = regexUtils.safeSearch(self.LOCATION_PATTERN, text, self.LOCATION_OPTIONS)
            self.matchFinalPosition = found_locations.end()
            self.locations = found_locations.group("asuinpaikat")
            self._clean_locations()

            parsed_locations = migration_parser.parse_locations(self.locations)

            try:
                for location in parsed_locations:
                    self._create_location_entry(location)
            except InvalidLocationException as e:
                pass

        except regexUtils.RegexNoneMatchException as e:
            self.errorLogger.logError(OtherLocationException.eType, self.currentChild)
            self.location_error = OtherLocationException.eType

    def _clean_locations(self):
        self.locations = self.locations.strip(",")
        self.locations = self.locations.strip(".")
        self.locations = self.locations.strip()
        self.locations = re.sub(r"([a-zä-ö])(?:\s|\-)([a-zä-ö])", r"\1\2", self.locations)
        self.locations = self.locations.lstrip()

    def _create_location_entry(self, location):
        # If there is municipality information, use it as an main entry name
        village_name = None

        if 'municipality' in location:
            entry_name = location['municipality']
            village_name = location['place']
        else:
            entry_name = location['place']

        def get_coordinates_by_name(place_name):
            try:
                return self.geocoder.get_coordinates(place_name, "finland")
            except LocationNotFound:
                return {"latitude": "", "longitude": ""}

        geocoordinates = get_coordinates_by_name(entry_name)

        entry_name = validate_location_name(entry_name, geocoordinates)
        village_name = validate_village_name(village_name)

        village_coordinates = {"latitude": "", "longitude": ""}
        if village_name is not None:
            village_coordinates = get_coordinates_by_name(village_name)

        village_information = {
            KEYS["otherlocation"]: ValueWrapper(village_name or None),
            KEYS["othercoordinate"]: ValueWrapper({
                KEYS["latitude"]: village_coordinates["latitude"],
                KEYS["longitude"]: village_coordinates["longitude"]
            })
        }

        moved_in = ''
        moved_out = ''

        def add_location_to_list():
            self.location_listing.append(ValueWrapper({
                KEYS["otherlocation"]: ValueWrapper(entry_name),
                KEYS["othercoordinate"]: ValueWrapper({
                    KEYS["latitude"]: ValueWrapper(geocoordinates["latitude"]),
                    KEYS["longitude"]: ValueWrapper(geocoordinates["longitude"])
                }),
                KEYS["movedOut"]: ValueWrapper(moved_out),
                KEYS["movedIn"]: ValueWrapper(moved_in),
                KEYS["region"]: self.OTHER_REGION_ID,
                KEYS["village"]: ValueWrapper(village_information)
            }))

        if 'year_information' in location:
            for migration in location['year_information']:
                if 'moved_in' in migration:
                    moved_in = migration['moved_in']
                else:
                    moved_in = ''

                if 'moved_out' in migration:
                    moved_out = migration['moved_out']
                else:
                    moved_out = ''

                try:
                    if 41 <= int(moved_in) <= 43:
                        self.returned = True
                except ValueError:
                    pass

                add_location_to_list()
        else:
            add_location_to_list()

    def _constructReturnDict(self):
        loc = ValueWrapper(self.location_listing)
        loc.error = self.location_error
        return {KEYS["otherlocations"] : loc, KEYS["otherlocationsCount"] : ValueWrapper(len(self.location_listing))}


class KarelianLocationsExtractor(BaseExtractor):
    """
    Tries to extract the locations of the person in karelia.
    """
    geocoder = GeoCoder()
    KARELIAN_REGION_ID = 'karelia'

    def extract(self, text):
        self.LOCATION_PATTERN = r"Asuinp{s<=1}\.?,?\s?(?:Karjalassa){i<=1}(?::|;)?(?P<asuinpaikat>[A-ZÄ-Öa-zä-ö\s\.,0-9——-]*)(?=\.?\s(Muut))" # r"Muut\.?,?\s?(?:asuinp(\.|,)){i<=1}(?::|;)?(?P<asuinpaikat>[A-ZÄ-Öa-zä-ö\s\.,0-9——-]*)(?=—)"
        self.LOCATION_OPTIONS = (re.UNICODE | re.IGNORECASE)
        self.returned = ""
        self.locations = ""
        self.location_listing = []
        self.location_error = False
        self._find_locations(text)

        return self._constructReturnDict()

    def _find_locations(self, text):
        # Replace all weird invisible white space characters with regular space
        text = re.sub(r"\s", r" ", text)

        try:
            found_locations = regexUtils.safeSearch(self.LOCATION_PATTERN, text, self.LOCATION_OPTIONS)
            self.matchFinalPosition = found_locations.end()
            self.locations = found_locations.group("asuinpaikat")
            self._clean_locations()

            parsed_locations = migration_parser.parse_locations(self.locations)

            try:
                for location in parsed_locations:
                    self._create_location_entry(location)
            except InvalidLocationException:
                pass

        except regexUtils.RegexNoneMatchException as e:
            self.errorLogger.logError(KarelianLocationException.eType, self.currentChild)
            self.location_error = KarelianLocationException.eType

    def _clean_locations(self):
        self.locations = self.locations.strip(",")
        self.locations = self.locations.strip(".")
        self.locations = self.locations.strip()

        # Strip away spaces and hyphens from center of words
        self.locations = re.sub(r"([a-zä-ö])(?:\s|\-)([a-zä-ö])", r"\1\2", self.locations)

        self.locations = self.locations.lstrip()

    def _create_location_entry(self, location):
        # If there is municipality information, use it as an main entry name
        village_name = None

        if 'municipality' in location:
            entry_name = location['municipality']
            village_name = location['place']
        else:
            entry_name = location['place']

        def get_coordinates_by_name(place_name):
            try:
                return self.geocoder.get_coordinates(place_name, "russia")
            except LocationNotFound:
                return {"latitude": "", "longitude": ""}

        geocoordinates = get_coordinates_by_name(entry_name)

        entry_name = validate_location_name(entry_name, geocoordinates)
        village_name = validate_village_name(village_name)

        village_coordinates = {"latitude": "", "longitude": ""}
        if village_name is not None:
            village_coordinates = get_coordinates_by_name(village_name)

        village_information = {
            KEYS["karelianlocation"]: ValueWrapper(village_name or None),
            KEYS["kareliancoordinate"]: ValueWrapper({
                KEYS["latitude"]: village_coordinates["latitude"],
                KEYS["longitude"]: village_coordinates["longitude"]
            })
        }

        moved_in = ''
        moved_out = ''

        def add_location_to_list():
            self.location_listing.append(ValueWrapper({
                KEYS["karelianlocation"]: ValueWrapper(entry_name),
                KEYS["kareliancoordinate"]: ValueWrapper({
                    KEYS["latitude"]: ValueWrapper(geocoordinates["latitude"]),
                    KEYS["longitude"]: ValueWrapper(geocoordinates["longitude"])
                }),
                KEYS["movedOut"]: ValueWrapper(moved_out),
                KEYS["movedIn"]: ValueWrapper(moved_in),
                KEYS["region"]: self.KARELIAN_REGION_ID,
                KEYS["village"]: ValueWrapper(village_information)
            }))

        if 'year_information' in location:
            for migration in location['year_information']:
                if 'moved_in' in migration:
                    moved_in = migration['moved_in']
                else:
                    moved_in = ''

                if 'moved_out' in migration:
                    moved_out = migration['moved_out']
                else:
                    moved_out = ''

                try:
                    if 41 <= int(moved_in) <= 43:
                        self.returned = True
                except ValueError:
                    pass

                add_location_to_list()
        else:
            add_location_to_list()

    def _constructReturnDict(self):
        loc = ValueWrapper(self.location_listing)
        loc.error = self.location_error
        return {KEYS["karelianlocations"]: loc,
                KEYS["returnedkarelia"]: ValueWrapper(self.returned),
                KEYS["karelianlocationsCount"]: ValueWrapper(len(self.location_listing))}


class LocationThresholdException(Exception):
    message = "Locations couldn't be found from db"

    def __unicode__(self):
        return repr(self.message)


class InvalidLocationException(Exception):
    message = "Location name likely not a valid place: "

    def __init__(self, place_name):
        self._place_name = place_name

    def __unicode__(self):
        return repr(self.message + self._place_name)
# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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.

import mock
import six

from st2common.transport.publishers import PoolPublisher
from tests import FunctionalTest

http_client = six.moves.http_client

TRIGGER_0 = {
    'name': 'st2.test.trigger0',
    'pack': 'dummy_pack_1',
    'description': 'test trigger',
    'type': 'dummy_pack_1.st2.test.triggertype0',
    'parameters': {}
}

TRIGGER_1 = {
    'name': 'st2.test.trigger1',
    'pack': 'dummy_pack_1',
    'description': 'test trigger',
    'type': 'dummy_pack_1.st2.test.triggertype1',
    'parameters': {}
}

TRIGGER_2 = {
    'name': 'st2.test.trigger2',
    'pack': 'dummy_pack_1',
    'description': 'test trigger',
    'type': 'dummy_pack_1.st2.test.triggertype2',
    'parameters': {
        'param1': {
            'foo': 'bar'
        }
    }
}


@mock.patch.object(PoolPublisher, 'publish', mock.MagicMock())
class TestTriggerController(FunctionalTest):

    @classmethod
    def setUpClass(cls):
        super(TestTriggerController, cls).setUpClass()
        cls._setupTriggerTypes()

    def test_get_all(self):
        resp = self.app.get('/v1/triggers')
        self.assertEqual(resp.status_int, http_client.OK)
        # TriggerType without parameters will register a trigger
        # with same name.
        self.assertEqual(len(resp.json), 2, 'Get all failure. %s' % resp.json)
        post_resp = self._do_post(TRIGGER_0)
        trigger_id_0 = self._get_trigger_id(post_resp)
        post_resp = self._do_post(TRIGGER_1)
        trigger_id_1 = self._get_trigger_id(post_resp)
        resp = self.app.get('/v1/triggers')
        self.assertEqual(resp.status_int, http_client.OK)
        # TriggerType without parameters will register a trigger
        # with same name. So here we see 4 instead of 2.
        self.assertEqual(len(resp.json), 4, 'Get all failure.')
        self._do_delete(trigger_id_0)
        self._do_delete(trigger_id_1)

    def test_get_one(self):
        post_resp = self._do_post(TRIGGER_1)
        trigger_id = self._get_trigger_id(post_resp)
        get_resp = self._do_get_one(trigger_id)
        self.assertEqual(get_resp.status_int, http_client.OK)
        self.assertEqual(self._get_trigger_id(get_resp), trigger_id)
        self._do_delete(trigger_id)

    def test_get_one_fail(self):
        resp = self._do_get_one('1')
        self.assertEqual(resp.status_int, http_client.NOT_FOUND)

    def test_post(self):
        post_resp = self._do_post(TRIGGER_1)
        self.assertEqual(post_resp.status_int, http_client.CREATED)
        self._do_delete(self._get_trigger_id(post_resp))

    def test_post_with_params(self):
        post_resp = self._do_post(TRIGGER_2)
        self.assertEqual(post_resp.status_int, http_client.CREATED)
        self._do_delete(self._get_trigger_id(post_resp))

    def test_post_duplicate(self):
        post_resp = self._do_post(TRIGGER_1)
        self.assertEqual(post_resp.status_int, http_client.CREATED)
        # Trying to create the same trigger again will still say "CREATED"
        # but under the hood gets the one already in db. So we just check
        # id is same in both cases.
        post_resp_2 = self._do_post(TRIGGER_1)
        self.assertEqual(post_resp_2.status_int, http_client.CREATED)
        self.assertEqual(self._get_trigger_id(post_resp), self._get_trigger_id(post_resp_2))
        self._do_delete(self._get_trigger_id(post_resp))

    def test_put(self):
        post_resp = self._do_post(TRIGGER_1)
        update_input = post_resp.json
        update_input['description'] = 'updated description.'
        put_resp = self._do_put(self._get_trigger_id(post_resp), update_input)
        self.assertEqual(put_resp.status_int, http_client.OK)
        self._do_delete(self._get_trigger_id(put_resp))

    def test_put_fail(self):
        post_resp = self._do_post(TRIGGER_1)
        update_input = post_resp.json
        # If the id in the URL is incorrect the update will fail since id in the body is ignored.
        put_resp = self._do_put(1, update_input)
        self.assertEqual(put_resp.status_int, http_client.NOT_FOUND)
        self._do_delete(self._get_trigger_id(post_resp))

    def test_delete(self):
        post_resp = self._do_post(TRIGGER_1)
        del_resp = self._do_delete(self._get_trigger_id(post_resp))
        self.assertEqual(del_resp.status_int, http_client.NO_CONTENT)

    @classmethod
    def _setupTriggerTypes(cls):
        TRIGGERTYPE_0 = {
            'name': 'st2.test.triggertype0',
            'pack': 'dummy_pack_1',
            'description': 'test trigger',
            'payload_schema': {'tp1': None, 'tp2': None, 'tp3': None},
            'parameters_schema': {}
        }
        TRIGGERTYPE_1 = {
            'name': 'st2.test.triggertype1',
            'pack': 'dummy_pack_1',
            'description': 'test trigger',
            'payload_schema': {'tp1': None, 'tp2': None, 'tp3': None},
        }
        TRIGGERTYPE_2 = {
            'name': 'st2.test.triggertype2',
            'pack': 'dummy_pack_1',
            'description': 'test trigger',
            'payload_schema': {'tp1': None, 'tp2': None, 'tp3': None},
            'parameters_schema': {'param1': {'type': 'object'}}
        }
        cls.app.post_json('/v1/triggertypes', TRIGGERTYPE_0, expect_errors=False)
        cls.app.post_json('/v1/triggertypes', TRIGGERTYPE_1, expect_errors=False)
        cls.app.post_json('/v1/triggertypes', TRIGGERTYPE_2, expect_errors=False)

    @staticmethod
    def _get_trigger_id(resp):
        return resp.json['id']

    def _do_get_one(self, trigger_id):
        return self.app.get('/v1/triggers/%s' % trigger_id, expect_errors=True)

    def _do_post(self, trigger):
        return self.app.post_json('/v1/triggers', trigger, expect_errors=True)

    def _do_put(self, trigger_id, trigger):
        return self.app.put_json('/v1/triggers/%s' % trigger_id, trigger, expect_errors=True)

    def _do_delete(self, trigger_id):
        return self.app.delete('/v1/triggers/%s' % trigger_id)

#!/usr/bin/env python
'''
User event notifications endpoints (for Alerts & Alarms Notification process)

'''
__author__ = 'Edna Donoughe'

from flask import (jsonify, request, current_app)
from ooiservices.app.main import api
from ooiservices.app import db
from ooiservices.app.decorators import scope_required
from ooiservices.app.main.authentication import auth
from ooiservices.app.models import (UserEventNotification, User, SystemEvent, SystemEventDefinition, TicketSystemEventLink)
from ooiservices.app.main.errors import conflict, bad_request
import json

@api.route('/user_event_notifications')
def get_user_event_notifications():
    """ List all user_event_notifications (by user_id if provided)
    """
    result = []
    try:
        if 'user_id' in request.args:
            user_id = request.args.get('user_id')
            user = User.query.get(user_id)
            if user is None:
                message = "Invalid User ID, User record not found."
                return bad_request(message)
            notifications = UserEventNotification.query.filter_by(user_id=user_id).all()
        else:
            notifications = UserEventNotification.query.all()
        if notifications:
            result = [notify.to_json() for notify in notifications]
        return jsonify( {'notifications' : result })
    except:
        return conflict('Insufficient data, or bad data format.')

#List a user_event_notification by id
@api.route('/user_event_notification/<int:id>')
def get_user_event_notification(id):
    result = {}
    #try:
    notification = UserEventNotification.query.filter_by(id=id).first()
    if notification is not None:
        result = notification.to_json()
    return jsonify(result)

#Create a new user_event_notification
@api.route('/user_event_notification', methods=['POST'])
@auth.login_required
@scope_required(u'user_admin')
def create_user_event_notification():
    """
    Create user_event_notification associated with SystemEventDefinition.

    Usage: Whenever a SystemEvent occurs, for the system_event_definition_id, this notification
    indicates who and how to contact them with the SystemEvent information.
    """
    log = False
    try:
        data = json.loads(request.data)
        create_has_required_fields(data)

        system_event_definition_id = data['system_event_definition_id']
        definition = SystemEventDefinition.query.get(system_event_definition_id)
        if definition is None:
            message = "Invalid SystemEventDefinition ID, SystemEventDefinition record not found."
            #if log: print '\n message: ', message
            return bad_request(message)
            #return jsonify(error=message), 404

        # Validate user to be notified exists
        user_id = data['user_id']
        user = User.query.filter_by(id=user_id).first()
        if not user:
            message = "Invalid User ID, User record not found."
            #if log: print '\n message: ', message
            return bad_request(message)

        # Create UserEventNotification
        notification = UserEventNotification()
        notification.system_event_definition_id = data['system_event_definition_id']
        notification.user_id = data['user_id']
        notification.use_email = data['use_email']
        notification.use_redmine = data['use_redmine']
        notification.use_phone = data['use_phone']
        notification.use_log = data['use_log']
        notification.use_sms = data['use_sms']
        try:
            db.session.add(notification)
            db.session.commit()
        except Exception as err:
            #if log: print '\n (log) create_user_event_notification - message: ', err.message
            db.session.rollback()
            return bad_request('IntegrityError creating notification')
        return jsonify(notification.to_json()), 201
    except Exception as err:
        #if log: print '\n (log) create_user_event_notification - exception: ', err.message
        return conflict('Insufficient data, or bad data format.')

@api.route('/user_event_notification/<int:id>', methods=['PUT'])
@auth.login_required
@scope_required(u'user_admin')
def update_user_event_notification(id):
    """ Update user_event_notification associated with SystemEventDefinition.
    """
    log = False
    try:
        data = json.loads(request.data)

        # Get existing notification
        notification_id = data['id']
        if notification_id != id:
            message = "Inconsistent ID, user_event_notification id provided in data does not match id provided."
            return bad_request(message)

        notification = UserEventNotification.query.filter_by(id=notification_id).first()
        #print '\n test notification...'
        if notification is None:
            message = "Invalid ID, user_event_notification record not found."
            #print '\n message: ', message
            return bad_request(message)

        # Validate user to be notified exists
        user = User.query.filter_by(id=notification.user_id).first()

        # Validate user_id matches id value
        user_id = data['user_id']
        if user_id != notification.user_id:
            message = "Inconsistent User ID, user_id provided in data does not match id."
            return bad_request(message)

        notification.system_event_definition_id = data['system_event_definition_id']
        notification.user_id = data['user_id']
        notification.use_email = data['use_email']
        notification.use_redmine = data['use_redmine']
        notification.use_phone = data['use_phone']
        notification.use_log = data['use_log']
        notification.use_sms = data['use_sms']
        try:
            db.session.add(notification)
            db.session.commit()
        except Exception as err:
            db.session.rollback()
            return bad_request('IntegrityError creating user_event_notification.')

        #print '\n notification.to_json(): ', notification.to_json()
        return jsonify(notification.to_json()), 201
    except Exception as err:
        #if log: print '\n (log) update_user_event_notification - exception: ', err.message
        return conflict('Insufficient data, or bad data format.')

# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# Private Methods for user_event_notification routes
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
def create_has_required_fields(data):
    """ Verify create_user_event_notification request.data has required fields. Error otherwise.
    """
    log = False
    try:
        required_fields = ['system_event_definition_id', 'user_id', 'use_email', 'use_redmine',
                           'use_phone', 'use_log', 'use_sms']
        for field in required_fields:
            if field not in data:
                message = 'Missing required field (%s) in request.data' % field
                #if log: print '\n (log) create_has_required_fields - message: ', message
                raise Exception(message)
        if not isinstance(data['user_id'], int):
            message = 'Invalid user_id; parameter type invalid.'
            #if log: print '\n (log) create_has_required_fields - message: ', message
            raise Exception(message)
        return
    except Exception as err:
        message = 'Insufficient data, or bad data format. (%s)' % err.message
        #if log: print '\n (log) create_has_required_fields - message: ', message
        raise





import unittest

from armonic.variable import VList, VString, VInt, VBool, VFloat, Port, Hostname
from armonic.common import ValidationError


class TestVariable(unittest.TestCase):

    def test_VString(self):
        t = VString("str1", default="default1")
        self.assertEqual(t.value, "default1")
        self.assertEqual(str(t), "default1")
        t.value = 1
        self.assertEqual(t.value, "1")
        t.fill(45)
        self.assertEqual(t.value, "45")
        t.value = "default2"
        self.assertEqual(t.value, "default2")
        t.fill("default3")
        self.assertEqual(t.value, "default3")

    def test_VInt(self):
        t = VInt("int", default=10)
        self.assertEqual(t.value, 10)
        self.assertEqual(int(t), 10)
        t.value = 20
        self.assertEqual(t.value, 20)
        t.fill(30)
        self.assertEqual(t.value, 30)
        with self.assertRaises(ValidationError):
            t.value = "foo"
            t.validate()
        with self.assertRaises(ValidationError):
            t.validate("bar")

    def test_VFloat(self):
        t = VFloat("float", default=10.2)
        self.assertEqual(t.value, 10.2)
        self.assertEqual(float(t), 10.2)
        t.value = 20.4500
        self.assertEqual(t.value, 20.45)
        t.fill(30.4)
        self.assertEqual(t.value, 30.4)
        with self.assertRaises(ValidationError):
            t.value = "foo"
            t.validate()
        with self.assertRaises(ValidationError):
            t.validate("bar")

    def test_VBool(self):
        t = VBool("bool1", default=False)
        for v in ('True', 'y', 'Y'):
            t.value = v
            self.assertTrue(t.value)
        for v in ('False', 'n', 'N'):
            t.value = v
            self.assertFalse(t.value)
        with self.assertRaises(ValidationError):
            t.value = "foo"
            t.validate()
        with self.assertRaises(ValidationError):
            t.validate(34)

    def test_VList(self):
        t = VList("list1", inner=VString)
        t.value = [1]
        self.assertEqual(t.value[0].value, "1")
        t.fill([2])
        self.assertEqual(t.value[0].value, "2")
        # A correct data type can be set
        t.value = ["default1"]
        self.assertEqual(t.value[0].value, "default1")
        t.value[0].value = "default2"
        self.assertEqual(t.value[0].value, "default2")
        t.fill(["foo", "bar"])
        self.assertEqual(t.value[0].value, "foo")
        self.assertEqual(t.value[1].value, "bar")

    def test_VList_validation(self):
        class VIntMax(VInt):
            max_val = 5
        t = VList("list1", inner=VIntMax)

        with self.assertRaises(ValidationError):
            t.fill(["foo", "bar"])
            t.validate()

        t.fill([1, 2, 3])
        t.validate()
        t.validate([1, 2, 3])

        with self.assertRaises(ValidationError):
            t.fill([1, 22, 35])
            t.validate()

        with self.assertRaises(ValidationError):
            t.validate([1, 22, 35])

    def test_VList_of_VList(self):
        t = VList("Vlist", inner=VList("innerVList", inner=VString))
        t.value = [["foo", "bar"], ["test", "str"]]
        t.value[0].value = ["v1", "v2"]
        self.assertEqual(t.value[0].value[0].value, "v1")
        self.assertEqual(t.value[0].value[1].value, "v2")
        self.assertEqual(t.value[1].value[0].value, "test")
        self.assertEqual(t.value[1].value[1].value, "str")
        t.fill([["str1"], ["str2", "str3"], ["str4"]])
        self.assertEqual(t.value[0].value[0].value, "str1")
        self.assertEqual(t.value[1].value[0].value, "str2")
        self.assertEqual(t.value[1].value[1].value, "str3")
        self.assertEqual(t.value[2].value[0].value, "str4")

    def test_required(self):
        t = VString("str")
        with self.assertRaises(ValidationError):
            t.validate()

    def test_max_min(self):
        t = Port("port")
        with self.assertRaises(ValidationError):
            t.value = 300000
            t.validate()

        with self.assertRaises(ValidationError):
            t.value = -20
            t.validate()

    def test_pattern(self):
        t = Hostname("host")

        with self.assertRaises(ValidationError):
            t.value = "45"
            t.validate()

        t.value = "test45"
        self.assertTrue(t.validate())

    def test_custom_validation(self):
        class Custom(VString):
            def validation(self, value):
                if not value == "foo":
                    raise ValidationError("Is not foo")

        t = Custom("custom")
        with self.assertRaises(ValidationError):
            t.validate("bar")
        with self.assertRaises(ValidationError):
            t.value = "bar"
            t.validate()
        t.value = "foo"
        self.assertTrue(t.validate())

        class Custom(VInt):
            def validation(self, value):
                if not value == 5:
                    raise ValidationError("Is not 5")

        t = Custom("custom")
        with self.assertRaises(ValidationError):
            t.validate(2)
        with self.assertRaises(ValidationError):
            t.value = 3
            t.validate()
        self.assertTrue(t.validate(5))
        t.value = 5
        self.assertTrue(t.validate())


if __name__ == '__main__':
    unittest.main()

"""
Forms to support third-party to first-party OAuth 2.0 access token exchange
"""
from django.contrib.auth.models import User
from django.forms import CharField
from oauth2_provider.constants import SCOPE_NAMES
import provider.constants
from provider.forms import OAuthForm, OAuthValidationError
from provider.oauth2.forms import ScopeChoiceField, ScopeMixin
from provider.oauth2.models import Client
from requests import HTTPError
from social.backends import oauth as social_oauth
from social.exceptions import AuthException

from third_party_auth import pipeline


class AccessTokenExchangeForm(ScopeMixin, OAuthForm):
    """Form for access token exchange endpoint"""
    access_token = CharField(required=False)
    scope = ScopeChoiceField(choices=SCOPE_NAMES, required=False)
    client_id = CharField(required=False)

    def __init__(self, request, *args, **kwargs):
        super(AccessTokenExchangeForm, self).__init__(*args, **kwargs)
        self.request = request

    def _require_oauth_field(self, field_name):
        """
        Raise an appropriate OAuthValidationError error if the field is missing
        """
        field_val = self.cleaned_data.get(field_name)
        if not field_val:
            raise OAuthValidationError(
                {
                    "error": "invalid_request",
                    "error_description": "{} is required".format(field_name),
                }
            )
        return field_val

    def clean_access_token(self):
        """
        Validates and returns the "access_token" field.
        """
        return self._require_oauth_field("access_token")

    def clean_client_id(self):
        """
        Validates and returns the "client_id" field.
        """
        return self._require_oauth_field("client_id")

    def clean(self):
        if self._errors:
            return {}

        backend = self.request.backend
        if not isinstance(backend, social_oauth.BaseOAuth2):
            raise OAuthValidationError(
                {
                    "error": "invalid_request",
                    "error_description": "{} is not a supported provider".format(backend.name),
                }
            )

        self.request.session[pipeline.AUTH_ENTRY_KEY] = pipeline.AUTH_ENTRY_LOGIN_API

        client_id = self.cleaned_data["client_id"]
        try:
            client = Client.objects.get(client_id=client_id)
        except Client.DoesNotExist:
            raise OAuthValidationError(
                {
                    "error": "invalid_client",
                    "error_description": "{} is not a valid client_id".format(client_id),
                }
            )
        if client.client_type != provider.constants.PUBLIC:
            raise OAuthValidationError(
                {
                    # invalid_client isn't really the right code, but this mirrors
                    # https://github.com/edx/django-oauth2-provider/blob/edx/provider/oauth2/forms.py#L331
                    "error": "invalid_client",
                    "error_description": "{} is not a public client".format(client_id),
                }
            )
        self.cleaned_data["client"] = client

        user = None
        try:
            user = backend.do_auth(self.cleaned_data.get("access_token"), allow_inactive_user=True)
        except (HTTPError, AuthException):
            pass
        if user and isinstance(user, User):
            self.cleaned_data["user"] = user
        else:
            # Ensure user does not re-enter the pipeline
            self.request.social_strategy.clean_partial_pipeline()
            raise OAuthValidationError(
                {
                    "error": "invalid_grant",
                    "error_description": "access_token is not valid",
                }
            )

        return self.cleaned_data

# Copyright (c) 2013 Amazon.com, Inc. or its affiliates.  All Rights Reserved
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish, dis-
# tribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the fol-
# lowing conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#

def tag(key, value):
    start = '<%s>' % key
    end = '</%s>' % key
    return '%s%s%s' % (start, value, end)


class WebsiteConfiguration(object):
    """
    Website configuration for a bucket.

    :ivar suffix: Suffix that is appended to a request that is for a
        "directory" on the website endpoint (e.g. if the suffix is
        index.html and you make a request to samplebucket/images/
        the data that is returned will be for the object with the
        key name images/index.html).  The suffix must not be empty
        and must not include a slash character.

    :ivar error_key: The object key name to use when a 4xx class error
        occurs.  This key identifies the page that is returned when
        such an error occurs.

    :ivar redirect_all_requests_to: Describes the redirect behavior for every
        request to this bucket's website endpoint. If this value is non None,
        no other values are considered when configuring the website
        configuration for the bucket. This is an instance of
        ``RedirectLocation``.

    :ivar routing_rules: ``RoutingRules`` object which specifies conditions
        and redirects that apply when the conditions are met.

    """

    def __init__(self, suffix=None, error_key=None,
                 redirect_all_requests_to=None, routing_rules=None):
        self.suffix = suffix
        self.error_key = error_key
        self.redirect_all_requests_to = redirect_all_requests_to
        if routing_rules is not None:
            self.routing_rules = routing_rules
        else:
            self.routing_rules = RoutingRules()

    def startElement(self, name, attrs, connection):
        if name == 'RoutingRules':
            self.routing_rules = RoutingRules()
            return self.routing_rules
        elif name == 'IndexDocument':
            return _XMLKeyValue([('Suffix', 'suffix')], container=self)
        elif name == 'ErrorDocument':
            return _XMLKeyValue([('Key', 'error_key')], container=self)

    def endElement(self, name, value, connection):
        pass

    def to_xml(self):
        parts = ['<?xml version="1.0" encoding="UTF-8"?>',
          '<WebsiteConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">']
        if self.suffix is not None:
            parts.append(tag('IndexDocument', tag('Suffix', self.suffix)))
        if self.error_key is not None:
            parts.append(tag('ErrorDocument', tag('Key', self.error_key)))
        if self.redirect_all_requests_to is not None:
            parts.append(self.redirect_all_requests_to.to_xml())
        if self.routing_rules:
            parts.append(self.routing_rules.to_xml())
        parts.append('</WebsiteConfiguration>')
        return ''.join(parts)


class _XMLKeyValue(object):
    def __init__(self, translator, container=None):
        self.translator = translator
        if container:
            self.container = container
        else:
            self.container = self

    def startElement(self, name, attrs, connection):
        pass

    def endElement(self, name, value, connection):
        for xml_key, attr_name in self.translator:
            if name == xml_key:
                setattr(self.container, attr_name, value)

    def to_xml(self):
        parts = []
        for xml_key, attr_name in self.translator:
            content = getattr(self.container, attr_name)
            if content is not None:
                parts.append(tag(xml_key, content))
        return ''.join(parts)


class RedirectLocation(_XMLKeyValue):
    """Specify redirect behavior for every request to a bucket's endpoint.

    :ivar hostname: Name of the host where requests will be redirected.

    :ivar protocol: Protocol to use (http, https) when redirecting requests.
        The default is the protocol that is used in the original request.

    """
    TRANSLATOR = [('HostName', 'hostname'),
                  ('Protocol', 'protocol'),
                 ]

    def __init__(self, hostname=None, protocol=None):
        self.hostname = hostname
        self.protocol = protocol
        super(RedirectLocation, self).__init__(self.TRANSLATOR)

    def to_xml(self):
        return tag('RedirectAllRequestsTo',
            super(RedirectLocation, self).to_xml())


class RoutingRules(list):

    def add_rule(self, rule):
        """

        :type rule: :class:`boto.s3.website.RoutingRule`
        :param rule: A routing rule.

        :return: This ``RoutingRules`` object is returned,
            so that it can chain subsequent calls.

        """
        self.append(rule)
        return self

    def startElement(self, name, attrs, connection):
        if name == 'RoutingRule':
            rule = RoutingRule(Condition(), Redirect())
            self.add_rule(rule)
            return rule

    def endElement(self, name, value, connection):
        pass

    def __repr__(self):
        return "RoutingRules(%s)" % super(RoutingRules, self).__repr__()

    def to_xml(self):
        inner_text = []
        for rule in self:
            inner_text.append(rule.to_xml())
        return tag('RoutingRules', '\n'.join(inner_text))


class RoutingRule(object):
    """Represents a single routing rule.

    There are convenience methods to making creating rules
    more concise::

        rule = RoutingRule.when(key_prefix='foo/').then_redirect('example.com')

    :ivar condition: Describes condition that must be met for the
        specified redirect to apply.

    :ivar redirect: Specifies redirect behavior.  You can redirect requests to
        another host, to another page, or with another protocol. In the event
        of an error, you can can specify a different error code to return.

    """
    def __init__(self, condition=None, redirect=None):
        self.condition = condition
        self.redirect = redirect

    def startElement(self, name, attrs, connection):
        if name == 'Condition':
            return self.condition
        elif name == 'Redirect':
            return self.redirect

    def endElement(self, name, value, connection):
        pass

    def to_xml(self):
        parts = []
        if self.condition:
            parts.append(self.condition.to_xml())
        if self.redirect:
            parts.append(self.redirect.to_xml())
        return tag('RoutingRule', '\n'.join(parts))

    @classmethod
    def when(cls, key_prefix=None, http_error_code=None):
        return cls(Condition(key_prefix=key_prefix,
                             http_error_code=http_error_code), None)

    def then_redirect(self, hostname=None, protocol=None, replace_key=None,
                      replace_key_prefix=None, http_redirect_code=None):
        self.redirect = Redirect(
                hostname=hostname, protocol=protocol,
                replace_key=replace_key,
                replace_key_prefix=replace_key_prefix,
                http_redirect_code=http_redirect_code)
        return self


class Condition(_XMLKeyValue):
    """
    :ivar key_prefix: The object key name prefix when the redirect is applied.
        For example, to redirect requests for ExamplePage.html, the key prefix
        will be ExamplePage.html. To redirect request for all pages with the
        prefix docs/, the key prefix will be /docs, which identifies all
        objects in the docs/ folder.

    :ivar http_error_code: The HTTP error code when the redirect is applied. In
        the event of an error, if the error code equals this value, then the
        specified redirect is applied.

    """
    TRANSLATOR = [
        ('KeyPrefixEquals', 'key_prefix'),
        ('HttpErrorCodeReturnedEquals', 'http_error_code'),
        ]

    def __init__(self, key_prefix=None, http_error_code=None):
        self.key_prefix = key_prefix
        self.http_error_code = http_error_code
        super(Condition, self).__init__(self.TRANSLATOR)

    def to_xml(self):
        return tag('Condition', super(Condition, self).to_xml())


class Redirect(_XMLKeyValue):
    """
    :ivar hostname: The host name to use in the redirect request.

    :ivar protocol: The protocol to use in the redirect request.  Can be either
    'http' or 'https'.

    :ivar replace_key: The specific object key to use in the redirect request.
        For example, redirect request to error.html.

    :ivar replace_key_prefix: The object key prefix to use in the redirect
        request. For example, to redirect requests for all pages with prefix
        docs/ (objects in the docs/ folder) to documents/, you can set a
        condition block with KeyPrefixEquals set to docs/ and in the Redirect
        set ReplaceKeyPrefixWith to /documents.

    :ivar http_redirect_code: The HTTP redirect code to use on the response.

    """

    TRANSLATOR = [
        ('Protocol', 'protocol'),
        ('HostName', 'hostname'),
        ('ReplaceKeyWith', 'replace_key'),
        ('ReplaceKeyPrefixWith', 'replace_key_prefix'),
        ('HttpRedirectCode', 'http_redirect_code'),
        ]

    def __init__(self, hostname=None, protocol=None, replace_key=None,
                 replace_key_prefix=None, http_redirect_code=None):
        self.hostname = hostname
        self.protocol = protocol
        self.replace_key = replace_key
        self.replace_key_prefix = replace_key_prefix
        self.http_redirect_code = http_redirect_code
        super(Redirect, self).__init__(self.TRANSLATOR)

    def to_xml(self):
        return tag('Redirect', super(Redirect, self).to_xml())



# python 2/3 interoperability
try:
    range = xrange
except NameError:
    pass

import numpy as np
import implicit
from polara.recommender.models import RecommenderModel
from polara.tools.timing import track_time


class ImplicitALS(RecommenderModel):

    def __init__(self, *args, **kwargs):
        super(ImplicitALS, self).__init__(*args, **kwargs)
        self._rank = 10
        self.alpha = 1
        self.epsilon = 1
        self.weight_func = np.log2
        self.regularization = 0.01
        self.num_threads = 0
        self.num_epochs = 15
        self.method = 'iALS'
        self._model = None

    @property
    def rank(self):
        return self._rank

    @rank.setter
    def rank(self, new_value):
        if new_value != self._rank:
            self._rank = new_value
            self._is_ready = False
            self._recommendations = None


    @staticmethod
    def confidence(values, alpha=1, weight=None, epsilon=1, dtype='double'):
        '''implementation of a generic confidence-based function'''
        values = weight(values/epsilon) if weight is not None else values/epsilon
        return (alpha * values).astype(dtype)


    def build(self):
        # define iALS model instance
        self._model = implicit.als.AlternatingLeastSquares(factors=self.rank,
                                                           regularization=self.regularization,
                                                           iterations=self.num_epochs,
                                                           num_threads=self.num_threads)

        # prepare input matrix for learning the model
        matrix = self.get_training_matrix() # user_by_item sparse matrix
        matrix.data = self.confidence(matrix.data, alpha=self.alpha,
                                      weight=self.weight_func, epsilon=self.epsilon)

        with track_time(self.training_time, verbose=self.verbose, model=self.method):
            # build the model
            # implicit takes item_by_user matrix as input, need to transpose
            self._model.fit(matrix.T)


    def get_recommendations(self):
        recalculate = self.data.warm_start # used to force folding-in computation
        if recalculate:
            if self.filter_seen is False:
                raise ValueError('The model always filters seen items from results.')
            # prepare test matrix with preferences of unseen users
            matrix, _ = self.get_test_matrix()
            matrix.data = self.confidence(matrix.data, alpha=self.alpha,
                                          weight=self.weight_func, epsilon=self.epsilon)
            num_users = matrix.shape[0]
            users_idx = range(num_users)

            top_recs = np.empty((num_users, self.topk), dtype=np.intp)
            for i, user_row in enumerate(users_idx):
                recs = self._model.recommend(user_row, matrix, N=self.topk, recalculate_user=recalculate)
                top_recs[i, :] = [item for item, _ in recs]
        else:
            top_recs = super(ImplicitALS, self).get_recommendations()
        return top_recs


    def slice_recommendations(self, test_data, shape, start, stop, test_users=None):
        slice_data = self._slice_test_data(test_data, start, stop)

        user_factors = self._model.user_factors[test_users[start:stop], :]
        item_factors = self._model.item_factors
        scores = user_factors.dot(item_factors.T)
        return scores, slice_data

# coding=utf-8
from service.action import CommandActionMixin


class OrderOption(object):
    def __init__(self, name, url, login=None):
        self.name = name
        self.url = url
        self.login = login

    def __repr__(self):
        _repr = '%(name)s @ %(url)s' % self.__dict__
        if self.login:
            _repr += '\n' \
                     'credentials: %(login)s' % self.__dict__

        return _repr


class OrdersCommandAction(CommandActionMixin):
    @property
    def help_text(self):
        return 'Displays all order options'

    @property
    def name(self):
        return 'orders'

    def _writer_callback(self, writer, message=None):
        _string = 'The following order options are available:\n'
        _string += '\n'.join(['- %s\n' % option for option in options])
        writer.out(_string)


CONTAINER = 'https://my.1password.com/vaults/rllzgcg4nk5j3axeoedj3vvnku/allitems/'

options = (OrderOption('GoodKarmaCoffee', 'https://http://www.goodkarmacoffee.de/epages/64249863.sf/de_DE/?'
                                          'ObjectPath=/Shops/64249863/Products/057CoMan/SubProducts/057E-0001',
                       CONTAINER + 'ekommw2x4ringiqa2rv5djczd4'),
           )

from django.core.management.base import BaseCommand


def module_to_dict(module, omittable=lambda k: k.startswith('_')):
    """Convert a module namespace to a Python dictionary."""
    return {k: repr(v) for k, v in module.__dict__.items() if not omittable(k)}


class Command(BaseCommand):
    help = """Displays differences between the current settings.py and Django's
    default settings. Settings that don't appear in the defaults are
    followed by "###"."""

    requires_system_checks = False

    def add_arguments(self, parser):
        parser.add_argument(
            '--all', action='store_true', dest='all', default=False,
            help='Display all settings, regardless of their value. Default values are prefixed by "###".',
        )
        parser.add_argument(
            '--default', dest='default', metavar='MODULE', default=None,
            help=(
                "The settings module to compare the current settings against. Leave empty to "
                "compare against Django's default settings."
            ),
        )

    def handle(self, **options):
        # Inspired by Postfix's "postconf -n".
        from django.conf import settings, Settings, global_settings

        # Because settings are imported lazily, we need to explicitly load them.
        settings._setup()

        user_settings = module_to_dict(settings._wrapped)
        default = options['default']
        default_settings = module_to_dict(Settings(default) if default else global_settings)

        output = []
        for key in sorted(user_settings):
            if key not in default_settings:
                output.append("%s = %s  ###" % (key, user_settings[key]))
            elif user_settings[key] != default_settings[key]:
                output.append("%s = %s" % (key, user_settings[key]))
            elif options['all']:
                output.append("### %s = %s" % (key, user_settings[key]))
        return '\n'.join(output)

"""
Generic NAT Port mapping interface.

TODO: Example

@author: Raphael Slinckx
@copyright: Copyright 2005
@license: LGPL
@contact: U{raphael@slinckx.net<mailto:raphael@slinckx.net>}
@version: 0.1.0
"""

__revision__ = "$id"

from twisted.internet.base import BasePort

# Public API
def get_port_mapper(proto="TCP"):
    """
    Returns a L{NATMapper} instance, suited to map a port for
    the given protocol. Defaults to TCP.
    
    For the moment, only upnp mapper is available. It accepts both UDP and TCP.
    
    @param proto: The protocol: 'TCP' or 'UDP'
    @type proto: string
    @return: A deferred called with a L{NATMapper} instance
    @rtype: L{twisted.internet.defer.Deferred}
    """
    import nattraverso.pynupnp
    return nattraverso.pynupnp.get_port_mapper()

class NATMapper:
    """
    Define methods to map port objects (as returned by twisted's listenXX).
    This allows NAT to be traversed from incoming packets.
    
    Currently the only implementation of this class is the UPnP Mapper, which
    can map UDP and TCP ports, if an UPnP Device exists.
    """
    def __init__(self):
        raise NotImplementedError("Cannot instantiate the class")
    
    def map(self, port):
        """
        Create a mapping for the given twisted's port object.
        
        The deferred will call back with a tuple (extaddr, extport):
            - extaddr: The ip string of the external ip address of this host
            - extport: the external port number used to map the given Port object
        
        When called multiple times with the same Port,
        callback with the existing mapping.
        
        @param port: The port object to map
        @type port: a L{twisted.internet.interfaces.IListeningPort} object
        @return: A deferred called with the above defined tuple
        @rtype: L{twisted.internet.defer.Deferred}
        """
        raise NotImplementedError
    
    def info(self, port):
        """
        Returns the existing mapping for the given port object. That means map()
        has to be called before.
        
        @param port: The port object to retreive info from
        @type port: a L{twisted.internet.interfaces.IListeningPort} object
        @raise ValueError: When there is no such existing mapping
        @return: a tuple (extaddress, extport).
        @see: L{map() function<map>}
        """
        raise NotImplementedError
    
    def unmap(self, port):
        """
        Remove an existing mapping for the given twisted's port object.
        
        @param port: The port object to unmap
        @type port: a L{twisted.internet.interfaces.IListeningPort} object
        @return: A deferred called with None
        @rtype: L{twisted.internet.defer.Deferred}
        @raise ValueError: When there is no such existing mapping
        """
        raise NotImplementedError
    
    def get_port_mappings(self):
        """
        Returns a deferred that will be called with a dictionnary of the
        existing mappings.
        
        The dictionnary structure is the following:
            - Keys: tuple (protocol, external_port)
                - protocol is "TCP" or "UDP".
                - external_port is the external port number, as see on the
                    WAN side.
            - Values:tuple (internal_ip, internal_port)
                - internal_ip is the LAN ip address of the host.
                - internal_port is the internal port number mapped
                    to external_port.
        
        @return: A deferred called with the above defined dictionnary
        @rtype: L{twisted.internet.defer.Deferred}
        """
        raise NotImplementedError
    
    def _check_valid_port(self, port):
        """Various Port object validity checks. Raise a ValueError."""
        if not isinstance(port, BasePort):
            raise ValueError("expected a Port, got %r"%(port))
        
        if not port.connected:
            raise ValueError("Port %r is not listening"%(port))
        
        loc_addr = port.getHost()
        if loc_addr.port == 0:
            raise ValueError("Port %r has port number of 0"%(port))


""" Python Character Mapping Codec for KOI8U.

    This character scheme is compliant to RFC2319

Written by Marc-Andre Lemburg (mal@lemburg.com).
Modified by Maxim Dzumanenko <mvd@mylinux.com.ua>.

(c) Copyright 2002, Python Software Foundation.

"""#"

import codecs, koi8_r

### Codec APIs

class Codec(codecs.Codec):

    def encode(self,input,errors='strict'):

        return codecs.charmap_encode(input,errors,encoding_map)

    def decode(self,input,errors='strict'):

        return codecs.charmap_decode(input,errors,decoding_map)

class StreamWriter(Codec,codecs.StreamWriter):
    pass

class StreamReader(Codec,codecs.StreamReader):
    pass

### encodings module API

def getregentry():

    return (Codec().encode,Codec().decode,StreamReader,StreamWriter)

### Decoding Map

decoding_map = koi8_r.decoding_map.copy()
decoding_map.update({
        0x00a4: 0x0454, #       CYRILLIC SMALL LETTER UKRAINIAN IE
        0x00a6: 0x0456, #       CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
        0x00a7: 0x0457, #       CYRILLIC SMALL LETTER YI (UKRAINIAN)
        0x00ad: 0x0491, #       CYRILLIC SMALL LETTER UKRAINIAN GHE WITH UPTURN
        0x00b4: 0x0404, #       CYRILLIC CAPITAL LETTER UKRAINIAN IE
        0x00b6: 0x0406, #       CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I
        0x00b7: 0x0407, #       CYRILLIC CAPITAL LETTER YI (UKRAINIAN)
        0x00bd: 0x0490, #       CYRILLIC CAPITAL LETTER UKRAINIAN GHE WITH UPTURN
})

### Encoding Map

encoding_map = codecs.make_encoding_map(decoding_map)

# -*- coding: utf-8 -*-
import DeepFried2 as df


class AdaDelta(df.Optimizer):
    """
    Implements Matt Zeiler's "Adaptive Learningrate" method, aka. AdaDelta.
    The paper itself is really neat, and both very convincing and practical.

    TL;DR: 1. AdaGrad quickly anneals, AdaDelta doesn't. (No proof.)
           2. AdaGrad *is* sensitive to learning-rate, AdaDelta not so much. (Table 1.)
           3. AdaDelta includes 2nd-order approximation. (3.2)

    The updates are:

        g²_{e+1} = ρ * g²_e + (1-ρ) * ∇p_e²
        up_{e+1} = √(d²_e / g²_{e+1}) * ∇p_e
        d²_{e+1} = ρ * d²_e + (1-ρ) * up²
        p_{e+1} = p_e - up_{e+1}

    As in RMSProp, we need to add epsilons in order to create stability.

    It turns out that the effective learning-rate will converge to 1 as the
    gradients decrease (and thus learning grinds to a halt). This could be used
    to check for convergence by a specialized trainer.

    The only reason `lr` is still there is this tweet by Alec Radford:

    https://twitter.com/AlecRad/status/543518744799358977

        @kastnerkyle @ogrisel @johnmyleswhite @tcovert Adadelta raw is finicky,
        shrinking its updates by 0.5 "just works" in my experience as well.
    """

    def __init__(self, rho, eps=1e-7, lr=1):
        df.Optimizer.__init__(self, rho=rho, eps=eps, lr=lr)

    def get_updates(self, params, grads, rho, eps, lr):
        updates = []

        for param, grad in zip(params, grads):
            g2_state = df.utils.create_param_state_as(param, prefix='g2_')
            d2_state = df.utils.create_param_state_as(param, prefix='d2_')

            new_g2 = rho*g2_state + (1-rho)*grad*grad
            up = lr * df.T.sqrt((d2_state+eps) / (new_g2+eps)) * grad
            new_d2 = rho*d2_state + (1-rho)*up*up

            updates.append((g2_state, new_g2))
            updates.append((param, param - up))
            updates.append((d2_state, new_d2))

        return updates

#  Copyright 2008-2013 Nokia Siemens Networks Oyj
#
#  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.

import re
from functools import partial

from .normalizing import normalize


def eq(str1, str2, ignore=(), caseless=True, spaceless=True):
    str1 = normalize(str1, ignore, caseless, spaceless)
    str2 = normalize(str2, ignore, caseless, spaceless)
    return str1 == str2


class Matcher(object):
    _pattern_tokenizer = re.compile('(\*|\?)')
    _wildcards = {'*': '.*', '?': '.'}

    def __init__(self, pattern, ignore=(), caseless=True, spaceless=True):
        self.pattern = pattern
        self._normalize = partial(normalize, ignore=ignore, caseless=caseless,
                                  spaceless=spaceless)
        self._regexp = self._get_and_compile_regexp(self._normalize(pattern))

    def _get_and_compile_regexp(self, pattern):
        pattern = '^%s$' % ''.join(self._yield_regexp(pattern))
        return re.compile(pattern, re.DOTALL)

    def _yield_regexp(self, pattern):
        for token in self._pattern_tokenizer.split(pattern):
            if token in self._wildcards:
                yield self._wildcards[token]
            else:
                yield re.escape(token)

    def match(self, string):
        return self._regexp.match(self._normalize(string)) is not None

    def match_any(self, strings):
        return any(self.match(s) for s in strings)


class MultiMatcher(object):

    def __init__(self, patterns=None, ignore=(), caseless=True, spaceless=True,
                 match_if_no_patterns=False):
        self._matchers = [Matcher(pattern, ignore, caseless, spaceless)
                          for pattern in self._ensure_list(patterns)]
        self._match_if_no_patterns = match_if_no_patterns

    def _ensure_list(self, patterns):
        if patterns is None:
            return []
        if isinstance(patterns, basestring):
            return [patterns]
        return patterns

    def match(self, string):
        if self._matchers:
            return any(m.match(string) for m in self._matchers)
        return self._match_if_no_patterns

    def match_any(self, strings):
        return any(self.match(s) for s in strings)

    def __len__(self):
        return len(self._matchers)

    def __iter__(self):
        for matcher in self._matchers:
            yield matcher.pattern

# oxAuth is available under the MIT License (2008). See http://opensource.org/licenses/MIT for full text.
# Copyright (c) 2016, Gluu
#
# Author: Sahil Arora
#

from org.gluu.model.custom.script.type.scope import DynamicScopeType
from org.gluu.oxauth.service.common import UserService
from org.gluu.util import StringHelper, ArrayHelper
from java.util import Arrays, ArrayList
from org.gluu.service.cdi.util import CdiUtil

import java

class DynamicScope(DynamicScopeType):
    def __init__(self, currentTimeMillis):
        self.currentTimeMillis = currentTimeMillis

    def init(self, configurationAttributes):
        print "Dynamic scope. Initialization"

        print "Dynamic scope. Initialized successfully"

        return True   

    def destroy(self, configurationAttributes):
        print "Dynamic scope. Destroy"
        print "Dynamic scope. Destroyed successfully"
        return True   

    # Update Json Web token before signing/encrypring it
    #   dynamicScopeContext is org.gluu.oxauth.service.external.context.DynamicScopeExternalContext
    #   configurationAttributes is java.util.Map<String, SimpleCustomProperty>
    def update(self, dynamicScopeContext, configurationAttributes):
        print "Dynamic scope. Update method"
        userService = CdiUtil.bean(UserService)
        print "-->userService: " + userService.toString()

        dynamicScopes = dynamicScopeContext.getDynamicScopes()
        authorizationGrant = dynamicScopeContext.getAuthorizationGrant()
        user = dynamicScopeContext.getUser()
        jsonWebResponse = dynamicScopeContext.getJsonWebResponse()
        claims = jsonWebResponse.getClaims()

        member_of_list= userService.getCustomAttribute(user, "memberof")
        if member_of_list == None:
            print "-->memberOf: is null"
            return None
        else:
             members_list = member_of_list.getValues()
             membersArray = []
             for members in members_list:
                 group = userService.getUserByDn(members, "displayName")
                 membersArray.append(group.getAttribute("displayName"))

             claims.setClaim("memberof", Arrays.asList(membersArray ) )

        return True

    def getSupportedClaims(self, configurationAttributes):
        return Arrays.asList("memberof")

    def getApiVersion(self):
        return 2

# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# MIT License. See license.txt

from __future__ import unicode_literals

import frappe
import os, json

from frappe import _
from frappe.modules import scrub, get_module_path
from frappe.utils import flt, cint, get_html_format
from frappe.translate import send_translations
import frappe.desk.reportview

def get_report_doc(report_name):
	doc = frappe.get_doc("Report", report_name)
	if not doc.has_permission("read"):
		frappe.throw(_("You don't have access to Report: {0}").format(report_name), frappe.PermissionError)

	if not frappe.has_permission(doc.ref_doctype, "report"):
		frappe.throw(_("You don't have permission to get a report on: {0}").format(doc.ref_doctype),
			frappe.PermissionError)

	if doc.disabled:
		frappe.throw(_("Report {0} is disabled").format(report_name))

	return doc

@frappe.whitelist()
def get_script(report_name):
	report = get_report_doc(report_name)

	module = report.module or frappe.db.get_value("DocType", report.ref_doctype, "module")
	module_path = get_module_path(module)
	report_folder = os.path.join(module_path, "report", scrub(report.name))
	script_path = os.path.join(report_folder, scrub(report.name) + ".js")
	print_path = os.path.join(report_folder, scrub(report.name) + ".html")

	script = None
	if os.path.exists(script_path):
		with open(script_path, "r") as f:
			script = f.read()

	html_format = get_html_format(print_path)

	if not script and report.javascript:
		script = report.javascript

	if not script:
		script = "frappe.query_reports['%s']={}" % report_name

	# load translations
	if frappe.lang != "en":
		send_translations(frappe.get_lang_dict("report", report_name))

	return {
		"script": script,
		"html_format": html_format
	}

@frappe.whitelist()
def run(report_name, filters=()):
	report = get_report_doc(report_name)

	if filters and isinstance(filters, basestring):
		filters = json.loads(filters)

	if not frappe.has_permission(report.ref_doctype, "report"):
		frappe.msgprint(_("Must have report permission to access this report."),
			raise_exception=True)

	columns, result = [], []
	if report.report_type=="Query Report":
		if not report.query:
			frappe.msgprint(_("Must specify a Query to run"), raise_exception=True)


		if not report.query.lower().startswith("select"):
			frappe.msgprint(_("Query must be a SELECT"), raise_exception=True)

		result = [list(t) for t in frappe.db.sql(report.query, filters)]
		columns = [c[0] for c in frappe.db.get_description()]
	else:
		module = report.module or frappe.db.get_value("DocType", report.ref_doctype, "module")
		if report.is_standard=="Yes":
			method_name = get_report_module_dotted_path(module, report.name) + ".execute"
			columns, result = frappe.get_attr(method_name)(frappe._dict(filters))

	if report.apply_user_permissions and result:
		result = get_filtered_data(report.ref_doctype, columns, result)

	if cint(report.add_total_row) and result:
		result = add_total_row(result, columns)

	return {
		"result": result,
		"columns": columns
	}

def get_report_module_dotted_path(module, report_name):
	return frappe.local.module_app[scrub(module)] + "." + scrub(module) \
		+ ".report." + scrub(report_name) + "." + scrub(report_name)

def add_total_row(result, columns):
	total_row = [""]*len(columns)
	has_percent = []
	for row in result:
		for i, col in enumerate(columns):
			fieldtype = None
			if isinstance(col, basestring):
				col = col.split(":")
				if len(col) > 1:
					fieldtype = col[1]
			else:
				fieldtype = col.get("fieldtype")

			if fieldtype in ["Currency", "Int", "Float", "Percent"] and flt(row[i]):
				total_row[i] = flt(total_row[i]) + flt(row[i])
			if fieldtype == "Percent" and i not in has_percent:
				has_percent.append(i)

	for i in has_percent:
		total_row[i] = total_row[i] / len(result)

	first_col_fieldtype = None
	if isinstance(columns[0], basestring):
		first_col = columns[0].split(":")
		if len(first_col) > 1:
			first_col_fieldtype = first_col[1].split("/")[0]
	else:
		first_col_fieldtype = columns[0].get("fieldtype")

	if first_col_fieldtype not in ["Currency", "Int", "Float", "Percent"]:
		if first_col_fieldtype == "Link":
			total_row[0] = "'" + _("Total") + "'"
		else:
			total_row[0] = _("Total")

	result.append(total_row)
	return result

def get_filtered_data(ref_doctype, columns, data):
	result = []
	linked_doctypes = get_linked_doctypes(columns, data)
	match_filters_per_doctype = get_user_match_filters(linked_doctypes, ref_doctype)
	shared = frappe.share.get_shared(ref_doctype)

	if match_filters_per_doctype:
		for row in data:
			if shared and row[linked_doctypes[ref_doctype]] in shared:
				result.append(row)

			elif has_match(row, linked_doctypes, match_filters_per_doctype):
				result.append(row)
	else:
		result = list(data)

	return result

def has_match(row, linked_doctypes, doctype_match_filters):
	resultant_match = True

	if not row:
		# allow empty rows :)
		return resultant_match

	for doctype, filter_list in doctype_match_filters.items():
		matched_for_doctype = False

		for match_filters in filter_list:
			match = True
			for dt, idx in linked_doctypes.items():
				if dt in match_filters and row[idx] not in match_filters[dt]:
					match = False
					break

			# each doctype could have multiple conflicting user permission doctypes, hence using OR
			# so that even if one of the sets allows a match, it is true
			matched_for_doctype = matched_for_doctype or match

			if matched_for_doctype:
				break

		# each doctype's user permissions should match the row! hence using AND
		resultant_match = resultant_match and matched_for_doctype

		if not resultant_match:
			break

	return resultant_match

def get_linked_doctypes(columns, data):
	linked_doctypes = {}

	for idx, col in enumerate(columns):
		if isinstance(col, basestring):
			col = col.split(":")
			if len(col) > 1 and col[1].startswith("Link"):
				link_dt = col[1].split("/")[1]
				linked_doctypes[link_dt] = idx

		# dict
		elif col.get("fieldtype")=="Link" and col.get("options"):
			linked_doctypes[col["options"]] = col["fieldname"]

	# remove doctype if column is empty
	for doctype, key in linked_doctypes.items():
		if not any(d[key] for d in data if d):
			del linked_doctypes[doctype]

	return linked_doctypes

def get_user_match_filters(doctypes, ref_doctype):
	match_filters = {}

	for dt in doctypes:
		filter_list = frappe.desk.reportview.build_match_conditions(dt, False)
		if filter_list:
			match_filters[dt] = filter_list

	return match_filters

"""s6 services management.
"""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import abc
import errno
import os
import logging

import six

from treadmill import fs

from .. import _utils
from .. import _service_base


_LOGGER = logging.getLogger(__name__)


class BundleService(_service_base.Service):
    """s6 rc bundle service.
    """
    __slots__ = (
        '_contents',
    )

    _TYPE = _service_base.ServiceType.Bundle

    def __init__(self, directory, name, contents=None):
        super(BundleService, self).__init__(directory, name)
        self._contents = contents

    @property
    def type(self):
        return self._TYPE

    @property
    def _contents_file(self):
        return os.path.join(self._dir, 'contents')

    @property
    def contents(self):
        """Gets the contents of the bundle.
        """
        if self._contents is None:
            self._contents = _utils.set_list_read(self._contents_file)
        return self._contents

    def write(self):
        """Write down the service definition.
        """
        super(BundleService, self).write()
        # Mandatory settings
        if not self._contents and not os.path.exists(self._contents_file):
            raise ValueError('Invalid Bundle: No content')
        if self._contents is not None:
            if not self._contents:
                raise ValueError('Invalid Bundle: empty')
            _utils.set_list_write(self._contents_file, self._contents)


@six.add_metaclass(abc.ABCMeta)
class _AtomicService(_service_base.Service):
    """Abstract base class for all atomic services (per s6-rc definition).
    """
    __slots__ = (
        '_dependencies',
        '_timeout_up',
        '_timeout_down',
        '_env',
    )

    def __init__(self, directory, name,
                 timeout_up=None, timeout_down=None,
                 dependencies=None, environ=None):
        super(_AtomicService, self).__init__(directory, name)
        self._dependencies = dependencies
        self._timeout_up = timeout_up
        self._timeout_down = timeout_down
        self._env = environ

    @property
    def data_dir(self):
        """Returns the data directory for the services.

        :returns ``str``:
            Full path to the service data directory.
        """
        return os.path.join(self._dir, 'data')

    @property
    def env_dir(self):
        """Returns the environ directory for the services.

        :returns ``str``:
            Full path to the service environ directory.
        """
        return os.path.join(self._dir, 'env')

    @property
    def environ(self):
        """Returns the environ dictionary for the services.

        :returns ``dict``:
            Service environ dictionary.
        """
        if self._env is None:
            self._env = _utils.environ_dir_read(self.env_dir)
        return self._env

    @environ.setter
    def environ(self, new_environ):
        self._env = new_environ

    @property
    def _dependencies_file(self):
        return os.path.join(self._dir, 'dependencies')

    @property
    def dependencies(self):
        """Returns the dependencies set for the services.

        :returns ``set``:
            Service dependencies set.
        """
        if self._dependencies is None:
            self._dependencies = _utils.set_list_read(self._dependencies_file)
        return self._dependencies

    @dependencies.setter
    def dependencies(self, new_deps):
        self._dependencies = set(new_deps)

    @property
    def timeout_up(self):
        """Returns amount of milliseconds to wait for the service to come up.

        :returns ``int``:
            Amount of milliseconds to wait. 0 means infinitely.
        """
        if self._timeout_up is None:
            self._timeout_up = _utils.value_read(
                os.path.join(self._dir, 'timeout-up'),
                default=0
            )
        return self._timeout_up

    @property
    def timeout_down(self):
        """Returns amount of milliseconds to wait for the service to come down.

        :returns ``int``:
            Amount of milliseconds to wait. 0 means infinitely.
        """
        if self._timeout_down is None:
            self._timeout_down = _utils.value_read(
                os.path.join(self._dir, 'timeout-down'),
                default=0
            )
        return self._timeout_down

    @abc.abstractmethod
    def write(self):
        """Write down the service definition.
        """
        super(_AtomicService, self).write()
        # We only write dependencies/environ if we have new ones.
        fs.mkdir_safe(self.env_dir)
        fs.mkdir_safe(self.data_dir)
        if self._dependencies is not None:
            _utils.set_list_write(self._dependencies_file, self._dependencies)
        if self._env is not None:
            _utils.environ_dir_write(self.env_dir, self._env)
        if self._timeout_up is not None:
            _utils.value_write(
                os.path.join(self._dir, 'timeout-up'),
                self._timeout_up
            )
        if self._timeout_down is not None:
            _utils.value_write(
                os.path.join(self._dir, 'timeout-down'),
                self._timeout_down
            )


class LongrunService(_AtomicService):
    """s6 long running service.
    """

    __slots__ = (
        '_consumer_for',
        '_default_down',
        '_finish_script',
        '_log_run_script',
        '_notification_fd',
        '_pipeline_name',
        '_producer_for',
        '_run_script',
        '_timeout_finish',
    )

    _TYPE = _service_base.ServiceType.LongRun

    def __init__(self, directory, name,
                 run_script=None, finish_script=None, notification_fd=None,
                 log_run_script=None, timeout_finish=None, default_down=None,
                 pipeline_name=None, producer_for=None, consumer_for=None,
                 dependencies=None, environ=None):
        super(LongrunService, self).__init__(
            directory,
            name,
            dependencies=dependencies,
            environ=environ
        )
        if producer_for and log_run_script:
            raise ValueError('Invalid LongRun service options: producer/log')
        self._consumer_for = consumer_for
        self._default_down = default_down
        self._finish_script = finish_script
        self._log_run_script = log_run_script
        self._notification_fd = notification_fd
        self._pipeline_name = pipeline_name
        self._producer_for = producer_for
        self._run_script = run_script
        self._timeout_finish = timeout_finish

    @property
    def type(self):
        return self._TYPE

    @property
    def logger_dir(self):
        """Returns the logger directory for the services.

        :returns ``str``:
            Full path to the service log directory.
        """
        return os.path.join(self._dir, 'log')

    @property
    def notification_fd(self):
        """s6 "really up" notification fd.
        """
        if self._notification_fd is None:
            self._notification_fd = _utils.value_read(
                os.path.join(self._dir, 'notification-fd'),
                default=-1
            )
        return self._notification_fd

    @notification_fd.setter
    def notification_fd(self, new_notification_fd):
        self._notification_fd = new_notification_fd

    @property
    def default_down(self):
        """Is the default service state set to down?
        """
        if self._default_down is None:
            self._default_down = os.path.exists(
                os.path.join(self._dir, 'down')
            )
        return self._default_down

    @default_down.setter
    def default_down(self, default_down):
        self._default_down = bool(default_down)

    @property
    def _run_file(self):
        return os.path.join(self._dir, 'run')

    @property
    def _finish_file(self):
        return os.path.join(self._dir, 'finish')

    @property
    def _log_run_file(self):
        return os.path.join(self.logger_dir, 'run')

    @property
    def run_script(self):
        """Service run script.
        """
        if self._run_script is None:
            self._run_script = _utils.script_read(self._run_file)
        return self._run_script

    @run_script.setter
    def run_script(self, new_script):
        self._run_script = new_script

    @property
    def finish_script(self):
        """Service finish script.
        """
        if self._finish_script is None:
            try:
                self._finish_script = _utils.script_read(self._finish_file)
            except IOError as err:
                if err.errno is not errno.ENOENT:
                    raise
        return self._finish_script

    @finish_script.setter
    def finish_script(self, new_script):
        self._finish_script = new_script

    @property
    def log_run_script(self):
        """Service log run script.
        """
        if self._log_run_script is None:
            try:
                self._log_run_script = _utils.script_read(self._log_run_file)
            except IOError as err:
                if err.errno is not errno.ENOENT:
                    raise
        return self._log_run_script

    @log_run_script.setter
    def log_run_script(self, new_script):
        self._log_run_script = new_script

    @property
    def timeout_finish(self):
        """Returns amount of milliseconds to wait for the finish script to
        complete.

        :returns ``int``:
            Amount of milliseconds to wait. 0 means infinitely. Default 5000.
        """
        if self._timeout_finish is None:
            self._timeout_finish = _utils.value_read(
                os.path.join(self._dir, 'timeout-finish'),
                default=5000
            )
        return self._timeout_finish

    @timeout_finish.setter
    def timeout_finish(self, timeout_finish):
        """Service finish script timeout.
        """
        if timeout_finish is not None:
            if isinstance(timeout_finish, six.integer_types):
                self._timeout_finish = timeout_finish
            else:
                self._timeout_finish = int(timeout_finish, 10)

    @property
    def _pipeline_name_file(self):
        return os.path.join(self._dir, 'pipeline-name')

    @property
    def pipeline_name(self):
        """Gets the name of the pipeline.
        """
        if self._pipeline_name is None:
            self._pipeline_name = _utils.data_read(self._pipeline_name_file)
        return self._pipeline_name

    @pipeline_name.setter
    def pipeline_name(self, new_name):
        self._pipeline_name = new_name

    @property
    def _producer_for_file(self):
        return os.path.join(self._dir, 'producer-for')

    @property
    def producer_for(self):
        """Gets which services this service is a producer for.
        """
        if self._producer_for is None:
            self._producer_for = _utils.data_read(self._producer_for_file)
        return self._producer_for

    @producer_for.setter
    def producer_for(self, new_name):
        """Sets the producer for another service.
        """
        self._producer_for = new_name

    @property
    def _consumer_for_file(self):
        return os.path.join(self._dir, 'consumer-for')

    @property
    def consumer_for(self):
        """Gets which services this service is a consumer for.
        """
        if self._consumer_for is None:
            self._consumer_for = _utils.data_read(self._consumer_for_file)
        return self._consumer_for

    @consumer_for.setter
    def consumer_for(self, new_name):
        """Sets which services this service is a consumer for.
        """
        self._consumer_for = new_name

    def write(self):
        """Write down the service definition.
        """
        # Disable R0912: Too many branche
        # pylint: disable=R0912
        super(LongrunService, self).write()
        # Mandatory settings
        if self._run_script is None and not os.path.exists(self._run_file):
            raise ValueError('Invalid LongRun service: not run script')
        if self._run_script is not None:
            _utils.script_write(self._run_file, self._run_script)
            # Handle the case where the run script is a generator
            if not isinstance(self._run_script, six.string_types):
                self._run_script = None
        # Optional settings
        if self._finish_script is not None:
            _utils.script_write(self._finish_file, self._finish_script)
            # Handle the case where the finish script is a generator
            if not isinstance(self._finish_script, six.string_types):
                self._finish_script = None
        if self._log_run_script is not None:
            # Create the log dir on the spot
            fs.mkdir_safe(os.path.dirname(self._log_run_file))
            _utils.script_write(self._log_run_file, self._log_run_script)
            # Handle the case where the run script is a generator
            if not isinstance(self._log_run_script, six.string_types):
                self._log_run_script = None
        if self._default_down:
            _utils.data_write(
                os.path.join(self._dir, 'down'),
                None
            )
        else:
            fs.rm_safe(os.path.join(self._dir, 'down'))
        if self._timeout_finish is not None:
            _utils.value_write(
                os.path.join(self._dir, 'timeout-finish'),
                self._timeout_finish
            )
        if self._notification_fd is not None:
            _utils.value_write(
                os.path.join(self._dir, 'notification-fd'),
                self._notification_fd
            )
        if self._pipeline_name is not None:
            _utils.data_write(self._pipeline_name_file, self._pipeline_name)
        if self._producer_for is not None:
            _utils.data_write(self._producer_for_file, self._producer_for)
        if self._consumer_for is not None:
            _utils.data_write(self._consumer_for_file, self._consumer_for)


class OneshotService(_AtomicService):
    """Represents a s6 rc one-shot service which is only ever executed once.
    """
    __slots__ = (
        '_up',
        '_down',
    )
    # TODO: timeout-up/timeout-down

    _TYPE = _service_base.ServiceType.Oneshot

    def __init__(self, directory, name=None,
                 up_script=None, down_script=None,
                 dependencies=None, environ=None):
        super(OneshotService, self).__init__(
            directory,
            name,
            dependencies=dependencies,
            environ=environ
        )
        self._up = up_script
        self._down = down_script

    @property
    def type(self):
        return self._TYPE

    @property
    def _up_file(self):
        return os.path.join(self._dir, 'up')

    @property
    def _down_file(self):
        return os.path.join(self._dir, 'down')

    @property
    def up(self):
        """Gets the one shot service up file.
        """
        if self._up is None:
            self._up = _utils.script_read(self._up_file)
        return self._up

    @up.setter
    def up(self, new_script):
        """Sets the one-shot service up file.
        """
        self._up = new_script

    @property
    def down(self):
        """Gets the one-shot service down file.
        """
        if self._down is None:
            self._down = _utils.script_read(self._down_file)
        return self._down

    @down.setter
    def down(self, new_script):
        """Sets the one-shot service down file.
        """
        self._down = new_script

    def write(self):
        """Write down the service definition.
        """
        super(OneshotService, self).write()
        # Mandatory settings
        if not self._up and not os.path.exists(self._up_file):
            raise ValueError('Invalid Oneshot service: not up script')
        if self._up is not None:
            _utils.script_write(self._up_file, self._up)
            if not isinstance(self._up_file, six.string_types):
                self._up_file = None
        # Optional settings
        if self._down is not None:
            _utils.script_write(self._down_file, self._down)
            if not isinstance(self._down_file, six.string_types):
                self._down_file = None


def create_service(svc_basedir, svc_name, svc_type, **kwargs):
    """Factory function instantiating a new service object from parameters.

    :param ``str`` svc_basedir:
        Base directory where to create the service.
    :param ``str`` svc_name:
        Name of the new service.
    :param ``_service_base.ServiceType`` svc_type:
        Type for the new service.
    :param ``dict`` kw_args:
        Additional argument passed to the constructor of the new service.
    :returns ``Service``:
        New instance of the service
    """
    cls = {
        _service_base.ServiceType.Bundle: BundleService,
        _service_base.ServiceType.LongRun: LongrunService,
        _service_base.ServiceType.Oneshot: OneshotService,
    }.get(svc_type, None)

    if cls is None:
        _LOGGER.critical('No implementation for service type %r', svc_type)
        cls = LongrunService

    return cls(svc_basedir, svc_name, **kwargs)


__all__ = (
    'BundleService',
    'LongrunService',
    'OneshotService',
    'create_service',
)

#! /usr/bin/env python

import urllib3
import requests
import urlparse
from .page import Page

# Gevent!
import gevent
from gevent import sleep
from gevent import monkey; monkey.patch_all()

import logging
logging.basicConfig()
logger = logging.getLogger('gcrawl')
logger.setLevel(logging.INFO)


class TimeoutException(Exception):
    '''A timeout happened'''
    pass


class Crawl(object):
    '''A crawl of a set of urls'''
    # The headers that we'd like to use when making requests
    headers = {}

    @staticmethod
    def crawl(job):
        # @Matt, this is where you'd describe your qless job. For
        # example, you'd probably so something like this. This would
        # allow you to spawn up a bunch of these, and really saturate
        # all the CPU without worrying about network IO stuff
        c = Crawl(job['seed'], job['allow_subdomains'], job['max_pages'])
        results = c.run()
        with file('%s-dump' % job.jid, 'w+') as f:
            import cPickle as pickle
            pickle.dump(results, f)
        job.complete()

    def __init__(self, seed, allow_subdomains=False, max_pages=10, allow_redirects=False, timeout=10):
        self.requests         = [seed]
        self.results          = []
        self.crawled          = 0
        self.timeout          = 10
        self.allow_subdomains = allow_subdomains
        self.max_pages        = max_pages
        self.allow_redirects  = allow_redirects

    def before(self):
        '''This is executed before we run the main crawl loop'''
        pass

    def run(self):
        '''Run the crawl!'''
        self.before()
        while self.requests and self.crawled < self.max_pages:
            url = self.pop()
            try:
                logger.info('Requesting %s' % url)
                try:
                    page = None
                    with gevent.timeout.Timeout(self.timeout, False):
                        page = Page(requests.get(url, headers=self.headers,
                            allow_redirects=self.allow_redirects))
                    if page is None:
                        logger.warn('Timed out fetching %s' % url)
                        raise TimeoutException('Url %s timed out' % url)
                except Exception as exc:
                    res = self.exception(url, exc)
                    if res:
                        self.results.append(res)
                    continue

                # Should we append these results?
                res = self.got(page)
                if res:
                    self.results.append(res)

                if self.count(page):
                    self.crawled += 1

                delay = None
                with gevent.timeout.Timeout(self.timeout, False):
                    delay = self.delay(page)
                    sleep(delay)
                if delay is None:
                    logger.warn('Timed out getting dealy for %s' % url)
            except Exception as exc:
                logger.exception('Failed to request %s' % url)

        self.after()
        return self.results

    def after(self):
        '''This is executed after we run the main crawl loop, befor returning'''
        pass

    def delay(self, page):
        '''How long to wait before sending the next request'''
        hostname = urlparse.urlparse(page.url).hostname
        if (hostname == 'localhost') or (hostname == '127.0.0.1'):
            # No delay if the request was to localhost
            return 0
        return 2

    def pop(self):
        '''Get the next url we should fetch'''
        return self.requests.pop(0)

    def extend(self, urls, page):
        '''Add these urls to the list of requests we have to make'''
        self.requests.extend(urls)
    
    def exception(self, url, exc):
        '''We encountered an exception when parsing this page'''
        pass
    
    def got(self, page):
        '''We fetched a page. Here is where you should decide what
        to do. Most likely, you'll add all the followable links to
        the requests you'll make. If you want something appended to
        the array returned by `run`, return that value here'''
        logger.info('Fetched %s' % page.url)
        if page.status in (301, 302, 303, 307):
            logger.info('Following redirect %s => %s' % (page.url, page.redirection))
            self.extend([page.redirection], page)
        else:
            self.extend(page.links['follow'], page)
        return None
    
    def count(self, page):
        '''Return true here if this request should count toward the 
        max number of pages.'''
        return page.status not in (301, 302, 303, 307)
    
import os
import sys
from django.db.backends.creation import BaseDatabaseCreation
from django.utils.six.moves import input

class DatabaseCreation(BaseDatabaseCreation):
    # SQLite doesn't actually support most of these types, but it "does the right
    # thing" given more verbose field definitions, so leave them as is so that
    # schema inspection is more useful.
    data_types = {
        'AutoField':                    'integer',
        'BinaryField':                  'BLOB',
        'BooleanField':                 'bool',
        'CharField':                    'varchar(%(max_length)s)',
        'CommaSeparatedIntegerField':   'varchar(%(max_length)s)',
        'DateField':                    'date',
        'DateTimeField':                'datetime',
        'DecimalField':                 'decimal',
        'FileField':                    'varchar(%(max_length)s)',
        'FilePathField':                'varchar(%(max_length)s)',
        'FloatField':                   'real',
        'IntegerField':                 'integer',
        'BigIntegerField':              'bigint',
        'IPAddressField':               'char(15)',
        'GenericIPAddressField':        'char(39)',
        'NullBooleanField':             'bool',
        'OneToOneField':                'integer',
        'PositiveIntegerField':         'integer unsigned',
        'PositiveSmallIntegerField':    'smallint unsigned',
        'SlugField':                    'varchar(%(max_length)s)',
        'SmallIntegerField':            'smallint',
        'TextField':                    'text',
        'TimeField':                    'time',
    }

    def sql_for_pending_references(self, model, style, pending_references):
        "SQLite3 doesn't support constraints"
        return []

    def sql_remove_table_constraints(self, model, references_to_delete, style):
        "SQLite3 doesn't support constraints"
        return []

    def _get_test_db_name(self):
        test_database_name = self.connection.settings_dict['TEST_NAME']
        if test_database_name and test_database_name != ':memory:':
            return test_database_name
        return ':memory:'

    def _create_test_db(self, verbosity, autoclobber):
        test_database_name = self._get_test_db_name()
        if test_database_name != ':memory:':
            # Erase the old test database
            if verbosity >= 1:
                print("Destroying old test database '%s'..." % self.connection.alias)
            if os.access(test_database_name, os.F_OK):
                if not autoclobber:
                    confirm = input("Type 'yes' if you would like to try deleting the test database '%s', or 'no' to cancel: " % test_database_name)
                if autoclobber or confirm == 'yes':
                    try:
                        os.remove(test_database_name)
                    except Exception as e:
                        sys.stderr.write("Got an error deleting the old test database: %s\n" % e)
                        sys.exit(2)
                else:
                    print("Tests cancelled.")
                    sys.exit(1)
        return test_database_name

    def _destroy_test_db(self, test_database_name, verbosity):
        if test_database_name and test_database_name != ":memory:":
            # Remove the SQLite database file
            os.remove(test_database_name)

    def test_db_signature(self):
        """
        Returns a tuple that uniquely identifies a test database.

        This takes into account the special cases of ":memory:" and "" for
        SQLite since the databases will be distinct despite having the same
        TEST_NAME. See http://www.sqlite.org/inmemorydb.html
        """
        settings_dict = self.connection.settings_dict
        test_dbname = self._get_test_db_name()
        sig = [self.connection.settings_dict['NAME']]
        if test_dbname == ':memory:':
            sig.append(self.connection.alias)
        return tuple(sig)

# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
# You can obtain one at http://mozilla.org/MPL/2.0/.

from auto_nag import utils
from auto_nag.bzcleaner import BzCleaner
from auto_nag.nag_me import Nag


class Tracking(BzCleaner, Nag):
    def __init__(self, channel, untouched):
        # since it's used in name() we must have it before to call parent ctor
        self.untouched = untouched
        super(Tracking, self).__init__()
        self.channel = channel
        self.assignees = {}
        if not self.init_versions():
            return

        self.version = self.versions[self.channel]

    def description(self):
        if self.untouched:
            return (
                "Bugs which are tracked in {} and untouched in the last 3 days".format(
                    self.channel
                )
            )

        return "Bugs which are tracked in {}".format(self.channel)

    def name(self):
        return "tracking" + ("_untouched" if self.untouched else "")

    def template(self):
        return "tracking.html"

    def nag_template(self):
        return "tracking_nag.html"

    def has_last_comment_time(self):
        return True

    def has_default_products(self):
        return False

    def has_needinfo(self):
        return True

    def has_assignee(self):
        return True

    def get_extra_for_template(self):
        return {
            "channel": "nightly" if self.channel == "central" else self.channel,
            "version": self.version,
            "untouched": self.untouched,
            "next_release": (utils.get_next_release_date() - self.nag_date).days,
        }

    def get_extra_for_nag_template(self):
        return self.get_extra_for_template()

    def columns(self):
        return ["id", "summary", "needinfos", "assignee", "last_comment"]

    def columns_nag(self):
        return ["id", "summary", "needinfos", "To", "last_comment"]

    def set_people_to_nag(self, bug, buginfo):
        priority = self.get_priority(bug)
        if not self.filter_bug(priority):
            return None

        assignee = bug["assigned_to"]
        real = bug["assigned_to_detail"]["real_name"]
        buginfo["to"] = assignee
        buginfo["To"] = real

        if not self.add(assignee, buginfo, priority=priority):
            self.add_no_manager(buginfo["id"])

        return bug

    def get_bz_params(self, date):
        status = utils.get_flag(self.version, "status", self.channel)
        self.tracking = utils.get_flag(self.version, "tracking", self.channel)
        tracking_value = (
            "+,blocking" if self.channel != "esr" else self.versions["beta"] + "+"
        )
        fields = [self.tracking]
        params = {
            "include_fields": fields,
            "f1": self.tracking,
            "o1": "anywords",
            "v1": tracking_value,
            "f2": status,
            "o2": "nowordssubstr",
            "v2": ",".join(["wontfix", "fixed", "disabled", "verified", "unaffected"]),
            "f3": self.tracking,
            "o3": "changedbefore",
            "v3": "-1d",
            "n4": 1,
            "f4": self.tracking,
            "o4": "changedafter",
            "v4": "-1d",
        }

        if self.channel == "central":
            tracking = utils.get_flag(self.versions["beta"], "tracking", "beta")
            params.update({"f5": tracking, "o5": "nowordssubstr", "v5": "+,blocking"})
        elif self.channel != "esr":
            approval = utils.get_flag(self.version, "approval", self.channel)
            params.update(
                {"f5": "flagtypes.name", "o5": "notsubstring", "v5": approval + "?"}
            )

        if self.untouched:
            params.update({"f6": "days_elapsed", "o6": "greaterthan", "v6": 3})

        return params


if __name__ == "__main__":
    Tracking("beta", False).run()
    Tracking("beta", True).run()
    Tracking("central", False).run()
    Tracking("central", True).run()
    Tracking("esr", False).run()

# Terribly useful debugging tweaks
import os
import sys
import pdb
import cgitb
import traceback

if sys.executable is None:
    # If sys.executable is None, it will cause an exception inside of
    # cgitb at this line:
    #  pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable
    sys.executable = "Jython?"

try:
    from java.lang import Throwable
    from net.gnehzr.tnoodle.utils import TNoodleLogging
    TNoodleLogging.initializeLogging()
except ImportError:
    Throwable = None
    # Do nothing, we're just running in pure python
    pass

def excepthook(etype, value, tb):
    # Added this line for debugging why https://travis-ci.org/cubing/tnoodle/builds/15966902
    # hit pdb instead of just printing a traceback and exiting.
    # Once that problem is solved, we can delete this code.
    print("Hit excepthook! stderr.isatty: %s stdin.isatty: %s stdout.isatty: %s" % (sys.stderr.isatty(), sys.stdin.isatty(), sys.stdout.isatty()))

    # Workaround for isatty weirdness mentioned above.
    isTravisCiBuild = os.environ.get('TRAVIS_BRANCH', None)
    if not sys.stdout.isatty() or not sys.stderr.isatty() or not sys.stdin.isatty() or isTravisCiBuild:
        # stdin, stdout, or stderr is redirected, so don't enter pdb
        sys.stderr.write(cgitb.text((etype, value, tb)))
    else:
        if tb:
            traceback.print_exception(etype, value, tb)
        if Throwable and issubclass(etype, Throwable):
            value.printStackTrace()
        pdb.post_mortem(tb)
sys.excepthook = excepthook

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable=no-self-use, pointless-statement, missing-docstring, invalid-name
import logging
import os
# io.open supports encoding= in python 2.7
from io import open  # pylint: disable=redefined-builtin

import babelfish
import six  # pylint:disable=wrong-import-order
import yaml  # pylint:disable=wrong-import-order
from rebulk.remodule import re
from rebulk.utils import is_iterable

from .. import guessit
from ..options import parse_options
from ..yamlutils import OrderedDictYAMLLoader

logger = logging.getLogger(__name__)

__location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))


class EntryResult(object):
    def __init__(self, string, negates=False):
        self.string = string
        self.negates = negates
        self.valid = []
        self.missing = []
        self.different = []
        self.extra = []
        self.others = []

    @property
    def ok(self):
        if self.negates:
            return self.missing or self.different
        return not self.missing and not self.different and not self.extra and not self.others

    @property
    def warning(self):
        if self.negates:
            return False
        return not self.missing and not self.different and self.extra

    @property
    def error(self):
        if self.negates:
            return not self.missing and not self.different and not self.others
        return self.missing or self.different or self.others

    def __repr__(self):
        if self.ok:
            return self.string + ': OK!'
        if self.warning:
            return '%s%s: WARNING! (valid=%i, extra=%i)' % ('-' if self.negates else '', self.string, len(self.valid),
                                                            len(self.extra))
        if self.error:
            return '%s%s: ERROR! (valid=%i, missing=%i, different=%i, extra=%i, others=%i)' % \
                   ('-' if self.negates else '', self.string, len(self.valid), len(self.missing), len(self.different),
                    len(self.extra), len(self.others))

        return '%s%s: UNKOWN! (valid=%i, missing=%i, different=%i, extra=%i, others=%i)' % \
               ('-' if self.negates else '', self.string, len(self.valid), len(self.missing), len(self.different),
                len(self.extra), len(self.others))

    @property
    def details(self):
        ret = []
        if self.valid:
            ret.append('valid=' + str(len(self.valid)))
        for valid in self.valid:
            ret.append(' ' * 4 + str(valid))
        if self.missing:
            ret.append('missing=' + str(len(self.missing)))
        for missing in self.missing:
            ret.append(' ' * 4 + str(missing))
        if self.different:
            ret.append('different=' + str(len(self.different)))
        for different in self.different:
            ret.append(' ' * 4 + str(different))
        if self.extra:
            ret.append('extra=' + str(len(self.extra)))
        for extra in self.extra:
            ret.append(' ' * 4 + str(extra))
        if self.others:
            ret.append('others=' + str(len(self.others)))
        for other in self.others:
            ret.append(' ' * 4 + str(other))
        return ret


class Results(list):
    def assert_ok(self):
        errors = [entry for entry in self if entry.error]
        assert not errors


def files_and_ids(predicate=None):
    files = []
    ids = []

    for (dirpath, _, filenames) in os.walk(__location__):
        if os.path.split(dirpath)[-1] == 'config':
            continue
        if dirpath == __location__:
            dirpath_rel = ''
        else:
            dirpath_rel = os.path.relpath(dirpath, __location__)
        for filename in filenames:
            name, ext = os.path.splitext(filename)
            filepath = os.path.join(dirpath_rel, filename)
            if ext == '.yml' and (not predicate or predicate(filepath)):
                files.append(filepath)
                ids.append(os.path.join(dirpath_rel, name))

    return files, ids


class TestYml(object):
    """
    Run tests from yaml files.
    Multiple input strings having same expected results can be chained.
    Use $ marker to check inputs that should not match results.
    """

    options_re = re.compile(r'^([ +-]+)(.*)')

    def _get_unique_id(self, collection, base_id):
        ret = base_id
        i = 2
        while ret in collection:
            suffix = "-" + str(i)
            ret = base_id + suffix
            i += 1
        return ret

    def pytest_generate_tests(self, metafunc):
        if 'yml_test_case' in metafunc.fixturenames:
            entries = []
            entry_ids = []
            entry_set = set()

            for filename, _ in zip(*files_and_ids()):
                with open(os.path.join(__location__, filename), 'r', encoding='utf-8') as infile:
                    data = yaml.load(infile, OrderedDictYAMLLoader)

                last_expected = None
                for string, expected in reversed(list(data.items())):
                    if expected is None:
                        data[string] = last_expected
                    else:
                        last_expected = expected

                default = None
                try:
                    default = data['__default__']
                    del data['__default__']
                except KeyError:
                    pass

                for string, expected in data.items():
                    TestYml.set_default(expected, default)
                    string = TestYml.fix_encoding(string, expected)

                    entries.append((filename, string, expected))
                    unique_id = self._get_unique_id(entry_set, '[' + filename + '] ' + str(string))
                    entry_set.add(unique_id)
                    entry_ids.append(unique_id)

            metafunc.parametrize('yml_test_case', entries, ids=entry_ids)

    @staticmethod
    def set_default(expected, default):
        if default:
            for k, v in default.items():
                if k not in expected:
                    expected[k] = v

    @classmethod
    def fix_encoding(cls, string, expected):
        if six.PY2:
            if isinstance(string, six.text_type):
                string = string.encode('utf-8')
            converts = []
            for k, v in expected.items():
                if isinstance(v, six.text_type):
                    v = v.encode('utf-8')
                    converts.append((k, v))
            for k, v in converts:
                expected[k] = v
        if not isinstance(string, str):
            string = str(string)
        return string

    def test_entry(self, yml_test_case):
        filename, string, expected = yml_test_case
        result = self.check_data(filename, string, expected)
        assert not result.error

    def check_data(self, filename, string, expected):
        entry = self.check(string, expected)
        if entry.ok:
            logger.debug('[%s] %s', filename, entry)
        elif entry.warning:
            logger.warning('[%s] %s', filename, entry)
        elif entry.error:
            logger.error('[%s] %s', filename, entry)
            for line in entry.details:
                logger.error('[%s] %s', filename, ' ' * 4 + line)
        return entry

    def check(self, string, expected):
        negates, global_, string = self.parse_token_options(string)

        options = expected.get('options')
        if options is None:
            options = {}
        if not isinstance(options, dict):
            options = parse_options(options)
        try:
            result = guessit(string, options)
        except Exception as exc:
            logger.error('[%s] Exception: %s', string, exc)
            raise exc

        entry = EntryResult(string, negates)

        if global_:
            self.check_global(string, result, entry)

        self.check_expected(result, expected, entry)

        return entry

    def parse_token_options(self, string):
        matches = self.options_re.search(string)
        negates = False
        global_ = False
        if matches:
            string = matches.group(2)
            for opt in matches.group(1):
                if '-' in opt:
                    negates = True
                if '+' in opt:
                    global_ = True
        return negates, global_, string

    def check_global(self, string, result, entry):
        global_span = []
        for result_matches in result.matches.values():
            for result_match in result_matches:
                if not global_span:
                    global_span = list(result_match.span)
                else:
                    if global_span[0] > result_match.span[0]:
                        global_span[0] = result_match.span[0]
                    if global_span[1] < result_match.span[1]:
                        global_span[1] = result_match.span[1]
        if global_span and global_span[1] - global_span[0] < len(string):
            entry.others.append("Match is not global")

    def is_same(self, value, expected):
        values = set(value) if is_iterable(value) else set((value,))
        expecteds = set(expected) if is_iterable(expected) else set((expected,))
        if len(values) != len(expecteds):
            return False
        if isinstance(next(iter(values)), babelfish.Language):
            # pylint: disable=no-member
            expecteds = {babelfish.Language.fromguessit(expected) for expected in expecteds}
        elif isinstance(next(iter(values)), babelfish.Country):
            # pylint: disable=no-member
            expecteds = {babelfish.Country.fromguessit(expected) for expected in expecteds}
        return values == expecteds

    def check_expected(self, result, expected, entry):
        if expected:
            for expected_key, expected_value in expected.items():
                if expected_key and expected_key != 'options' and expected_value is not None:
                    negates_key, _, result_key = self.parse_token_options(expected_key)
                    if result_key in result.keys():
                        if not self.is_same(result[result_key], expected_value):
                            if negates_key:
                                entry.valid.append((expected_key, expected_value))
                            else:
                                entry.different.append((expected_key, expected_value, result[result_key]))
                        else:
                            if negates_key:
                                entry.different.append((expected_key, expected_value, result[result_key]))
                            else:
                                entry.valid.append((expected_key, expected_value))
                    elif not negates_key:
                        entry.missing.append((expected_key, expected_value))

        for result_key, result_value in result.items():
            if result_key not in expected.keys():
                entry.extra.append((result_key, result_value))

import datetime
import unittest
from nose.tools import *  # flake8: noqa
from website.util import sanitize


class TestSanitize(unittest.TestCase):
    def test_escape_html(self):
        assert_equal(
            sanitize.clean_tag('<script> evil code </script>'),
            '&lt;script&gt; evil code &lt;/script&gt;',
        )
        assert_equal(
            sanitize.clean_tag('<img src=javascript:moreevil><img>'),
            '&lt;img src=&quot;javascript:moreevil&quot;&gt;&lt;img&gt;',
        )
        assert_equal(
            sanitize.clean_tag('<iframe src=evilsite>'),
            '&lt;iframe src=&quot;evilsite&quot;&gt;',
        )
        assert_equal(
            sanitize.clean_tag(');</span><script></script><span>'),
            ');&lt;/span&gt;&lt;script&gt;&lt;/script&gt;&lt;span&gt;',
        )

    def test_clean_tag(self):
        assert_equal(
            sanitize.clean_tag('\'\'\'\'\'"""""""<script></script>'),
            '&#39&#39&#39&#39&#39&quot;&quot;&quot;&quot;&quot;&quot;&quot;&lt;script&gt;&lt;/script&gt;',
        )

    def test_strip_html(self):
        assert_equal(
            sanitize.strip_html('<foo>bar</foo>'),
            'bar'
        )
        assert_equal(
            sanitize.strip_html(b'<foo>bar</foo>'),
            'bar'
        )

    def test_strip_html_on_non_strings_returns_original_value(self):
        assert_true(sanitize.strip_html(True))
        assert_false(sanitize.strip_html(False))

        assert_equal(sanitize.strip_html(12), 12)
        assert_equal(sanitize.strip_html(12.3), 12.3)

        dtime = datetime.datetime.now()
        assert_equal(sanitize.strip_html(dtime), dtime)

    def test_strip_html_sanitizes_collection_types_as_strings(self):
        assert_equal(sanitize.strip_html({'foo': '<b>bar</b>'}), "{'foo': 'bar'}")
        assert_equal(sanitize.strip_html(['<em>baz</em>']), "['baz']")

    def test_unescape_html(self):
        assert_equal(
            sanitize.unescape_entities('&lt;&gt; diamonds &amp; diamonds &lt;&gt;'),
            '&lt;&gt; diamonds & diamonds &lt;&gt;'
        )
        assert_equal(
            sanitize.unescape_entities(['&lt;&gt;&amp;'])[0],
            '&lt;&gt;&'
        )
        assert_equal(
            sanitize.unescape_entities(('&lt;&gt;&amp;', ))[0],
            '&lt;&gt;&'
        )
        assert_equal(
            sanitize.unescape_entities({'key': '&lt;&gt;&amp;'})['key'],
            '&lt;&gt;&'
        )

    def test_safe_json(self):
        """Add escaping of forward slashes, but only where string literal contains closing markup"""
        assert_equal(
            sanitize.safe_json("I'm a string with / containing </closingtags>"),
                               '"I\'m a string with / containing <\\/closingtags>"'
        )

#!/usr/bin/env python
"""Prints type-coercion tables for the built-in NumPy types

"""
from __future__ import division, absolute_import, print_function

import numpy as np

# Generic object that can be added, but doesn't do anything else
class GenericObject(object):
    def __init__(self, v):
        self.v = v

    def __add__(self, other):
        return self

    def __radd__(self, other):
        return self

    dtype = np.dtype('O')

def print_cancast_table(ntypes):
    print('X', end=' ')
    for char in ntypes: print(char, end=' ')
    print()
    for row in ntypes:
        print(row, end=' ')
        for col in ntypes:
            print(int(np.can_cast(row, col)), end=' ')
        print()

def print_coercion_table(ntypes, inputfirstvalue, inputsecondvalue, firstarray, use_promote_types=False):
    print('+', end=' ')
    for char in ntypes: print(char, end=' ')
    print()
    for row in ntypes:
        if row == 'O':
            rowtype = GenericObject
        else:
            rowtype = np.obj2sctype(row)

        print(row, end=' ')
        for col in ntypes:
            if col == 'O':
                coltype = GenericObject
            else:
                coltype = np.obj2sctype(col)
            try:
                if firstarray:
                    rowvalue = np.array([rowtype(inputfirstvalue)], dtype=rowtype)
                else:
                    rowvalue = rowtype(inputfirstvalue)
                colvalue = coltype(inputsecondvalue)
                if use_promote_types:
                    char = np.promote_types(rowvalue.dtype, colvalue.dtype).char
                else:
                    value = np.add(rowvalue, colvalue)
                    if isinstance(value, np.ndarray):
                        char = value.dtype.char
                    else:
                        char = np.dtype(type(value)).char
            except ValueError:
                char = '!'
            except OverflowError:
                char = '@'
            except TypeError:
                char = '#'
            print(char, end=' ')
        print()

print("can cast")
print_cancast_table(np.typecodes['All'])
print()
print("In these tables, ValueError is '!', OverflowError is '@', TypeError is '#'")
print()
print("scalar + scalar")
print_coercion_table(np.typecodes['All'], 0, 0, False)
print()
print("scalar + neg scalar")
print_coercion_table(np.typecodes['All'], 0, -1, False)
print()
print("array + scalar")
print_coercion_table(np.typecodes['All'], 0, 0, True)
print()
print("array + neg scalar")
print_coercion_table(np.typecodes['All'], 0, -1, True)
print()
print("promote_types")
print_coercion_table(np.typecodes['All'], 0, 0, False, True)


# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt

from __future__ import unicode_literals
import frappe
from frappe import _
from frappe.utils import flt, getdate, add_days, formatdate
from frappe.model.document import Document
from datetime import date
from erpnext.controllers.item_variant import ItemTemplateCannotHaveStock
from erpnext.accounts.utils import get_fiscal_year

class StockFreezeError(frappe.ValidationError): pass

exclude_from_linked_with = True

class StockLedgerEntry(Document):
	def validate(self):
		self.flags.ignore_submit_comment = True
		from erpnext.stock.utils import validate_warehouse_company
		self.validate_mandatory()
		self.validate_item()
		self.validate_batch()
		validate_warehouse_company(self.warehouse, self.company)
		self.scrub_posting_time()
		self.validate_and_set_fiscal_year()
		self.block_transactions_against_group_warehouse()

	def on_submit(self):
		self.check_stock_frozen_date()
		self.actual_amt_check()

		if not self.get("via_landed_cost_voucher") and self.voucher_type != 'Stock Reconciliation':
			from erpnext.stock.doctype.serial_no.serial_no import process_serial_no
			process_serial_no(self)

	#check for item quantity available in stock
	def actual_amt_check(self):
		if self.batch_no and not self.get("allow_negative_stock"):
			batch_bal_after_transaction = flt(frappe.db.sql("""select sum(actual_qty)
				from `tabStock Ledger Entry`
				where warehouse=%s and item_code=%s and batch_no=%s""",
				(self.warehouse, self.item_code, self.batch_no))[0][0])

			if batch_bal_after_transaction < 0:
				frappe.throw(_("Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3}")
					.format(self.batch_no, batch_bal_after_transaction, self.item_code, self.warehouse))

	def validate_mandatory(self):
		mandatory = ['warehouse','posting_date','voucher_type','voucher_no','company']
		for k in mandatory:
			if not self.get(k):
				frappe.throw(_("{0} is required").format(self.meta.get_label(k)))

		if self.voucher_type != "Stock Reconciliation" and not self.actual_qty:
			frappe.throw(_("Actual Qty is mandatory"))

	def validate_item(self):
		item_det = frappe.db.sql("""select name, has_batch_no, docstatus,
			is_stock_item, has_variants, stock_uom, create_new_batch
			from tabItem where name=%s""", self.item_code, as_dict=True)

		if not item_det:
			frappe.throw(_("Item {0} not found").format(self.item_code))

		item_det = item_det[0]

		if item_det.is_stock_item != 1:
			frappe.throw(_("Item {0} must be a stock Item").format(self.item_code))

		# check if batch number is required
		if self.voucher_type != 'Stock Reconciliation':
			if item_det.has_batch_no ==1:
				if not self.batch_no:
					frappe.throw(_("Batch number is mandatory for Item {0}").format(self.item_code))
				elif not frappe.db.get_value("Batch",{"item": self.item_code, "name": self.batch_no}):
					frappe.throw(_("{0} is not a valid Batch Number for Item {1}").format(self.batch_no, self.item_code))

			elif item_det.has_batch_no ==0 and self.batch_no and self.is_cancelled == "No":
				frappe.throw(_("The Item {0} cannot have Batch").format(self.item_code))

		if item_det.has_variants:
			frappe.throw(_("Stock cannot exist for Item {0} since has variants").format(self.item_code),
				ItemTemplateCannotHaveStock)

		self.stock_uom = item_det.stock_uom

	def check_stock_frozen_date(self):
		stock_frozen_upto = frappe.db.get_value('Stock Settings', None, 'stock_frozen_upto') or ''
		if stock_frozen_upto:
			stock_auth_role = frappe.db.get_value('Stock Settings', None,'stock_auth_role')
			if getdate(self.posting_date) <= getdate(stock_frozen_upto) and not stock_auth_role in frappe.get_roles():
				frappe.throw(_("Stock transactions before {0} are frozen").format(formatdate(stock_frozen_upto)), StockFreezeError)

		stock_frozen_upto_days = int(frappe.db.get_value('Stock Settings', None, 'stock_frozen_upto_days') or 0)
		if stock_frozen_upto_days:
			stock_auth_role = frappe.db.get_value('Stock Settings', None,'stock_auth_role')
			older_than_x_days_ago = (add_days(getdate(self.posting_date), stock_frozen_upto_days) <= date.today())
			if older_than_x_days_ago and not stock_auth_role in frappe.get_roles():
				frappe.throw(_("Not allowed to update stock transactions older than {0}").format(stock_frozen_upto_days), StockFreezeError)

	def scrub_posting_time(self):
		if not self.posting_time or self.posting_time == '00:0':
			self.posting_time = '00:00'

	def validate_batch(self):
		if self.batch_no and self.voucher_type != "Stock Entry":
			expiry_date = frappe.db.get_value("Batch", self.batch_no, "expiry_date")
			if expiry_date:
				if getdate(self.posting_date) > getdate(expiry_date):
					frappe.throw(_("Batch {0} of Item {1} has expired.").format(self.batch_no, self.item_code))

	def validate_and_set_fiscal_year(self):
		if not self.fiscal_year:
			self.fiscal_year = get_fiscal_year(self.posting_date, company=self.company)[0]
		else:
			from erpnext.accounts.utils import validate_fiscal_year
			validate_fiscal_year(self.posting_date, self.fiscal_year, self.company,
				self.meta.get_label("posting_date"), self)

	def block_transactions_against_group_warehouse(self):
		from erpnext.stock.utils import is_group_warehouse
		is_group_warehouse(self.warehouse)

def on_doctype_update():
	if not frappe.db.sql("""show index from `tabStock Ledger Entry`
		where Key_name="posting_sort_index" """):
		frappe.db.commit()
		frappe.db.sql("""alter table `tabStock Ledger Entry`
			add index posting_sort_index(posting_date, posting_time, name)""")

	frappe.db.add_index("Stock Ledger Entry", ["voucher_no", "voucher_type"])
	frappe.db.add_index("Stock Ledger Entry", ["batch_no", "item_code", "warehouse"])


# -*- coding: utf-8 -*-

# crunchyfrog - a database schema browser and query tool
# Copyright (C) 2009 Andi Albrecht <albrecht.andi@gmail.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""Data source URL"""

import logging
import urlparse
try:
    from urlparse import parse_qsl
except ImportError:
    from cgi import parse_qsl

import cf.db

def _initialize():
    # Customize urlparse
    global _intialized
    if _initialized:
        return
    [urlparse.uses_netloc.append(drivername)
     for drivername in cf.db.DIALECTS
     if drivername not in urlparse.uses_netloc]

    [urlparse.uses_query.append(drivername)
     for drivername in cf.db.DIALECTS
     if drivername not in urlparse.uses_query]

    _intialized = True

_initialized = False


class URL(object):

    def __init__(self, drivername, user=None, password=None,
                 host=None, port=None, database=None, **kwds):
        self.drivername = drivername
        self.user = user
        self.password = password
        self.host = host
        self.port = self._clean_port(port)
        self.database = database
        self.query = kwds
        _initialize()

    def _get_username(self):
        return self.user

    def _set_username(self, username):
        self.user = username

    username = property(fget=_get_username, fset=_set_username)

    def __str__(self):
        netloc = ''
        if self.user:
            netloc += self.user
        if self.password:
            netloc += ':%s' % self.password
        if self.user:
            netloc += '@'
        if self.host:
            netloc += self.host
        if self.port:
            netloc += ':%s' % self.port
        if self.database and self.database.startswith('/'):
            netloc += '/'
        if self.query:
            query = '%s' % '&'.join(['%s=%s' % (k, v)
                                     for k, v in self.query.iteritems()])
        else:
            query = None
        return urlparse.urlunsplit((self.drivername, netloc,
                                    self.database or '', query, None))

    @classmethod
    def _clean_port(cls, port):
        """Return port as integer or None."""
        if port is None:
            return port
        if not isinstance(port, int):
            try:
                port = int(port)
            except (TypeError, ValueError), err:
                port = None
                logging.exception('Failed to convert port to int %r: %s',
                                  port, err)
        return port

    def get_dict(self):
        """Return instance values as dictionary."""
        data = {}
        if self.user:
            data['username'] = self.user
        if self.password:
            data['password'] = self.password
        if self.host:
            data['host'] = self.host
        if self.port:
            data['port'] = self.port
        if self.database:
            data['database'] = self.database
        data.update(self.query)
        return data


def make_url(raw):
    """Create URL from string."""
    _initialize()
    parsed = urlparse.urlsplit(raw)
    if (parsed.path and parsed.path.startswith('/')
        and not parsed.path.startswith('//')):
        database = parsed.path[1:]
    else:
        database = parsed.path or None
    if database and database.startswith('//'):
        database = database[1:]
    if parsed.query:
        kwds = dict(parse_qsl(parsed.query))
    else:
        kwds = {}
    # The following try-except block cleans up bad data that may life
    # in the datasource configuration file (see issue70).
    try:
        port = parsed.port
    except ValueError:
        port = None
    return URL(parsed.scheme,
               parsed.username or None, parsed.password or None,
               parsed.hostname or None, port or None,
               database, **kwds)

# Copyright © 2016, Ugo Pozo
#             2016, Câmara Municipal de São Paulo

# utils.py - utility views.

# This file is part of Anubis.

# Anubis is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.

# Anubis is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.

from rest_framework.views import exception_handler as rest_exception_handler
from rest_framework.response import Response

from django.conf import settings

def exception_handler(exc, context):
    response = rest_exception_handler(exc, context)

    if response is None:
        if hasattr(exc, "name") and callable(exc.name):
            name = exc.name()
        else:
            name = exc.__class__.__name__

        response = {
            "detail": str(exc),
            "name": name
        }

        if settings.DEBUG:
            import traceback

            response['traceback'] = traceback.format_tb(exc.__traceback__)

        response = Response(response)
    else:
        response.data["name"] = exc.__class__.__name__

    response.status_code = 500

    return response


from socketio.namespace import BaseNamespace
from socketio import socketio_manage
from socketio.mixins import BroadcastMixin


def index(request):
    """ Base view to load our template """
    return {}


class NamedUsersRoomsMixin(BroadcastMixin):
    def __init__(self, *args, **kwargs):
        super(NamedUsersRoomsMixin, self).__init__(*args, **kwargs)
        if 'rooms' not in self.session:
            self.session['rooms'] = set()  # a set of simple strings
            self.session['nickname'] = 'guest123'

    def join(self, room):
        """Lets a user join a room on a specific Namespace."""
        self.socket.rooms.add(self._get_room_name(room))

    def leave(self, room):
        """Lets a user leave a room on a specific Namespace."""
        self.socket.rooms.remove(self._get_room_name(room))

    def _get_room_name(self, room):
        return self.ns_name + '_' + room

    def emit_to_room(self, event, args, room):
        """This is sent to all in the room (in this particular Namespace)"""
        pkt = dict(type="event",
                   name=event,
                   args=args,
                   endpoint=self.ns_name)
        room_name = self._get_room_name(room)
        for sessid, socket in self.socket.server.sockets.iteritems():
            if not hasattr(socket, 'rooms'):
                continue
            if room_name in socket.rooms:
                socket.send_packet(pkt)


class ChatNamespace(BaseNamespace, NamedUsersRoomsMixin):
    def on_chat(self, msg):
        self.broadcast_event('chat', msg)

    def recv_connect(self):
        self.broadcast_event('user_connect')

    def recv_disconnect(self):
        self.broadcast_event('user_disconnect')
        self.disconnect(silent=True)

    def on_join(self, channel):
        self.join(channel)



from pyramid.response import Response
def socketio_service(request):
    socketio_manage(request.environ,
                    {'/chat': ChatNamespace},
                    request=request)

    return Response('')


# coding=utf-8

"""
Collects Cassandra JMX metrics from the Jolokia Agent.  Extends the
JolokiaCollector to interpret Histogram beans with information about the
distribution of request latencies.

#### Example Configuration
CassandraJolokiaCollector uses a regular expression to determine which
attributes represent histograms. This regex can be overridden by providing a
`histogram_regex` in your configuration.  You can also override `percentiles` to
collect specific percentiles from the histogram statistics.  The format is shown
below with the default values.

CassandraJolokiaCollector.conf

```
    percentiles '50,95,99'
    histogram_regex '.*HistogramMicros$'
```
"""

from jolokia import JolokiaCollector
import math
import string
import re


class CassandraJolokiaCollector(JolokiaCollector):
    # override to allow setting which percentiles will be collected

    def get_default_config_help(self):
        config_help = super(CassandraJolokiaCollector,
                            self).get_default_config_help()
        config_help.update({
            'percentiles':
            'Comma separated list of percentiles to be collected '
            '(e.g., "50,95,99").',
            'histogram_regex':
            'Filter to only process attributes that match this regex'
        })
        return config_help

    # override to allow setting which percentiles will be collected
    def get_default_config(self):
        config = super(CassandraJolokiaCollector, self).get_default_config()
        config.update({
            'percentiles': ['50', '95', '99'],
            'histogram_regex': '.*HistogramMicros$'
        })
        return config

    def __init__(self, *args, **kwargs):
        super(CassandraJolokiaCollector, self).__init__(*args, **kwargs)
        self.offsets = self.create_offsets(91)
        self.update_config(self.config)

    def update_config(self, config):
        if 'percentiles' in config:
            self.percentiles = map(int, config['percentiles'])
        if 'histogram_regex' in config:
            self.histogram_regex = re.compile(config['histogram_regex'])

    # override: Interpret beans that match the `histogram_regex` as histograms,
    # and collect percentiles from them.
    def interpret_bean_with_list(self, prefix, values):
        if not self.histogram_regex.match(prefix):
            return

        buckets = values
        offsets = self.offsets
        for percentile in self.percentiles:
            value = self.compute_percentile(offsets, buckets, percentile)
            cleaned_key = self.clean_up("%s.p%s" % (prefix, percentile))
            self.publish(cleaned_key, value)

    # Adapted from Cassandra docs:
    # https://bit.ly/13M5JPE
    # The index corresponds to the x-axis in a histogram.  It represents buckets
    # of values, which are a series of ranges. Each offset includes the range of
    # values greater than the previous offset and less than or equal to the
    # current offset. The offsets start at 1 and each subsequent offset is
    # calculated by multiplying the previous offset by 1.2, rounding up, and
    # removing duplicates. The offsets can range from 1 to approximately 25
    # million, with less precision as the offsets get larger.
    def compute_percentile(self, offsets, buckets, percentile_int):
        non_zero_points_sum = sum(buckets)
        if non_zero_points_sum is 0:
            return 0
        middle_point_index = math.floor(
            non_zero_points_sum * (percentile_int / float(100)))

        points_seen = 0
        for index, bucket in enumerate(buckets):
            points_seen += bucket
            if points_seen >= middle_point_index:
                return round((offsets[index] - offsets[index - 1]) / 2)

    # Returns a list of offsets for `n` buckets.
    def create_offsets(self, bucket_count):
        last_num = 1
        offsets = [last_num]

        for index in range(bucket_count):
            next_num = round(last_num * 1.2)
            if next_num == last_num:
                next_num += 1
            offsets.append(next_num)
            last_num = next_num

        return offsets

import re
import sys
from decimal import Decimal

from django.contrib.gis.db.backends.base import BaseSpatialOperations
from django.contrib.gis.db.backends.util import SpatialOperation, SpatialFunction
from django.contrib.gis.db.backends.spatialite.adapter import SpatiaLiteAdapter
from django.contrib.gis.geometry.backend import Geometry
from django.contrib.gis.measure import Distance
from django.core.exceptions import ImproperlyConfigured
from django.db.backends.sqlite3.base import DatabaseOperations
from django.db.utils import DatabaseError
from django.utils import six
from django.utils.functional import cached_property


class SpatiaLiteOperator(SpatialOperation):
    "For SpatiaLite operators (e.g. `&&`, `~`)."
    def __init__(self, operator):
        super(SpatiaLiteOperator, self).__init__(operator=operator)

class SpatiaLiteFunction(SpatialFunction):
    "For SpatiaLite function calls."
    def __init__(self, function, **kwargs):
        super(SpatiaLiteFunction, self).__init__(function, **kwargs)

class SpatiaLiteFunctionParam(SpatiaLiteFunction):
    "For SpatiaLite functions that take another parameter."
    sql_template = '%(function)s(%(geo_col)s, %(geometry)s, %%s)'

class SpatiaLiteDistance(SpatiaLiteFunction):
    "For SpatiaLite distance operations."
    dist_func = 'Distance'
    sql_template = '%(function)s(%(geo_col)s, %(geometry)s) %(operator)s %%s'

    def __init__(self, operator):
        super(SpatiaLiteDistance, self).__init__(self.dist_func,
                                                 operator=operator)

class SpatiaLiteRelate(SpatiaLiteFunctionParam):
    "For SpatiaLite Relate(<geom>, <pattern>) calls."
    pattern_regex = re.compile(r'^[012TF\*]{9}$')
    def __init__(self, pattern):
        if not self.pattern_regex.match(pattern):
            raise ValueError('Invalid intersection matrix pattern "%s".' % pattern)
        super(SpatiaLiteRelate, self).__init__('Relate')

# Valid distance types and substitutions
dtypes = (Decimal, Distance, float) + six.integer_types
def get_dist_ops(operator):
    "Returns operations for regular distances; spherical distances are not currently supported."
    return (SpatiaLiteDistance(operator),)

class SpatiaLiteOperations(DatabaseOperations, BaseSpatialOperations):
    compiler_module = 'django.contrib.gis.db.models.sql.compiler'
    name = 'spatialite'
    spatialite = True
    version_regex = re.compile(r'^(?P<major>\d)\.(?P<minor1>\d)\.(?P<minor2>\d+)')
    valid_aggregates = dict([(k, None) for k in ('Extent', 'Union')])

    Adapter = SpatiaLiteAdapter
    Adaptor = Adapter # Backwards-compatibility alias.

    area = 'Area'
    centroid = 'Centroid'
    contained = 'MbrWithin'
    difference = 'Difference'
    distance = 'Distance'
    envelope = 'Envelope'
    intersection = 'Intersection'
    length = 'GLength' # OpenGis defines Length, but this conflicts with an SQLite reserved keyword
    num_geom = 'NumGeometries'
    num_points = 'NumPoints'
    point_on_surface = 'PointOnSurface'
    scale = 'ScaleCoords'
    svg = 'AsSVG'
    sym_difference = 'SymDifference'
    transform = 'Transform'
    translate = 'ShiftCoords'
    union = 'GUnion' # OpenGis defines Union, but this conflicts with an SQLite reserved keyword
    unionagg = 'GUnion'

    from_text = 'GeomFromText'
    from_wkb = 'GeomFromWKB'
    select = 'AsText(%s)'

    geometry_functions = {
        'equals' : SpatiaLiteFunction('Equals'),
        'disjoint' : SpatiaLiteFunction('Disjoint'),
        'touches' : SpatiaLiteFunction('Touches'),
        'crosses' : SpatiaLiteFunction('Crosses'),
        'within' : SpatiaLiteFunction('Within'),
        'overlaps' : SpatiaLiteFunction('Overlaps'),
        'contains' : SpatiaLiteFunction('Contains'),
        'intersects' : SpatiaLiteFunction('Intersects'),
        'relate' : (SpatiaLiteRelate, six.string_types),
        # Returns true if B's bounding box completely contains A's bounding box.
        'contained' : SpatiaLiteFunction('MbrWithin'),
        # Returns true if A's bounding box completely contains B's bounding box.
        'bbcontains' : SpatiaLiteFunction('MbrContains'),
        # Returns true if A's bounding box overlaps B's bounding box.
        'bboverlaps' : SpatiaLiteFunction('MbrOverlaps'),
        # These are implemented here as synonyms for Equals
        'same_as' : SpatiaLiteFunction('Equals'),
        'exact' : SpatiaLiteFunction('Equals'),
        }

    distance_functions = {
        'distance_gt' : (get_dist_ops('>'), dtypes),
        'distance_gte' : (get_dist_ops('>='), dtypes),
        'distance_lt' : (get_dist_ops('<'), dtypes),
        'distance_lte' : (get_dist_ops('<='), dtypes),
        }
    geometry_functions.update(distance_functions)

    def __init__(self, connection):
        super(DatabaseOperations, self).__init__(connection)

        # Creating the GIS terms dictionary.
        self.gis_terms = set(['isnull'])
        self.gis_terms.update(self.geometry_functions)

    @cached_property
    def spatial_version(self):
        """Determine the version of the SpatiaLite library."""
        try:
            version = self.spatialite_version_tuple()[1:]
        except Exception as msg:
            new_msg = (
                'Cannot determine the SpatiaLite version for the "%s" '
                'database (error was "%s").  Was the SpatiaLite initialization '
                'SQL loaded on this database?') % (self.connection.settings_dict['NAME'], msg)
            six.reraise(ImproperlyConfigured, ImproperlyConfigured(new_msg), sys.exc_info()[2])
        if version < (2, 3, 0):
            raise ImproperlyConfigured('GeoDjango only supports SpatiaLite versions '
                                       '2.3.0 and above')
        return version

    @property
    def _version_greater_2_4_0_rc4(self):
        if self.spatial_version >= (2, 4, 1):
            return True
        elif self.spatial_version < (2, 4, 0):
            return False
        else:
            # Spatialite 2.4.0-RC4 added AsGML and AsKML, however both
            # RC2 (shipped in popular Debian/Ubuntu packages) and RC4
            # report version as '2.4.0', so we fall back to feature detection
            try:
                self._get_spatialite_func("AsGML(GeomFromText('POINT(1 1)'))")
            except DatabaseError:
                return False
            return True

    @cached_property
    def gml(self):
        return 'AsGML' if self._version_greater_2_4_0_rc4 else None

    @cached_property
    def kml(self):
        return 'AsKML' if self._version_greater_2_4_0_rc4 else None

    @cached_property
    def geojson(self):
        return 'AsGeoJSON' if self.spatial_version >= (3, 0, 0) else None

    def check_aggregate_support(self, aggregate):
        """
        Checks if the given aggregate name is supported (that is, if it's
        in `self.valid_aggregates`).
        """
        agg_name = aggregate.__class__.__name__
        return agg_name in self.valid_aggregates

    def convert_geom(self, wkt, geo_field):
        """
        Converts geometry WKT returned from a SpatiaLite aggregate.
        """
        if wkt:
            return Geometry(wkt, geo_field.srid)
        else:
            return None

    def geo_db_type(self, f):
        """
        Returns None because geometry columnas are added via the
        `AddGeometryColumn` stored procedure on SpatiaLite.
        """
        return None

    def get_distance(self, f, value, lookup_type):
        """
        Returns the distance parameters for the given geometry field,
        lookup value, and lookup type.  SpatiaLite only supports regular
        cartesian-based queries (no spheroid/sphere calculations for point
        geometries like PostGIS).
        """
        if not value:
            return []
        value = value[0]
        if isinstance(value, Distance):
            if f.geodetic(self.connection):
                raise ValueError('SpatiaLite does not support distance queries on '
                                 'geometry fields with a geodetic coordinate system. '
                                 'Distance objects; use a numeric value of your '
                                 'distance in degrees instead.')
            else:
                dist_param = getattr(value, Distance.unit_attname(f.units_name(self.connection)))
        else:
            dist_param = value
        return [dist_param]

    def get_geom_placeholder(self, f, value):
        """
        Provides a proper substitution value for Geometries that are not in the
        SRID of the field.  Specifically, this routine will substitute in the
        Transform() and GeomFromText() function call(s).
        """
        def transform_value(value, srid):
            return not (value is None or value.srid == srid)
        if hasattr(value, 'expression'):
            if transform_value(value, f.srid):
                placeholder = '%s(%%s, %s)' % (self.transform, f.srid)
            else:
                placeholder = '%s'
            # No geometry value used for F expression, substitue in
            # the column name instead.
            return placeholder % self.get_expression_column(value)
        else:
            if transform_value(value, f.srid):
                # Adding Transform() to the SQL placeholder.
                return '%s(%s(%%s,%s), %s)' % (self.transform, self.from_text, value.srid, f.srid)
            else:
                return '%s(%%s,%s)' % (self.from_text, f.srid)

    def _get_spatialite_func(self, func):
        """
        Helper routine for calling SpatiaLite functions and returning
        their result.
        """
        cursor = self.connection._cursor()
        try:
            try:
                cursor.execute('SELECT %s' % func)
                row = cursor.fetchone()
            except:
                # Responsibility of caller to perform error handling.
                raise
        finally:
            cursor.close()
        return row[0]

    def geos_version(self):
        "Returns the version of GEOS used by SpatiaLite as a string."
        return self._get_spatialite_func('geos_version()')

    def proj4_version(self):
        "Returns the version of the PROJ.4 library used by SpatiaLite."
        return self._get_spatialite_func('proj4_version()')

    def spatialite_version(self):
        "Returns the SpatiaLite library version as a string."
        return self._get_spatialite_func('spatialite_version()')

    def spatialite_version_tuple(self):
        """
        Returns the SpatiaLite version as a tuple (version string, major,
        minor, subminor).
        """
        # Getting the SpatiaLite version.
        try:
            version = self.spatialite_version()
        except DatabaseError:
            # The `spatialite_version` function first appeared in version 2.3.1
            # of SpatiaLite, so doing a fallback test for 2.3.0 (which is
            # used by popular Debian/Ubuntu packages).
            version = None
            try:
                tmp = self._get_spatialite_func("X(GeomFromText('POINT(1 1)'))")
                if tmp == 1.0: version = '2.3.0'
            except DatabaseError:
                pass
            # If no version string defined, then just re-raise the original
            # exception.
            if version is None: raise

        m = self.version_regex.match(version)
        if m:
            major = int(m.group('major'))
            minor1 = int(m.group('minor1'))
            minor2 = int(m.group('minor2'))
        else:
            raise Exception('Could not parse SpatiaLite version string: %s' % version)

        return (version, major, minor1, minor2)

    def spatial_aggregate_sql(self, agg):
        """
        Returns the spatial aggregate SQL template and function for the
        given Aggregate instance.
        """
        agg_name = agg.__class__.__name__
        if not self.check_aggregate_support(agg):
            raise NotImplementedError('%s spatial aggregate is not implmented for this backend.' % agg_name)
        agg_name = agg_name.lower()
        if agg_name == 'union': agg_name += 'agg'
        sql_template = self.select % '%(function)s(%(field)s)'
        sql_function = getattr(self, agg_name)
        return sql_template, sql_function

    def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn):
        """
        Returns the SpatiaLite-specific SQL for the given lookup value
        [a tuple of (alias, column, db_type)], lookup type, lookup
        value, the model field, and the quoting function.
        """
        alias, col, db_type = lvalue

        # Getting the quoted field as `geo_col`.
        geo_col = '%s.%s' % (qn(alias), qn(col))

        if lookup_type in self.geometry_functions:
            # See if a SpatiaLite geometry function matches the lookup type.
            tmp = self.geometry_functions[lookup_type]

            # Lookup types that are tuples take tuple arguments, e.g., 'relate' and
            # distance lookups.
            if isinstance(tmp, tuple):
                # First element of tuple is the SpatiaLiteOperation instance, and the
                # second element is either the type or a tuple of acceptable types
                # that may passed in as further parameters for the lookup type.
                op, arg_type = tmp

                # Ensuring that a tuple _value_ was passed in from the user
                if not isinstance(value, (tuple, list)):
                    raise ValueError('Tuple required for `%s` lookup type.' % lookup_type)

                # Geometry is first element of lookup tuple.
                geom = value[0]

                # Number of valid tuple parameters depends on the lookup type.
                if len(value) != 2:
                    raise ValueError('Incorrect number of parameters given for `%s` lookup type.' % lookup_type)

                # Ensuring the argument type matches what we expect.
                if not isinstance(value[1], arg_type):
                    raise ValueError('Argument type should be %s, got %s instead.' % (arg_type, type(value[1])))

                # For lookup type `relate`, the op instance is not yet created (has
                # to be instantiated here to check the pattern parameter).
                if lookup_type == 'relate':
                    op = op(value[1])
                elif lookup_type in self.distance_functions:
                    op = op[0]
            else:
                op = tmp
                geom = value
            # Calling the `as_sql` function on the operation instance.
            return op.as_sql(geo_col, self.get_geom_placeholder(field, geom))
        elif lookup_type == 'isnull':
            # Handling 'isnull' lookup type
            return "%s IS %sNULL" % (geo_col, ('' if value else 'NOT ')), []

        raise TypeError("Got invalid lookup_type: %s" % repr(lookup_type))

    # Routines for getting the OGC-compliant models.
    def geometry_columns(self):
        from django.contrib.gis.db.backends.spatialite.models import GeometryColumns
        return GeometryColumns

    def spatial_ref_sys(self):
        from django.contrib.gis.db.backends.spatialite.models import SpatialRefSys
        return SpatialRefSys

# Copyright 2016 Letv Cloud Computing
# All Rights Reserved.
#
#    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.

from collections import OrderedDict

from django.core.urlresolvers import reverse
from django.core.urlresolvers import reverse_lazy
from django.utils.translation import ugettext_lazy as _
import netaddr

from horizon import exceptions
from horizon import forms
from horizon import tables
from horizon.utils import memoized
from horizon import views

from openstack_dashboard import api

from openstack_dashboard.dashboards.admin.floating_ips \
    import forms as fip_forms
from openstack_dashboard.dashboards.admin.floating_ips \
    import tables as fip_tables
from openstack_dashboard.dashboards.project.access_and_security.\
    floating_ips import tables as project_tables


def get_floatingip_pools(request):
    pools = []
    try:
        search_opts = {'router:external': True}
        pools = api.neutron.network_list(request, **search_opts)
    except Exception:
        exceptions.handle(request,
                          _("Unable to retrieve floating IP pools."))
    return pools


def get_tenant_list(request):
    tenants = []
    try:
        tenants, has_more = api.keystone.tenant_list(request)
    except Exception:
        msg = _('Unable to retrieve project list.')
        exceptions.handle(request, msg)
    return tenants


class IndexView(tables.DataTableView):
    table_class = fip_tables.FloatingIPsTable
    template_name = 'admin/floating_ips/index.html'
    page_title = _("Floating IPs")

    @memoized.memoized_method
    def get_data(self):
        floating_ips = []
        try:
            floating_ips = api.network.tenant_floating_ip_list(
                self.request,
                all_tenants=True)
        except Exception:
            exceptions.handle(self.request,
                              _('Unable to retrieve floating IP list.'))

        if floating_ips:
            instances = []
            try:
                instances, has_more = api.nova.server_list(self.request,
                                                           all_tenants=True)
            except Exception:
                exceptions.handle(
                    self.request,
                    _('Unable to retrieve instance list.'))
            instances_dict = dict([(obj.id, obj.name) for obj in instances])

            tenants = get_tenant_list(self.request)
            tenant_dict = OrderedDict([(t.id, t) for t in tenants])

            pools = get_floatingip_pools(self.request)
            pool_dict = dict([(obj.id, obj.name) for obj in pools])

            for ip in floating_ips:
                ip.instance_name = instances_dict.get(ip.instance_id)
                ip.pool_name = pool_dict.get(ip.pool, ip.pool)
                tenant = tenant_dict.get(ip.tenant_id, None)
                ip.tenant_name = getattr(tenant, "name", None)

        return floating_ips


class DetailView(views.HorizonTemplateView):
    template_name = 'admin/floating_ips/detail.html'
    page_title = _("Floating IP Details")

    def _get_corresponding_data(self, resource, resource_id):
        function_dict = {"floating IP": api.network.tenant_floating_ip_get,
                         "instance": api.nova.server_get,
                         "network": api.neutron.network_get,
                         "router": api.neutron.router_get}
        url = reverse('horizon:admin:floating_ips:index')
        try:
            res = function_dict[resource](
                self.request, resource_id)
            if resource in ["network", "router"]:
                res.set_id_as_name_if_empty(length=0)
            return res
        except KeyError:
            msg = _('Unknown resource type for detail API.')
            exceptions.handle(self.request, msg, redirect=url)
        except Exception:
            msg = _('Unable to retrieve details for '
                    '%(resource)s "%(resource_id)s".') % {
                        "resource": resource,
                        "resource_id": resource_id}
            exceptions.handle(self.request, msg, redirect=url)

    def get_context_data(self, **kwargs):
        context = super(DetailView, self).get_context_data(**kwargs)

        floating_ip_id = self.kwargs['floating_ip_id']
        floating_ip = self._get_corresponding_data("floating IP",
                                                   floating_ip_id)

        network = self._get_corresponding_data("network", floating_ip.pool)
        floating_ip.pool_name = network.name

        if floating_ip.instance_id and floating_ip.instance_type == 'compute':
            instance = self._get_corresponding_data(
                "instance", floating_ip.instance_id)
            floating_ip.instance_name = instance.name
        floating_ip.mapped_fixed_ip = project_tables.get_instance_info(
            floating_ip)

        if floating_ip.router_id:
            router = self._get_corresponding_data("router",
                                                  floating_ip.router_id)
            floating_ip.router_name = router.name
        table = fip_tables.FloatingIPsTable(self.request)
        context['floating_ip'] = floating_ip
        context["url"] = reverse('horizon:admin:floating_ips:index')
        context["actions"] = table.render_row_actions(floating_ip)
        return context


class AllocateView(forms.ModalFormView):
    form_class = fip_forms.AdminFloatingIpAllocate
    form_id = "allocate_floating_ip_form"
    template_name = 'admin/floating_ips/allocate.html'
    modal_header = _("Allocate Floating IP")
    submit_label = _("Allocate Floating IP")
    submit_url = reverse_lazy("horizon:admin:floating_ips:allocate")
    cancel_url = reverse_lazy('horizon:admin:floating_ips:index')
    success_url = reverse_lazy('horizon:admin:floating_ips:index')
    page_title = _("Allocate Floating IP")

    @memoized.memoized_method
    def get_initial(self):
        tenants = get_tenant_list(self.request)
        tenant_list = [(t.id, t.name) for t in tenants]
        if not tenant_list:
            tenant_list = [(None, _("No project available"))]

        pools = get_floatingip_pools(self.request)
        pool_list = []
        for pool in pools:
            for subnet in pool.subnets:
                if netaddr.IPNetwork(subnet.cidr).version != 4:
                    continue
                pool_display_name = (_("%(cidr)s %(pool_name)s")
                                     % {'cidr': subnet.cidr,
                                        'pool_name': pool.name})
                pool_list.append((pool.id, pool_display_name))
        if not pool_list:
            pool_list = [
                (None, _("No floating IP pools with IPv4 subnet available"))]

        return {'pool_list': pool_list,
                'tenant_list': tenant_list}


"""
Label textsize
============

This example shows how to size a Label to its content (texture_size) and how
setting text_size controls text wrapping.
"""
from kivy.app import App
from kivy.clock import Clock
from kivy.lang import Builder
from kivy.properties import StringProperty, NumericProperty, BooleanProperty

# Copied from https://en.wikipedia.org/wiki/A_Tale_of_Two_Cities
# Published in 1859 and public domain.
# The newline after the title will help demonstrate halign
_example_title_text = 'A Tale of Two Cities, by Charles Dickens\n'
_example_text = """It was the best of times, it was the worst of times,
it was the age of wisdom, it was the age of foolishness, it was the epoch of
belief, it was the epoch of incredulity, it was the season of Light, it was
the season of Darkness, it was the spring of hope, it was the winter of
despair, we had everything before us, we had nothing before us, we were all
going direct to Heaven, we were all going direct the other way - in short,
the period was so far like the present period, that some of its noisiest
authorities insisted on its being received, for good or for evil, in the
superlative degree of comparison only.
"""

# Note: Many of the Widgets (StackLayout, ToggleButton, Spinner) have
# defaults set at the bottom of the KV, where  DemoLabel and HeadingLabel
# are also defined.
_kv_code = """
BoxLayout:
    orientation: 'vertical'

    HeadingLabel:
        text: 'These modify all demonstration Labels'

    StackLayout:
        # Button is a subclass of Label and can be sized
        # to text in the same way

        Button:
            text: 'Reset'
            on_press: app.reset_words()

        ToggleButton:
            text: 'Shorten'
            on_state:
                app.shorten=self.state=='down'

        ToggleButton:
            text: 'max_lines=3'
            on_state:
                app.max_lines=3 if self.state=='down' else 0

        Spinner:
            text: 'bottom'
            values: 'bottom', 'middle', 'top'
            on_text: app.valign=self.text

        Spinner:
            text: 'left'
            values: 'left', 'center', 'right', 'justify'
            on_text: app.halign=self.text

    GridLayout:
        id: grid_layout
        cols: 2
        height: cm(6)
        size_hint_y: None

        HeadingLabel:
            text: "Default, no text_size set"

        HeadingLabel:
            text: 'text_size bound to size'

        DemoLabel:
            id: left_content
            disabled_color: 0, 0, 0, 0

        DemoLabel:
            id: right_content
            text_size: self.size
            padding: dp(6), dp(6)

    ToggleButton:
        text: 'Disable left'
        on_state:
            left_content.disabled=self.state=='down'

    # Need one Widget without size_hint_y: None, so that BoxLayout fills
    # available space.
    HeadingLabel:
        text: 'text_size width set, size bound to texture_size'
        text_size: self.size
        size_hint_y: 1

    DemoLabel:
        id: bottom_content
        # This Label wraps and expands its height to fit the text because
        # only text_size width is set and the Label size binds to texture_size.
        text_size: self.width, None
        size: self.texture_size
        padding: mm(4), mm(4)
        size_hint_y: None

# The column heading labels have their width set by the parent,
# but determine their height from the text.
<HeadingLabel@Label>:
    bold: True
    padding: dp(6), dp(4)
    valign: 'bottom'
    height: self.texture_size[1]
    text_size: self.width, None
    size_hint_y: None

<ToggleButton,Button>:
    padding: dp(10), dp(8)
    size_hint: None, None
    size: self.texture_size

# This inherits Button and the modifications above, so reset size
<Spinner>:
    size: sp(68), self.texture_size[1]

<DemoLabel@Label>:
    halign: app.halign
    valign: app.valign
    shorten: app.shorten
    max_lines: app.max_lines

    canvas:
        Color:
            rgb: 68/255.0, 164/255.0, 201/255.0
        Line:
            rectangle: self.x, self.y, self.width, self.height

<StackLayout>:
    size_hint_y: None
    spacing: dp(6)
    padding: dp(6), dp(4)
    height: self.minimum_height
"""


class LabelTextureSizeExample(App):
    # All Labels use these properties, set to Label defaults
    valign = StringProperty('bottom')
    halign = StringProperty('left')
    shorten = BooleanProperty(False)
    max_lines = NumericProperty(0)

    def build(self):
        self._add_word_ev = None
        return Builder.load_string(_kv_code)

    def on_start(self):
        widget_ids = self.root.ids
        self.text_content_widgets = (widget_ids.left_content,
                                     widget_ids.right_content,
                                     widget_ids.bottom_content)
        self.reset_words()

    def reset_words(self):
        if self._add_word_ev is not None:
            self._add_word_ev.cancel()
            self._add_word_ev = None
        for content_widget in self.text_content_widgets:
            content_widget.text = _example_title_text
        # initialize words generator
        self.words = (word for word in _example_text.split())
        self.add_word()

    def add_word(self, dt=None):
        try:
            word = next(self.words)
        except StopIteration:
            return

        for content_widget in self.text_content_widgets:
            content_widget.text += word + ' '

        pause_time = 0.03 * len(word)
        if word.endswith(','):
            pause_time += 0.6

        self._add_word_ev = Clock.schedule_once(self.add_word, pause_time)


if __name__ == '__main__':
    LabelTextureSizeExample().run()

from __future__ import unicode_literals

import re
import sure  # noqa
import threading
import time

import moto.server as server

'''
Test the different server responses
'''


def test_sqs_list_identities():
    backend = server.create_backend_app("sqs")
    test_client = backend.test_client()

    res = test_client.get('/?Action=ListQueues')
    res.data.should.contain(b"ListQueuesResponse")

    res = test_client.put('/?Action=CreateQueue&QueueName=testqueue')
    res = test_client.put('/?Action=CreateQueue&QueueName=otherqueue')

    res = test_client.get('/?Action=ListQueues&QueueNamePrefix=other')
    res.data.should_not.contain(b'testqueue')

    res = test_client.put(
        '/123/testqueue?MessageBody=test-message&Action=SendMessage')

    res = test_client.get(
        '/123/testqueue?Action=ReceiveMessage&MaxNumberOfMessages=1')

    message = re.search("<Body>(.*?)</Body>", res.data.decode('utf-8')).groups()[0]
    message.should.equal('test-message')


def test_messages_polling():
    backend = server.create_backend_app("sqs")
    test_client = backend.test_client()
    messages = []

    test_client.put('/?Action=CreateQueue&QueueName=testqueue')

    def insert_messages():
        messages_count = 5
        while messages_count > 0:
            test_client.put(
                '/123/testqueue?MessageBody=test-message&Action=SendMessage'
                '&Attribute.1.Name=WaitTimeSeconds&Attribute.1.Value=10'
            )
            messages_count -= 1
            time.sleep(.5)

    def get_messages():
        count = 0
        while count < 5:
            msg_res = test_client.get(
                '/123/testqueue?Action=ReceiveMessage&MaxNumberOfMessages=1&WaitTimeSeconds=5'
            )
            new_msgs = re.findall("<Body>(.*?)</Body>", msg_res.data.decode('utf-8'))
            count += len(new_msgs)
            messages.append(new_msgs)

    get_messages_thread = threading.Thread(target=get_messages)
    insert_messages_thread = threading.Thread(target=insert_messages)

    get_messages_thread.start()
    insert_messages_thread.start()

    get_messages_thread.join()
    insert_messages_thread.join()

    # got each message in a separate call to ReceiveMessage, despite the long WaitTimeSeconds
    assert len(messages) == 5

# -*- coding: utf-8 -*-
from navmazing import NavigateToSibling
from widgetastic.widget import Text
from widgetastic_patternfly import Button

from cfme.base import Server
from cfme.base.login import BaseLoggedInPage
from cfme.utils.appliance.implementations.ui import navigator, CFMENavigateStep


class ControlLogView(BaseLoggedInPage):
    """Basic view for Control/Log tab."""
    title = Text(".//div[@id='main-content']//h1")
    subtitle = Text(".//div[@id='main_div']/h3")
    refresh_button = Button(id="refresh_log")
    download_button = Button(id="fetch_log")

    @property
    def is_displayed(self):
        return (
            self.title.text == "Log" and
            "Last 1000 lines from server" in self.subtitle.text and
            self.refresh_button.is_displayed and
            self.download_button.is_displayed
        )


@navigator.register(Server)
class ControlLog(CFMENavigateStep):
    VIEW = ControlLogView
    prerequisite = NavigateToSibling("LoggedIn")

    def step(self):
        self.view.navigation.select("Control", "Log")

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import re
import sys

from setuptools import setup


def get_version(package):
    """
    Return package version as listed in `__version__` in `init.py`.
    """
    init_py = open(os.path.join(package, '__init__.py')).read()
    return re.search("__version__ = ['\"]([^'\"]+)['\"]", init_py).group(1)


def get_packages(package):
    """
    Return root package and all sub-packages.
    """
    return [dirpath
            for dirpath, dirnames, filenames in os.walk(package)
            if os.path.exists(os.path.join(dirpath, '__init__.py'))]


def get_package_data(package):
    """
    Return all files under the root package, that are not in a
    package themselves.
    """
    walk = [(dirpath.replace(package + os.sep, '', 1), filenames)
            for dirpath, dirnames, filenames in os.walk(package)
            if not os.path.exists(os.path.join(dirpath, '__init__.py'))]

    filepaths = []
    for base, filenames in walk:
        filepaths.extend([os.path.join(base, filename)
                          for filename in filenames])
    return {package: filepaths}


version = get_version('rest_framework')


if sys.argv[-1] == 'publish':
    if os.system("pip freeze | grep wheel"):
        print("wheel not installed.\nUse `pip install wheel`.\nExiting.")
        sys.exit()
    if os.system("pip freeze | grep twine"):
        print("twine not installed.\nUse `pip install twine`.\nExiting.")
        sys.exit()
    os.system("python setup.py sdist bdist_wheel")
    os.system("twine upload dist/*")
    print("You probably want to also tag the version now:")
    print("  git tag -a %s -m 'version %s'" % (version, version))
    print("  git push --tags")
    sys.exit()


setup(
    name='djangorestframework',
    version=version,
    url='http://www.django-rest-framework.org',
    license='BSD',
    description='Web APIs for Django, made easy.',
    author='Tom Christie',
    author_email='tom@tomchristie.com',  # SEE NOTE BELOW (*)
    packages=get_packages('rest_framework'),
    package_data=get_package_data('rest_framework'),
    install_requires=[],
    zip_safe=False,
    classifiers=[
        'Development Status :: 5 - Production/Stable',
        'Environment :: Web Environment',
        'Framework :: Django',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: BSD License',
        'Operating System :: OS Independent',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3',
        'Topic :: Internet :: WWW/HTTP',
    ]
)

# (*) Please direct queries to the discussion group, rather than to me directly
#     Doing so helps ensure your question is helpful to other users.
#     Queries directly to my email are likely to receive a canned response.
#
#     Many thanks for your understanding.

#!/usr/local/bin/python
# -*- coding: utf-8 -*-

import csv
import os
import re
import caffe
import numpy as np
from sklearn import preprocessing
from sklearn.externals import joblib
from pprint import pprint

def classify(imagelist, labels, protofilename, pretrainedname,
             meanfilename, modelfilename):
    mean = np.load(meanfilename)
    net = caffe.Classifier(protofilename, pretrainedname, mean=mean,
                           channel_swap=(2,1,0), image_dims=(256,256), raw_scale=255)
    print('# ----- Target labels -----')
    print(labels)
    
    estimator = joblib.load(modelfilename)
    clf = estimator.best_estimator_
    print(clf)
    features = []
    for imagefilename in imagelist:
        image = caffe.io.load_image(imagefilename)
        oversampled = caffe.io.oversample([caffe.io.resize_image(image, net.image_dims)],
                                          net.crop_dims)
        inputdata = np.asarray([net.preprocess('data', in_) for in_ in oversampled])
        net.forward(data=inputdata)
        feature = net.blobs['fc6i'].data[4]
        flattenfeature = feature.flatten().tolist()
        scaledfeature = preprocessing.scale(flattenfeature)
        features.append(scaledfeature)

    #predlabels = clf.predict(features)
    predprobas = clf.predict_proba(features)
    predictions = []
    #print(predprobas)
    for predproba in predprobas:
        topk = predproba.argsort()[-1:-6:-1]
        predictions.append(zip(labels[topk], predproba[topk]))
    pprint(zip(imagelist, predictions))

    
def getlabels(labelfilename):
    labels = []
    reader = csv.reader(file(labelfilename, 'r'), delimiter='\t', lineterminator='\n')
    for line in reader:
        labels.append(line[0])
    return np.array(labels)
    

def createimagelist(imagefileordir):
    if os.path.isdir(imagefileordir):
        pattern = re.compile('.*[.](jpg|jpeg|png|bmp|gif)$')
        images = [imagefileordir + '/' + image for image
                  in os.listdir(imagefileordir) if re.match(pattern, image)]
    elif os.path.isfile(imagefileordir):
        images = [imagefileordir]
    return images
        

if __name__ == '__main__':
    os.chdir(os.path.dirname(__file__))
    
    IMAGE_FILE = '../data/cat_images/Russian_Blue_212.jpg'
    IMAGE_DIR = '../../cat_test_images'
    LABEL_FILE = '../data/cat_label.tsv'
    PROTO_FILE = '../data/imagenet_feature.prototxt'
    PRETRAINED = '../data/caffe_reference_imagenet_model'
    MEAN_FILE = '../data/ilsvrc_2012_mean.npy'
    MODEL_FILE = '../data/models/cat_model_lr.pkl'
    imagelist = createimagelist(IMAGE_FILE)
    labels = getlabels(LABEL_FILE)
    
    classify(imagelist, labels, PROTO_FILE, PRETRAINED, MEAN_FILE, MODEL_FILE)

#!/usr/bin/env python
"""
summarize.py

Show a summary about which NumPy functions are documented and which are not.

"""
from __future__ import division, absolute_import, print_function

import os, glob, re, sys, inspect, optparse
try:
    # Accessing collections abstract classes from collections
    # has been deprecated since Python 3.3
    import collections.abc as collections_abc
except ImportError:
    import collections as collections_abc
sys.path.append(os.path.join(os.path.dirname(__file__), 'sphinxext'))
from sphinxext.phantom_import import import_phantom_module

from sphinxext.autosummary_generate import get_documented

CUR_DIR = os.path.dirname(__file__)
SOURCE_DIR = os.path.join(CUR_DIR, 'source', 'reference')

SKIP_LIST = """
# --- aliases:
alltrue sometrue bitwise_not cumproduct
row_stack column_stack product rank

# -- skipped:
core lib f2py dual doc emath ma rec char distutils oldnumeric numarray
testing version matlib

add_docstring add_newdoc add_newdocs fastCopyAndTranspose pkgload
conjugate disp

int0 object0 unicode0 uint0 string_ string0 void0

flagsobj

setup PackageLoader

lib.scimath.arccos lib.scimath.arcsin lib.scimath.arccosh lib.scimath.arcsinh
lib.scimath.arctanh lib.scimath.log lib.scimath.log2 lib.scimath.log10
lib.scimath.logn lib.scimath.power lib.scimath.sqrt

# --- numpy.random:
random random.info random.mtrand random.ranf random.sample random.random

# --- numpy.fft:
fft fft.Tester fft.bench fft.fftpack fft.fftpack_lite fft.helper
fft.info fft.test

# --- numpy.linalg:
linalg linalg.Tester
linalg.bench linalg.info linalg.lapack_lite linalg.linalg linalg.test

# --- numpy.ctypeslib:
ctypeslib ctypeslib.test

""".split()

def main():
    p = optparse.OptionParser(__doc__)
    p.add_option("-c", "--columns", action="store", type="int", dest="cols",
                 default=3, help="Maximum number of columns")
    options, args = p.parse_args()

    if len(args) != 0:
        p.error('Wrong number of arguments')

    # prepare
    fn = os.path.join(CUR_DIR, 'dump.xml')
    if os.path.isfile(fn):
        import_phantom_module(fn)

    # check
    documented, undocumented = check_numpy()

    # report
    in_sections = {}
    for name, locations in documented.items():
        for (filename, section, keyword, toctree) in locations:
            in_sections.setdefault((filename, section, keyword), []).append(name)

    print("Documented")
    print("==========\n")

    last_filename = None
    for (filename, section, keyword), names in sorted(in_sections.items()):
        if filename != last_filename:
            print("--- %s\n" % filename)
        last_filename = filename
        print(" ** ", section)
        print(format_in_columns(sorted(names), options.cols))
        print("\n")

    print("")
    print("Undocumented")
    print("============\n")
    print(format_in_columns(sorted(undocumented.keys()), options.cols))

def check_numpy():
    documented = get_documented(glob.glob(SOURCE_DIR + '/*.rst'))
    undocumented = {}

    import numpy, numpy.fft, numpy.linalg, numpy.random
    for mod in [numpy, numpy.fft, numpy.linalg, numpy.random,
                numpy.ctypeslib, numpy.emath, numpy.ma]:
        undocumented.update(get_undocumented(documented, mod, skip=SKIP_LIST))

    for d in (documented, undocumented):
        for k in d.keys():
            if k.startswith('numpy.'):
                d[k[6:]] = d[k]
                del d[k]

    return documented, undocumented

def get_undocumented(documented, module, module_name=None, skip=[]):
    """
    Find out which items in NumPy are not documented.

    Returns
    -------
    undocumented : dict of bool
        Dictionary containing True for each documented item name
        and False for each undocumented one.

    """
    undocumented = {}

    if module_name is None:
        module_name = module.__name__

    for name in dir(module):
        obj = getattr(module, name)
        if name.startswith('_'): continue

        full_name = '.'.join([module_name, name])

        if full_name in skip: continue
        if full_name.startswith('numpy.') and full_name[6:] in skip: continue
        if not (inspect.ismodule(obj) or isinstance(obj, collections_abc.Callable) or inspect.isclass(obj)):
            continue

        if full_name not in documented:
            undocumented[full_name] = True

    return undocumented

def format_in_columns(lst, max_columns):
    """
    Format a list containing strings to a string containing the items
    in columns.
    """
    lst = [str(_m) for _m in lst]
    col_len = max([len(_m) for _m in lst]) + 2
    ncols = 80//col_len
    if ncols > max_columns:
        ncols = max_columns
    if ncols <= 0:
        ncols = 1

    if len(lst) % ncols == 0:
        nrows = len(lst)//ncols
    else:
        nrows = 1 + len(lst)//ncols

    fmt = ' %%-%ds ' % (col_len-2)

    lines = []
    for n in range(nrows):
        lines.append("".join([fmt % x for x in lst[n::nrows]]))
    return "\n".join(lines)

if __name__ == "__main__": main()

"""Support for deCONZ sensors."""
from pydeconz.sensor import (
    Battery,
    Consumption,
    Daylight,
    Humidity,
    LightLevel,
    Power,
    Pressure,
    Switch,
    Temperature,
    Thermostat,
)

from homeassistant.const import (
    ATTR_TEMPERATURE,
    ATTR_VOLTAGE,
    DEVICE_CLASS_BATTERY,
    DEVICE_CLASS_HUMIDITY,
    DEVICE_CLASS_ILLUMINANCE,
    DEVICE_CLASS_POWER,
    DEVICE_CLASS_PRESSURE,
    DEVICE_CLASS_TEMPERATURE,
    ENERGY_KILO_WATT_HOUR,
    POWER_WATT,
    PRESSURE_HPA,
    TEMP_CELSIUS,
    UNIT_PERCENTAGE,
)
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import (
    async_dispatcher_connect,
    async_dispatcher_send,
)

from .const import ATTR_DARK, ATTR_ON, NEW_SENSOR
from .deconz_device import DeconzDevice
from .deconz_event import DeconzEvent
from .gateway import get_gateway_from_config_entry

ATTR_CURRENT = "current"
ATTR_POWER = "power"
ATTR_DAYLIGHT = "daylight"
ATTR_EVENT_ID = "event_id"

DEVICE_CLASS = {
    Humidity: DEVICE_CLASS_HUMIDITY,
    LightLevel: DEVICE_CLASS_ILLUMINANCE,
    Power: DEVICE_CLASS_POWER,
    Pressure: DEVICE_CLASS_PRESSURE,
    Temperature: DEVICE_CLASS_TEMPERATURE,
}

ICON = {
    Daylight: "mdi:white-balance-sunny",
    Pressure: "mdi:gauge",
    Temperature: "mdi:thermometer",
}

UNIT_OF_MEASUREMENT = {
    Consumption: ENERGY_KILO_WATT_HOUR,
    Humidity: UNIT_PERCENTAGE,
    LightLevel: "lx",
    Power: POWER_WATT,
    Pressure: PRESSURE_HPA,
    Temperature: TEMP_CELSIUS,
}


async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
    """Old way of setting up deCONZ platforms."""


async def async_setup_entry(hass, config_entry, async_add_entities):
    """Set up the deCONZ sensors."""
    gateway = get_gateway_from_config_entry(hass, config_entry)

    batteries = set()
    battery_handler = DeconzBatteryHandler(gateway)

    @callback
    def async_add_sensor(sensors, new=True):
        """Add sensors from deCONZ.

        Create DeconzEvent if part of ZHAType list.
        Create DeconzSensor if not a ZHAType and not a binary sensor.
        Create DeconzBattery if sensor has a battery attribute.
        If new is false it means an existing sensor has got a battery state reported.
        """
        entities = []

        for sensor in sensors:

            if new and sensor.type in Switch.ZHATYPE:

                if gateway.option_allow_clip_sensor or not sensor.type.startswith(
                    "CLIP"
                ):
                    new_event = DeconzEvent(sensor, gateway)
                    hass.async_create_task(new_event.async_update_device_registry())
                    gateway.events.append(new_event)

            elif (
                new
                and sensor.BINARY is False
                and sensor.type not in Battery.ZHATYPE + Thermostat.ZHATYPE
                and (
                    gateway.option_allow_clip_sensor
                    or not sensor.type.startswith("CLIP")
                )
            ):
                entities.append(DeconzSensor(sensor, gateway))

            if sensor.battery is not None:
                new_battery = DeconzBattery(sensor, gateway)
                if new_battery.unique_id not in batteries:
                    batteries.add(new_battery.unique_id)
                    entities.append(new_battery)
                    battery_handler.remove_tracker(sensor)
            else:
                battery_handler.create_tracker(sensor)

        async_add_entities(entities, True)

    gateway.listeners.append(
        async_dispatcher_connect(
            hass, gateway.async_signal_new_device(NEW_SENSOR), async_add_sensor
        )
    )

    async_add_sensor(
        [gateway.api.sensors[key] for key in sorted(gateway.api.sensors, key=int)]
    )


class DeconzSensor(DeconzDevice):
    """Representation of a deCONZ sensor."""

    @callback
    def async_update_callback(self, force_update=False, ignore_update=False):
        """Update the sensor's state."""
        if ignore_update:
            return

        keys = {"on", "reachable", "state"}
        if force_update or self._device.changed_keys.intersection(keys):
            self.async_write_ha_state()

    @property
    def state(self):
        """Return the state of the sensor."""
        return self._device.state

    @property
    def device_class(self):
        """Return the class of the sensor."""
        return DEVICE_CLASS.get(type(self._device))

    @property
    def icon(self):
        """Return the icon to use in the frontend."""
        return ICON.get(type(self._device))

    @property
    def unit_of_measurement(self):
        """Return the unit of measurement of this sensor."""
        return UNIT_OF_MEASUREMENT.get(type(self._device))

    @property
    def device_state_attributes(self):
        """Return the state attributes of the sensor."""
        attr = {}

        if self._device.on is not None:
            attr[ATTR_ON] = self._device.on

        if self._device.secondary_temperature is not None:
            attr[ATTR_TEMPERATURE] = self._device.secondary_temperature

        if self._device.type in Consumption.ZHATYPE:
            attr[ATTR_POWER] = self._device.power

        elif self._device.type in Daylight.ZHATYPE:
            attr[ATTR_DAYLIGHT] = self._device.daylight

        elif self._device.type in LightLevel.ZHATYPE:

            if self._device.dark is not None:
                attr[ATTR_DARK] = self._device.dark

            if self._device.daylight is not None:
                attr[ATTR_DAYLIGHT] = self._device.daylight

        elif self._device.type in Power.ZHATYPE:
            attr[ATTR_CURRENT] = self._device.current
            attr[ATTR_VOLTAGE] = self._device.voltage

        return attr


class DeconzBattery(DeconzDevice):
    """Battery class for when a device is only represented as an event."""

    @callback
    def async_update_callback(self, force_update=False, ignore_update=False):
        """Update the battery's state, if needed."""
        if ignore_update:
            return

        keys = {"battery", "reachable"}
        if force_update or self._device.changed_keys.intersection(keys):
            self.async_write_ha_state()

    @property
    def unique_id(self):
        """Return a unique identifier for this device."""
        return f"{self.serial}-battery"

    @property
    def state(self):
        """Return the state of the battery."""
        return self._device.battery

    @property
    def name(self):
        """Return the name of the battery."""
        return f"{self._device.name} Battery Level"

    @property
    def device_class(self):
        """Return the class of the sensor."""
        return DEVICE_CLASS_BATTERY

    @property
    def unit_of_measurement(self):
        """Return the unit of measurement of this entity."""
        return UNIT_PERCENTAGE

    @property
    def device_state_attributes(self):
        """Return the state attributes of the battery."""
        attr = {}

        if self._device.type in Switch.ZHATYPE:
            for event in self.gateway.events:
                if self._device == event.device:
                    attr[ATTR_EVENT_ID] = event.event_id

        return attr


class DeconzSensorStateTracker:
    """Track sensors without a battery state and signal when battery state exist."""

    def __init__(self, sensor, gateway):
        """Set up tracker."""
        self.sensor = sensor
        self.gateway = gateway
        sensor.register_callback(self.async_update_callback)

    @callback
    def close(self):
        """Clean up tracker."""
        self.sensor.remove_callback(self.async_update_callback)
        self.gateway = None
        self.sensor = None

    @callback
    def async_update_callback(self, ignore_update=False):
        """Sensor state updated."""
        if "battery" in self.sensor.changed_keys:
            async_dispatcher_send(
                self.gateway.hass,
                self.gateway.async_signal_new_device(NEW_SENSOR),
                [self.sensor],
                False,
            )


class DeconzBatteryHandler:
    """Creates and stores trackers for sensors without a battery state."""

    def __init__(self, gateway):
        """Set up battery handler."""
        self.gateway = gateway
        self._trackers = set()

    @callback
    def create_tracker(self, sensor):
        """Create new tracker for battery state."""
        for tracker in self._trackers:
            if sensor == tracker.sensor:
                return
        self._trackers.add(DeconzSensorStateTracker(sensor, self.gateway))

    @callback
    def remove_tracker(self, sensor):
        """Remove tracker of battery state."""
        for tracker in self._trackers:
            if sensor == tracker.sensor:
                tracker.close()
                self._trackers.remove(tracker)
                break

# pylint: disable=missing-docstring

from django.conf import settings
from lettuce import before, step, world
from nose.tools import assert_equals, assert_in
from pymongo import MongoClient

REQUIRED_EVENT_FIELDS = [
    'agent',
    'event',
    'event_source',
    'event_type',
    'host',
    'ip',
    'page',
    'time',
    'username'
]


@before.all
def connect_to_mongodb():
    world.mongo_client = MongoClient(host=settings.MONGO_HOST, port=settings.MONGO_PORT_NUM)
    world.event_collection = world.mongo_client['track']['events']


@before.each_scenario
def reset_captured_events(_scenario):
    world.event_collection.drop()


@before.outline
def reset_between_outline_scenarios(_scenario, order, outline, reasons_to_fail):
    world.event_collection.drop()


@step(r'[aA]n? course url "(.*)" event is emitted$')
def course_url_event_is_emitted(_step, url_regex):
    event_type = url_regex.format(world.scenario_dict['COURSE'].id)
    n_events_are_emitted(_step, 1, event_type, "server")


@step(r'([aA]n?|\d+) "(.*)" (server|browser) events? is emitted$')
def n_events_are_emitted(_step, count, event_type, event_source):

    # Ensure all events are written out to mongo before querying.
    world.mongo_client.fsync()

    # Note that splinter makes 2 requests when you call browser.visit('/foo')
    # the first just checks to see if the server responds with a status
    # code of 200, the next actually uses the browser to submit the request.
    # We filter out events associated with the status code checks by ignoring
    # events that come directly from splinter.
    criteria = {
        'event_type': event_type,
        'event_source': event_source,
        'agent': {
            '$ne': 'python/splinter'
        }
    }

    cursor = world.event_collection.find(criteria)

    try:
        number_events = int(count)
    except ValueError:
        number_events = 1

    assert_equals(cursor.count(), number_events)

    event = cursor.next()

    expected_field_values = {
        "username": world.scenario_dict['USER'].username,
        "event_type": event_type,
    }
    for key, value in expected_field_values.iteritems():
        assert_equals(event[key], value)

    for field in REQUIRED_EVENT_FIELDS:
        assert_in(field, event)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2015-2015: Alignak team, see AUTHORS.txt file for contributors
#
# This file is part of Alignak.
#
# Alignak is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Alignak is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with Alignak.  If not, see <http://www.gnu.org/licenses/>.
#
#
# This file incorporates work covered by the following copyright and
# permission notice:
#
#  Copyright (C) 2009-2014:
#     Jean Gabes, naparuba@gmail.com
#     Hartmut Goebel, h.goebel@goebel-consult.de
#     Grégory Starck, g.starck@gmail.com
#     Zoran Zaric, zz@zoranzaric.de
#     Sebastien Coavoux, s.coavoux@free.fr

#  This file is part of Shinken.
#
#  Shinken is free software: you can redistribute it and/or modify
#  it under the terms of the GNU Affero General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  Shinken is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU Affero General Public License for more details.
#
#  You should have received a copy of the GNU Affero General Public License
#  along with Shinken.  If not, see <http://www.gnu.org/licenses/>.

#
# This file is used to test reading and processing of config files
#

from alignak_test import *


class TestConfig(AlignakTest):
    def setUp(self):
        self.setup_with_file(['etc/alignak_resultmodulation.cfg'])

    def get_svc(self):
        return self.sched.services.find_srv_by_name_and_hostname("test_host_0", "test_ok_0_resmod")

    def get_host(self):
        return self.sched.hosts.find_by_name("test_host_0")

    def get_router(self):
        return self.sched.hosts.find_by_name("test_router_0_resmod")

    def test_service_resultmodulation(self):
        svc = self.get_svc()
        host = self.get_host()
        router = self.get_router()

        self.scheduler_loop(2, [[host, 0, 'UP | value1=1 value2=2'], [svc, 2, 'BAD | value1=0 value2=0'],])
        self.assertEqual('UP', host.state)
        self.assertEqual('HARD', host.state_type)

        # This service got a result modulation. So Criticals are in fact
        # Warnings. So even with some CRITICAL (2), it must be warning
        self.assertEqual('WARNING', svc.state)

        # If we remove the resultmodulations, we should have theclassic behavior
        svc.resultmodulations = []
        self.scheduler_loop(2, [[host, 0, 'UP | value1=1 value2=2'], [svc, 2, 'BAD | value1=0 value2=0']])
        self.assertEqual('CRITICAL', svc.state)

        # Now look for the inheritaed thing
        # resultmodulation is a inplicit inherited parameter
        # and router define it, but not test_router_0_resmod/test_ok_0_resmod. So this service should also be impacted
        svc2 = self.sched.services.find_srv_by_name_and_hostname("test_router_0_resmod", "test_ok_0_resmod")
        self.assertEqual(router.resultmodulations, svc2.resultmodulations)

        self.scheduler_loop(2, [[svc2, 2, 'BAD | value1=0 value2=0']])
        self.assertEqual('WARNING', svc2.state)


if __name__ == '__main__':
    unittest.main()

"""
A service-like user_info interface.  Could be made into an http API later, but for now
just in-process.  Exposes global and per-course key-value pairs for users.

Implementation note:
Stores global metadata using the UserPreference model, and per-course metadata using the
UserCourseTag model.
"""

from ..models import UserCourseTag

# Scopes
# (currently only allows per-course tags.  Can be expanded to support
# global tags (e.g. using the existing UserPreferences table))
COURSE_SCOPE = 'course'


def get_course_tag(user, course_id, key):
    """
    Gets the value of the user's course tag for the specified key in the specified
    course_id.

    Args:
        user: the User object for the course tag
        course_id: course identifier (string)
        key: arbitrary (<=255 char string)

    Returns:
        string value, or None if there is no value saved
    """
    try:
        record = UserCourseTag.objects.get(
            user=user,
            course_id=course_id,
            key=key)

        return record.value
    except UserCourseTag.DoesNotExist:
        return None


def set_course_tag(user, course_id, key, value):
    """
    Sets the value of the user's course tag for the specified key in the specified
    course_id.  Overwrites any previous value.

    The intention is that the values are fairly short, as they will be included in all
    analytics events about this user.

    Args:
        user: the User object
        course_id: course identifier (string)
        key: arbitrary (<=255 char string)
        value: arbitrary string
    """
    # pylint: disable=fixme
    # TODO: There is a risk of IntegrityErrors being thrown here given
    # simultaneous calls from many processes. Handle by retrying after
    # a short delay?

    record, _ = UserCourseTag.objects.get_or_create(
        user=user,
        course_id=course_id,
        key=key)

    record.value = value
    record.save()

# -*- coding: utf-8 -*-

import re

from module.plugins.internal.Addon import Addon


class LinkdecrypterComHook(Addon):
    __name__    = "LinkdecrypterComHook"
    __type__    = "hook"
    __version__ = "1.07"
    __status__  = "testing"

    __config__ = [("activated"     , "bool"               , "Activated"                    , True ),
                  ("pluginmode"    , "all;listed;unlisted", "Use for plugins"              , "all"),
                  ("pluginlist"    , "str"                , "Plugin list (comma separated)", ""   ),
                  ("reload"        , "bool"               , "Reload plugin list"           , True ),
                  ("reloadinterval", "int"                , "Reload interval in hours"     , 12   )]

    __description__ = """Linkdecrypter.com hook plugin"""
    __license__     = "GPLv3"
    __authors__     = [("Walter Purcaro", "vuolter@gmail.com")]


    def get_hosters(self):
        list = re.search(r'>Supported\(\d+\)</b>: <i>(.[\w.\-, ]+)',
                         self.load("http://linkdecrypter.com/").replace("(g)", "")).group(1).split(', ')
        try:
            list.remove("download.serienjunkies.org")
        except ValueError:
            pass

        return list

from __future__ import print_function

__author__ = "Pierre Barbier de Reuille <pierre.barbierdereuille@gmail.com>"

from ..utils import namedtuple
from .. import loader
from path import path
import os

_fields = ['name', 'description', 'invert', 'Dfun', '__call__']

residuals = None

Residual = namedtuple('Residual', ['fct', 'name', 'description', 'invert', 'Dfun', '__call__'])


def find_functions(module):
    """
    Find and all the residual functions defined in the given module
    """
    content = dir(module)
    result = {}
    for c in content:
        obj = getattr(module, c)
        try:
            if isinstance(obj, type):
                obj = obj()
            for attr in _fields:
                if not hasattr(obj, attr):
                    break
            else:
                result[obj.name] = obj
        except Exception as ex:  # Silently ignore any exception
            print("Error: '{}'".format(ex))
            pass
    return result


def load():
    """
    Load and register all the residual functions available.

    It will be looking in the current folder, but also in the "residuals"
    subfolders of the paths defined in the PYQTFIT_PATH environment
    variable.
    """
    global residuals
    residuals = loader.load(find_functions)
    extra_path = os.environ.get("PYQTFIT_PATH", "").split(":")
    for ep in extra_path:
        ep = path(ep)
        if ep and (ep / "residuals").exists():
            residuals.update(loader.load(find_functions, ep / "residuals"))
    return residuals

load()


def get(name):
    """
    Return the description of the residuals names 'name'

    Parameters
    ----------
    name: str
        Name of the residuals

    Returns
    -------
    fct: callable object
        Callable object that will compute the residuals. The callable has the following attributes:
        fct: callable
            Function computing the residuals
        name: str
            Name of the residuals type
        description: str
            Formula of the residual
        invert: callable
            Function to add residuals to a data set
    """
    return residuals.get(name, None)


def names():
    """
    List the names of available residuals
    """
    return residuals.keys()

#!/usr/bin/python
# coding=utf-8

from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import patch
from mock import Mock

from diamond.collector import Collector
from flume import FlumeCollector


class TestFlumeCollector(CollectorTestCase):

    def setUp(self):
        config = get_collector_config('FlumeCollector', {
            'interval': 10
        })

        self.collector = FlumeCollector(config, None)

    def test_import(self):
        self.assertTrue(FlumeCollector)

    @patch.object(Collector, 'publish')
    @patch.object(Collector, 'publish_gauge')
    @patch.object(Collector, 'publish_counter')
    def test_collect_should_work(self,
                                 publish_mock,
                                 publish_gauge_mock,
                                 publish_counter_mock):
        patch_urlopen = patch('urllib2.urlopen',
                              Mock(return_value=self.getFixture('metrics')))

        patch_urlopen.start()
        self.collector.collect()
        patch_urlopen.stop()

        metrics = {
            'CHANNEL.channel1.ChannelFillPercentage': 0.0,
            'CHANNEL.channel1.EventPutAttempt': 50272828,
            'CHANNEL.channel1.EventPutSuccess': 50255318,
            'CHANNEL.channel1.EventTakeAttempt': 50409933,
            'CHANNEL.channel1.EventTakeSuccess': 50255318,
            'SINK.sink1.BatchComplete': 251705,
            'SINK.sink1.BatchEmpty': 76250,
            'SINK.sink1.BatchUnderflow': 379,
            'SINK.sink1.ConnectionClosed': 6,
            'SINK.sink1.ConnectionCreated': 7,
            'SINK.sink1.ConnectionFailed': 0,
            'SINK.sink1.EventDrainAttempt': 25190171,
            'SINK.sink1.EventDrainSuccess': 25189571,
            'SOURCE.source1.AppendAccepted': 0,
            'SOURCE.source1.AppendBatchAccepted': 56227,
            'SOURCE.source1.AppendBatchReceived': 56258,
            'SOURCE.source1.AppendReceived': 0,
            'SOURCE.source1.EventAccepted': 50282681,
            'SOURCE.source1.EventReceived': 50311681,
            'SOURCE.source1.OpenConnection': 0
        }

        self.setDocExample(collector=self.collector.__class__.__name__,
                           metrics=metrics,
                           defaultpath=self.collector.config['path'])
        self.assertPublishedMany([publish_mock,
                                  publish_gauge_mock,
                                  publish_counter_mock
                                  ], metrics)

    @patch.object(Collector, 'publish')
    def test_blank_should_fail_gracefully(self, publish_mock):
        patch_urlopen = patch('urllib2.urlopen', Mock(
            return_value=self.getFixture('metrics_blank')))

        patch_urlopen.start()
        self.collector.collect()
        patch_urlopen.stop()

        self.assertPublishedMany(publish_mock, {})

    @patch.object(Collector, 'publish')
    def test_invalid_should_fail_gracefully(self, publish_mock):
        patch_urlopen = patch(
            'urllib2.urlopen',
            Mock(return_value=self.getFixture('metrics_invalid')))

        patch_urlopen.start()
        self.collector.collect()
        patch_urlopen.stop()

        self.assertPublishedMany(publish_mock, {})

if __name__ == "__main__":
    unittest.main()

#!/usr/bin/env python
#
# Copyright 2014 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#


from gnuradio import gr, gr_unittest, blocks
import os
import socket
from time import sleep

from threading import Timer
from multiprocessing import Process

class test_tcp_sink(gr_unittest.TestCase):

    def setUp(self):
        os.environ['GR_CONF_CONTROLPORT_ON'] = 'False'
        self.tb_snd = gr.top_block()
        self.tb_rcv = gr.top_block()

    def tearDown(self):
        self.tb_rcv = None
        self.tb_snd = None

    def _tcp_client(self):
        dst = blocks.vector_sink_s()
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        for t in (0, 0.2):
# wait until server listens
            sleep(t)
            try:
                sock.connect((self.addr, self.port))
            except socket.error as e:
                if e.errno != 111:
                    raise
                continue
            break
        fd = os.dup(sock.fileno())
        self.tb_rcv.connect(blocks.file_descriptor_source(self.itemsize, fd), dst)
        self.tb_rcv.run()
        self.assertEqual(self.data, dst.data())

    def test_001(self):
        self.addr = '127.0.0.1'
        self.port = 65510
        self.itemsize = gr.sizeof_short
        n_data = 16
        self.data = tuple([x for x in range(n_data)])

# tcp_server_sink blocks until client does not connect, start client process first
        p = Process(target=self._tcp_client)
        p.start()

        src = blocks.vector_source_s(self.data, False)
        tcp_snd = blocks.tcp_server_sink(self.itemsize, self.addr, self.port, False)
        self.tb_snd.connect(src, tcp_snd)

        self.tb_snd.run()
        del tcp_snd
        self.tb_snd = None
        p.join()

    def stop_rcv(self):
        self.timeout = True
        self.tb_rcv.stop()
        #print "tb_rcv stopped by Timer"

if __name__ == '__main__':
    gr_unittest.run(test_tcp_sink, "test_tcp_server_sink.xml")


import HTMLParser
from datetime import datetime
import random

import markovify
import praw
import pytz
from sqlalchemy import (
    Boolean,
    Column,
    DateTime,
    Index,
    Integer,
    String,
    Text,
)
from sqlalchemy.sql.expression import func

from database import Base, JSONSerialized, db

MAX_OVERLAP_RATIO = 0.5
MAX_OVERLAP_TOTAL = 10

class SubredditSimulatorText(markovify.Text):
    html_parser = HTMLParser.HTMLParser()

    def test_sentence_input(self, sentence):
        return True

    def _prepare_text(self, text):
        text = self.html_parser.unescape(text)
        text = text.strip()
        if not text.endswith((".", "?", "!")):
            text += "."

        return text

    def sentence_split(self, text):
        # split everything up by newlines, prepare them, and join back together
        lines = text.splitlines()
        text = " ".join([self._prepare_text(line)
            for line in lines if line.strip()])

        return markovify.split_into_sentences(text)


class Setting(Base):
    __tablename__ = "settings"

    name = Column(String(100), primary_key=True)
    value = Column(JSONSerialized)


Settings = {}
for setting in db.query(Setting):
    Settings[setting.name] = setting.value


class Account(Base):
    __tablename__ = "accounts"

    name = Column(String(20), primary_key=True)
    subreddit = Column(String(21))
    special_class = Column(String(50))
    added = Column(DateTime(timezone=True))
    can_submit = Column(Boolean, default=False)
    link_karma = Column(Integer)
    num_submissions = Column(Integer, default=0)
    last_submitted = Column(DateTime(timezone=True))
    can_comment = Column(Boolean, default=True)
    comment_karma = Column(Integer)
    num_comments = Column(Integer, default=0)
    last_commented = Column(DateTime(timezone=True))

    __mapper_args__ = {
        "polymorphic_on": special_class,
        "polymorphic_identity": None,
    }

    def __init__(self, name, subreddit, can_comment=True, can_submit=False):
        self.name = name
        self.subreddit = subreddit.lower()
        self.can_comment = can_comment
        self.can_submit = can_submit
        self.added = datetime.now(pytz.utc)

    @property
    def session(self):
        if not hasattr(self, "_session"):
            self._session = praw.Reddit(Settings["user agent"])
            self._session.login(
                self.name, Settings["password"], disable_warning=True)
            self.comment_karma = self._session.user.comment_karma
            self.link_karma = self._session.user.link_karma

        return self._session

    @property
    def is_able_to_submit(self):
        captcha_exempt = self.comment_karma > 5 or self.link_karma > 2
        return self.can_submit and captcha_exempt

    @property
    def mean_comment_karma(self):
        if self.num_comments == 0:
            return 0
        else:
            return round(self.comment_karma / float(self.num_comments), 2)

    @property
    def mean_link_karma(self):
        if self.num_submissions == 0:
            return 0
        else:
            return round(self.link_karma / float(self.num_submissions), 2)

    def get_comments_from_site(self, limit=None, store_in_db=True):
        subreddit = self.session.get_subreddit(self.subreddit)

        # get the newest comment we've previously seen as a stopping point
        last_comment = (
            db.query(Comment)
                .filter_by(subreddit=self.subreddit)
                .order_by(Comment.date.desc())
                .first()
        )

        seen_ids = set()
        comments = []

        for comment in subreddit.get_comments(limit=limit):
            comment = Comment(comment)

            if last_comment:
                if (comment.id == last_comment.id or 
                        comment.date <= last_comment.date):
                    break

            # somehow there are occasionally duplicates - skip over them
            if comment.id in seen_ids:
                continue
            seen_ids.add(comment.id)

            comments.append(comment)
            if store_in_db:
                db.add(comment)

        if store_in_db:
            db.commit()
        return comments

    def get_submissions_from_site(self, limit=None, store_in_db=True):
        subreddit = self.session.get_subreddit(self.subreddit)

        # get the newest submission we've previously seen as a stopping point
        last_submission = (
            db.query(Submission)
                .filter_by(subreddit=self.subreddit)
                .order_by(Submission.date.desc())
                .first()
        )

        seen_ids = set()
        submissions = []

        for submission in subreddit.get_new(limit=limit):
            submission = Submission(submission)

            if last_submission:
                if (submission.id == last_submission.id or 
                        submission.date <= last_submission.date):
                    break

            # somehow there are occasionally duplicates - skip over them
            if submission.id in seen_ids:
                continue
            seen_ids.add(submission.id)

            submissions.append(submission)
            if store_in_db:
                db.add(submission)

        if store_in_db:
            db.commit()
        return submissions

    def should_include_comment(self, comment):
        if comment.author in Settings["ignored users"]:
            return False

        if "+/u/user_simulator" in comment.body.lower():
            return False

        return True

    def get_comments_for_training(self, limit=None):
        comments = (db.query(Comment)
            .filter_by(subreddit=self.subreddit)
            .order_by(func.random())
            .limit(Settings["max corpus size"])
        )
        valid_comments = [comment for comment in comments
            if self.should_include_comment(comment)]
        return valid_comments

    def get_submissions_for_training(self, limit=None):
        submissions = db.query(Submission).filter_by(subreddit=self.subreddit)
        return [submission for submission in submissions
            if submission.author not in Settings["ignored users"]]

    def train_from_comments(self, get_new_comments=True):
        if get_new_comments:
            self.get_comments_from_site()

        comments = []
        for comment in self.get_comments_for_training():
            comments.append(comment.body)
        self.avg_comment_len = sum(len(c) for c in comments) / float(len(comments))
        self.avg_comment_len = min(250, self.avg_comment_len)
        if self.avg_comment_len >= 140:
            state_size = 3
        else:
            state_size = 2
        self.comment_model = SubredditSimulatorText(
            "\n".join(comments), state_size=state_size)

    def train_from_submissions(self, get_new_submissions=True):
        if get_new_submissions:
            self.get_submissions_from_site()

        titles = []
        selftexts = []
        self.link_submissions = []

        all_submissions = self.get_submissions_for_training()
        for submission in all_submissions:
            titles.append(submission.title)
            if submission.url:
                self.link_submissions.append(submission)
            else:
                selftexts.append(submission.body or "")

        self.link_submission_chance = len(self.link_submissions) / float(len(all_submissions))
        
        self.title_model = SubredditSimulatorText("\n".join(titles), state_size=2)
        if selftexts:
            self.avg_selftext_len = sum(len(s) for s in selftexts) / float(len(selftexts))
            self.avg_selftext_len = min(250, self.avg_selftext_len)
            # if the average selftext length is very low, we won't even bother
            # creating a model, and will submit with only titles
            if self.avg_selftext_len <= 50:
                self.selftext_model = None
            else:
                if self.avg_selftext_len >= 140:
                    state_size = 3
                else:
                    state_size = 2
                try:
                    self.selftext_model = SubredditSimulatorText(
                        "\n".join(selftexts), state_size=state_size)
                except IndexError:
                    # I'm not sure what causes this yet
                    self.selftext_model = None

    def make_comment_sentence(self):
        return self.comment_model.make_sentence(tries=10000,
            max_overlap_total=MAX_OVERLAP_TOTAL,
            max_overlap_ratio=MAX_OVERLAP_RATIO)

    def build_comment(self):
        comment = ""
        while True:
            # For each sentence, check how close to the average comment length
            # we are, then use the remaining percentage as the chance of
            # adding another sentence. For example, if we're at 70% of the
            # average comment length, there will be a 30% chance of adding
            # another sentence. We're also adding a fixed 10% on top of that
            # just to increase the length a little, and have some chance of
            # continuing once we're past the average.
            portion_done = len(comment) / float(self.avg_comment_len)
            continue_chance = 1.0 - portion_done
            continue_chance = max(0, continue_chance)
            continue_chance += 0.1
            if random.random() > continue_chance:
                break

            new_sentence = self.make_comment_sentence()
            comment += " " + new_sentence

        comment = comment.strip()
        
        return comment

    def make_selftext_sentence(self):
        if self.selftext_model:
            return self.selftext_model.make_sentence(tries=10000,
                max_overlap_total=MAX_OVERLAP_TOTAL,
                max_overlap_ratio=MAX_OVERLAP_RATIO)
        else:
            return None

    def post_comment_on(self, submission):
        comment = self.build_comment()

        # decide if we're going to post top-level or reply
        if (submission.num_comments == 0 or
                random.random() < 0.5):
            submission.add_comment(comment)
        else:
            comments = praw.helpers.flatten_tree(submission.comments)
            reply_to = random.choice(comments)
            reply_to.reply(comment)

        # update the database
        self.last_commented = datetime.now(pytz.utc)
        self.num_comments += 1
        db.add(self)
        db.commit()

    def pick_submission_type(self):
        if not self.link_submissions:
            return "text"

        if random.random() < self.link_submission_chance:
            return "link"
        else:
            return "text"

    def post_submission(self, subreddit, type=None):
        subreddit = self.session.get_subreddit(subreddit)

        title = self.title_model.make_short_sentence(300, tries=10000,
                max_overlap_total=MAX_OVERLAP_TOTAL,
                max_overlap_ratio=MAX_OVERLAP_RATIO)
        title = title.rstrip(".")

        if not type:
            type = self.pick_submission_type()

        if type == "link":
            url_source = random.choice(self.link_submissions)

            if url_source.over_18:
                title = "[NSFW] " + title

            subreddit.submit(title, url=url_source.url, send_replies=False)
        else:
            selftext = ""
            while len(selftext) < self.avg_selftext_len:
                new_sentence = self.make_selftext_sentence()
                if not new_sentence:
                    break
                selftext += " " + new_sentence
            selftext = selftext.strip()

            # need to do this to be able to submit an empty self-post
            if len(selftext) == 0:
                selftext = " "

            subreddit.submit(title, text=selftext, send_replies=False)

        # update the database
        self.last_submitted = datetime.now(pytz.utc)
        self.num_submissions += 1
        db.add(self)
        db.commit()


class TopTodayAccount(Account):
    __mapper_args__ = {
        "polymorphic_identity": "TopToday",
    }

    def get_submissions_for_training(self, limit=500):
        subreddit = self.session.get_subreddit(self.subreddit)
        submissions = [Submission(s)
            for s in subreddit.get_top_from_day(limit=limit)]
        return [s for s in submissions if not s.over_18]

    def train_from_submissions(self, get_new_submissions=False):
        super(TopTodayAccount, self).train_from_submissions(get_new_submissions)

    def pick_submission_type(self):
        return "link"


class Comment(Base):
    __tablename__ = "comments"

    id = Column(String(10), primary_key=True)
    subreddit = Column(String(21))
    date = Column(DateTime)
    is_top_level = Column(Boolean)
    author = Column(String(20))
    body = Column(Text)
    score = Column(Integer)

    __table_args__ = (
        Index("ix_comment_subreddit_date", "subreddit", "date"),
    )

    def __init__(self, comment):
        self.id = comment.id
        self.subreddit = comment.subreddit.display_name.lower()
        self.date = datetime.utcfromtimestamp(comment.created_utc)
        self.is_top_level = comment.parent_id.startswith("t3_")
        if comment.author:
            self.author = comment.author.name
        else:
            self.author = "[deleted]"
        self.body = comment.body
        self.score = comment.score


class Submission(Base):
    __tablename__ = "submissions"

    id = Column(String(10), primary_key=True)
    subreddit = Column(String(21))
    date = Column(DateTime)
    author = Column(String(20))
    title = Column(Text)
    url = Column(Text)
    body = Column(Text)
    score = Column(Integer)
    over_18 = Column(Boolean)

    __table_args__ = (
        Index("ix_submission_subreddit_date", "subreddit", "date"),
    )

    def __init__(self, submission):
        self.id = submission.id
        self.subreddit = submission.subreddit.display_name.lower()
        self.date = datetime.utcfromtimestamp(submission.created_utc)
        if submission.author:
            self.author = submission.author.name
        else:
            self.author = "[deleted]"
        self.title = submission.title
        if submission.is_self:
            self.body = submission.selftext
            self.url = None
        else:
            self.body = None
            self.url = submission.url
        self.score = submission.score
        self.over_18 = submission.over_18

#!/usr/bin/python
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

DOCUMENTATION = '''
---
module: stat
version_added: "1.3"
short_description: retrieve file or file system status
description:
     - Retrieves facts for a file similar to the linux/unix 'stat' command.
options:
  path:
    description:
      - The full path of the file/object to get the facts of
    required: true
    default: null
  follow:
    description:
      - Whether to follow symlinks
    required: false
    default: no
  get_md5:
    description:
      - Whether to return the md5 sum of the file.  Will return None if we're unable to use md5 (Common for FIPS-140 compliant systems)
    required: false
    default: yes
  get_checksum:
    description:
      - Whether to return a checksum of the file (default sha1)
    required: false
    default: yes
    version_added: "1.8"
  checksum_algorithm:
    description:
      - Algorithm to determine checksum of file. Will throw an error if the host is unable to use specified algorithm.
    required: false
    choices: [ 'sha1', 'sha224', 'sha256', 'sha384', 'sha512' ]
    default: sha1
    aliases: [ 'checksum_algo', 'checksum' ]
    version_added: "2.0"
  mime:
    description:
      - Use file magic and return data about the nature of the file. this uses the 'file' utility found on most Linux/Unix systems.
      - This will add both `mime_type` and 'charset' fields to the return, if possible.
    required: false
    choices: [ Yes, No ]
    default: No
    version_added: "2.1"
    aliases: [ 'mime_type', 'mime-type' ]
author: "Bruce Pennypacker (@bpennypacker)"
'''

EXAMPLES = '''
# Obtain the stats of /etc/foo.conf, and check that the file still belongs
# to 'root'. Fail otherwise.
- stat: path=/etc/foo.conf
  register: st
- fail: msg="Whoops! file ownership has changed"
  when: st.stat.pw_name != 'root'

# Determine if a path exists and is a symlink. Note that if the path does
# not exist, and we test sym.stat.islnk, it will fail with an error. So
# therefore, we must test whether it is defined.
# Run this to understand the structure, the skipped ones do not pass the
# check performed by 'when'
- stat: path=/path/to/something
  register: sym
- debug: msg="islnk isn't defined (path doesn't exist)"
  when: sym.stat.islnk is not defined
- debug: msg="islnk is defined (path must exist)"
  when: sym.stat.islnk is defined
- debug: msg="Path exists and is a symlink"
  when: sym.stat.islnk is defined and sym.stat.islnk
- debug: msg="Path exists and isn't a symlink"
  when: sym.stat.islnk is defined and sym.stat.islnk == False


# Determine if a path exists and is a directory.  Note that we need to test
# both that p.stat.isdir actually exists, and also that it's set to true.
- stat: path=/path/to/something
  register: p
- debug: msg="Path exists and is a directory"
  when: p.stat.isdir is defined and p.stat.isdir

# Don't do md5 checksum
- stat: path=/path/to/myhugefile get_md5=no

# Use sha256 to calculate checksum
- stat: path=/path/to/something checksum_algorithm=sha256
'''

RETURN = '''
stat:
    description: dictionary containing all the stat data
    returned: success
    type: dictionary
    contains:
        exists:
            description: if the destination path actually exists or not
            returned: success
            type: boolean
            sample: True
        path:
            description: The full path of the file/object to get the facts of
            returned: success and if path exists
            type: string
            sample: '/path/to/file'
        mode:
            description: Unix permissions of the file in octal
            returned: success, path exists and user can read stats
            type: octal
            sample: 1755
        isdir:
            description: Tells you if the path is a directory
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        ischr:
            description: Tells you if the path is a character device
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        isblk:
            description: Tells you if the path is a block device
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        isreg:
            description: Tells you if the path is a regular file
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        isfifo:
            description: Tells you if the path is a named pipe
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        islnk:
            description: Tells you if the path is a symbolic link
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        issock:
            description: Tells you if the path is a unix domain socket
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        uid:
            description: Numeric id representing the file owner
            returned: success, path exists and user can read stats
            type: int
            sample: 1003
        gid:
            description: Numeric id representing the group of the owner
            returned: success, path exists and user can read stats
            type: int
            sample: 1003
        size:
            description: Size in bytes for a plain file, ammount of data for some special files
            returned: success, path exists and user can read stats
            type: int
            sample: 203
        inode:
            description: Inode number of the path
            returned: success, path exists and user can read stats
            type: int
            sample: 12758
        dev:
            description: Device the inode resides on
            returned: success, path exists and user can read stats
            type: int
            sample: 33
        nlink:
            description: Number of links to the inode (hard links)
            returned: success, path exists and user can read stats
            type: int
            sample: 1
        atime:
            description: Time of last access
            returned: success, path exists and user can read stats
            type: float
            sample: 1424348972.575
        mtime:
            description: Time of last modification
            returned: success, path exists and user can read stats
            type: float
            sample: 1424348972.575
        ctime:
            description: Time of last metadata update or creation (depends on OS)
            returned: success, path exists and user can read stats
            type: float
            sample: 1424348972.575
        wusr:
            description: Tells you if the owner has write permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        rusr:
            description: Tells you if the owner has read permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        xusr:
            description: Tells you if the owner has execute permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        wgrp:
            description: Tells you if the owner's group has write permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        rgrp:
            description: Tells you if the owner's group has read permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        xgrp:
            description: Tells you if the owner's group has execute permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        woth:
            description: Tells you if others have write permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        roth:
            description: Tells you if others have read permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        xoth:
            description: Tells you if others have execute permission
            returned: success, path exists and user can read stats
            type: boolean
            sample: True
        isuid:
            description: Tells you if the invoking user's id matches the owner's id
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        isgid:
            description: Tells you if the invoking user's group id matches the owner's group id
            returned: success, path exists and user can read stats
            type: boolean
            sample: False
        lnk_source:
            description: Original path
            returned: success, path exists and user can read stats and the path is a symbolic link
            type: string
            sample: /home/foobar/21102015-1445431274-908472971
        md5:
            description: md5 hash of the path
            returned: success, path exists and user can read stats and path supports hashing and md5 is supported
            type: string
            sample: f88fa92d8cf2eeecf4c0a50ccc96d0c0
        checksum_algorithm:
            description: hash of the path
            returned: success, path exists, user can read stats, path supports hashing and supplied checksum algorithm is available
            type: string
            sample: 50ba294cdf28c0d5bcde25708df53346825a429f
            aliases: ['checksum', 'checksum_algo']
        pw_name:
            description: User name of owner
            returned: success, path exists and user can read stats and installed python supports it
            type: string
            sample: httpd
        gr_name:
            description: Group name of owner
            returned: success, path exists and user can read stats and installed python supports it
            type: string
            sample: www-data
        mime_type:
            description: file magic data or mime-type
            returned: success, path exists and user can read stats and installed python supports it and the `mime` option was true, will return 'unknown' on error.
            type: string
            sample: PDF document, version 1.2
        charset:
            description: file character set or encoding
            returned: success, path exists and user can read stats and installed python supports it and the `mime` option was true, will return 'unknown' on error.
            type: string
            sample: us-ascii
'''

import os
import sys
from stat import *
import pwd
import grp

def main():
    module = AnsibleModule(
        argument_spec = dict(
            path = dict(required=True, type='path'),
            follow = dict(default='no', type='bool'),
            get_md5 = dict(default='yes', type='bool'),
            get_checksum = dict(default='yes', type='bool'),
            checksum_algorithm = dict(default='sha1', type='str', choices=['sha1', 'sha224', 'sha256', 'sha384', 'sha512'], aliases=['checksum_algo', 'checksum']),
            mime = dict(default=False, type='bool', aliases=['mime_type', 'mime-type']),
        ),
        supports_check_mode = True
    )

    path = module.params.get('path')
    follow = module.params.get('follow')
    get_md5 = module.params.get('get_md5')
    get_checksum = module.params.get('get_checksum')
    checksum_algorithm = module.params.get('checksum_algorithm')

    try:
        if follow:
            st = os.stat(path)
        else:
            st = os.lstat(path)
    except OSError, e:
        if e.errno == errno.ENOENT:
            d = { 'exists' : False }
            module.exit_json(changed=False, stat=d)

        module.fail_json(msg = e.strerror)

    mode = st.st_mode

    # back to ansible
    d = {
        'exists'   : True,
        'path'     : path,
        'mode'    : "%04o" % S_IMODE(mode),
        'isdir'    : S_ISDIR(mode),
        'ischr'    : S_ISCHR(mode),
        'isblk'    : S_ISBLK(mode),
        'isreg'    : S_ISREG(mode),
        'isfifo'   : S_ISFIFO(mode),
        'islnk'    : S_ISLNK(mode),
        'issock'   : S_ISSOCK(mode),
        'uid'      : st.st_uid,
        'gid'      : st.st_gid,
        'size'     : st.st_size,
        'inode'    : st.st_ino,
        'dev'      : st.st_dev,
        'nlink'    : st.st_nlink,
        'atime'    : st.st_atime,
        'mtime'    : st.st_mtime,
        'ctime'    : st.st_ctime,
        'wusr'     : bool(mode & stat.S_IWUSR),
        'rusr'     : bool(mode & stat.S_IRUSR),
        'xusr'     : bool(mode & stat.S_IXUSR),
        'wgrp'     : bool(mode & stat.S_IWGRP),
        'rgrp'     : bool(mode & stat.S_IRGRP),
        'xgrp'     : bool(mode & stat.S_IXGRP),
        'woth'     : bool(mode & stat.S_IWOTH),
        'roth'     : bool(mode & stat.S_IROTH),
        'xoth'     : bool(mode & stat.S_IXOTH),
        'isuid'    : bool(mode & stat.S_ISUID),
        'isgid'    : bool(mode & stat.S_ISGID),
        }

    if S_ISLNK(mode):
        d['lnk_source'] = os.path.realpath(path)

    if S_ISREG(mode) and get_md5 and os.access(path,os.R_OK):
        # Will fail on FIPS-140 compliant systems
        try:
            d['md5']       = module.md5(path)
        except ValueError:
            d['md5']       = None

    if S_ISREG(mode) and get_checksum and os.access(path,os.R_OK):
        d['checksum']      = module.digest_from_file(path, checksum_algorithm)

    try:
        pw = pwd.getpwuid(st.st_uid)

        d['pw_name']   = pw.pw_name

        grp_info = grp.getgrgid(st.st_gid)
        d['gr_name'] = grp_info.gr_name
    except:
        pass

    if module.params.get('mime'):
        d['mime_type'] = 'unknown'
        d['charset'] = 'unknown'

        filecmd = [module.get_bin_path('file', True),'-i', path]
        try:
            rc, out, err = module.run_command(filecmd)
            if rc == 0:
                mtype, chset = out.split(':')[1].split(';')
                d['mime_type'] = mtype.strip()
                d['charset'] = chset.split('=')[1].strip()
        except:
            pass

    module.exit_json(changed=False, stat=d)

# import module snippets
from ansible.module_utils.basic import *

main()

import unittest, time, sys, random, logging
sys.path.extend(['.','..','../..','py'])
import h2o, h2o_cmd, h2o_browse as h2b, h2o_import as h2i, h2o_glm
import h2o_exec as h2e, h2o_jobs

DO_IMPORT_CHECK = True
class Basic(unittest.TestCase):
    def tearDown(self):
        h2o.check_sandbox_for_errors()

    @classmethod
    def setUpClass(cls):
        pass

    @classmethod
    def tearDownClass(cls):
        # time.sleep(3600)
        h2o.tear_down_cloud()

    def test_parse_manyfiles_fvec(self):
        # typical size of the michal files
        avgMichalSizeUncompressed = 237270000 
        avgMichalSize = 116561140 
        avgSynSize = 4020000
        covtype200xSize = 15033863400
        synSize =  183
        if 1==1:
            # importFolderPath = '/home/0xdiag/datasets/more1_1200_link'
            # importFolderPathFull = '/home/0xdiag/datasets/manyfiles-nflx-gz'
            # importFolderPath = 'more1_1200_link'
            importFolderPath = 'manyfiles-nflx-gz'
            print "Using .gz'ed files in", importFolderPath
            # this pattern from browser correctly does 100 files, 1M rowsj
            # source_key=*/home/0xdiag/datasets/manyfiles-nflx-gz/file_1[0-9][0-9].dat.gz
            csvFilenameAll = [
                ("file_1.dat.gz", "file_1_A.dat.gz", 1 * avgMichalSize, 3600),
                ("file_[1-2].dat.gz", "file_2_A.dat.gz", 2 * avgMichalSize, 3600),
                ("file_[1-4].dat.gz", "file_4_A.dat.gz", 4 * avgMichalSize, 3600),
            ]

        # csvFilenameList = random.sample(csvFilenameAll,1)
        csvFilenameList = csvFilenameAll

        # split out the pattern match and the filename used for the hex
        trialMax = 1
        # rebuild the cloud for each file
        # can fire a parse off and go wait on the jobs queue (inspect afterwards is enough?)
        DO_GLM = False
        noPoll = False
        # benchmarkLogging = ['cpu','disk', 'iostats', 'jstack']
        # benchmarkLogging = None
        benchmarkLogging = ['cpu','disk', 'network', 'iostats', 'jstack']
        benchmarkLogging = ['cpu','disk', 'network', 'iostats']
        # IOStatus can hang?
        benchmarkLogging = ['cpu', 'disk' 'network']
        pollTimeoutSecs = 180
        retryDelaySecs = 10

        tryHeap = 6
        h2o.init(2, java_heap_GB=tryHeap, enable_benchmark_log=True)

        for i,(csvFilepattern, csvFilename, totalBytes, timeoutSecs) in enumerate(csvFilenameList):
            # pop open a browser on the cloud
            ### h2b.browseTheCloud()

            # to avoid sticky ports?

            for trial in range(trialMax):
                # (importResult, importPattern) = h2i.import_only(path=importFolderPath+"/*")

                if DO_IMPORT_CHECK:
                    for i in range(2):
                        csvPathname = importFolderPath + "/" + csvFilepattern
                        (importResult, importPattern) = h2i.import_only(bucket='home-0xdiag-datasets', 
                                path=csvPathname, schema='local', timeoutSecs=timeoutSecs)

                        importFullList = importResult['files']
                        importFailList = importResult['fails']
                        print "\n Problem if this is not empty: importFailList:", h2o.dump_json(importFailList)
                        # creates csvFilename.hex from file in importFolder dir 

                h2o.cloudPerfH2O.change_logfile(csvFilename)
                h2o.cloudPerfH2O.message("")
                h2o.cloudPerfH2O.message("Parse " + csvFilename + " Start--------------------------------")
                csvPathname = importFolderPath + "/" + csvFilepattern
                start = time.time()
                parseResult = h2i.import_parse(bucket='home-0xdiag-datasets', path=csvPathname, schema='local',
                    hex_key=csvFilename + ".hex", timeoutSecs=timeoutSecs, 
                    retryDelaySecs=retryDelaySecs,
                    pollTimeoutSecs=pollTimeoutSecs,
                    noPoll=noPoll,
                    benchmarkLogging=benchmarkLogging)
                elapsed = time.time() - start
                print "Parse#", trial, parseResult['destination_key'], "took", elapsed, "seconds",\
                    "%d pct. of timeout" % ((elapsed*100)/timeoutSecs)

                inspect = h2o_cmd.runInspect(None, parseResult['destination_key'], timeoutSecs=360)
                h2o_cmd.infoFromInspect(inspect, csvPathname)

                if noPoll:
                    if (i+1) < len(csvFilenameList):
                        h2o.check_sandbox_for_errors()
                        (csvFilepattern, csvFilename, totalBytes2, timeoutSecs) = csvFilenameList[i+1]
                        # parseResult = h2i.import_parse(path=importFolderPath + "/" + csvFilepattern,
                        csvPathname = importFolderPathFull + "/" + csvFilepattern
                        start = time.time()
                        parseResult = h2i.import_parse(path=csvPathname,
                            hex_key=csvFilename + ".hex", 
                            timeoutSecs=timeoutSecs, 
                            retryDelaySecs=retryDelaySecs,
                            pollTimeoutSecs=pollTimeoutSecs,
                            noPoll=noPoll,
                            benchmarkLogging=benchmarkLogging)
                        elapsed = time.time() - start
                        print "Parse#", trial, parseResult['destination_key'], "took", elapsed, "seconds",\
                            "%d pct. of timeout" % ((elapsed*100)/timeoutSecs)
                        inspect = h2o_cmd.runInspect(None, parseResult['destination_key'], timeoutSecs=360)
                        h2o_cmd.infoFromInspect(inspect, csvPathname)

                    if (i+2) < len(csvFilenameList):
                        h2o.check_sandbox_for_errors()
                        (csvFilepattern, csvFilename, totalBytes3, timeoutSecs) = csvFilenameList[i+2]
                        csvPathname = importFolderPathFull + "/" + csvFilepattern
                        parseResult = h2i.import_parse(path=csvPathname,
                            hex_key=csvFilename + ".hex", timeoutSecs=timeoutSecs, 
                            retryDelaySecs=retryDelaySecs,
                            pollTimeoutSecs=pollTimeoutSecs,
                            noPoll=noPoll,
                            benchmarkLogging=benchmarkLogging)
                        elapsed = time.time() - start
                        print "Parse#", trial, parseResult['destination_key'], "took", elapsed, "seconds",\
                            "%d pct. of timeout" % ((elapsed*100)/timeoutSecs)
                        inspect = h2o_cmd.runInspect(None, parseResult['destination_key'], timeoutSecs=360)
                        h2o_cmd.infoFromInspect(inspect, csvPathname)


                # print stats on all three if noPoll
                if noPoll:
                    # does it take a little while to show up in Jobs, from where we issued the parse?
                    time.sleep(2)
                    # FIX! use the last (biggest?) timeoutSecs? maybe should increase since parallel
                    h2o_jobs.pollWaitJobs(pattern=csvFilename,
                        timeoutSecs=timeoutSecs, benchmarkLogging=benchmarkLogging)
                    # for getting the MB/sec closer to 'right'
                    totalBytes += totalBytes2 + totalBytes3
                    elapsed = time.time() - start
                    h2o.check_sandbox_for_errors()


                if totalBytes is not None:
                    fileMBS = (totalBytes/1e6)/elapsed
                    l = '{!s} jvms, {!s}GB heap, {:s} {:s} {:6.2f} MB/sec for {:.2f} secs'.format(
                        len(h2o.nodes), tryHeap, csvFilepattern, csvFilename, fileMBS, elapsed)
                    print l
                    h2o.cloudPerfH2O.message(l)

                print "Parse result['destination_key']:", parseResult['destination_key']

                # BUG here?
                if not noPoll:
                    pass
                    # We should be able to see the parse result?
                    # h2o_cmd.check_enums_from_inspect(parseResult)
                        
                # the nflx data doesn't have a small enough # of classes in any col
                # use exec to randomFilter out 200 rows for a quick RF. that should work for everyone?
                origKey = parseResult['destination_key']
                # execExpr = 'a = randomFilter('+origKey+',200,12345678)' 
                execExpr = 'a = slice('+origKey+',1,200)' 
                # h2e.exec_expr(h2o.nodes[0], execExpr, "a", timeoutSecs=30)
                # runRF takes the parseResult directly
                newParseKey = {'destination_key': 'a'}

                print "\n" + csvFilepattern
                # poker and the water.UDP.set3(UDP.java) fail issue..
                # constrain depth to 25
                print "Temporarily hacking to do nothing instead of RF on the parsed file"
                ### RFview = h2o_cmd.runRF(trees=1,depth=25,parseResult=newParseKey, timeoutSecs=timeoutSecs)
                ### h2b.browseJsonHistoryAsUrlLastMatch("RFView")

                #**********************************************************************************
                # Do GLM too
                # Argument case error: Value 0.0 is not between 12.0 and 9987.0 (inclusive)
                if DO_GLM:
                    # these are all the columns that are enums in the dataset...too many for GLM!
                    x = range(542) # don't include the output column
                    # remove the output too! (378)
                    for i in [3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 16, 17, 18, 19, 20, 424, 425, 426, 540, 541, 378]:
                        x.remove(i)
                    x = ",".join(map(str,x))

                    GLMkwargs = {'x': x, 'y': 378, 'case': 15, 'case_mode': '>',
                        'max_iter': 10, 'n_folds': 1, 'alpha': 0.2, 'lambda': 1e-5}
                    start = time.time()
                    glm = h2o_cmd.runGLM(parseResult=parseResult, timeoutSecs=timeoutSecs, **GLMkwargs)
                    h2o_glm.simpleCheckGLM(self, glm, None, **GLMkwargs)
                    elapsed = time.time() - start
                    h2o.check_sandbox_for_errors()
                    l = '{:d} jvms, {:d}GB heap, {:s} {:s} GLM: {:6.2f} secs'.format(
                        len(h2o.nodes), tryHeap, csvFilepattern, csvFilename, elapsed)
                    print l
                    h2o.cloudPerfH2O.message(l)

                #**********************************************************************************
                # print "Waiting 30 secs"
                # time.sleep(30)

                h2o_cmd.checkKeyDistribution()
                h2i.delete_keys_from_import_result(pattern=csvFilename, importResult=importResult)
                h2o.nodes[0].remove_all_keys()

                ### time.sleep(3600)

                ### h2o.tear_down_cloud()
                if not h2o.localhost:
                    print "Waiting 30 secs before building cloud again (sticky ports?)"
                    ### time.sleep(30)

                sys.stdout.write('.')
                sys.stdout.flush() 

if __name__ == '__main__':
    h2o.unit_main()

# This file is part of Buildbot.  Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members

from twisted.python import reflect

commandRegistry = {
    # command name : fully qualified factory name (callable)
    "shell": "buildslave.commands.shell.SlaveShellCommand",
    "uploadFile": "buildslave.commands.transfer.SlaveFileUploadCommand",
    "uploadDirectory": "buildslave.commands.transfer.SlaveDirectoryUploadCommand",
    "downloadFile": "buildslave.commands.transfer.SlaveFileDownloadCommand",
    "svn": "buildslave.commands.svn.SVN",
    "bk": "buildslave.commands.bk.BK",
    "cvs": "buildslave.commands.cvs.CVS",
    "darcs": "buildslave.commands.darcs.Darcs",
    "git": "buildslave.commands.git.Git",
    "repo": "buildslave.commands.repo.Repo",
    "bzr": "buildslave.commands.bzr.Bzr",
    "hg": "buildslave.commands.hg.Mercurial",
    "p4": "buildslave.commands.p4.P4",
    "mtn": "buildslave.commands.mtn.Monotone",
    "mkdir": "buildslave.commands.fs.MakeDirectory",
    "rmdir": "buildslave.commands.fs.RemoveDirectory",
    "cpdir": "buildslave.commands.fs.CopyDirectory",
    "stat": "buildslave.commands.fs.StatFile",
    "glob": "buildslave.commands.fs.GlobPath",
    "listdir": "buildslave.commands.fs.ListDir",
}


def getFactory(command):
    factory_name = commandRegistry[command]
    factory = reflect.namedObject(factory_name)
    return factory


def getAllCommandNames():
    return commandRegistry.keys()

# -*- coding: utf-8 -*-
#
# Copyright (2016-2017) Hewlett Packard Enterprise Development LP
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.


class ModuleDocFragment(object):

    # OneView doc fragment
    DOCUMENTATION = '''
options:
    config:
      description:
        - Path to a .json configuration file containing the OneView client configuration.
          The configuration file is optional and when used should be present in the host running the ansible commands.
          If the file path is not provided, the configuration will be loaded from environment variables.
          For links to example configuration files or how to use the environment variables verify the notes section.

requirements:
  - python >= 2.7.9

notes:
    - "A sample configuration file for the config parameter can be found at:
       U(https://github.com/HewlettPackard/oneview-ansible/blob/master/examples/oneview_config-rename.json)"
    - "Check how to use environment variables for configuration at:
       U(https://github.com/HewlettPackard/oneview-ansible#environment-variables)"
    - "Additional Playbooks for the HPE OneView Ansible modules can be found at:
       U(https://github.com/HewlettPackard/oneview-ansible/tree/master/examples)"
    - "The OneView API version used will directly affect returned and expected fields in resources.
       Information on setting the desired API version and can be found at:
       U(https://github.com/HewlettPackard/oneview-ansible#setting-your-oneview-version)"
    '''

    VALIDATEETAG = '''
options:
    validate_etag:
        description:
            - When the ETag Validation is enabled, the request will be conditionally processed only if the current ETag
                for the resource matches the ETag provided in the data.
        default: true
        choices: ['true', 'false']
'''

    FACTSPARAMS = '''
options:
    params:
        description:
        - List of params to delimit, filter and sort the list of resources.
        - "params allowed:
            - C(start): The first item to return, using 0-based indexing.
            - C(count): The number of resources to return.
            - C(filter): A general filter/query string to narrow the list of items returned.
            - C(sort): The sort order of the returned data set."
'''

#-----------------------------------------------------------------------------
# Copyright (c) 2012 - 2018, Anaconda, Inc. All rights reserved.
#
# Powered by the Bokeh Development Team.
#
# The full license is in the file LICENSE.txt, distributed with this software.
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Boilerplate
#-----------------------------------------------------------------------------
from __future__ import absolute_import, division, print_function, unicode_literals

import pytest ; pytest

#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------

# Standard library imports
import argparse
import os
import sys

# External imports

# Bokeh imports
from bokeh.command.bootstrap import main
from bokeh._testing.util.filesystem import TmpDir, WorkingDir, with_directory_contents

from . import basic_scatter_script

# Module under test
import bokeh.command.subcommands.json as scjson

#-----------------------------------------------------------------------------
# Setup
#-----------------------------------------------------------------------------

is_python2 = sys.version_info[0] == 2

#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Dev API
#-----------------------------------------------------------------------------

def test_create():
    import argparse
    from bokeh.command.subcommand import Subcommand

    obj = scjson.JSON(parser=argparse.ArgumentParser())
    assert isinstance(obj, Subcommand)

def test_name():
    assert scjson.JSON.name == "json"

def test_help():
    assert scjson.JSON.help == "Create JSON files for one or more applications"

def test_args():
    assert scjson.JSON.args == (

        ('files', dict(
            metavar='DIRECTORY-OR-SCRIPT',
            nargs='+',
            help="The app directories or scripts to generate JSON for",
            default=None
        )),

        ('--indent', dict(
            metavar='LEVEL',
            type=int,
            help="indentation to use when printing",
            default=None
        )),

        (('-o', '--output'), dict(
                metavar='FILENAME',
                action='append',
                type=str,
                help="Name of the output file or - for standard output."
        )),

        ('--args', dict(
            metavar='COMMAND-LINE-ARGS',
            nargs=argparse.REMAINDER,
            help="Any command line arguments remaining are passed on to the application handler",
        )),

    )

def test_no_script(capsys):
    with (TmpDir(prefix="bokeh-json-no-script")) as dirname:
        with WorkingDir(dirname):
            with pytest.raises(SystemExit):
                main(["bokeh", "json"])
        out, err = capsys.readouterr()
        if is_python2:
            too_few = "too few arguments"
        else:
            too_few = "the following arguments are required: DIRECTORY-OR-SCRIPT"
        assert err == """usage: bokeh json [-h] [--indent LEVEL] [-o FILENAME] [--args ...]
                  DIRECTORY-OR-SCRIPT [DIRECTORY-OR-SCRIPT ...]
bokeh json: error: %s
""" % (too_few)
        assert out == ""

def test_basic_script(capsys):
    def run(dirname):
        with WorkingDir(dirname):
            main(["bokeh", "json", "scatter.py"])
        out, err = capsys.readouterr()
        assert err == ""
        assert out == ""

        assert set(["scatter.json", "scatter.py"]) == set(os.listdir(dirname))

    with_directory_contents({ 'scatter.py' : basic_scatter_script },
                            run)

def test_basic_script_with_output_after(capsys):
    def run(dirname):
        with WorkingDir(dirname):
            main(["bokeh", "json", "scatter.py", "--output", "foo.json"])
        out, err = capsys.readouterr()
        assert err == ""
        assert out == ""

        assert set(["foo.json", "scatter.py"]) == set(os.listdir(dirname))

    with_directory_contents({ 'scatter.py' : basic_scatter_script },
                            run)

def test_basic_script_with_output_before(capsys):
    def run(dirname):
        with WorkingDir(dirname):
            main(["bokeh", "json", "--output", "foo.json", "scatter.py"])
        out, err = capsys.readouterr()
        assert err == ""
        assert out == ""

        assert set(["foo.json", "scatter.py"]) == set(os.listdir(dirname))

    with_directory_contents({ 'scatter.py' : basic_scatter_script },
                            run)

#-----------------------------------------------------------------------------
# Private API
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Code
#-----------------------------------------------------------------------------

import ctypes # used for accessing the dynamic library

import graph_partitioning.partitioners.utils as putils # used for some of the utilities functions

class LibScotch(putils.CLibInterface):
    def __init__(self, libraryPath = None):
        super().__init__(libraryPath=libraryPath)

    def _getDefaultLibPath(self):
        return putils.defaultSCOTCHLibraryPath()

    def _loadLibraryFunctions(self):
        # *****************
        # structures & data
        # *****************

        # These describe the type of object to be created
        self.SCOTCH_Arch = ctypes.c_double*128
        self.SCOTCH_Graph = ctypes.c_double*128
        self.SCOTCH_Strat = ctypes.c_double*128

        # These store the scotch data objects (ie. graph = SCOTCH_Graph())
        self.architecture = None
        self.graph = None
        self.strategy = None

        self.SCOTCH_version = self.clib.SCOTCH_version
        self.SCOTCH_version.argtypes = [ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)]

        # SCOTCH_archAlloc
        self.SCOTCH_archAlloc = self.clib.SCOTCH_archAlloc
        #self.SCOTCH_archAlloc.argtypes = [ None ]

        # SCOTCH_archInit
        self.SCOTCH_archInit = self.clib.SCOTCH_archInit
        self.SCOTCH_archInit.argtypes = [ctypes.POINTER(self.SCOTCH_Arch)]

        # SCOTCH_archExit
        self.SCOTCH_archExit = self.clib.SCOTCH_archExit
        self.SCOTCH_archExit.argtypes = [ctypes.POINTER(self.SCOTCH_Arch)]

        # SCOTCH_archCmplt - builds architecture for partitioning
        self.SCOTCH_archCmplt = self.clib.SCOTCH_archCmplt
        self.SCOTCH_archCmplt.argtypes = [ctypes.POINTER(self.SCOTCH_Arch), ctypes.c_int]

        # SCOTCH_graphAlloc
        self.SCOTCH_graphAlloc = self.clib.SCOTCH_graphAlloc
        #self.SCOTCH_graphAlloc.argtypes = [ None ]

        # SCOTCH_graphInit
        self.SCOTCH_graphInit = self.clib.SCOTCH_graphInit
        self.SCOTCH_graphInit.argtypes = [ctypes.POINTER(self.SCOTCH_Graph)]

        # SCOTCH_graphExit
        self.SCOTCH_graphExit = self.clib.SCOTCH_graphExit
        self.SCOTCH_graphExit.argtypes = [ctypes.POINTER(self.SCOTCH_Graph)]

        # SCOTCH_graphCheck
        self.SCOTCH_graphCheck = self.clib.SCOTCH_graphCheck
        self.SCOTCH_graphCheck.argtypes = [ctypes.POINTER(self.SCOTCH_Graph)]

        # SCOTCH_graphBuild
        self.SCOTCH_graphBuild = self.clib.SCOTCH_graphBuild
        self.SCOTCH_graphBuild.argtypes = [
            ctypes.POINTER(self.SCOTCH_Graph), ctypes.c_int, ctypes.c_int,
            ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p,
            ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p
        ]

        # SCOTCH_stratAlloc
        self.SCOTCH_stratAlloc = self.clib.SCOTCH_stratAlloc
        #self.SCOTCH_stratAlloc.argtypes = [ None ]

        # SCOTCH_stratInit
        self.SCOTCH_stratInit = self.clib.SCOTCH_stratInit
        self.SCOTCH_stratInit.argtypes = [ctypes.POINTER(self.SCOTCH_Strat)]

        self.SCOTCH_stratExit = self.clib.SCOTCH_stratExit
        self.SCOTCH_stratExit.argtypes = [ctypes.POINTER(self.SCOTCH_Strat)]

        self.SCOTCH_stratGraphMap = self.clib.SCOTCH_stratGraphMap
        self.SCOTCH_stratGraphMap.argtypes = [ctypes.POINTER(self.SCOTCH_Strat), ctypes.c_char_p]

        self.SCOTCH_stratGraphMapBuild = self.clib.SCOTCH_stratGraphMapBuild
        self.SCOTCH_stratGraphMapBuild.argtypes = [ctypes.POINTER(self.SCOTCH_Strat), ctypes.c_int, ctypes.c_int, ctypes.c_double]

        # MAPPING Functions
        self.SCOTCH_graphMap = self.clib.SCOTCH_graphMap
        self.SCOTCH_graphMap.argtypes = [ctypes.POINTER(self.SCOTCH_Graph), ctypes.POINTER(self.SCOTCH_Arch), ctypes.POINTER(self.SCOTCH_Strat), ctypes.c_void_p]

        self.SCOTCH_graphMapFixed = self.clib.SCOTCH_graphMapFixed
        self.SCOTCH_graphMapFixed.argtypes = [ctypes.POINTER(self.SCOTCH_Graph), ctypes.POINTER(self.SCOTCH_Arch), ctypes.POINTER(self.SCOTCH_Strat), ctypes.c_void_p]

    def isLoaded(self):
        if self.clib is None:
            return False
        return True

    def version(self):
        major_ptr = ctypes.c_int(0)
        relative_ptr = ctypes.c_int(0)
        patch_ptr = ctypes.c_int(0)

        ret = self.SCOTCH_version(major_ptr, relative_ptr, patch_ptr)
        return "{}.{}.{}".format(major_ptr.value, relative_ptr.value, patch_ptr.value)

    def createSCOTCHArch(self):
        #self.SCOTCH_Arch = self.SCOTCH_archAlloc()
        #print(self.SCOTCH_Arch)
        self.architecture = self.SCOTCH_Arch()
        ret = self.SCOTCH_archInit(self.architecture)
        if(ret == 0):
            return True
        return False

    def deleteSCOTCHStrat(self):
        self.SCOTCH_stratExit(self.strategy)
        del self.strategy
        self.strategy = None

    def deleteSCOTCHArch(self):
        self.SCOTCH_archExit(self.architecture)
        del self.architecture
        self.architecture = None

    def populatePartitionArchitecture(self, numPartitions):
        if(self.architecture is None):
            return False

        if(isinstance(numPartitions, int)):
            ret = self.SCOTCH_archCmplt(self.architecture, numPartitions)
            if(ret == 0):
                return True
        return False

    def createSCOTCHGraph(self):
        #self.SCOTCH_Graph = self.SCOTCH_graphAlloc()
        self.graph = self.SCOTCH_Graph()
        ret = self.SCOTCH_graphInit(self.graph)
        if(ret == 0):
            return True
        return False

    def buildSCOTCHGraphFromData(self, scotchData):
        #if isinstance(scotchData, scotchio.ScotchGraphArrays) == False:
        #    return False

        if self.graph is None:
            if(self.createSCOTCHGraph() == False):
                return False

        if scotchData._vlbltab is None:
            success = self.SCOTCH_graphBuild(self.graph, scotchData.baseval, scotchData.vertnbr, scotchData._verttab.ctypes, 0, scotchData._velotab.ctypes, 0, scotchData.edgenbr, scotchData._edgetab.ctypes, scotchData._edlotab.ctypes)
        else:
            #print('SCOTCH.py, using vlbltab array')
            success = self.SCOTCH_graphBuild(self.graph, scotchData.baseval, scotchData.vertnbr, scotchData._verttab.ctypes, 0, scotchData._velotab.ctypes, scotchData._vlbltab.ctypes, scotchData.edgenbr, scotchData._edgetab.ctypes, scotchData._edlotab.ctypes)

        if success == 0:
            return True
        return False


    def deleteSCOTCHGraph(self):
        # TODO write test for this
        self.SCOTCH_graphExit(self.graph)
        del self.graph
        self.graph = None

    def scotchGraphValid(self):
        # TODO write test for this
        ret = self.SCOTCH_graphCheck(self.graph)
        if(ret == 0):
            return True
        return False

    def createStrategy(self):
        self.strategy = self.SCOTCH_Strat()
        ret = self.SCOTCH_stratInit(self.strategy)
        if ret == 0:
            return True
        return False

    def setStrategyGraphMapBuild(self, straval, partitionNbr, kbalval = 0.1):
        ret = self.SCOTCH_stratGraphMapBuild(self.strategy, straval, partitionNbr, kbalval)
        if ret == 0:
            return True
        return False

    def setStrategyFlags(self, strategyFlags):
        if(isinstance(strategyFlags, str) == False):
            strategyFlags = ''
        # Note: must encode the string as that returns a bytecode equivalent
        success = self.SCOTCH_stratGraphMap(self.strategy, strategyFlags.encode('utf-8'))
        if(success == 0):
            return True
        return False

    def createSCOTCHGraphMapStrategy(self, strategyFlags):
        #self.strategy = self.SCOTCH_stratAlloc()
        self.strategy = self.SCOTCH_Strat()
        ret = self.SCOTCH_stratInit(self.strategy)
        if(ret == 0):
            if(isinstance(strategyFlags, str) == False):
                strategyFlags = ''
            # Note: must encode the string as that returns a bytecode equivalent
            success = self.SCOTCH_stratGraphMap(self.strategy, strategyFlags.encode('utf-8'))
            if(success == 0):
                return True
        return False

    def graphMap(self, parttab):

        ret = self.SCOTCH_graphMap(self.graph, self.architecture, self.strategy, parttab.ctypes)
        if ret == 0:
            return True
        return False

    def graphMapFixed(self, parttab):
        ret = self.SCOTCH_graphMapFixed(self.graph, self.architecture, self.strategy, parttab.ctypes)
        if ret == 0:
            return True
        return False

#!/usr/bin/python

import sys
from xml.dom import minidom

class UnknownEntry(Exception):
    pass
class UnhandledCase(Exception):
    pass

GMAIL_PROPERTIES = {
    #Criteria
    'to' : 'c',
    'from' : 'c',
    'hasTheWord' : 'c',
    'doesNotHaveTheWord' : 'c',
    'subject' : 'c',

    #Actions
    'label' : 'a',
    'shouldTrash' : 'a',
    'shouldAlwaysMarkAsImportant' : 'a',
    'shouldNeverSpam' : 'a',
    'shouldMarkAsRead' : 'a',
    'shouldArchive' : 'a',

    #Ignore (What _are_ these?)
    'sizeUnit' : 'i',
    'sizeOperator' : 'i',    
}

def getFilterCriteria(properties):
    return {p:v for p,v in properties.iteritems() if p in GMAIL_PROPERTIES and GMAIL_PROPERTIES[p] == 'c'}
def getFilterActions(properties):
    return {p:v for p,v in properties.iteritems() if p in GMAIL_PROPERTIES and GMAIL_PROPERTIES[p] == 'a'}
def getFilterUnknown(properties):
    return {p:v for p,v in properties.iteritems() if p not in GMAIL_PROPERTIES}

def filterToSieve(properties):
    criteria = getFilterCriteria(properties)
    actions = getFilterActions(properties)
    unknown = getFilterUnknown(properties)

    if len(unknown) >= 1:
        raise UnknownEntry("Identified the following unknown filter criteria:" + str(unknown))

    folder = None
    sieve_title = ""
    sieve_script  = "# rule:[XXX_REPLACEME_XXX]\n"
    sieve_script += "if allof ("

    #===================================================================================================
    sieve_criteria = []
    for c in criteria:
        this_criteria = ""
        #Simple From, To, or Subject Matching
        if c in ["from", "to", "subject"]:
            subcriteria = criteria[c].split(" OR ")
            this_criteria += "header :contains \"" + c + "\" "
            if len(subcriteria) > 1: this_criteria += "["
            this_criteria += "\"" + "\",\"".join(subcriteria) + "\""
            if len(subcriteria) > 1: this_criteria += "]"
        #Match a Mailing List
        elif c == "hasTheWord" and "list:" in criteria[c]:
            list_id = criteria[c].replace("list:", "").strip("('\")")
            this_criteria += "header :contains \"list-id\" \"" + list_id + "\""
        elif c == "hasTheWord":
            raise UnhandledCase("hasTheWord without a list: identifier")
        #Match a missing word
        elif c == "doesNotHaveTheWord":
            subcriteria = criteria[c].split(" OR ")
            this_criteria += "not body :text :contains "
            if len(subcriteria) > 1: this_criteria += "["
            this_criteria += "\"" + "\",\"".join(subcriteria) + "\""
            if len(subcriteria) > 1: this_criteria += "]"

        sieve_criteria.append(this_criteria)

    sieve_script += ", ".join(sieve_criteria)
    sieve_script += ")\n{\n"

    #===================================================================================================
    didAction = False
    for a in actions:
        if a == 'label':
            didAction = True
            folder = actions[a].replace(".", "-").replace("/", ".")
            sieve_title = actions[a]
            sieve_script += "\tfileinto \"" + folder + "\";\n"
        elif a == 'shouldTrash':
            didAction = True
            sieve_script += "\tdiscard;\n"
        elif a == 'shouldMarkAsRead':
            didAction = True
            sieve_script += "\taddflag \"\\\\Seen\";\n"
        elif a == 'shouldAlwaysMarkAsImportant':
            didAction = True
            sieve_script += "\taddflag \"\\\\Flagged\";\n"
        elif a == 'shouldArchive':
            pass
        elif a == 'shouldNeverSpam':
            pass

    if not didAction:
        return "",""

    sieve_script += "}\n"
    if sieve_title:
        sieve_script = sieve_script.replace("XXX_REPLACEME_XXX", sieve_title)
    else:
        sieve_script = sieve_script.replace("# rule:[XXX_REPLACEME_XXX]\n", "")
    return sieve_script.encode('utf-8'), folder

#===================================================================================================

if __name__ == "__main__":
    if len(sys.argv) < 4:
        print "Usage: " + sys.argv[0] + " input:filters.xml output:filters.sieve output:folderscript.sh"
        sys.exit()

    inputfile = sys.argv[1]
    xmldoc = minidom.parse(inputfile)

    filters = []
    for p in xmldoc.getElementsByTagName("entry"):
        properties = {}
        for n in p.childNodes:
            if n.nodeName == "apps:property":
                properties[n.getAttribute('name')] = n.getAttribute('value')
        filters.append(properties)

    sieveout = open(sys.argv[2], "w")
    bashout = open(sys.argv[3], "w")

    sieveout.write('require ["body","fileinto","imap4flags"];\n')

    folders  = set()
    unhandled = 0
    unhandled_criteria = set()
    for f in filters:
        try:
            script, folder = filterToSieve(f)
            sieveout.write(script)
            if folder:
                folders.add(folder)
        except UnknownEntry     :
            unhandled += 1
            unhandled_criteria.update(getFilterUnknown(f))

    if len(folders) > 0:
        bashout.write("#!/bin/bash\n")
        for i in folders:
            bashout.write('mkdir -p ".' + i + '/new"\n')
            bashout.write('mkdir -p ".' + i + '/tmp"\n')
            bashout.write('mkdir -p ".' + i + '/cur"\n')
            bashout.write('touch ".' + i + '/maildirfolder"\n')
        bashout.write('chown -R vmail:vmail .*')

    if unhandled > 0:
        print unhandled, "filters were unable to be processed. The following unknown attributes were seen:", list(unhandled_criteria)


#! /usr/bin/env python

# Copyright (c) 2016 Zielezinski A, combio.pl

import argparse
import sys

from alfpy import word_distance
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__


def get_parser():
    parser = argparse.ArgumentParser(
        description='''Calculate distances between protein/DNA sequences based
        on Return Time Distribution (RTD) of words\' occurrences and their
        relative orders''',
        add_help=False, prog='calc_word_rtd.py'
    )
    group = parser.add_argument_group('REQUIRED ARGUMENTS')
    group.add_argument('--fasta', '-f',
                       help='input FASTA sequence filename', required=True,
                       type=argparse.FileType('r'), metavar="FILE")

    group = parser.add_argument_group('  Choose between the two options')
    g1 = group.add_mutually_exclusive_group()
    g1.add_argument('--word_size', '-s', metavar="N",
                    help='word size for creating word patterns',
                    type=int)
    g1.add_argument('--word_pattern', '-w',
                    help='input filename w/ pre-computed word patterns',
                    type=argparse.FileType('r'), metavar="FILE")

    group = parser.add_argument_group('OPTIONAL ARGUMENTS')
    distlist = word_distance.Distance.get_disttypes()
    group.add_argument('--distance', '-d', choices=distlist,
                       help='choose from: {} [DEFAULT: %(default)s]'.format(
                           ", ".join(distlist)),
                       metavar='', default="google")

    group = parser.add_argument_group('OUTPUT ARGUMENTS')
    group.add_argument('--out', '-o', help="output filename",
                       metavar="FILE")
    group.add_argument('--outfmt', choices=['phylip', 'pairwise'],
                       default='phylip',
                       help='distances output format [DEFAULT: %(default)s]')

    group = parser.add_argument_group("OTHER OPTIONS")
    group.add_argument("-h", "--help", action="help",
                       help="show this help message and exit")
    group.add_argument('--version', action='version',
                       version='%(prog)s {}'.format(__version__))

    if len(sys.argv[1:]) == 0:
        # parser.print_help()
        parser.print_usage()
        parser.exit()

    return parser


def validate_args(parser):
    args = parser.parse_args()
    if args.word_size:
        if args.word_size < 1:
            parser.error('word size must be >= 1')
    elif args.word_pattern:
        p = word_pattern.read(args.word_pattern)
        if not p.pos_list:
            e = "{0} does not contain info on word positions.\n"
            e += "Please use: create_wordpattern.py with"
            e += " --word_position option."
            parser.error(e.format(args.word_pattern.name))
        else:
            args.word_pattern = p
    else:
        parser.error("Specify either: --word_size or --word_pattern.")
    return args


def main():
    parser = get_parser()
    args = validate_args(parser)

    seq_records = seqrecords.read_fasta(args.fasta)
    if args.word_size:
        p = word_pattern.create(seq_records.seq_list, args.word_size, True)
    else:
        p = args.word_pattern

    vector = word_rtd.create_vector(seq_records.count, p)
    dist = word_rtd.Distance(vector, args.distance)

    matrix = distmatrix.create(seq_records.id_list, dist)

    if args.out:
        oh = open(args.out, 'w')
        matrix.write_to_file(oh, args.outfmt)
        oh.close()
    else:
        matrix.display(args.outfmt)


if __name__ == '__main__':
    main()

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================

"""Logging utilities."""
# pylint: disable=unused-import
# pylint: disable=g-bad-import-order
# pylint: disable=invalid-name
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import logging as _logging
import os as _os
import sys as _sys
import time as _time
from logging import DEBUG
from logging import ERROR
from logging import FATAL
from logging import INFO
from logging import WARN

import six

from tensorflow.python.util.all_util import remove_undocumented


# Determine whether we are in an interactive environment
_interactive = False
try:
  # This is only defined in interactive shells
  if _sys.ps1: _interactive = True
except AttributeError:
  # Even now, we may be in an interactive shell with `python -i`.
  _interactive = _sys.flags.interactive

# Scope the tensorflow logger to not conflict with users' loggers
_logger = _logging.getLogger('tensorflow')

# If we are in an interactive environment (like jupyter), set loglevel to info
# and pipe the output to stdout
if _interactive:
  _logger.setLevel(INFO)
  _logging_target = _sys.stdout
else:
  _logging_target = _sys.stderr

# Add the output handler
_handler = _logging.StreamHandler(_logging_target)
_handler.setFormatter(_logging.Formatter(_logging.BASIC_FORMAT, None))
_logger.addHandler(_handler)


def log(level, msg, *args, **kwargs):
  _logger.log(level, msg, *args, **kwargs)


def debug(msg, *args, **kwargs):
  _logger.debug(msg, *args, **kwargs)


def error(msg, *args, **kwargs):
  _logger.error(msg, *args, **kwargs)


def fatal(msg, *args, **kwargs):
  _logger.fatal(msg, *args, **kwargs)


def info(msg, *args, **kwargs):
  _logger.info(msg, *args, **kwargs)


def warn(msg, *args, **kwargs):
  _logger.warn(msg, *args, **kwargs)


def warning(msg, *args, **kwargs):
  _logger.warning(msg, *args, **kwargs)


_level_names = {
    FATAL: 'FATAL',
    ERROR: 'ERROR',
    WARN: 'WARN',
    INFO: 'INFO',
    DEBUG: 'DEBUG',
}

# Mask to convert integer thread ids to unsigned quantities for logging
# purposes
_THREAD_ID_MASK = 2 * _sys.maxsize + 1

_log_prefix = None  # later set to google2_log_prefix

# Counter to keep track of number of log entries per token.
_log_counter_per_token = {}


def TaskLevelStatusMessage(msg):
  error(msg)


def flush():
  raise NotImplementedError()


# Code below is taken from pyglib/logging
def vlog(level, msg, *args, **kwargs):
  _logger.log(level, msg, *args, **kwargs)


def _GetNextLogCountPerToken(token):
  """Wrapper for _log_counter_per_token.

  Args:
    token: The token for which to look up the count.

  Returns:
    The number of times this function has been called with
    *token* as an argument (starting at 0)
  """
  global _log_counter_per_token  # pylint: disable=global-variable-not-assigned
  _log_counter_per_token[token] = 1 + _log_counter_per_token.get(token, -1)
  return _log_counter_per_token[token]


def log_every_n(level, msg, n, *args):
  """Log 'msg % args' at level 'level' once per 'n' times.

  Logs the 1st call, (N+1)st call, (2N+1)st call,  etc.
  Not threadsafe.

  Args:
    level: The level at which to log.
    msg: The message to be logged.
    n: The number of times this should be called before it is logged.
    *args: The args to be substituted into the msg.
  """
  count = _GetNextLogCountPerToken(_GetFileAndLine())
  log_if(level, msg, not (count % n), *args)


def log_first_n(level, msg, n, *args):  # pylint: disable=g-bad-name
  """Log 'msg % args' at level 'level' only first 'n' times.

  Not threadsafe.

  Args:
    level: The level at which to log.
    msg: The message to be logged.
    n: The number of times this should be called before it is logged.
    *args: The args to be substituted into the msg.
  """
  count = _GetNextLogCountPerToken(_GetFileAndLine())
  log_if(level, msg, count < n, *args)


def log_if(level, msg, condition, *args):
  """Log 'msg % args' at level 'level' only if condition is fulfilled."""
  if condition:
    vlog(level, msg, *args)


def _GetFileAndLine():
  """Returns (filename, linenumber) for the stack frame."""
  # Use sys._getframe().  This avoids creating a traceback object.
  # pylint: disable=protected-access
  f = _sys._getframe()
  # pylint: enable=protected-access
  our_file = f.f_code.co_filename
  f = f.f_back
  while f:
    code = f.f_code
    if code.co_filename != our_file:
      return (code.co_filename, f.f_lineno)
    f = f.f_back
  return ('<unknown>', 0)


def google2_log_prefix(level, timestamp=None, file_and_line=None):
  """Assemble a logline prefix using the google2 format."""
  # pylint: disable=global-variable-not-assigned
  global _level_names
  # pylint: enable=global-variable-not-assigned

  # Record current time
  now = timestamp or _time.time()
  now_tuple = _time.localtime(now)
  now_microsecond = int(1e6 * (now % 1.0))

  (filename, line) = file_and_line or _GetFileAndLine()
  basename = _os.path.basename(filename)

  # Severity string
  severity = 'I'
  if level in _level_names:
    severity = _level_names[level][0]

  s = '%c%02d%02d %02d:%02d:%02d.%06d %5d %s:%d] ' % (
      severity,
      now_tuple[1],  # month
      now_tuple[2],  # day
      now_tuple[3],  # hour
      now_tuple[4],  # min
      now_tuple[5],  # sec
      now_microsecond,
      _get_thread_id(),
      basename,
      line)

  return s


def get_verbosity():
  """Return how much logging output will be produced."""
  return _logger.getEffectiveLevel()


def set_verbosity(v):
  """Sets the threshold for what messages will be logged."""
  _logger.setLevel(v)


def _get_thread_id():
  """Get id of current thread, suitable for logging as an unsigned quantity."""
  # pylint: disable=protected-access
  thread_id = six.moves._thread.get_ident()
  # pylint:enable=protected-access
  return thread_id & _THREAD_ID_MASK


_log_prefix = google2_log_prefix

# Controls which methods from pyglib.logging are available within the project.
# Do not add methods here without also adding to platform/tf_logging.py.
_allowed_symbols = [
    'DEBUG',
    'ERROR',
    'FATAL',
    'INFO',
    'TaskLevelStatusMessage',
    'WARN',
    'debug',
    'error',
    'fatal',
    'flush',
    'get_verbosity',
    'info',
    'log',
    'log_if',
    'log_every_n',
    'log_first_n',
    'set_verbosity',
    'vlog',
    'warn',
    'warning',
]

remove_undocumented(__name__, _allowed_symbols)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Functions for performing and processing ROC analyses.

@author: David Samu
"""

import numpy as np
import pandas as pd

from sklearn.metrics import roc_auc_score
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import permutation_test_score

from seal.util import util
from seal.roc import rocutil, rocpost


# Some analysis constants.
min_sample_size = 10
n_folds = 5
n_jobs = 1  # or util.get_n_cores() - 1


# DataFrame containing analysis params per feature to analyze.
feat_pars = {'DS': ('pref_anti_dirs', 'pref and anti dirs', None, None),
             # 'CE': ('S_D_trials', 'S and D trials', 1900*ms, None)}
             'CE': ('S_D_trials', 'S and D trials', None, None)}
feat_pars = pd.DataFrame(feat_pars, index=('prefix', 'btw_str', 't1', 't2')).T


# %% Core ROC analysis functions.

def calc_auc(clf, x, y):
    """
    Calculate area under the curve of ROC analysis.

    y values have to be 0 and 1!
    """

    # Format x into array of arrays.
    if len(x.shape) < 2:
        x = np.array(x, ndmin=2).T

    # Fit model to data.
    clf.fit(x, y)

    # Get prediction probability of classes.
    preds = clf.predict_proba(x)

    # Select class of higher mean to be taken as one to be predicted.
    # idx = pd.Series(x, index=y).groupby(y).mean().idxmax()  # much slower :(
    idx = int(np.mean(x[y == 0]) < np.mean(x[y == 1]))
    y_pred = preds[:, idx]

    # Calculate area under the curve (AUC) using true and predicted y values.
    auc = roc_auc_score(y, y_pred)

    return auc


def ROC(x, y, n_perm=None, clf=None):
    """
    Perform ROC analysis with optional permutation test.

    y values have to be 0 and 1 for calc_auc()!
    """

    # Remove NaN values.
    idx = np.logical_and(~np.isnan(x), ~np.isnan(y))
    x, y = np.array(x[idx]), np.array(y[idx])

    # Insufficient sample size or not exactly two values to classify.
    n_yvals = len(np.unique(y))
    if (min(len(x), len(y)) < min_sample_size) or (n_yvals != 2):
        if n_yvals > 2:
            print('More than two values to classify:' + str(np.unique(y)))
        return np.nan, None

    # Format x into array of arrays.
    x = np.array(x, ndmin=2).T

    # Default classifier.
    if clf is None:
        clf = LogisticRegression()

    # Calculate AUC of true data.
    true_auc = calc_auc(clf, x, y)

    # Permutation test.
    pvalue = None
    if n_perm is not None and n_perm > 0:

        cv = StratifiedKFold(n_folds)

        # Test significance of classification with cross-validated permutation.
        res = permutation_test_score(clf, x, y, scoring='accuracy', cv=cv,
                                     n_permutations=n_perm, n_jobs=n_jobs)
        score, perm_scores, pvalue = res

    return true_auc, pvalue


# %% Higher level functions to run AROC on a unit and group of units over time.

def run_ROC_over_time(rates1, rates2, n_perm=None, clf=None):
    """Run ROC analysis between two rate frames (trials by time)."""

    # Merge rates and create and target vector.
    rates = pd.concat([rates1, rates2])
    target_vec = pd.Series(len(rates.index)*[1], index=rates.index)
    target_vec[rates2.index] = 0  # all y values have to be 0/1 for ROC

    # Default classifier.
    if clf is None:
        clf = LogisticRegression()

    # Run ROC across time.
    roc_res = pd.DataFrame([ROC(rates[t], target_vec, n_perm, clf)
                            for t in rates],
                           index=rates.columns, columns=['auc', 'pval'])

    return roc_res


def run_unit_ROC_over_time(u, prd, ref_ev, trs_list, nrate, tstep, n_perm,
                           zscore_by, verbose):
    """Run ROC analysis of unit over time. Suitable for parallelization."""

    # Report progress.
    if verbose:
        print(u.Name)

    # Set up params: trials, time period and rates.
    t1s, t2s = u.pr_times(prd, concat=False)
    ref_ts = u.ev_times(ref_ev)

    # Prepare rates.
    rates1, rates2 = [u._Rates[nrate].get_rates(trs, t1s, t2s, ref_ts, tstep)
                      for trs in trs_list]

    # Z-score rates by some trial parameter.
    rates = pd.concat([rates1, rates2])
    if zscore_by is not None:
        ztrs = u.trials_by_param(zscore_by)
        for par, trs in ztrs.items():
            itrs = rates.index.intersection(trs)
            if len(itrs):
                irates = rates.loc[itrs]
                mean = irates.mean()
                std = irates.std(ddof=0)
                rates.loc[itrs, :] = (irates - mean)/std
    rates1, rates2 = [rates.loc[r.index] for r in (rates1, rates2)]

    # Calculate AROC on rates.
    aroc_res = run_ROC_over_time(rates1, rates2, n_perm)

    return aroc_res


def run_group_ROC_over_time(ulist, trs_list, prd, ref_ev, n_perm=None,
                            nrate=None, tstep=None, zscore_by=None,
                            verbose=True):
    """Run ROC over list of units over time."""

    # Run unit-wise AROC test in pool.
    params = [(u, prd, ref_ev, trs_list[i], nrate, tstep,
               n_perm, zscore_by, verbose) for i, u in enumerate(ulist)]
    aroc_res = util.run_in_pool(run_unit_ROC_over_time, params)

    # Separate AUC and p-values.
    aroc_dict = {u.Name: aroc.auc for u, aroc in zip(ulist, aroc_res)}
    pval_dict = {u.Name: aroc.pval for u, aroc in zip(ulist, aroc_res)}

    # Concat into DF.
    aroc_res = pd.concat(aroc_dict, axis=1).T
    pval_res = pd.concat(pval_dict, axis=1).T

    return aroc_res, pval_res


def calc_AROC(ulist, trs_list, prd_pars, n_perm, nrate, tstep, fres,
              verbose=True, rem_all_nan_units=True, rem_any_nan_times=True):
    """Calculate and plot AROC over time between specified sets of trials."""

    stims = prd_pars.index
    aroc_list, pval_list = [], []
    for stim in stims:
        print('    ' + stim)

        # Extract period params.
        pars = ['prd', 'ref_ev', 'feat', 'cond_by', 'zscore_by']
        prd, ref_ev, sfeat, sep_by, zscore_by = prd_pars.loc[stim, pars]

        # Calculate AROC DF.
        aroc, pval = run_group_ROC_over_time(ulist, trs_list[stim], prd,
                                             ref_ev, n_perm, nrate, tstep,
                                             zscore_by, verbose)
        aroc_list.append(aroc)
        pval_list.append(pval)

    # Concatenate stimulus-specific results.
    tshifts = list(prd_pars.stim_start)
    truncate_prds = [list(prd_pars.loc[stim, ['prd_start', 'prd_stop']])
                     for stim in stims]

    aroc = util.concat_stim_prd_res(aroc_list, tshifts, truncate_prds,
                                    rem_all_nan_units, rem_any_nan_times)
    pval = util.concat_stim_prd_res(pval_list, tshifts, truncate_prds,
                                    rem_all_nan_units, rem_any_nan_times)

    # Refill pvals with NaN's if it gets completely emptied above.
    if pval.empty:
        pval = pd.DataFrame(columns=pval.columns, index=aroc.index)

    # Save results.
    if fres is not None:
        aroc_res = {'aroc': aroc, 'pval': pval, 'nrate': nrate,
                    'tstep': tstep, 'n_perm': n_perm}
        util.write_objects(aroc_res, fres)

    return aroc, pval


# %% ROC misc functions.

def run_ROC(ulist, trs_list, nrate, tstep, n_perm, offsets, prd_pars,
            ares_dir):

    # Calculate and save AROC results.
    fres = rocutil.aroc_res_fname(ares_dir, nrate, tstep, n_perm, offsets)
    calc_AROC(ulist, trs_list, prd_pars, n_perm, nrate, tstep, fres)


def plot_ROC(nrate, task, sort_prds, prd_pars, tstep, n_perm, offsets, prefix,
             btw_str, pth, min_len, vth_hi, vth_lo, cmaps,  merge_hi_lo,
             flip_aroc_vals, ares_dir, t1=None, t2=None):

    # Plot AROC matrix sorted by different periods.
    res = rocutil.load_aroc_res(ares_dir, nrate, tstep, n_perm, offsets)
    aroc, pval = res['aroc'], res['pval']

    # Plot results on heatmap.
    rocpost.plot_ROC_heatmap(aroc, pval, task, nrate, tstep, n_perm,
                             sort_prds, prd_pars, offsets, ares_dir,
                             prefix, btw_str, pth, min_len, vth_hi, vth_lo,
                             cmaps, merge_hi_lo, flip_aroc_vals, t1, t2)


def run_plot_feat_ROC(task, feat, feat_params, sort_prds, prd_pars, stims,
                      tstep, nrate, n_perm, offsets, pth, min_len, nlist,
                      ulist, runroc, plotroc, vth_hi, vth_lo, cmaps,
                      merge_hi_lo, flip_aroc_vals, aroc_res_dir,
                      t1=None, t2=None):
    """Run and plot ROC run on given feature."""

    ares_dir = aroc_res_dir + '{}/{}/'.format(feat, nlist)
    prefix, btw_str, t1, t2 = feat_params.loc[feat]

    if runroc:

        # Collect trials to use.
        if feat == 'DS':
            trs_list = {stim: [u.dir_pref_anti_trials(stim, [stim], offsets)
                        for u in ulist] for stim in stims}
        elif feat == 'CE':
            trs_list = {stim: [u.S_D_trials('S2', offsets)
                        for u in ulist] for stim in stims}
        else:
            print('Unknown feature to run ROC on: ', feat)
            return

        # Run ROC.
        run_ROC(ulist, trs_list, nrate, tstep, n_perm, offsets, prd_pars,
                ares_dir)

    if plotroc:

        # Plot ROC results.
        plot_ROC(nrate, task, sort_prds, prd_pars, tstep, n_perm, offsets,
                 prefix, btw_str, pth, min_len, vth_hi, vth_lo, cmaps,
                 merge_hi_lo, flip_aroc_vals, ares_dir, t1, t2)

from __future__ import division, print_function, absolute_import

import warnings

import numpy as np
import numpy.testing as npt

from scipy import integrate
from scipy import stats
from scipy.special import betainc
from common_tests import (check_normalization, check_moment, check_mean_expect,
                          check_var_expect, check_skew_expect,
                          check_kurt_expect, check_entropy,
                          check_private_entropy,
                          check_edge_support, check_named_args,
                          check_random_state_property,
                          check_meth_dtype, check_ppf_dtype, check_cmplx_deriv,
                          check_pickling, check_rvs_broadcast)
from scipy.stats._distr_params import distcont

"""
Test all continuous distributions.

Parameters were chosen for those distributions that pass the
Kolmogorov-Smirnov test.  This provides safe parameters for each
distributions so that we can perform further testing of class methods.

These tests currently check only/mostly for serious errors and exceptions,
not for numerically exact results.
"""

# Note that you need to add new distributions you want tested
# to _distr_params

DECIMAL = 5  # specify the precision of the tests  # increased from 0 to 5

# Last four of these fail all around. Need to be checked
distcont_extra = [
    ['betaprime', (100, 86)],
    ['fatiguelife', (5,)],
    ['mielke', (4.6420495492121487, 0.59707419545516938)],
    ['invweibull', (0.58847112119264788,)],
    # burr: sample mean test fails still for c<1
    ['burr', (0.94839838075366045, 4.3820284068855795)],
    # genextreme: sample mean test, sf-logsf test fail
    ['genextreme', (3.3184017469423535,)],
]


distslow = ['rdist', 'gausshyper', 'recipinvgauss', 'ksone', 'genexpon',
            'vonmises', 'vonmises_line', 'mielke', 'semicircular',
            'cosine', 'invweibull', 'powerlognorm', 'johnsonsu', 'kstwobign']
# distslow are sorted by speed (very slow to slow)


# These distributions fail the complex derivative test below.
# Here 'fail' mean produce wrong results and/or raise exceptions, depending
# on the implementation details of corresponding special functions.
# cf https://github.com/scipy/scipy/pull/4979 for a discussion.
fails_cmplx = set(['beta', 'betaprime', 'chi', 'chi2', 'dgamma', 'dweibull',
                   'erlang', 'f', 'gamma', 'gausshyper', 'gengamma',
                   'gennorm', 'genpareto', 'halfgennorm', 'invgamma',
                   'ksone', 'kstwobign', 'levy_l', 'loggamma', 'logistic',
                   'maxwell', 'nakagami', 'ncf', 'nct', 'ncx2',
                   'pearson3', 'rice', 't', 'skewnorm', 'tukeylambda',
                   'vonmises', 'vonmises_line',])

def test_cont_basic():
    # this test skips slow distributions
    with warnings.catch_warnings():
        warnings.filterwarnings('ignore',
                                category=integrate.IntegrationWarning)
        for distname, arg in distcont[:]:
            if distname in distslow:
                continue
            if distname is 'levy_stable':
                continue
            distfn = getattr(stats, distname)
            np.random.seed(765456)
            sn = 500
            rvs = distfn.rvs(size=sn, *arg)
            sm = rvs.mean()
            sv = rvs.var()
            m, v = distfn.stats(*arg)

            yield (check_sample_meanvar_, distfn, arg, m, v, sm, sv, sn,
                   distname + 'sample mean test')
            yield check_cdf_ppf, distfn, arg, distname
            yield check_sf_isf, distfn, arg, distname
            yield check_pdf, distfn, arg, distname
            yield check_pdf_logpdf, distfn, arg, distname
            yield check_cdf_logcdf, distfn, arg, distname
            yield check_sf_logsf, distfn, arg, distname

            alpha = 0.01
            yield check_distribution_rvs, distname, arg, alpha, rvs

            locscale_defaults = (0, 1)
            meths = [distfn.pdf, distfn.logpdf, distfn.cdf, distfn.logcdf,
                     distfn.logsf]
            # make sure arguments are within support
            spec_x = {'frechet_l': -0.5, 'weibull_max': -0.5, 'levy_l': -0.5,
                      'pareto': 1.5, 'tukeylambda': 0.3}
            x = spec_x.get(distname, 0.5)
            yield check_named_args, distfn, x, arg, locscale_defaults, meths
            yield check_random_state_property, distfn, arg
            yield check_pickling, distfn, arg

            # Entropy
            skp = npt.dec.skipif
            yield check_entropy, distfn, arg, distname

            if distfn.numargs == 0:
                yield check_vecentropy, distfn, arg
            if distfn.__class__._entropy != stats.rv_continuous._entropy:
                yield check_private_entropy, distfn, arg, stats.rv_continuous

            yield check_edge_support, distfn, arg

            yield check_meth_dtype, distfn, arg, meths
            yield check_ppf_dtype, distfn, arg
            yield skp(distname in fails_cmplx)(check_cmplx_deriv), distfn, arg

            knf = npt.dec.knownfailureif
            yield (knf(distname == 'truncnorm')(check_ppf_private), distfn,
                   arg, distname)


def test_levy_stable_random_state_property():
    # levy_stable only implements rvs(), so it is skipped in the
    # main loop in test_cont_basic(). Here we apply just the test
    # check_random_state_property to levy_stable.
    check_random_state_property(stats.levy_stable, (0.5, 0.1))


@npt.dec.slow
def test_cont_basic_slow():
    # same as above for slow distributions
    with warnings.catch_warnings():
        warnings.filterwarnings('ignore',
                                category=integrate.IntegrationWarning)
        for distname, arg in distcont[:]:
            if distname not in distslow:
                continue
            if distname is 'levy_stable':
                continue
            distfn = getattr(stats, distname)
            np.random.seed(765456)
            sn = 500
            rvs = distfn.rvs(size=sn, *arg)
            sm = rvs.mean()
            sv = rvs.var()
            m, v = distfn.stats(*arg)
            yield (check_sample_meanvar_, distfn, arg, m, v, sm, sv, sn,
                   distname + 'sample mean test')
            yield check_cdf_ppf, distfn, arg, distname
            yield check_sf_isf, distfn, arg, distname
            yield check_pdf, distfn, arg, distname
            yield check_pdf_logpdf, distfn, arg, distname
            yield check_cdf_logcdf, distfn, arg, distname
            yield check_sf_logsf, distfn, arg, distname
            # yield check_oth, distfn, arg # is still missing

            alpha = 0.01
            yield check_distribution_rvs, distname, arg, alpha, rvs

            locscale_defaults = (0, 1)
            meths = [distfn.pdf, distfn.logpdf, distfn.cdf, distfn.logcdf,
                     distfn.logsf]
            # make sure arguments are within support
            x = 0.5
            if distname == 'invweibull':
                arg = (1,)
            elif distname == 'ksone':
                arg = (3,)
            yield check_named_args, distfn, x, arg, locscale_defaults, meths
            yield check_random_state_property, distfn, arg
            yield check_pickling, distfn, arg

            # Entropy
            skp = npt.dec.skipif
            ks_cond = distname in ['ksone', 'kstwobign']
            yield skp(ks_cond)(check_entropy), distfn, arg, distname

            if distfn.numargs == 0:
                yield check_vecentropy, distfn, arg
            if (distfn.__class__._entropy != stats.rv_continuous._entropy
                    and distname != 'vonmises'):
                yield check_private_entropy, distfn, arg, stats.rv_continuous

            yield check_edge_support, distfn, arg

            yield check_meth_dtype, distfn, arg, meths
            yield check_ppf_dtype, distfn, arg
            yield skp(distname in fails_cmplx)(check_cmplx_deriv), distfn, arg


@npt.dec.slow
def test_moments():
    with warnings.catch_warnings():
        warnings.filterwarnings('ignore',
                                category=integrate.IntegrationWarning)
        knf = npt.dec.knownfailureif
        fail_normalization = set(['vonmises', 'ksone'])
        fail_higher = set(['vonmises', 'ksone', 'ncf'])
        for distname, arg in distcont[:]:
            if distname is 'levy_stable':
                continue
            distfn = getattr(stats, distname)
            m, v, s, k = distfn.stats(*arg, moments='mvsk')
            cond1 = distname in fail_normalization
            cond2 = distname in fail_higher
            msg = distname + ' fails moments'
            yield knf(cond1, msg)(check_normalization), distfn, arg, distname
            yield knf(cond2, msg)(check_mean_expect), distfn, arg, m, distname
            yield (knf(cond2, msg)(check_var_expect), distfn, arg, m, v,
                   distname)
            yield (knf(cond2, msg)(check_skew_expect), distfn, arg, m, v, s,
                   distname)
            yield (knf(cond2, msg)(check_kurt_expect), distfn, arg, m, v, k,
                   distname)
            yield check_loc_scale, distfn, arg, m, v, distname
            yield check_moment, distfn, arg, m, v, distname


def test_rvs_broadcast():
    for dist, shape_args in distcont:
        # If shape_only is True, it means the _rvs method of the
        # distribution uses more than one random number to generate a random
        # variate.  That means the result of using rvs with broadcasting or
        # with a nontrivial size will not necessarily be the same as using the
        # numpy.vectorize'd version of rvs(), so we can only compare the shapes
        # of the results, not the values.
        # Whether or not a distribution is in the following list is an
        # implementation detail of the distribution, not a requirement.  If
        # the implementation the rvs() method of a distribution changes, this
        # test might also have to be changed.
        shape_only = dist in ['betaprime', 'dgamma', 'exponnorm',
                              'nct', 'dweibull', 'rice', 'levy_stable',
                              'skewnorm']

        distfunc = getattr(stats, dist)
        loc = np.zeros(2)
        scale = np.ones((3, 1))
        nargs = distfunc.numargs
        allargs = []
        bshape = [3, 2]
        # Generate shape parameter arguments...
        for k in range(nargs):
            shp = (k + 4,) + (1,)*(k + 2)
            allargs.append(shape_args[k]*np.ones(shp))
            bshape.insert(0, k + 4)
        allargs.extend([loc, scale])
        # bshape holds the expected shape when loc, scale, and the shape
        # parameters are all broadcast together.
        yield check_rvs_broadcast, distfunc, dist, allargs, bshape, shape_only, 'd'


def test_rvs_gh2069_regression():
    # Regression tests for gh-2069.  In scipy 0.17 and earlier,
    # these tests would fail.
    #
    # A typical example of the broken behavior:
    # >>> norm.rvs(loc=np.zeros(5), scale=np.ones(5))
    # array([-2.49613705, -2.49613705, -2.49613705, -2.49613705, -2.49613705])
    np.random.seed(123)
    vals = stats.norm.rvs(loc=np.zeros(5), scale=1)
    d = np.diff(vals)
    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")
    vals = stats.norm.rvs(loc=0, scale=np.ones(5))
    d = np.diff(vals)
    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")
    vals = stats.norm.rvs(loc=np.zeros(5), scale=np.ones(5))
    d = np.diff(vals)
    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")
    vals = stats.norm.rvs(loc=np.array([[0], [0]]), scale=np.ones(5))
    d = np.diff(vals.ravel())
    npt.assert_(np.all(d != 0), "All the values are equal, but they shouldn't be!")

    npt.assert_raises(ValueError, stats.norm.rvs, [[0, 0], [0, 0]],
                  [[1, 1], [1, 1]], 1)
    npt.assert_raises(ValueError, stats.gamma.rvs, [2, 3, 4, 5], 0, 1, (2, 2))
    npt.assert_raises(ValueError, stats.gamma.rvs, [1, 1, 1, 1], [0, 0, 0, 0],
                     [[1], [2]], (4,))


def check_sample_meanvar_(distfn, arg, m, v, sm, sv, sn, msg):
    # this did not work, skipped silently by nose
    if np.isfinite(m):
        check_sample_mean(sm, sv, sn, m)
    if np.isfinite(v):
        check_sample_var(sv, sn, v)


def check_sample_mean(sm, v, n, popmean):
    # from stats.stats.ttest_1samp(a, popmean):
    # Calculates the t-obtained for the independent samples T-test on ONE group
    # of scores a, given a population mean.
    #
    # Returns: t-value, two-tailed prob
    df = n-1
    svar = ((n-1)*v) / float(df)    # looks redundant
    t = (sm-popmean) / np.sqrt(svar*(1.0/n))
    prob = betainc(0.5*df, 0.5, df/(df + t*t))

    # return t,prob
    npt.assert_(prob > 0.01, 'mean fail, t,prob = %f, %f, m, sm=%f,%f' %
                (t, prob, popmean, sm))


def check_sample_var(sv, n, popvar):
    # two-sided chisquare test for sample variance equal to
    # hypothesized variance
    df = n-1
    chi2 = (n-1)*popvar/float(popvar)
    pval = stats.distributions.chi2.sf(chi2, df) * 2
    npt.assert_(pval > 0.01, 'var fail, t, pval = %f, %f, v, sv=%f, %f' %
                (chi2, pval, popvar, sv))


def check_cdf_ppf(distfn, arg, msg):
    values = [0.001, 0.5, 0.999]
    npt.assert_almost_equal(distfn.cdf(distfn.ppf(values, *arg), *arg),
                            values, decimal=DECIMAL, err_msg=msg +
                            ' - cdf-ppf roundtrip')


def check_sf_isf(distfn, arg, msg):
    npt.assert_almost_equal(distfn.sf(distfn.isf([0.1, 0.5, 0.9], *arg), *arg),
                            [0.1, 0.5, 0.9], decimal=DECIMAL, err_msg=msg +
                            ' - sf-isf roundtrip')
    npt.assert_almost_equal(distfn.cdf([0.1, 0.9], *arg),
                            1.0 - distfn.sf([0.1, 0.9], *arg),
                            decimal=DECIMAL, err_msg=msg +
                            ' - cdf-sf relationship')


def check_pdf(distfn, arg, msg):
    # compares pdf at median with numerical derivative of cdf
    median = distfn.ppf(0.5, *arg)
    eps = 1e-6
    pdfv = distfn.pdf(median, *arg)
    if (pdfv < 1e-4) or (pdfv > 1e4):
        # avoid checking a case where pdf is close to zero or
        # huge (singularity)
        median = median + 0.1
        pdfv = distfn.pdf(median, *arg)
    cdfdiff = (distfn.cdf(median + eps, *arg) -
               distfn.cdf(median - eps, *arg))/eps/2.0
    # replace with better diff and better test (more points),
    # actually, this works pretty well
    msg += ' - cdf-pdf relationship'
    npt.assert_almost_equal(pdfv, cdfdiff, decimal=DECIMAL, err_msg=msg)


def check_pdf_logpdf(distfn, args, msg):
    # compares pdf at several points with the log of the pdf
    points = np.array([0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])
    vals = distfn.ppf(points, *args)
    pdf = distfn.pdf(vals, *args)
    logpdf = distfn.logpdf(vals, *args)
    pdf = pdf[pdf != 0]
    logpdf = logpdf[np.isfinite(logpdf)]
    msg += " - logpdf-log(pdf) relationship"
    npt.assert_almost_equal(np.log(pdf), logpdf, decimal=7, err_msg=msg)


def check_sf_logsf(distfn, args, msg):
    # compares sf at several points with the log of the sf
    points = np.array([0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])
    vals = distfn.ppf(points, *args)
    sf = distfn.sf(vals, *args)
    logsf = distfn.logsf(vals, *args)
    sf = sf[sf != 0]
    logsf = logsf[np.isfinite(logsf)]
    msg += " - logsf-log(sf) relationship"
    npt.assert_almost_equal(np.log(sf), logsf, decimal=7, err_msg=msg)


def check_cdf_logcdf(distfn, args, msg):
    # compares cdf at several points with the log of the cdf
    points = np.array([0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8])
    vals = distfn.ppf(points, *args)
    cdf = distfn.cdf(vals, *args)
    logcdf = distfn.logcdf(vals, *args)
    cdf = cdf[cdf != 0]
    logcdf = logcdf[np.isfinite(logcdf)]
    msg += " - logcdf-log(cdf) relationship"
    npt.assert_almost_equal(np.log(cdf), logcdf, decimal=7, err_msg=msg)


def check_distribution_rvs(dist, args, alpha, rvs):
    # test from scipy.stats.tests
    # this version reuses existing random variables
    D, pval = stats.kstest(rvs, dist, args=args, N=1000)
    if (pval < alpha):
        D, pval = stats.kstest(dist, '', args=args, N=1000)
        npt.assert_(pval > alpha, "D = " + str(D) + "; pval = " + str(pval) +
                    "; alpha = " + str(alpha) + "\nargs = " + str(args))


def check_vecentropy(distfn, args):
    npt.assert_equal(distfn.vecentropy(*args), distfn._entropy(*args))


def check_loc_scale(distfn, arg, m, v, msg):
    loc, scale = 10.0, 10.0
    mt, vt = distfn.stats(loc=loc, scale=scale, *arg)
    npt.assert_allclose(m*scale + loc, mt)
    npt.assert_allclose(v*scale*scale, vt)


def check_ppf_private(distfn, arg, msg):
    # fails by design for truncnorm self.nb not defined
    ppfs = distfn._ppf(np.array([0.1, 0.5, 0.9]), *arg)
    npt.assert_(not np.any(np.isnan(ppfs)), msg + 'ppf private is nan')


if __name__ == "__main__":
    npt.run_module_suite()

# -*- coding: UTF-8 -*-

import os.path
import time
import codecs
import logging

from gi.repository import Gtk, Gdk, Pango, GObject

from pychess.compat import unicode
from pychess.System import glock, uistuff
from pychess.System.Log import log, logemitter
from pychess.System.prefix import addDataPrefix

def rawreplace(error):
    symbols = (ur"\x%02x" % ord(s)
        for s in error.object[error.start:error.end])
    return u"".join(symbols), error.end
codecs.register_error("rawreplace", rawreplace)

class InformationWindow:
    
    @classmethod
    def _init (cls):
        cls.tagToIter = {}
        cls.tagToPage = {}
        cls.pathToPage = {}
        cls.tagToTime = {}
        
        cls.window = Gtk.Window()
        cls.window.set_title(_("PyChess Information Window"))
        cls.window.set_border_width(12)
        cls.window.set_icon_name("pychess")
        uistuff.keepWindowSize("logdialog", cls.window, (640,480))
        mainHBox = Gtk.HBox()
        mainHBox.set_spacing(6)
        cls.window.add(mainHBox)
        
        sw = Gtk.ScrolledWindow()
        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        sw.set_shadow_type(Gtk.ShadowType.IN)
        mainHBox.pack_start(sw, False, True, 0)
        cls.treeview = Gtk.TreeView(Gtk.TreeStore(str))
        cls.treeview.append_column(Gtk.TreeViewColumn("", Gtk.CellRendererText(), text=0))
        cls.treeview.set_headers_visible(False)
        cls.treeview.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
        sw.add(cls.treeview)
        cls.pages = Gtk.Notebook()
        cls.pages.set_show_tabs(False)
        cls.pages.set_show_border(False)
        mainHBox.pack_start(cls.pages, True, True, 0)
        
        mainHBox.show_all()
        
        def selectionChanged (selection):
            treestore, iter = selection.get_selected()
            if iter:
                child = cls.pathToPage[treestore.get_path(iter).to_string()]["child"]
                cls.pages.set_current_page(cls.pages.page_num(child))
        cls.treeview.get_selection().connect("changed", selectionChanged)
    
    @classmethod
    def show (cls):
        cls.window.show()
    
    @classmethod
    def hide (cls):
        cls.window.hide()
    
    @classmethod
    def newMessage (cls, tag, timestamp, message, importance):
        textview = cls._getPageFromTag(tag)["textview"]
        
        if not tag in cls.tagToTime or timestamp-cls.tagToTime[tag] >= 1:
            t = time.strftime("%H:%M:%S", time.localtime(timestamp))
            textview.get_buffer().insert_with_tags_by_name(
                textview.get_buffer().get_end_iter(), "\n%s\n%s\n"%(t,"-"*60), str(logging.INFO))
            cls.tagToTime[tag] = timestamp
        
        if isinstance(message, str):
            message = unicode(message, "utf-8", 'rawreplace')
        if not message.endswith("\n"):
            message = "%s\n" % message
        textview.get_buffer().insert_with_tags_by_name(
            textview.get_buffer().get_end_iter(), message, str(importance))
    
    @classmethod
    def _createPage (cls, parrentIter, tag):
        name = tag[-1]
        if isinstance(name, int):
            name=str(name)
        iter = cls.treeview.get_model().append(parrentIter, (name,))
        cls.tagToIter[tag] = iter
        
        widgets = uistuff.GladeWidgets("findbar.glade")
        frame = widgets["frame"]
        frame.unparent()
        frame.show_all()
        
        uistuff.keepDown(widgets["scrolledwindow"])
        textview = widgets["textview"]
        tb = textview.get_buffer()
        tb.create_tag(str(logging.DEBUG), family='Monospace')
        tb.create_tag(str(logging.INFO), family='Monospace', weight=Pango.Weight.BOLD)
        tb.create_tag(str(logging.WARNING), family='Monospace', foreground="red")
        tb.create_tag(str(logging.ERROR), family='Monospace', weight=Pango.Weight.BOLD, foreground="red")
        
        
        findbar = widgets["findbar"]
        findbar.hide()
        # Make searchEntry and "out of label" share height with the buttons
        widgets["prevButton"].connect("size-allocate", lambda w, alloc:
                widgets["searchEntry"].set_size_request(-1, alloc.height) or
                widgets["outofLabel"].set_size_request(-1, alloc.height-2))
        
        # Make "out of label" more visually distinct
        uistuff.makeYellow(widgets["outofLabel"])
        widgets["outofLabel"].hide()
        
        widgets["closeButton"].connect("clicked", lambda w:
                                       widgets["findbar"].hide())
        
        # Connect showing/hiding of the findbar
        cls.window.connect("key-press-event", cls.onTextviewKeypress, widgets)
        widgets["findbar"].connect("key-press-event", cls.onFindbarKeypress)
        
        widgets["searchEntry"].connect("changed", cls.onSearchChanged, widgets)
        
        widgets["prevButton"].connect("clicked", lambda w: cls.searchJump(-1, widgets))
        widgets["nextButton"].connect("clicked", lambda w: cls.searchJump(1, widgets))
        
        
        
        
        cls.pages.append_page(frame, None)
        page = {"child": frame, "textview":textview}
        cls.tagToPage[tag] = page
        cls.pathToPage[cls.treeview.get_model().get_path(iter).to_string()] = page
        
        cls.treeview.expand_all()
    
    @classmethod
    def _getPageFromTag (cls, tag):
        if isinstance(tag, list):
            tag = tuple(tag)
        elif not isinstance(tag, tuple):
            tag = (tag,)
        
        if tag in cls.tagToPage:
            return cls.tagToPage[tag]
        
        for i in range(len(tag)-1):
            subtag = tag[:-i-1]
            if subtag in cls.tagToIter:
                newtag = subtag+(tag[len(subtag)],)
                iter = cls.tagToIter[subtag]
                cls._createPage(iter, newtag)
                return cls._getPageFromTag(tag)
        
        cls._createPage(None, tag[:1])
        return cls._getPageFromTag(tag)
    
    @classmethod
    def onSearchChanged (cls, searchEntry, widgets):
        pattern = searchEntry.get_text().lower()
        widgets["outofLabel"].props.visible = bool(pattern)
        if not pattern:
            return
        
        text = widgets["textview"].get_buffer().props.text.lower()
        
        widgets["outofLabel"].hits = []
        widgets["outofLabel"].searchCurrent = -1
        i = -len(pattern)
        while True:
            i = text.find(pattern, i+len(pattern))
            if i != -1:
                widgets["outofLabel"].hits.append(i)
            else: break
        
        cls.searchJump(1, widgets)
        
    @classmethod
    def searchJump (cls, count, widgets):
        if not hasattr(widgets["outofLabel"], "hits"):
            return
        amount = len(widgets["outofLabel"].hits)
        if not amount:
            widgets["outofLabel"].set_text("0 %s 0" % _("of"))
        else:
            widgets["outofLabel"].searchCurrent += count
            current = widgets["outofLabel"].searchCurrent % amount
            widgets["outofLabel"].set_text("%d %s %d" % (current+1, _("of"), amount))
            goto = widgets["outofLabel"].hits[current]
            iter0 = widgets["textview"].get_buffer().get_iter_at_offset(goto)
            length = len(widgets["searchEntry"].get_text())
            iter1 = widgets["textview"].get_buffer().get_iter_at_offset(goto+length)
            widgets["textview"].get_buffer().select_range(iter0, iter1)
            widgets["textview"].scroll_to_iter(iter0, 0.2, False, 0.5, 0.5)
    
    @classmethod
    def onTextviewKeypress (cls, textview, event, widgets):
        if event.get_state() & Gdk.ModifierType.CONTROL_MASK:
            if event.keyval in (ord("f"), ord("F")):
                widgets["findbar"].props.visible = not widgets["findbar"].props.visible
                if widgets["findbar"].props.visible:
                    signal = widgets["searchEntry"].connect_after("draw",
                            lambda w,e: w.grab_focus() or
                            widgets["searchEntry"].disconnect(signal))
    
    @classmethod
    def onFindbarKeypress (cls, findbar, event):
        if Gdk.keyval_name(event.keyval) == "Escape":
            findbar.props.visible = False
    
    
uistuff.cacheGladefile("findbar.glade")


################################################################################
# Add early messages and connect for new                                       #
################################################################################

InformationWindow._init()

from gi.repository import GObject
def addMessages2 (emitter, messages):
    GObject.idle_add(addMessages2, messages)

def addMessages (emitter, messages):
    for task, timestamp, message, type in messages:
        InformationWindow.newMessage (task, timestamp, message, type)

glock.acquire()
try:
    addMessages(logemitter, logemitter.messages)
    logemitter.messages = None
finally:
    glock.release()

logemitter.connect ("logged", addMessages)

################################################################################
# External functions                                                           #
################################################################################

destroy_funcs = []
def add_destroy_notify (func):
    destroy_funcs.append(func)
def _destroy_notify (widget, *args):
    [func() for func in destroy_funcs]
    return True
InformationWindow.window.connect("delete-event", _destroy_notify)

def show ():
    InformationWindow.show()

def hide ():
    InformationWindow.hide()

if __name__ == "__main__":
    show()
    InformationWindow.window.connect("delete-event", Gtk.main_quit)
    Gtk.main()

# -*- coding: utf-8 -*-
# This file is part of beets.
# Copyright 2016, Jan-Erik Dahlin
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.

"""If the title is empty, try to extract track and title from the
filename.
"""
from __future__ import division, absolute_import, print_function

from beets import plugins
from beets.util import displayable_path
import os
import re
import six


# Filename field extraction patterns.
PATTERNS = [
  # Useful patterns.
  r'^(?P<artist>.+)[\-_](?P<title>.+)[\-_](?P<tag>.*)$',
  r'^(?P<track>\d+)[\s.\-_]+(?P<artist>.+)[\-_](?P<title>.+)[\-_](?P<tag>.*)$',
  r'^(?P<artist>.+)[\-_](?P<title>.+)$',
  r'^(?P<track>\d+)[\s.\-_]+(?P<artist>.+)[\-_](?P<title>.+)$',
  r'^(?P<title>.+)$',
  r'^(?P<track>\d+)[\s.\-_]+(?P<title>.+)$',
  r'^(?P<track>\d+)\s+(?P<title>.+)$',
  r'^(?P<title>.+) by (?P<artist>.+)$',
  r'^(?P<track>\d+).*$',
]

# Titles considered "empty" and in need of replacement.
BAD_TITLE_PATTERNS = [
    r'^$',
]


def equal(seq):
    """Determine whether a sequence holds identical elements.
    """
    return len(set(seq)) <= 1


def equal_fields(matchdict, field):
    """Do all items in `matchdict`, whose values are dictionaries, have
    the same value for `field`? (If they do, the field is probably not
    the title.)
    """
    return equal(m[field] for m in matchdict.values())


def all_matches(names, pattern):
    """If all the filenames in the item/filename mapping match the
    pattern, return a dictionary mapping the items to dictionaries
    giving the value for each named subpattern in the match. Otherwise,
    return None.
    """
    matches = {}
    for item, name in names.items():
        m = re.match(pattern, name, re.IGNORECASE)
        if m and m.groupdict():
            # Only yield a match when the regex applies *and* has
            # capture groups. Otherwise, no information can be extracted
            # from the filename.
            matches[item] = m.groupdict()
        else:
            return None
    return matches


def bad_title(title):
    """Determine whether a given title is "bad" (empty or otherwise
    meaningless) and in need of replacement.
    """
    for pat in BAD_TITLE_PATTERNS:
        if re.match(pat, title, re.IGNORECASE):
            return True
    return False


def apply_matches(d):
    """Given a mapping from items to field dicts, apply the fields to
    the objects.
    """
    some_map = list(d.values())[0]
    keys = some_map.keys()

    # Only proceed if the "tag" field is equal across all filenames.
    if 'tag' in keys and not equal_fields(d, 'tag'):
        return

    # Given both an "artist" and "title" field, assume that one is
    # *actually* the artist, which must be uniform, and use the other
    # for the title. This, of course, won't work for VA albums.
    if 'artist' in keys:
        if equal_fields(d, 'artist'):
            artist = some_map['artist']
            title_field = 'title'
        elif equal_fields(d, 'title'):
            artist = some_map['title']
            title_field = 'artist'
        else:
            # Both vary. Abort.
            return

        for item in d:
            if not item.artist:
                item.artist = artist

    # No artist field: remaining field is the title.
    else:
        title_field = 'title'

    # Apply the title and track.
    for item in d:
        if bad_title(item.title):
            item.title = six.text_type(d[item][title_field])
        if 'track' in d[item] and item.track == 0:
            item.track = int(d[item]['track'])


# Plugin structure and hook into import process.

class FromFilenamePlugin(plugins.BeetsPlugin):
    def __init__(self):
        super(FromFilenamePlugin, self).__init__()
        self.register_listener('import_task_start', filename_task)


def filename_task(task, session):
    """Examine each item in the task to see if we can extract a title
    from the filename. Try to match all filenames to a number of
    regexps, starting with the most complex patterns and successively
    trying less complex patterns. As soon as all filenames match the
    same regex we can make an educated guess of which part of the
    regex that contains the title.
    """
    items = task.items if task.is_album else [task.item]

    # Look for suspicious (empty or meaningless) titles.
    missing_titles = sum(bad_title(i.title) for i in items)

    if missing_titles:
        # Get the base filenames (no path or extension).
        names = {}
        for item in items:
            path = displayable_path(item.path)
            name, _ = os.path.splitext(os.path.basename(path))
            names[item] = name

        # Look for useful information in the filenames.
        for pattern in PATTERNS:
            d = all_matches(names, pattern)
            if d:
                apply_matches(d)

#  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
#  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.
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
import numpy as np
from sklearn import metrics
import pandas

import tensorflow as tf
from tensorflow.contrib import learn

### Training data

# Downloads, unpacks and reads DBpedia dataset.
dbpedia = learn.datasets.load_dataset('dbpedia')
X_train, y_train = pandas.DataFrame(dbpedia.train.data)[1], pandas.Series(dbpedia.train.target)
X_test, y_test = pandas.DataFrame(dbpedia.test.data)[1], pandas.Series(dbpedia.test.target)

### Process vocabulary

MAX_DOCUMENT_LENGTH = 10

vocab_processor = learn.preprocessing.VocabularyProcessor(MAX_DOCUMENT_LENGTH)
X_train = np.array(list(vocab_processor.fit_transform(X_train)))
X_test = np.array(list(vocab_processor.transform(X_test)))

n_words = len(vocab_processor.vocabulary_)
print('Total words: %d' % n_words)

### Models

EMBEDDING_SIZE = 50

def average_model(X, y):
  word_vectors = learn.ops.categorical_variable(X, n_classes=n_words,
      embedding_size=EMBEDDING_SIZE, name='words')
  features = tf.reduce_max(word_vectors, reduction_indices=1)
  return learn.models.logistic_regression(features, y)

def rnn_model(X, y):
  """Recurrent neural network model to predict from sequence of words
    to a class."""
  # Convert indexes of words into embeddings.
  # This creates embeddings matrix of [n_words, EMBEDDING_SIZE] and then
  # maps word indexes of the sequence into [batch_size, sequence_length,
  # EMBEDDING_SIZE].
  word_vectors = learn.ops.categorical_variable(X, n_classes=n_words,
      embedding_size=EMBEDDING_SIZE, name='words')
  # Split into list of embedding per word, while removing doc length dim.
  # word_list results to be a list of tensors [batch_size, EMBEDDING_SIZE].
  word_list = tf.unpack(word_vectors, axis=1)
  # Create a Gated Recurrent Unit cell with hidden size of EMBEDDING_SIZE.
  cell = tf.nn.rnn_cell.GRUCell(EMBEDDING_SIZE)
  # Create an unrolled Recurrent Neural Networks to length of
  # MAX_DOCUMENT_LENGTH and passes word_list as inputs for each unit.
  _, encoding = tf.nn.rnn(cell, word_list, dtype=tf.float32)
  # Given encoding of RNN, take encoding of last step (e.g hidden size of the
  # neural network of last step) and pass it as features for logistic
  # regression over output classes.
  return learn.models.logistic_regression(encoding, y)

model_path = '/tmp/skflow_examples/text_classification'
if os.path.exists(model_path):
  classifier = learn.TensorFlowEstimator.restore(model_path)
else:
  classifier = learn.TensorFlowEstimator(model_fn=rnn_model, n_classes=15,
      steps=100, optimizer='Adam', learning_rate=0.01, continue_training=True)

  # Continuously train for 1000 steps
  while True:
    try:
      classifier.fit(X_train, y_train)
    except KeyboardInterrupt:
      classifier.save(model_path)
      break
# Predict on test set
score = metrics.accuracy_score(y_test, classifier.predict(X_test))
print('Accuracy: {0:f}'.format(score))

from django.core.paginator import Paginator, InvalidPage
from django.utils.translation import ugettext_lazy as _

from haystack import connections

from oscar.core.loading import get_class
from . import facets


FacetMunger = get_class('search.facets', 'FacetMunger')


class SearchHandler(object):
    """
    A class that is concerned with performing a search and paginating the
    results. The search is triggered upon initialisation (mainly to have a
    predictable point to process any errors).  Search results are cached, so
    they can be accessed multiple times without incurring any overhead.

    The raison d'etre for this third way to interface with Haystack is
    two-fold. The Haystack search form doesn't do enough for our needs, and
    basing a view off a Haystack search view is unnecessarily invasive.
    Furthermore, using our own search handler means it is easy to swap
    out Haystack, which has been considered before.

    Usage:

        handler = SearchHandler(request.GET, request.get_full_path)
        found_objects = handler.get_paginated_objects()
        context = handler.get_search_context_data()

    Error handling:

        You need to catch an InvalidPage exception which gets thrown when an
        invalid page number is supplied.
    """

    form_class = None
    model_whitelist = None
    paginate_by = None
    paginator_class = Paginator
    page_kwarg = 'page'

    def __init__(self, request_data, full_path):
        self.full_path = full_path
        self.request_data = request_data

        # Triggers the search.
        search_queryset = self.get_search_queryset()
        self.search_form = self.get_search_form(
            request_data, search_queryset)
        self.results = self.get_search_results(self.search_form)
        # If below raises an UnicodeDecodeError, you're running pysolr < 3.2
        # with Solr 4.
        self.paginator, self.page = self.paginate_queryset(
            self.results, request_data)

    # Search related methods

    def get_search_results(self, search_form):
        """
        Perform the actual search using Haystack's search form. Returns
        a SearchQuerySet. The SQS is empty if the form is invalid.
        """
        return search_form.search()

    def get_search_form(self, request_data, search_queryset):
        """
        Return a bound version of Haystack's search form.
        """
        kwargs = {
            'data': request_data,
            'selected_facets': request_data.getlist("selected_facets"),
            'searchqueryset': search_queryset
        }
        return self.form_class(**kwargs)

    def get_search_queryset(self):
        """
        Returns the search queryset that is used as a base for the search.
        """
        sqs = facets.base_sqs()
        if self.model_whitelist:
            # Limit queryset to specified list of models
            sqs = sqs.models(*self.model_whitelist)
        return sqs

    # Pagination related methods

    def paginate_queryset(self, queryset, request_data):
        """
        Paginate the search results. This is a simplified version of
        Django's MultipleObjectMixin.paginate_queryset
        """
        paginator = self.get_paginator(queryset)
        page_kwarg = self.page_kwarg
        page = request_data.get(page_kwarg, 1)
        try:
            page_number = int(page)
        except ValueError:
            if page == 'last':
                page_number = paginator.num_pages
            else:
                raise InvalidPage(_(
                    "Page is not 'last', nor can it be converted to an int."))
        # This can also raise an InvalidPage exception.
        return paginator, paginator.page(page_number)

    def get_paginator(self, queryset):
        """
        Return a paginator. Override this to set settings like orphans,
        allow_empty, etc.
        """
        return self.paginator_class(queryset, self.paginate_by)

    # Accessing the search results and meta data

    def bulk_fetch_results(self, paginated_results):
        """
        This method gets paginated search results and returns a list of Django
        objects in the same order.

        It preserves the order without doing any ordering in Python, even
        when more than one Django model are returned in the search results. It
        also uses the same queryset that was used to populate the search
        queryset, so any select_related/prefetch_related optimisations are
        in effect.

        It is heavily based on Haystack's SearchQuerySet.post_process_results,
        but works on the paginated results instead of all of them.
        """
        objects = []

        models_pks = loaded_objects = {}
        for result in paginated_results:
            models_pks.setdefault(result.model, []).append(result.pk)

        search_backend_alias = self.results.query.backend.connection_alias
        for model in models_pks:
            ui = connections[search_backend_alias].get_unified_index()
            index = ui.get_index(model)
            queryset = index.read_queryset(using=search_backend_alias)
            loaded_objects[model] = queryset.in_bulk(models_pks[model])

        for result in paginated_results:
            model_objects = loaded_objects.get(result.model, {})
            try:
                result._object = model_objects[int(result.pk)]
            except KeyError:
                # The object was either deleted since we indexed or should
                # be ignored; fail silently.
                pass
            else:
                objects.append(result._object)

        return objects

    def get_paginated_objects(self):
        """
        Return a paginated list of Django model instances. The call is cached.
        """
        if hasattr(self, '_objects'):
            return self._objects
        else:
            paginated_results = self.page.object_list
            self._objects = self.bulk_fetch_results(paginated_results)
        return self._objects

    def get_facet_munger(self):
        return FacetMunger(
            self.full_path,
            self.search_form.selected_multi_facets,
            self.results.facet_counts())

    def get_search_context_data(self, context_object_name=None):
        """
        Return metadata about the search in a dictionary useful to populate
        template contexts. If you pass in a context_object_name, the dictionary
        will also contain the actual list of found objects.

        The expected usage is to call this function in your view's
        get_context_data:

            search_context = self.search_handler.get_search_context_data(
                self.context_object_name)
            context.update(search_context)
            return context

        """

        # Use the FacetMunger to convert Haystack's awkward facet data into
        # something the templates can use.
        # Note that the FacetMunger accesses object_list (unpaginated results),
        # whereas we use the paginated search results to populate the context
        # with products
        munger = self.get_facet_munger()
        facet_data = munger.facet_data()
        has_facets = any([data['results'] for data in facet_data.values()])

        context = {
            'facet_data': facet_data,
            'has_facets': has_facets,
            # This is a serious code smell; we just pass through the selected
            # facets data to the view again, and the template adds those
            # as fields to the form. This hack ensures that facets stay
            # selected when changing relevancy.
            'selected_facets': self.request_data.getlist('selected_facets'),
            'form': self.search_form,
            'paginator': self.paginator,
            'page_obj': self.page,
        }

        # It's a pretty common pattern to want the actual results in the
        # context, so pass them in if context_object_name is set.
        if context_object_name is not None:
            context[context_object_name] = self.get_paginated_objects()

        return context

from random import random
import numpy

from sigmoidNode import SigmoidNode

class Network:
    def __init__(self, rowSizes):
        #Initialize the network's nodes
        self.network = list()
        for i in rowSizes:
            self.network += [[SigmoidNode() for x in range(i)]]
    def startFromScratch(self):
        #Iterates through the network giving a random vector of weights
        for rowNum in range(len(self.network)):
            if rowNum + 1 < len(self.network):
                for node in self.network[rowNum]:
                    node.theta = numpy.array([random() / len(self.network[rowNum + 1]) for x in range(len(self.network[rowNum + 1]) + 1)])
            else:
                for node in self.network[rowNum]:
                    node.theta = numpy.array([random() for x in range(2)])
    def startFromFile(self, fileName):
        #Read in the data from the file
        with open(fileName) as file:
            nodeStrings = file.readlines()
            file.close()
        nodeData = [numpy.fromstring(row[2:-1], sep=' ') for row in nodeStrings]
        #Assert that the data read in is equal to the network size
        assert len(nodeData) == sum([len(row) for row in self.network])
        #Give the data to the individual neurons
        dataRowCounter = 0
        for rowNum in range(len(self.network)):
            for nodeNum in range(len(self.network[rowNum])):
                #Assert that the number of inputs for that neuron is correct
                if rowNum + 1 < len(self.network):
                    assert len(nodeData[dataRowCounter]) == len(self.network[rowNum + 1]) + 1
                else:
                    assert len(nodeData[dataRowCounter]) == 2
                #Give the neuron the input data
                self.network[rowNum][nodeNum].theta = nodeData[dataRowCounter]
                dataRowCounter += 1
            
    def writeToFile(self, fileName):
        #Open the file, set print options, and iterate through the rows printing data
        file = open(fileName, 'w')
        numpy.set_printoptions(threshold = numpy.inf, linewidth = numpy.inf)
        for row in self.network:
            for node in row:
                file.write(numpy.array_str(node.theta) + "\n")
        numpy.set_printoptions(threshold = 10, linewidth = 75)
        file.close()
    def networkOutputs(self, inputs):
        assert len(inputs) == len(self.network[len(self.network) - 1])
        outputs = [inputs]
        for rowNum in reversed(range(0, len(self.network))):
            if rowNum + 1 < len(self.network):
                layorOutputs = [neuron.sigmoid(outputs[0]) for neuron in self.network[rowNum]]
                outputs = [layorOutputs] + outputs
            else:
                layorOutputs = [self.network[rowNum][i].sigmoid([outputs[0][i]]) for i in range(len(outputs[0]))]
                outputs = [layorOutputs] + outputs
        return outputs
    def classify(self, inputs):
        outputs = self.networkOutputs(inputs)
        maxValue = max(outputs[0])
        maxIndex = outputs[0].index(maxValue)
        return maxIndex, maxValue
    def backPropagate(self, inputs, targets):
        outputs = self.networkOutputs(inputs)
        for rowNum in range(0, len(self.network)):
            if rowNum == 0:
                for neuronNum in range(0, len(self.network[rowNum])):
                    error = targets[neuronNum] - outputs[rowNum][neuronNum]
                    self.network[rowNum][neuronNum].updateDelta(outputs[rowNum + 1], error)
            elif rowNum + 1 < len(self.network):
                for neuronNum in range(0, len(self.network[rowNum])):
                    error = 0
                    for neuron in self.network[rowNum - 1]:
                        error += neuron.theta[neuronNum + 1] * neuron.delta
                    self.network[rowNum][neuronNum].updateDelta(outputs[rowNum + 1], error)
            else:
                for neuronNum in range(0, len(self.network[rowNum])):
                    error = 0
                    for neuron in self.network[rowNum - 1]:
                        error += neuron.theta[neuronNum + 1] * neuron.delta
                    self.network[rowNum][neuronNum].updateDelta([outputs[rowNum + 1][neuronNum]], error)
        for rowNum in range(0, len(self.network)):
            if rowNum + 1 < len(self.network):
                for neuron in self.network[rowNum]:
                    neuron.updateWeights(outputs[rowNum + 1])
            else:
                for neuronNum in range(0, len(self.network[rowNum])):
                    self.network[rowNum][neuronNum].updateWeights([outputs[rowNum + 1][neuronNum]])
    
""" Some test usage
network = Network([40,100,161])
network.startFromFile("old.txt")
outputs = network.networkOutputs([1] * 161)
print(outputs[0])
#print(outputs[len(outputs) - 2])
#print(network.network[0][1].theta)

network.startFromScratch()
network.writeToFile("old.txt")
import time

network.backPropagate([1]*161, [0] + [1] + [0]*38)

start = time.time()
for i in range(1000):
    network.backPropagate([1]*161, [0] + [1] + [0]*38)
print(time.time() - start)
print(network.classify([1]*161))
print(network.networkOutputs([1]*161)[0])

network.writeToFile("test2.txt")
"""
from .env import YowsupEnv
import base64
import hashlib
class AndroidYowsupEnv(YowsupEnv):
    _SIGNATURE = "MIIDMjCCAvCgAwIBAgIETCU2pDALBgcqhkjOOAQDBQAwfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExFDASBgNV" \
                "BAcTC1NhbnRhIENsYXJhMRYwFAYDVQQKEw1XaGF0c0FwcCBJbmMuMRQwEgYDVQQLEwtFbmdpbmVlcmluZzEUMBIGA1UEAxMLQnJ" \
                "pYW4gQWN0b24wHhcNMTAwNjI1MjMwNzE2WhcNNDQwMjE1MjMwNzE2WjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2FsaWZvcm5" \
                "pYTEUMBIGA1UEBxMLU2FudGEgQ2xhcmExFjAUBgNVBAoTDVdoYXRzQXBwIEluYy4xFDASBgNVBAsTC0VuZ2luZWVyaW5nMRQwEg" \
                "YDVQQDEwtCcmlhbiBBY3RvbjCCAbgwggEsBgcqhkjOOAQBMIIBHwKBgQD9f1OBHXUSKVLfSpwu7OTn9hG3UjzvRADDHj+AtlEm" \
                "aUVdQCJR+1k9jVj6v8X1ujD2y5tVbNeBO4AdNG/yZmC3a5lQpaSfn+gEexAiwk+7qdf+t8Yb+DtX58aophUPBPuD9tPFHsMCN" \
                "VQTWhaRMvZ1864rYdcq7/IiAxmd0UgBxwIVAJdgUI8VIwvMspK5gqLrhAvwWBz1AoGBAPfhoIXWmz3ey7yrXDa4V7l5lK+7+jr" \
                "qgvlXTAs9B4JnUVlXjrrUWU/mcQcQgYC0SRZxI+hMKBYTt88JMozIpuE8FnqLVHyNKOCjrh4rs6Z1kW6jfwv6ITVi8ftiegEkO" \
                "8yk8b6oUZCJqIPf4VrlnwaSi2ZegHtVJWQBTDv+z0kqA4GFAAKBgQDRGYtLgWh7zyRtQainJfCpiaUbzjJuhMgo4fVWZIvXHaS" \
                "HBU1t5w//S0lDK2hiqkj8KpMWGywVov9eZxZy37V26dEqr/c2m5qZ0E+ynSu7sqUD7kGx/zeIcGT0H+KAVgkGNQCo5Uc0koLRW" \
                "YHNtYoIvt5R3X6YZylbPftF/8ayWTALBgcqhkjOOAQDBQADLwAwLAIUAKYCp0d6z4QQdyN74JDfQ2WCyi8CFDUM4CaNB+ceVXd" \
                "KtOrNTQcc0e+t"

    _MD5_CLASSES = "7Ai8bMBxBeO5SFSLutDs8A=="
    _KEY = "/UIGKU1FVQa+ATM2A0za7G2KI9S/CwPYjgAbc67v7ep42eO/WeTLx1lb1cHwxpsEgF4+PmYpLd2YpGUdX/A2JQitsHzDwgcdBpUf7psX1BU="

    _VERSION = "2.12.96"
    _OS_NAME= "Android"
    _OS_VERSION = "4.3"
    _DEVICE_NAME = "GalaxyS3"
    _AXOLOTL = True

    def getVersion(self):
        return self.__class__._VERSION

    def getOSName(self):
        return self.__class__._OS_NAME

    def getOSVersion(self):
        return self.__class__._OS_VERSION

    def getDeviceName(self):
        return self.__class__._DEVICE_NAME

    def isAxolotlEnabled(self):
        return self.__class__._AXOLOTL

    def getToken(self, phoneNumber):
        keyDecoded = bytearray(base64.b64decode(self.__class__._KEY))
        sigDecoded = base64.b64decode(self.__class__._SIGNATURE)
        clsDecoded = base64.b64decode(self.__class__._MD5_CLASSES)
        data = sigDecoded + clsDecoded + phoneNumber.encode()

        opad = bytearray()
        ipad = bytearray()
        for i in range(0, 64):
            opad.append(0x5C ^ keyDecoded[i])
            ipad.append(0x36 ^ keyDecoded[i])
        hash = hashlib.sha1()
        subHash = hashlib.sha1()
        subHash.update(ipad + data)
        hash.update(opad + subHash.digest())
        result = base64.b64encode(hash.digest())
        return result

"""Constants for the LCN component."""
from itertools import product

from homeassistant.const import (
    DEGREE,
    PERCENTAGE,
    TEMP_CELSIUS,
    TEMP_FAHRENHEIT,
    TEMP_KELVIN,
    VOLT,
)

DOMAIN = "lcn"
DATA_LCN = "lcn"
DEFAULT_NAME = "pchk"

CONF_CONNECTIONS = "connections"
CONF_SK_NUM_TRIES = "sk_num_tries"
CONF_OUTPUT = "output"
CONF_DIM_MODE = "dim_mode"
CONF_DIMMABLE = "dimmable"
CONF_TRANSITION = "transition"
CONF_MOTOR = "motor"
CONF_LOCKABLE = "lockable"
CONF_VARIABLE = "variable"
CONF_VALUE = "value"
CONF_RELVARREF = "value_reference"
CONF_SOURCE = "source"
CONF_SETPOINT = "setpoint"
CONF_LED = "led"
CONF_KEYS = "keys"
CONF_TIME = "time"
CONF_TIME_UNIT = "time_unit"
CONF_TABLE = "table"
CONF_ROW = "row"
CONF_TEXT = "text"
CONF_PCK = "pck"
CONF_CLIMATES = "climates"
CONF_MAX_TEMP = "max_temp"
CONF_MIN_TEMP = "min_temp"
CONF_SCENES = "scenes"
CONF_REGISTER = "register"
CONF_SCENE = "scene"
CONF_OUTPUTS = "outputs"
CONF_REVERSE_TIME = "reverse_time"

DIM_MODES = ["STEPS50", "STEPS200"]

OUTPUT_PORTS = ["OUTPUT1", "OUTPUT2", "OUTPUT3", "OUTPUT4"]

RELAY_PORTS = [
    "RELAY1",
    "RELAY2",
    "RELAY3",
    "RELAY4",
    "RELAY5",
    "RELAY6",
    "RELAY7",
    "RELAY8",
    "MOTORONOFF1",
    "MOTORUPDOWN1",
    "MOTORONOFF2",
    "MOTORUPDOWN2",
    "MOTORONOFF3",
    "MOTORUPDOWN3",
    "MOTORONOFF4",
    "MOTORUPDOWN4",
]

MOTOR_PORTS = ["MOTOR1", "MOTOR2", "MOTOR3", "MOTOR4", "OUTPUTS"]

LED_PORTS = [
    "LED1",
    "LED2",
    "LED3",
    "LED4",
    "LED5",
    "LED6",
    "LED7",
    "LED8",
    "LED9",
    "LED10",
    "LED11",
    "LED12",
]

LED_STATUS = ["OFF", "ON", "BLINK", "FLICKER"]

LOGICOP_PORTS = ["LOGICOP1", "LOGICOP2", "LOGICOP3", "LOGICOP4"]

BINSENSOR_PORTS = [
    "BINSENSOR1",
    "BINSENSOR2",
    "BINSENSOR3",
    "BINSENSOR4",
    "BINSENSOR5",
    "BINSENSOR6",
    "BINSENSOR7",
    "BINSENSOR8",
]

KEYS = [f"{t[0]:s}{t[1]:d}" for t in product(["A", "B", "C", "D"], range(1, 9))]

VARIABLES = [
    "VAR1ORTVAR",
    "VAR2ORR1VAR",
    "VAR3ORR2VAR",
    "TVAR",
    "R1VAR",
    "R2VAR",
    "VAR1",
    "VAR2",
    "VAR3",
    "VAR4",
    "VAR5",
    "VAR6",
    "VAR7",
    "VAR8",
    "VAR9",
    "VAR10",
    "VAR11",
    "VAR12",
]

SETPOINTS = ["R1VARSETPOINT", "R2VARSETPOINT"]

THRESHOLDS = [
    "THRS1",
    "THRS2",
    "THRS3",
    "THRS4",
    "THRS5",
    "THRS2_1",
    "THRS2_2",
    "THRS2_3",
    "THRS2_4",
    "THRS3_1",
    "THRS3_2",
    "THRS3_3",
    "THRS3_4",
    "THRS4_1",
    "THRS4_2",
    "THRS4_3",
    "THRS4_4",
]

S0_INPUTS = ["S0INPUT1", "S0INPUT2", "S0INPUT3", "S0INPUT4"]

VAR_UNITS = [
    "",
    "LCN",
    "NATIVE",
    TEMP_CELSIUS,
    TEMP_KELVIN,
    TEMP_FAHRENHEIT,
    "LUX_T",
    "LX_T",
    "LUX_I",
    "LUX",
    "LX",
    "M/S",
    "METERPERSECOND",
    PERCENTAGE,
    "PERCENT",
    "PPM",
    "VOLT",
    VOLT,
    "AMPERE",
    "AMP",
    "A",
    "DEGREE",
    DEGREE,
]

RELVARREF = ["CURRENT", "PROG"]

SENDKEYCOMMANDS = ["HIT", "MAKE", "BREAK", "DONTSEND"]

TIME_UNITS = [
    "SECONDS",
    "SECOND",
    "SEC",
    "S",
    "MINUTES",
    "MINUTE",
    "MIN",
    "M",
    "HOURS",
    "HOUR",
    "H",
    "DAYS",
    "DAY",
    "D",
]

MOTOR_REVERSE_TIME = ["RT70", "RT600", "RT1200"]

import websockets
import itertools
import asyncio
import json

class API:
    def __init__(self):
        # All registered clients
        self.clients = set()

        # All registered items
        self.items = set()

        # A map of items by their ID
        self.items_by_id = {}

        # Counter for used IDs
        self.id_counter = itertools.count()

        # Lock so we don't do weird things
        self.item_lock = asyncio.Lock()

    def register_client(self, client):
        """Registers a client (websocket?) to receive updates. It can be anything with a send() method."""

        self.clients.add(client)

    def register_item(self, item):
        """Registers an item to be sent with updates"""

        with self.item_lock:
            item.id = self.id_counter.next()

        return item.id

    def function_call(self, data):
        """Accepts a client function call request and performs the function as requested.

        Expects `data` to be a dictionary with some of the following keys:
        id: The id of the object on which to call the function. (required)
        name: The name of the function to call. (required)
        args: A list of positional arguments.
        kwargs: A dictionary of key:value arguments.
        """

        try:
            target = self.items_by_id[data["id"]]
            result = getattr(target, data["name"])(*(data.get("args", [])), **(data.get("kwargs", {})))
            return {"success": True, "result": result}
        except KeyError as e:
            print("Error, object with ID '{}' was not found.".format(data.get("id", None)))
            return {"success": False, "error": str(e)}
        except Exception as e:
            print("Error occurred while calling {}.{}".format(data.get("id", None), data.get("name", None)))
            raise e

    def send_updates(self):
        """Sends all updates for the server"""

        for client in self.client:
            for item in self.items:
                if hasattr(item, "jsonify"):
                    out = item.jsonify()
                else:
                    out = dict(item)

                client.send(json.dumps(out).encode('UTF-8'))

class Client:
    def __init__(self, api, socket):
        self.api = api
        self.socket = socket
        self.msg_queue = asyncio.Queue()

    @asyncio.coroutine
    def read(self):
        while True:
            data = yield from self.socket.recv()

            if data is None:
                print("Closing websocket")
                break

            data = json.loads(data)
            try:
                self.api.function_call(data)
            except Exception as e:
                print("Unable to call function from websocket data: ", e)

    @asyncio.coroutine
    def write(self):
        while True:
            msg = yield from self.msg_queue.get()
            yield from self.websocket.send(msg)

    def send(self, msg):
        self.msg_queue.put(msg)

class Server:
    def __init__(self, api, listen, port):
        self.listen = listen
        self.port = port
        self.api = api

    def start(self):
        """Begin serving websockets to clients, forever."""

        @asyncio.coroutine
        def websocket_server(websocket, path):
            client = Client(self.api, websocket)
            yield from asyncio.wait([client.read(), client.write()])

        start_ws_server = websockets.serve(websocket_server, self.listen, self.port)

        # Maybe don't do this? FIXME/TODO
        asyncio.get_event_loop().run_until_complete(start_ws_server)
        asyncio.get_event_loop().run_forever()

    def stop(self):
        """Close all websockets and stop listening."""
        pass

"""
Copyright 2011-13 Attila Zseder
Email: zseder@gmail.com

This file is part of hunmisc project
url: https://github.com/zseder/hunmisc

hunmisc is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
"""


import sys
import math
import re
"""This script calculates cross-entropy between two frequency lists. Zero frequencies, as well as words that are only present in one of the two files are discarded. Probability mass discarded in data1 is printed.
Usage:
    python entropy.py file1 file2
"""
def cross_entropy(q, p):
    qsum = float(sum(q.itervalues()))
    psum = float(sum(p.itervalues()))
    filtered_p = dict([(word, count) for (word, count) in p.iteritems()
                        if word in q and q[word] != 0])
    filtered_p_sum = float(sum(filtered_p.itervalues()))
    filtered_p_norm = dict([(w, count / filtered_p_sum) 
                            for w, count in filtered_p.iteritems()])
    qnorm = dict([(w, freq/qsum) for w, freq in q.iteritems()])
    pnorm = dict([(w, freq/psum) for w, freq in p.iteritems()])

    not_covered = 1.0 - sum([prob for (word, prob) in pnorm.iteritems()
                        if word in qnorm and qnorm[word] != 0])

    ce = 0
    for word, p_prob in filtered_p_norm.iteritems():
        q_prob = qnorm[word]
        ce += p_prob*math.log(p_prob/q_prob, 2)

    return ce, not_covered

if __name__ == '__main__':

    q = dict([(word, float(freq))
               for (word, freq) in [re.split("\s", line.rstrip())
                                    for line in file(sys.argv[1])]])
    p = dict([(word, float(freq))
               for (word, freq) in [re.split("\s", line.rstrip())
                                    for line in file(sys.argv[2])]])
    ce, uncovered = cross_entropy(q, p)
    print uncovered, ce

#!/usr/bin/python
# $Id: xsend.py,v 1.8 2006/10/06 12:30:42 normanr Exp $
import sys,os,xmpp,time

if len(sys.argv) < 2:
    print "Syntax: xsend JID text"
    sys.exit(0)

tojid=sys.argv[1]
text=' '.join(sys.argv[2:])

jidparams={}
if os.access(os.environ['HOME']+'/.xsend',os.R_OK):
    for ln in open(os.environ['HOME']+'/.xsend').readlines():
        if not ln[0] in ('#',';'):
            key,val=ln.strip().split('=',1)
            jidparams[key.lower()]=val
for mandatory in ['jid','password']:
    if mandatory not in jidparams.keys():
        open(os.environ['HOME']+'/.xsend','w').write('#Uncomment fields before use and type in correct credentials.\n#JID=romeo@montague.net/resource (/resource is optional)\n#PASSWORD=juliet\n')
        print 'Please point ~/.xsend config file to valid JID for sending messages.'
        sys.exit(0)

jid=xmpp.protocol.JID(jidparams['jid'])
cl=xmpp.Client(jid.getDomain(),debug=[])

con=cl.connect()
if not con:
    print 'could not connect!'
    sys.exit()
print 'connected with',con
auth=cl.auth(jid.getNode(),jidparams['password'],resource=jid.getResource())
if not auth:
    print 'could not authenticate!'
    sys.exit()
print 'authenticated using',auth

#cl.SendInitPresence(requestRoster=0)   # you may need to uncomment this for old server
id=cl.send(xmpp.protocol.Message(tojid,text))
print 'sent message with id',id

time.sleep(1)   # some older servers will not send the message if you disconnect immediately after sending

#cl.disconnect()

from .. import util

machinery = util.import_importlib('importlib.machinery')

import codecs
import importlib.util
import re
import types
# Because sys.path gets essentially blanked, need to have unicodedata already
# imported for the parser to use.
import unicodedata
import unittest
import warnings


CODING_RE = re.compile(r'^[ \t\f]*#.*?coding[:=][ \t]*([-\w.]+)', re.ASCII)


class EncodingTest:

    """PEP 3120 makes UTF-8 the default encoding for source code
    [default encoding].

    PEP 263 specifies how that can change on a per-file basis. Either the first
    or second line can contain the encoding line [encoding first line]
    encoding second line]. If the file has the BOM marker it is considered UTF-8
    implicitly [BOM]. If any encoding is specified it must be UTF-8, else it is
    an error [BOM and utf-8][BOM conflict].

    """

    variable = '\u00fc'
    character = '\u00c9'
    source_line = "{0} = '{1}'\n".format(variable, character)
    module_name = '_temp'

    def run_test(self, source):
        with util.create_modules(self.module_name) as mapping:
            with open(mapping[self.module_name], 'wb') as file:
                file.write(source)
            loader = self.machinery.SourceFileLoader(self.module_name,
                                                  mapping[self.module_name])
            return self.load(loader)

    def create_source(self, encoding):
        encoding_line = "# coding={0}".format(encoding)
        assert CODING_RE.match(encoding_line)
        source_lines = [encoding_line.encode('utf-8')]
        source_lines.append(self.source_line.encode(encoding))
        return b'\n'.join(source_lines)

    def test_non_obvious_encoding(self):
        # Make sure that an encoding that has never been a standard one for
        # Python works.
        encoding_line = "# coding=koi8-r"
        assert CODING_RE.match(encoding_line)
        source = "{0}\na=42\n".format(encoding_line).encode("koi8-r")
        self.run_test(source)

    # [default encoding]
    def test_default_encoding(self):
        self.run_test(self.source_line.encode('utf-8'))

    # [encoding first line]
    def test_encoding_on_first_line(self):
        encoding = 'Latin-1'
        source = self.create_source(encoding)
        self.run_test(source)

    # [encoding second line]
    def test_encoding_on_second_line(self):
        source = b"#/usr/bin/python\n" + self.create_source('Latin-1')
        self.run_test(source)

    # [BOM]
    def test_bom(self):
        self.run_test(codecs.BOM_UTF8 + self.source_line.encode('utf-8'))

    # [BOM and utf-8]
    def test_bom_and_utf_8(self):
        source = codecs.BOM_UTF8 + self.create_source('utf-8')
        self.run_test(source)

    # [BOM conflict]
    def test_bom_conflict(self):
        source = codecs.BOM_UTF8 + self.create_source('latin-1')
        with self.assertRaises(SyntaxError):
            self.run_test(source)


class EncodingTestPEP451(EncodingTest):

    def load(self, loader):
        module = types.ModuleType(self.module_name)
        module.__spec__ = importlib.util.spec_from_loader(self.module_name, loader)
        loader.exec_module(module)
        return module


(Frozen_EncodingTestPEP451,
 Source_EncodingTestPEP451
 ) = util.test_both(EncodingTestPEP451, machinery=machinery)


class EncodingTestPEP302(EncodingTest):

    def load(self, loader):
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', DeprecationWarning)
            return loader.load_module(self.module_name)


(Frozen_EncodingTestPEP302,
 Source_EncodingTestPEP302
 ) = util.test_both(EncodingTestPEP302, machinery=machinery)


class LineEndingTest:

    r"""Source written with the three types of line endings (\n, \r\n, \r)
    need to be readable [cr][crlf][lf]."""

    def run_test(self, line_ending):
        module_name = '_temp'
        source_lines = [b"a = 42", b"b = -13", b'']
        source = line_ending.join(source_lines)
        with util.create_modules(module_name) as mapping:
            with open(mapping[module_name], 'wb') as file:
                file.write(source)
            loader = self.machinery.SourceFileLoader(module_name,
                                                     mapping[module_name])
            return self.load(loader, module_name)

    # [cr]
    def test_cr(self):
        self.run_test(b'\r')

    # [crlf]
    def test_crlf(self):
        self.run_test(b'\r\n')

    # [lf]
    def test_lf(self):
        self.run_test(b'\n')


class LineEndingTestPEP451(LineEndingTest):

    def load(self, loader, module_name):
        module = types.ModuleType(module_name)
        module.__spec__ = importlib.util.spec_from_loader(module_name, loader)
        loader.exec_module(module)
        return module


(Frozen_LineEndingTestPEP451,
 Source_LineEndingTestPEP451
 ) = util.test_both(LineEndingTestPEP451, machinery=machinery)


class LineEndingTestPEP302(LineEndingTest):

    def load(self, loader, module_name):
        with warnings.catch_warnings():
            warnings.simplefilter('ignore', DeprecationWarning)
            return loader.load_module(module_name)


(Frozen_LineEndingTestPEP302,
 Source_LineEndingTestPEP302
 ) = util.test_both(LineEndingTestPEP302, machinery=machinery)


if __name__ == '__main__':
    unittest.main()

def merge(input_array, beg, mid, end):
  """Merge procedure for merge sort algorithm"""
  listA = input_array[beg:mid+1]
  listB = input_array[mid+1:end+1]
  current_position = beg
  while len(listA)>0 and len(listB)>0:
    if(listA[0] < listB[0]):
      input_array[current_position] = listA[0]
      listA.pop(0)
    else:
      input_array[current_position] = listB[0]
      listB.pop(0)
    current_position += 1
  input_array[current_position:end+1] = listA + listB
  pass

def msort(input_array, beg, end):
  """Main mergesort procedure"""
  # Boundary condition - subarray of size 1 is already sorted  
  if beg==end:
    return
  mid = int((beg+end)/2)
  msort(input_array, beg, mid)
  msort(input_array, mid+1, end)  
  merge(input_array, beg, mid, end)  # stub - merge the 2 halves together

def mergesort(input_array):
  """Wrapper for actual merge sort procedure"""
  array_length = len(input_array)
  msort(input_array, 0, array_length - 1)


number_of_input_values = int(raw_input())

current_input_position = 1
number_list=[]

for current_input_position in range(1, number_of_input_values+1):
  current_input = int(raw_input())
  number_list.append(current_input)

mergesort(number_list)

for current_number in number_list:
  print current_number
# Copyright (C) 2015 Yahoo! Inc. All Rights Reserved.
#
# 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.

from django.core.urlresolvers import reverse
from django.utils.translation import ugettext_lazy as _
from django.utils.translation import ungettext_lazy

from horizon import tables
from openstack_dashboard import api
from openstack_dashboard import policy


class AddProtocol(policy.PolicyTargetMixin, tables.LinkAction):
    name = "create"
    verbose_name = _("Add Protocol")
    url = "horizon:identity:identity_providers:protocols:create"
    classes = ("ajax-modal",)
    icon = "plus"
    policy_rules = (("identity", "identity:create_protocol"),)

    def get_link_url(self, datum=None):
        idp_id = self.table.kwargs['identity_provider_id']
        return reverse(self.url, args=(idp_id,))


class RemoveProtocol(policy.PolicyTargetMixin, tables.DeleteAction):
    @staticmethod
    def action_present(count):
        return ungettext_lazy(
            u"Delete Protocol",
            u"Delete Protocols",
            count
        )

    @staticmethod
    def action_past(count):
        return ungettext_lazy(
            u"Deleted Protocol",
            u"Deleted Protocols",
            count
        )

    policy_rules = (("identity", "identity:delete_protocol"),)

    def delete(self, request, obj_id):
        identity_provider = self.table.kwargs['identity_provider_id']
        protocol = obj_id
        api.keystone.protocol_delete(request, identity_provider, protocol)


class ProtocolsTable(tables.DataTable):
    protocol = tables.Column("id",
                             verbose_name=_("Protocol ID"))
    mapping = tables.Column("mapping_id",
                            verbose_name=_("Mapping ID"))

    def get_object_display(self, datum):
        return datum.id

    class Meta(object):
        name = "idp_protocols"
        verbose_name = _("Protocols")
        table_actions = (AddProtocol, RemoveProtocol)
        row_actions = (RemoveProtocol, )

#
#    Copyright 2010 OpenStack Foundation
#
#    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.

from cinder import test
from cinder.tests import utils as test_utils


class TestUtilsTestCase(test.TestCase):
    def test_get_test_admin_context(self):
        """get_test_admin_context's return value behaves like admin context."""
        ctxt = test_utils.get_test_admin_context()

        # TODO(soren): This should verify the full interface context
        # objects expose.
        self.assertTrue(ctxt.is_admin)

# (c) 2013, Serge van Ginderachter <serge@vanginderachter.be>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

from ansible.errors import *
from ansible.plugins.lookup import LookupBase
from ansible.utils.listify import listify_lookup_plugin_terms
from ansible.utils.boolean import boolean

FLAGS = ('skip_missing',)


class LookupModule(LookupBase):

    def run(self, terms, variables, **kwargs):

        def _raise_terms_error(msg=""):
            raise AnsibleError(
                "subelements lookup expects a list of two or three items, "
                + msg)

        terms[0] = listify_lookup_plugin_terms(terms[0], templar=self._templar, loader=self._loader)

        # check lookup terms - check number of terms
        if not isinstance(terms, list) or not 2 <= len(terms) <= 3:
            _raise_terms_error()

        # first term should be a list (or dict), second a string holding the subkey
        if not isinstance(terms[0], (list, dict)) or not isinstance(terms[1], basestring):
            _raise_terms_error("first a dict or a list, second a string pointing to the subkey")
        subelements = terms[1].split(".")

        if isinstance(terms[0], dict):  # convert to list:
            if terms[0].get('skipped', False) is not False:
                # the registered result was completely skipped
                return []
            elementlist = []
            for key in terms[0].iterkeys():
                elementlist.append(terms[0][key])
        else:
            elementlist = terms[0]

        # check for optional flags in third term
        flags = {}
        if len(terms) == 3:
            flags = terms[2]
        if not isinstance(flags, dict) and not all([isinstance(key, basestring) and key in FLAGS for key in flags]):
            _raise_terms_error("the optional third item must be a dict with flags %s" % FLAGS)

        # build_items
        ret = []
        for item0 in elementlist:
            if not isinstance(item0, dict):
                raise AnsibleError("subelements lookup expects a dictionary, got '%s'" % item0)
            if item0.get('skipped', False) is not False:
                # this particular item is to be skipped
                continue

            skip_missing = boolean(flags.get('skip_missing', False))
            subvalue = item0
            lastsubkey = False
            sublist = []
            for subkey in subelements:
                if subkey == subelements[-1]:
                    lastsubkey = True
                if not subkey in subvalue:
                    if skip_missing:
                        continue
                    else:
                        raise AnsibleError("could not find '%s' key in iterated item '%s'" % (subkey, subvalue))
                if not lastsubkey:
                    if not isinstance(subvalue[subkey], dict):
                        if skip_missing:
                            continue
                        else:
                            raise AnsibleError("the key %s should point to a dictionary, got '%s'" % (subkey, subvalue[subkey]))
                    else:
                        subvalue = subvalue[subkey]
                else:  # lastsubkey
                    if not isinstance(subvalue[subkey], list):
                        raise AnsibleError("the key %s should point to a list, got '%s'" % (subkey, subvalue[subkey]))
                    else:
                        sublist = subvalue.pop(subkey, [])
            for item1 in sublist:
                ret.append((item0, item1))

        return ret


#! /usr/bin/env python3
"""
 services-wrapper A small tool which wraps around check-services.php and tries to
                guide the services process with a more modern approach with a
                Queue and workers.

 Based on the original version of poller-wrapper.py by Job Snijders

 Author:        Neil Lathwood <neil@librenms.org>
                Orsiris de Jong <contact@netpower.fr>
 Date:          Oct 2019

 Usage:         This program accepts one command line argument: the number of threads
                that should run simultaneously. If no argument is given it will assume
                a default of 1 thread.

 Ubuntu Linux:  apt-get install python-mysqldb
 FreeBSD:       cd /usr/ports/*/py-MySQLdb && make install clean
 RHEL 7:        yum install MySQL-python
 RHEL 8:        dnf install mariadb-connector-c-devel gcc && python -m pip install mysqlclient

 Tested on:     Python 3.6.8 / PHP 7.2.11 / CentOS 8

 License:       This program is free software: you can redistribute it and/or modify it
                under the terms of the GNU General Public License as published by the
                Free Software Foundation, either version 3 of the License, or (at your
                option) any later version.

                This program is distributed in the hope that it will be useful, but
                WITHOUT ANY WARRANTY; without even the implied warranty of
                MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
                Public License for more details.

                You should have received a copy of the GNU General Public License along
                with this program. If not, see http://www.gnu.org/licenses/.

                LICENSE.txt contains a copy of the full GPLv3 licensing conditions.
"""

import LibreNMS.library as LNMS

try:

    import json
    import os
    import queue
    import subprocess
    import sys
    import threading
    import time
    from optparse import OptionParser

except ImportError as exc:
    print('ERROR: missing one or more of the following python modules:')
    print('threading, queue, sys, subprocess, time, os, json')
    print('ERROR: %s' % exc)
    sys.exit(2)


APP_NAME = "services_wrapper"
LOG_FILE = "logs/" + APP_NAME + ".log"
_DEBUG = False
servicedisco = False
real_duration = 0
service_devices = 0

"""
 Threading helper functions
"""
# (c) 2015, GPLv3, Daniel Preussker <f0o@devilcode.org> <<<EOC0
def memc_alive():
    try:
        global memc
        key = str(uuid.uuid4())
        memc.set('poller.ping.' + key, key, 60)
        if memc.get('poller.ping.' + key) == key:
            memc.delete('poller.ping.' + key)
            return True
        else:
            return False
    except:
        return False


def memc_touch(key, time):
    try:
        global memc
        val = memc.get(key)
        memc.set(key, val, time)
    except:
        pass


def get_time_tag(step):
    ts = int(time.time())
    return ts - ts % step
#EOC0


"""
    A seperate queue and a single worker for printing information to the screen prevents
    the good old joke:

        Some people, when confronted with a problem, think,
        "I know, I'll use threads," and then they two they hav erpoblesms.
"""


def printworker():
    nodeso = 0
    while True:
        # (c) 2015, GPLv3, Daniel Preussker <f0o@devilcode.org> <<<EOC4
        global IsNode
        global servicedisco
        if servicedisco:
            if not IsNode:
                memc_touch('service.master', 10)
                nodes = memc.get('service.nodes')
                if nodes is None and not memc_alive():
                    print("WARNING: Lost Memcached. Taking over all devices. Nodes will quit shortly.")
                    servicedisco = False
                    nodes = nodeso
                if nodes is not nodeso:
                    print("INFO: %s Node(s) Total" % (nodes))
                    nodeso = nodes
            else:
                memc_touch('service.nodes', 10)
            try:
                worker_id, device_id, elapsed_time = print_queue.get(False)
            except:
                pass
                try:
                    time.sleep(1)
                except:
                    pass
                continue
        else:
            worker_id, device_id, elapsed_time = print_queue.get()
        # EOC4
        global real_duration
        global per_device_duration
        global service_devices
        real_duration += elapsed_time
        per_device_duration[device_id] = elapsed_time
        service_devices += 1
        if elapsed_time < 300:
            print("INFO: worker %s finished device %s in %s seconds" % (worker_id, device_id, elapsed_time))
        else:
            print("WARNING: worker %s finished device %s in %s seconds" % (worker_id, device_id, elapsed_time))
        print_queue.task_done()

"""
    This class will fork off single instances of the check-services.php process, record
    how long it takes, and push the resulting reports to the printer queue
"""


def poll_worker():
    while True:
        device_id = poll_queue.get()
        # (c) 2015, GPLv3, Daniel Preussker <f0o@devilcode.org> <<<EOC5
        if not servicedisco or memc.get('service.device.' + str(device_id)) is None:
            if servicedisco:
                result = memc.add('service.device.' + str(device_id), config['distributed_poller_name'], 300)
                if not result:
                    print("This device (%s) appears to be being service checked by another service node" % (device_id))
                    poll_queue.task_done()
                    continue
                if not memc_alive() and IsNode:
                    print("Lost Memcached, Not service checking Device %s as Node. Master will check it." % device_id)
                    poll_queue.task_done()
                    continue
            # EOC5
            try:
                start_time = time.time()

                output = "-d >> %s/services_device_%s.log" % (log_dir, device_id) if debug else ">> /dev/null"
                # TODO replace with command_runner
                command = "/usr/bin/env php %s -h %s %s 2>&1" % (service_path, device_id, output)
                subprocess.check_call(command, shell=True)

                elapsed_time = int(time.time() - start_time)
                print_queue.put([threading.current_thread().name, device_id, elapsed_time])
            except (KeyboardInterrupt, SystemExit):
                raise
            except:
                pass
        poll_queue.task_done()


if __name__ == '__main__':
    logger = LNMS.logger_get_logger(LOG_FILE, debug=_DEBUG)

    install_dir = os.path.dirname(os.path.realpath(__file__))
    LNMS.check_for_file(install_dir + '/.env')
    config = json.loads(LNMS.get_config_data(install_dir))

    service_path = config['install_dir'] + '/check-services.php'
    log_dir = config['log_dir']

    # (c) 2015, GPLv3, Daniel Preussker <f0o@devilcode.org> <<<EOC1
    if 'distributed_poller_group' in config:
        service_group = str(config['distributed_poller_group'])
    else:
        service_group = False


    if ('distributed_poller' in config and
        'distributed_poller_memcached_host' in config and
        'distributed_poller_memcached_port' in config and
        config['distributed_poller']):
        try:
            import memcache
            import uuid
            memc = memcache.Client([config['distributed_poller_memcached_host'] + ':' +
                                    str(config['distributed_poller_memcached_port'])])
            if str(memc.get("service.master")) == config['distributed_poller_name']:
                print("This system is already joined as the service master.")
                sys.exit(2)
            if memc_alive():
                if memc.get("service.master") is None:
                    print("Registered as Master")
                    memc.set("service.master", config['distributed_poller_name'], 10)
                    memc.set("service.nodes", 0, 300)
                    IsNode = False
                else:
                    print("Registered as Node joining Master %s" % memc.get("service.master"))
                    IsNode = True
                    memc.incr("service.nodes")
                servicedisco = True
            else:
                print("Could not connect to memcached, disabling distributed service checks.")
                servicedisco = False
                IsNode = False
        except SystemExit:
            raise
        except ImportError:
            print("ERROR: missing memcache python module:")
            print("On deb systems: apt-get install python3-memcache")
            print("On other systems: pip3 install python-memcached")
            print("Disabling distributed discovery.")
            servicedisco = False
    else:
        servicedisco = False
    # EOC1

    s_time = time.time()
    real_duration = 0
    per_device_duration = {}
    service_devices = 0

    """
        Take the amount of threads we want to run in parallel from the commandline
        if None are given or the argument was garbage, fall back to default of 16
    """
    usage = "usage: %prog [options] <workers> (Default: 1 (Do not set too high)"
    description = "Spawn multiple check-services.php processes in parallel."
    parser = OptionParser(usage=usage, description=description)
    parser.add_option('-d', '--debug', action='store_true', default=False,
                      help="Enable debug output. WARNING: Leaving this enabled will consume a lot of disk space.")
    (options, args) = parser.parse_args()

    debug = options.debug
    try:
        amount_of_workers = int(args[0])
    except (IndexError, ValueError):
        amount_of_workers = 1

    devices_list = []

    # (c) 2015, GPLv3, Daniel Preussker <f0o@devilcode.org> <<<EOC2
    if service_group is not False:
        query = "SELECT DISTINCT(`services`.`device_id`) FROM `services` LEFT JOIN `devices` ON `services`.`device_id` = `devices`.`device_id` WHERE `devices`.`poller_group` IN(" + service_group + ") AND `devices`.`disabled` = 0"
    else:
        query = "SELECT DISTINCT(`services`.`device_id`) FROM `services` LEFT JOIN `devices` ON `services`.`device_id` = `devices`.`device_id` WHERE `devices`.`disabled` = 0"
    # EOC2

    db = LNMS.db_open(config['db_socket'], config['db_host'], config['db_port'], config['db_user'], config['db_pass'], config['db_name'])
    cursor = db.cursor()
    cursor.execute(query)
    devices = cursor.fetchall()
    for row in devices:
        devices_list.append(int(row[0]))
    # (c) 2015, GPLv3, Daniel Preussker <f0o@devilcode.org> <<<EOC3
    if servicedisco and not IsNode:
        query = "SELECT MAX(`device_id`), MIN(`device_id`) FROM `services`"
        cursor.execute(query)
        devices = cursor.fetchall()
        maxlocks = devices[0][0] or 0
        minlocks = devices[0][1] or 0
    # EOC3
    db.close()

    poll_queue = queue.Queue()
    print_queue = queue.Queue()

    print("INFO: starting the service check at %s with %s threads" % (time.strftime("%Y-%m-%d %H:%M:%S"),
                                                                      amount_of_workers))

    for device_id in devices_list:
        poll_queue.put(device_id)

    for i in range(amount_of_workers):
        t = threading.Thread(target=poll_worker)
        t.setDaemon(True)
        t.start()

    p = threading.Thread(target=printworker)
    p.setDaemon(True)
    p.start()

    try:
        poll_queue.join()
        print_queue.join()
    except (KeyboardInterrupt, SystemExit):
        raise

    total_time = int(time.time() - s_time)

    print("INFO: services-wrapper checked %s devices in %s seconds with %s workers" % (service_devices, total_time, amount_of_workers))

    # (c) 2015, GPLv3, Daniel Preussker <f0o@devilcode.org> <<<EOC6
    if servicedisco or memc_alive():
        master = memc.get("service.master")
        if master == config['distributed_poller_name'] and not IsNode:
            print("Wait for all service-nodes to finish")
            nodes = memc.get("service.nodes")
            while nodes is not None and nodes > 0:
                try:
                    time.sleep(1)
                    nodes = memc.get("service.nodes")
                except:
                    pass
            print("Clearing Locks")
            x = minlocks
            while x <= maxlocks:
                memc.delete('service.device.' + str(x))
                x = x + 1
            print("%s Locks Cleared" % x)
            print("Clearing Nodes")
            memc.delete("service.master")
            memc.delete("service.nodes")
        else:
            memc.decr("service.nodes")
        print("Finished %s." % time.time())
    # EOC6

    show_stopper = False

    if total_time > 300:
        print("WARNING: the process took more than 5 minutes to finish, you need faster hardware or more threads")
        print("INFO: in sequential style service checks the elapsed time would have been: %s seconds" % real_duration)
        for device in per_device_duration:
            if per_device_duration[device] > 300:
                print("WARNING: device %s is taking too long: %s seconds" % (device, per_device_duration[device]))
                show_stopper = True
        if show_stopper:
            print("ERROR: Some devices are taking more than 300 seconds, the script cannot recommend you what to do.")
        else:
            recommend = int(total_time / 300.0 * amount_of_workers + 1)
            print(
                "WARNING: Consider setting a minimum of %d threads. (This does not constitute professional advice!)" % recommend)

        sys.exit(2)

#!/usr/bin/env python
#
# This python file contains utility scripts to manage Django translations.
# It has to be run inside the django git root directory.
#
# The following commands are available:
#
# * update_catalogs: check for new strings in core and contrib catalogs, and
#                    output how much strings are new/changed.
#
# * lang_stats: output statistics for each catalog/language combination
#
# * fetch: fetch translations from transifex.com
#
# Each command support the --languages and --resources options to limit their
# operation to the specified language or resource. For example, to get stats
# for Spanish in contrib.admin, run:
#
#  $ python scripts/manage_translations.py lang_stats --language=es --resources=admin

import os
from optparse import OptionParser
from subprocess import call, Popen, PIPE

from django.core.management import call_command


HAVE_JS = ['admin']

def _get_locale_dirs(include_core=True):
    """
    Return a tuple (contrib name, absolute path) for all locale directories,
    optionally including the django core catalog.
    """
    contrib_dir = os.path.join(os.getcwd(), 'django', 'contrib')
    dirs = []
    for contrib_name in os.listdir(contrib_dir):
        path = os.path.join(contrib_dir, contrib_name, 'locale')
        if os.path.isdir(path):
            dirs.append((contrib_name, path))
            if contrib_name in HAVE_JS:
                dirs.append(("%s-js" % contrib_name, path))
    if include_core:
        dirs.insert(0, ('core', os.path.join(os.getcwd(), 'django', 'conf', 'locale')))
    return dirs

def _tx_resource_for_name(name):
    """ Return the Transifex resource name """
    if name == 'core':
        return "django-core.core"
    else:
        return "django-core.contrib-%s" % name

def _check_diff(cat_name, base_path):
    """
    Output the approximate number of changed/added strings in the en catalog.
    """
    po_path = '%(path)s/en/LC_MESSAGES/django%(ext)s.po' % {
        'path': base_path, 'ext': 'js' if cat_name.endswith('-js') else ''}
    p = Popen("git diff -U0 %s | egrep -v '^@@|^[-+]#|^..POT-Creation' | wc -l" % po_path,
              stdout=PIPE, stderr=PIPE, shell=True)
    output, errors = p.communicate()
    num_changes = int(output.strip()) - 4
    print("%d changed/added messages in '%s' catalog." % (num_changes, cat_name))


def update_catalogs(resources=None, languages=None):
    """
    Update the en/LC_MESSAGES/django.po (main and contrib) files with
    new/updated translatable strings.
    """
    contrib_dirs = _get_locale_dirs(include_core=False)

    os.chdir(os.path.join(os.getcwd(), 'django'))
    print("Updating main en catalog")
    call_command('makemessages', locale='en')
    _check_diff('core', os.path.join(os.getcwd(), 'conf', 'locale'))

    # Contrib catalogs
    for name, dir_ in contrib_dirs:
        if resources and not name in resources:
            continue
        os.chdir(os.path.join(dir_, '..'))
        print("Updating en catalog in %s" % dir_)
        if name.endswith('-js'):
            call_command('makemessages', locale='en', domain='djangojs')
        else:
            call_command('makemessages', locale='en')
        _check_diff(name, dir_)


def lang_stats(resources=None, languages=None):
    """
    Output language statistics of committed translation files for each
    Django catalog.
    If resources is provided, it should be a list of translation resource to
    limit the output (e.g. ['core', 'gis']).
    """
    locale_dirs = _get_locale_dirs()

    for name, dir_ in locale_dirs:
        if resources and not name in resources:
            continue
        print("\nShowing translations stats for '%s':" % name) 
        langs = sorted([d for d in os.listdir(dir_) if not d.startswith('_')])
        for lang in langs:
            if languages and not lang in languages:
                continue
            # TODO: merge first with the latest en catalog
            p = Popen("msgfmt -vc -o /dev/null %(path)s/%(lang)s/LC_MESSAGES/django%(ext)s.po" % {
                'path': dir_, 'lang': lang, 'ext': 'js' if name.endswith('-js') else ''},
                stdout=PIPE, stderr=PIPE, shell=True)
            output, errors = p.communicate()
            if p.returncode == 0:
                # msgfmt output stats on stderr
                print("%s: %s" % (lang, errors.strip()))


def fetch(resources=None, languages=None):
    """
    Fetch translations from Transifex, wrap long lines, generate mo files.
    """
    locale_dirs = _get_locale_dirs()

    for name, dir_ in locale_dirs:
        if resources and not name in resources:
            continue

        # Transifex pull
        if languages is None:
            call('tx pull -r %(res)s -a -f' % {'res': _tx_resource_for_name(name)}, shell=True)
            languages = sorted([d for d in os.listdir(dir_) if not d.startswith('_')])
        else:
            for lang in languages:
                call('tx pull -r %(res)s -f -l %(lang)s' % {
                    'res': _tx_resource_for_name(name), 'lang': lang}, shell=True)

        # msgcat to wrap lines and msgfmt for compilation of .mo file
        for lang in languages:
            po_path = '%(path)s/%(lang)s/LC_MESSAGES/django%(ext)s.po' % {
                'path': dir_, 'lang': lang, 'ext': 'js' if name.endswith('-js') else ''}
            call('msgcat -o %s %s' % (po_path, po_path), shell=True)
            mo_path = '%s.mo' % po_path[:-3]
            call('msgfmt -o %s %s' % (mo_path, po_path), shell=True)


if __name__ == "__main__":
    RUNABLE_SCRIPTS = ('update_catalogs', 'lang_stats', 'fetch')

    parser = OptionParser(usage="usage: %prog [options] cmd")
    parser.add_option("-r", "--resources", action='append',
        help="limit operation to the specified resources")
    parser.add_option("-l", "--languages", action='append',
        help="limit operation to the specified languages")
    options, args = parser.parse_args()

    if not args:
        parser.print_usage()
        exit(1)

    if args[0] in RUNABLE_SCRIPTS:
        eval(args[0])(options.resources, options.languages)
    else:
        print("Available commands are: %s" % ", ".join(RUNABLE_SCRIPTS))

#
# Copyright (C) 2010 The Android Open Source Project
#
# 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.

import re
import sys
from command import Command
from git_command import GitCommand

CHANGE_ID_RE = re.compile(r'^\s*Change-Id: I([0-9a-f]{40})\s*$')

class CherryPick(Command):
  common = True
  helpSummary = "Cherry-pick a change."
  helpUsage = """
%prog <sha1>
"""
  helpDescription = """
'%prog' cherry-picks a change from one branch to another.
The change id will be updated, and a reference to the old
change id will be added.
"""

  def _Options(self, p):
    pass

  def Execute(self, opt, args):
    if len(args) != 1:
      self.Usage()

    reference = args[0]

    p = GitCommand(None,
                   ['rev-parse', '--verify', reference],
                   capture_stdout = True,
                   capture_stderr = True)
    if p.Wait() != 0:
      print >>sys.stderr, p.stderr
      sys.exit(1)
    sha1 = p.stdout.strip()

    p = GitCommand(None, ['cat-file', 'commit', sha1], capture_stdout=True)
    if p.Wait() != 0:
      print >>sys.stderr, "error: Failed to retrieve old commit message"
      sys.exit(1)
    old_msg = self._StripHeader(p.stdout)

    p = GitCommand(None,
                   ['cherry-pick', sha1],
                   capture_stdout = True,
                   capture_stderr = True)
    status = p.Wait()

    print >>sys.stdout, p.stdout
    print >>sys.stderr, p.stderr

    if status == 0:
      # The cherry-pick was applied correctly. We just need to edit the
      # commit message.
      new_msg = self._Reformat(old_msg, sha1)

      p = GitCommand(None, ['commit', '--amend', '-F', '-'],
                     provide_stdin = True,
                     capture_stdout = True,
                     capture_stderr = True)
      p.stdin.write(new_msg)
      if p.Wait() != 0:
        print >>sys.stderr, "error: Failed to update commit message"
        sys.exit(1)

    else:
      print >>sys.stderr, """\
NOTE: When committing (please see above) and editing the commit message,
please remove the old Change-Id-line and add:
"""
      print >>sys.stderr, self._GetReference(sha1)
      print >>sys.stderr

  def _IsChangeId(self, line):
    return CHANGE_ID_RE.match(line)

  def _GetReference(self, sha1):
    return "(cherry picked from commit %s)" % sha1

  def _StripHeader(self, commit_msg):
    lines = commit_msg.splitlines()
    return "\n".join(lines[lines.index("")+1:])

  def _Reformat(self, old_msg, sha1):
    new_msg = []

    for line in old_msg.splitlines():
      if not self._IsChangeId(line):
        new_msg.append(line)

    # Add a blank line between the message and the change id/reference
    try:
      if new_msg[-1].strip() != "":
        new_msg.append("")
    except IndexError:
      pass

    new_msg.append(self._GetReference(sha1))
    return "\n".join(new_msg)

#
# (C) Copyright 2003-2011 Jacek Konieczny <jajcus@jajcus.net>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License Version
# 2.1 as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the Free Software
# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#

"""Dictionary with item expiration."""



__docformat__ = "restructuredtext en"

import time
import threading
import logging

logger = logging.getLogger("pyxmpp2.expdict")

_NO_DEFAULT = object()

class ExpiringDictionary(dict):
    """An extension to standard Python dictionary objects which implements item
    expiration.

    Each item in ExpiringDictionary has its expiration time assigned, after
    which the item is removed from the mapping.

    :Ivariables:
        - `_timeouts`: a dictionary with timeout values and timeout callback for
          stored objects.
        - `_default_timeout`: the default timeout value (in seconds from now).
        - `_lock`: access synchronization lock.
    :Types:
        - `_timeouts`: `dict`
        - `_default_timeout`: `float`
        - `_lock`: :std:`threading.RLock`"""
    __slots__ = ['_timeouts', '_default_timeout', '_lock']
    def __init__(self, default_timeout = 300.0):
        """Initialize an `ExpiringDictionary` object.

        :Parameters:
            - `default_timeout`: default timeout value (in seconds) for stored
              objects.
        :Types:
            - `default_timeout`: `float`
        """
        dict.__init__(self)
        self._timeouts = {}
        self._default_timeout = default_timeout
        self._lock = threading.RLock()

    def __delitem__(self, key):
        with self._lock:
            logger.debug("expdict.__delitem__({0!r})".format(key))
            del self._timeouts[key]
            return dict.__delitem__(self, key)

    def __getitem__(self, key):
        with self._lock:
            logger.debug("expdict.__getitem__({0!r})".format(key))
            self._expire_item(key)
            return dict.__getitem__(self, key)

    def pop(self, key, default = _NO_DEFAULT):
        with self._lock:
            self._expire_item(key)
            del self._timeouts[key]
            if default is not _NO_DEFAULT:
                return dict.pop(self, key, default)
            else:
                return dict.pop(self, key)

    def __setitem__(self, key, value):
        logger.debug("expdict.__setitem__({0!r}, {1!r})".format(key, value))
        return self.set_item(key, value)

    def set_item(self, key, value, timeout = None, timeout_callback = None):
        """Set item of the dictionary.

        :Parameters:
            - `key`: the key.
            - `value`: the object to store.
            - `timeout`: timeout value for the object (in seconds from now).
            - `timeout_callback`: function to be called when the item expires.
              The callback should accept none, one (the key) or two (the key
              and the value) arguments.
        :Types:
            - `key`: any hashable value
            - `value`: any python object
            - `timeout`: `int`
            - `timeout_callback`: callable
        """
        with self._lock:
            logger.debug("expdict.__setitem__({0!r}, {1!r}, {2!r}, {3!r})"
                            .format(key, value, timeout, timeout_callback))
            if not timeout:
                timeout = self._default_timeout
            self._timeouts[key] = (time.time() + timeout, timeout_callback)
            return dict.__setitem__(self, key, value)

    def expire(self):
        """Do the expiration of dictionary items.

        Remove items that expired by now from the dictionary.

        :Return: time, in seconds, when the next item expires or `None`
        :returntype: `float`
        """
        with self._lock:
            logger.debug("expdict.expire. timeouts: {0!r}"
                                                    .format(self._timeouts))
            next_timeout = None
            for k in list(self._timeouts.keys()):
                ret = self._expire_item(k)
                if ret is not None:
                    if next_timeout is None:
                        next_timeout = ret
                    else:
                        next_timeout = min(next_timeout, ret)
            return next_timeout

    def clear(self):
        with self._lock:
            self._timeouts.clear()
            dict.clear(self)

    def _expire_item(self, key):
        """Do the expiration of a dictionary item.

        Remove the item if it has expired by now.

        :Parameters:
            - `key`: key to the object.
        :Types:
            - `key`: any hashable value
        """
        (timeout, callback) = self._timeouts[key]
        now = time.time()
        if timeout <= now:
            item = dict.pop(self, key)
            del self._timeouts[key]
            if callback:
                try:
                    callback(key, item)
                except TypeError:
                    try:
                        callback(key)
                    except TypeError:
                        callback()
            return None
        else:
            return timeout - now

# vi: sts=4 et sw=4

from itertools import chain

from oscar.apps.promotions.models import KeywordPromotion, PagePromotion


def promotions(request):
    """
    For adding bindings for banners and pods to the template
    context.
    """
    promotions = get_request_promotions(request)

    # Split the promotions into separate lists for each position, and add them
    # to the template bindings
    context = {
        'url_path': request.path
    }
    split_by_position(promotions, context)

    return context


def get_request_promotions(request):
    """
    Return promotions relevant to this request
    """
    promotions = PagePromotion._default_manager.select_related() \
        .prefetch_related('content_object') \
        .filter(page_url=request.path) \
        .order_by('display_order')

    if 'q' in request.GET:
        keyword_promotions \
            = KeywordPromotion._default_manager.select_related()\
            .filter(keyword=request.GET['q'])
        if keyword_promotions.exists():
            promotions = list(chain(promotions, keyword_promotions))
    return promotions


def split_by_position(linked_promotions, context):
    """
    Split the list of promotions into separate lists, grouping
    by position, and write these lists to the context dict.
    """
    for linked_promotion in linked_promotions:
        promotion = linked_promotion.content_object
        if not promotion:
            continue
        key = 'promotions_%s' % linked_promotion.position.lower()
        if key not in context:
            context[key] = []
        context[key].append(promotion)

import unittest

import numpy as np

from holoviews import NdOverlay, Element

class CompositeTest(unittest.TestCase):
    "For testing of basic composite element types"

    def setUp(self):
        self.data1 = np.zeros((10, 2))
        self.data2 = np.ones((10, 2))
        self.data3 = np.ones((10, 2)) * 2

        self.view1 = Element(self.data1, label='view1')
        self.view2 = Element(self.data2, label='view2')
        self.view3 = Element(self.data3, label='view3')


class OverlayTest(CompositeTest):

    def test_overlay(self):
        NdOverlay(list(enumerate([self.view1, self.view2, self.view3])))

    def test_overlay_iter(self):
        views = [self.view1, self.view2, self.view3]
        overlay = NdOverlay(list(enumerate(views)))
        for el, v in zip(overlay, views):
            self.assertEqual(el, v)

    def test_overlay_integer_indexing(self):
        overlay = NdOverlay(list(enumerate([self.view1, self.view2, self.view3])))
        self.assertEqual(overlay[0], self.view1)
        self.assertEqual(overlay[1], self.view2)
        self.assertEqual(overlay[2], self.view3)
        try:
            overlay[3]
            raise AssertionError("Index should be out of range.")
        except KeyError: pass

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2016 Iotic Labs Ltd
#
# 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
#
#     https://github.com/Iotic-Labs/py-application-examples/blob/master/LICENSE
#
# 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.

# INFO-----------------------------------------------------------------------------------------------------------------

# 8.2_actuate_control_ask.py 12/02/2016 Iotic Labs.
# Creates a new Thing (or connects an existing one).
# Prints information about that Thing (Thing object, lid, guid).
# Attaches to a remote Control using hard-coded Point guid.
# Actuates remote Control using ask.

# PYTHON2 COMPATIBILITY -----------------------------------------------------------------------------------------------
from __future__ import unicode_literals, print_function  # pylint: disable=unused-import

# LOGGING -------------------------------------------------------------------------------------------------------------
# Logging set to only CRITICAL messages by default.  To see more, use logging.INFO, or to see loads, logging.DEBUG
import logging
logging.basicConfig(format='%(asctime)s,%(msecs)03d %(levelname)s [%(name)s] {%(threadName)s} %(message)s',
                    level=logging.CRITICAL)

# IMPORTS -------------------------------------------------------------------------------------------------------------
import time

# IOTIC AGENT IMPORTS -------------------------------------------------------------------------------------------------
from IoticAgent import IOT

# ---------------------------------------------------------------------------------------------------------------------


def create_thing(client):
    print("Creating my Thing")

    # Create your Thing in this script
    # Note:
    #  Calling 'create_thing' will create a new Thing, unless the Thing local ID (lid) is already in use.
    #  If it is, it will connect your script to that Thing.
    my_thing = client.create_thing('My_Controller_Thing')  # GIVE IT A NAME

    # Let's have a look at it
    # print some information about your Thing
    print("About my Thing")
    print("My Thing object:", my_thing)
    print("My Thing local ID (lid):", my_thing.lid)
    print("My Thing globally unique ID (guid):", my_thing.guid)

    return my_thing


def attach_to_control(my_thing):
    print("Attaching to remote Control")

    # Attach your Thing to someone else's Control Point with the intention of
    # sending an order (asking or telling) to it to do something
    # Note:
    #  Calling 'attach' will return the subscription object regardless of whether it already existed
    remote_control_gpid = '348603c2-e29b-fd53-e9b5-ad9d852ede5c'  # ADD THE GLOBAL POINT ID OF CONTROL YOU WISH TO ATTACH TO
    # attach to Control
    my_controller = my_thing.attach(remote_control_gpid)
    print("Remote Control subscription object:", my_controller)

    return my_controller


def actuate_ask(my_controller):
    print("Actuating remote Control - ask")

    # Actuate remote Control (ask)
    # Note:
    #   There is no notification of success when 'asking'
    print("Asking remote Control to act")
    data = {'something_useful': 'useful value'}
    # send data to the Control (ask)
    my_controller.ask(data)


# MAIN  ------------------------------------------------------------------------------------------------------------
def main():
    with IOT.Client('Control_Actuate.ini') as client:
        my_thing = create_thing(client)
        my_controller = attach_to_control(my_thing)

        while True:
            try:
                print("Main running, press ctrl+c to quit.")
                actuate_ask(my_controller)
                time.sleep(10)
            except KeyboardInterrupt:
                break


# RUN --------------------------------------------------------------------------------------------------

if __name__ == '__main__':
    main()

# END --------------------------------------------------------------------------------------------------

# -*- coding: latin-1 -*-
from __future__ import division
import sys, os, serial, time, glob
import numpy as np
from functools import partial
from PyQt4 import QtCore
# Imports Locais
import exporta_experimentos, trata_dados, automatico
import banco.bd_config as bd_config

def serial_ports():
    '''
    Retorna uma lista as possíveis portas seriais (reais ou virtuais) diponíveis no
    sistema operacional
    '''
    # windows:
    if sys.platform.startswith('win'):
        ports = ['COM' + str(i + 1) for i in range(256)]
    # Linux
    elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
        ports = glob.glob('/dev/tty[A-Za-z]*')
    # Mac OS
    elif sys.platform.startswith('darwin'):
        ports = glob.glob('/dev/tty.*')
    else:
        raise EnvironmentError('Unsupported platform')
    # Retorna a lista com as portas seriais encontradas
    return ports

def conecta(self):
    '''
    Evento ocorre quando o botao de conectar/desconectar é pressionado
    '''
    texto_botao = self.ui.pushButton_conectar.text()
    if ( texto_botao == 'Conectar' ):
        # Configurações da comunicação serial:
        baudrate = int(self.ui.comboBox_baudRate.currentText())
        porta    = str(self.ui.comboBox_portaSerial.currentText())
        # Caso os dados de conf. tenham sido selecionados (porta não é vazio)
        if ( porta > 1 and baudrate is not '' ):
            try:
                self.s.port = porta
                self.s.baudrate = baudrate
                self.s.timeout=0
                # caso a porta esteja aberta, feche e abre de novo.
                if self.s.is_open:
                    self.s.close()
                    time.sleep(0.05)
                self.s.open()
                # altera as informações da ui para conectado.
                self.enabled_disabled(True)
                self.ui.pushButton_conectar.setText('Desconectar')
                self.timer_serial.singleShot(100,partial(serial_read,self))
                self.timer_serial.singleShot(500,partial(envia_serial,self,self.CHR_check))
                self.timer_serial.singleShot(600,partial(envia_setanalog,self,atualiza=False))
                self.timer_serial.singleShot(700,partial(envia_setpwm,self,atualiza=False))
            except:
                self.alerta_toolbar('erro ao conectar')
    elif ( texto_botao == 'Desconectar'):
        self.enabled_disabled(False)
        try:
            self.s.close()
        except:
            self.alerta_toolbar('erro ao desconectar')
        self.ui.pushButton_conectar.setText('Conectar')

def serial_read(self):
    if self.s.is_open:
        self.texto += self.s.read(self.s.in_waiting)
        if '\r\n' in self.texto:
            # separa a string recebida (caso haja mais de um dado recebido)
            texto_depois = self.texto.split('\r\n')
            # if: verificar se o ultimo elemento da lista não é vazio e portanto
            # ainda existe parta do dao a ser recebida (salvar a parte recebida)
            if texto_depois[-1] != '':
                self.texto = texto_depois[-1]
            else:
                # caso os dados tenham chegado por compelto, apaga o buffer
                self.texto = ''
            # remove o ultimo elemento da lista ( '' ou dado parcial)
            texto_depois = texto_depois[:-1]
            for item in texto_depois:
                self.alerta_toolbar('Dado Recebido: ' + item)
                self.ui.textEdit_dadosSerial.insertPlainText(item + '\n')
                tipo, d = trata_dados.verifica_dado(item,self)
                trata_dados.resultado_dado(self, tipo, d)
        self.timer_serial.singleShot(50,partial(serial_read,self))

def envia_serial(self,dado):
    '''
    Método que envia uma string pela serial
    '''
    #print "DEBUG: enviando:", self.CHR_inicioDado + dado
    try:
        if self.s.is_open:
            self.s.write(self.CHR_inicioDado + dado + '\n')
    except:
        self.alerta_toolbar('Erro ao enviar dado pela serial')
        pass

def auto_ST(self):
    '''
    Método recursivo.
    É chamado quando a checkbox de receber a temperatura dos sensores
    automaticamente é ativada.
    A função ativa uma thread do QT no modo singleShot após a quantidad de tempo
    escolhida no spinBox_serialUpdate da GUI. caso a checkbox continue ativada,
    a função se chamará novamente de forma recursiva até que a checkbox seja
    desabilitada ou a conecção seja desfeita.
    '''
    # Executa apenas quando a checkbox está ativada
    if self.ui.checkBox_serialAuto.isChecked():
        # Função que envia o pedido de temperatura para o microcontrolador
        envia_serial(self,self.CHR_pedidoTemperaturas)
        # tempo para chamar a função de forma recursiva.
        tempo = 1000*self.ui.spinBox_serialUpdate.value()
        self.timer_ST.singleShot(tempo,partial(auto_ST,self))

def envia_setpwm(self, atualiza):
    try:
        if atualiza:
            self.tempo_pwm = int(str(self.ui.lineEdit_periodoPWM.text()))
            bd_config.salva_config_pwm(self.caminho_banco, self.tempo_pwm)
            self.ui.lineEdit_periodoPWM.setText("")
        else:
            self.tempo_pwm = bd_config.retorna_dados_config(self.caminho_banco)[12]
        automatico.atualiza_label_microcontrolador(self)
        envia_serial(self,self.CHR_tempoPWM + str(self.tempo_pwm))
    except:
        self.alerta_toolbar('Erro envia_setpwm - int')

def envia_setanalog(self, atualiza):
    try:
        if atualiza:
            nLeituras = int(str(self.ui.lineEdit_analogicaNleituras.text()))
            texto_delay = str(self.ui.lineEdit_analogicaDelayms.text())
            bd_config.salva_config_ad(self.caminho_banco, int(nLeituras),int(texto_delay))
            automatico.atualiza_label_microcontrolador(self)
            self.ui.lineEdit_analogicaNleituras.setText("")
            self.ui.lineEdit_analogicaDelayms.setText("")
        else:
            resposta_bd = bd_config.retorna_dados_config(self.caminho_banco)
            nLeituras, texto_delay = resposta_bd[13], resposta_bd[14]
        if nLeituras > 9 and nLeituras < 99:
            txt_nLeituras = str(nLeituras)
        elif nLeituras < 10:
            txt_nLeituras = '0' + str(nLeituras)
        else:
            self.alerta_toolbar('erro textbox nLeituras (2 caracteres)')
            return None
        envia_serial(self,self.CHR_setADC + txt_nLeituras + str(texto_delay))
    except:
        self.alerta_toolbar('Erro envia_setanalog')

def envia_manual(self):
    '''
    Envia os dados da string contida na lineEdit (envio manual)
    '''
    # captura o texto da lineEdit
    texto = self.ui.lineEdit_serialManual.text()
    try:
        if self.s.is_open:
            self.s.write(str(texto) + '\n')
    except:
        self.alerta_toolbar('Erro ao enviar dado pela serial')
        pass
    # Apaga a string enviada da lineEdit
    self.ui.lineEdit_serialManual.setText('')

def envia_resistencia(self,n):
    '''
    Função que é chamada quando alguma mudança no controle da GUI relativa a
    uma das resistências (1 a 6) ocorre.
    A função verifica o estado da resistência n e envia a informação adequada
    para o mc caso seja necessário.
    '''
    # Os dados são enviados apenas se o 'hold' não estiver pressionado.
    if (not self.ui.radioButton_hold.isChecked()):
        # pega o valor (posição) do slider da resistência 1.
        if n == 1:
            str_pin = self.pinR1
            valor = int(self.ui.horizontalSlider_r01.value())
        elif n == 2:
            str_pin = self.pinR2
            valor = int(self.ui.horizontalSlider_r02.value())
        elif n == 3:
            str_pin = self.pinR3
            valor = int(self.ui.horizontalSlider_r03.value())
        elif n == 4:
            str_pin = self.pinR4
            valor = int(self.ui.horizontalSlider_r04.value())
        elif n == 5:
            str_pin = self.pinR5
            valor = int(self.ui.horizontalSlider_r05.value())
        elif n == 6:
            str_pin = self.pinR6
            valor = int(self.ui.horizontalSlider_r06.value())
        else:
            self.alerta_toolbar(self,"n fora do range (1..6)")
            return None
        # envia o dado adequado em função do valor 0, 1..99, 100.
        if valor == 100:
            envia_serial(self,str_pin + self.CHR_ligaForno)
        elif valor == 0:
            envia_serial(self,str_pin + self.CHR_desligaForno)
        elif valor > 0 and valor < 100:
            envia_serial(self,self.CHR_setPotenciaPWM + str_pin + str(valor))
        else:
            self.alerta_toolbar(self,"valor fora do range (0..100)")
            return None
        #print 'DEBUG:', 'envia_serial', str_pin, valor
        # teste de retorno para verificar se os valores foram recebidos pelo mc
        QtCore.QTimer.singleShot(3000, partial(teste_retorno,self))

def hold(self):
    '''
    Função que é chamada quando o estado do checkbox 'hold' é alterado.
    Caso o hold seja desligado (solto). São chamadas as funções de todas as
    esteiras para enviar os dados caso haja diferença entre o estado da variável
    e do slider.
    Caso o hold tenha sido pressionado nada ocorre.
    '''
    # Caso o 'hold' tenha sido desligado:
    if ( self.ui.radioButton_hold.isChecked() == False ):
        for i in range(1,7):
            QtCore.QTimer.singleShot(100*i, partial(envia_resistencia,self,i))
        # teste de retorno para verificar se os valores foram recebidos pelo mc
        QtCore.QTimer.singleShot(3000, partial(teste_retorno,self))

def esteira(self,sinal):
    '''
    Função que é acionada ao alterar o valor do slider da esteira. Envia para o
    mc o comando adequado
    O sinal pode ter sido disparado por 4 eventos: alteração no slider da
    esteira, botao frente ou botao tras ou botao parada. A informação de quem
    disparou o sinal é enviada como uma string sinal em parâmetros.
    '''
    # Caso o sinal não seja do slider, atualizar o valor deste de acordo
    # com quem enviou o sinal: (botão parada, frente o tras)
    if sinal == 'frente':
        self.ui.horizontalSlider_esteira.setValue(100)
    elif sinal == 'tras':
        self.ui.horizontalSlider_esteira.setValue(-100)
    elif sinal == 'parar':
        self.ui.horizontalSlider_esteira.setValue(0)
    valor = self.ui.horizontalSlider_esteira.value()
    if valor > 0 and valor < 100:
        envia_serial(self,self.CHR_esteiraFrente + str(valor))
        self.ui.radioButton_esteiraFrente.setChecked(False)
        self.ui.radioButton_esteiraTras.setChecked(False)
    elif valor < 0 and valor > -100:
        self.ui.radioButton_esteiraFrente.setChecked(False)
        self.ui.radioButton_esteiraTras.setChecked(False)
        envia_serial(self,self.CHR_esteiraTras + str(abs(valor)))
    elif valor == -100:
        self.ui.radioButton_esteiraFrente.setChecked(False)
        self.ui.radioButton_esteiraTras.setChecked(True)
        envia_serial(self,self.CHR_esteiraTras + str(abs(valor)))
    elif valor == 100:
        self.ui.radioButton_esteiraFrente.setChecked(True)
        self.ui.radioButton_esteiraTras.setChecked(False)
        envia_serial(self,self.CHR_esteiraFrente + str(abs(valor)))
    else:
        envia_serial(self,self.CHR_esteiraParada)
    # teste de retorno para verificar se os valores foram recebidos pelo mc
    QtCore.QTimer.singleShot(3000, partial(teste_retorno,self))

def emergencia(self):
    '''
    Função de Emergência. Para a esteira e desliga todas as resistências
    '''
    envia_serial(self,self.STR_emergencia)
    # teste de retorno para verificar se os valores foram recebidos pelo mc
    QtCore.QTimer.singleShot(4000, partial(teste_retorno,self))

def teste_retorno(self):
    '''
    Função que é chamada após alteração no estado da esteira resistências.
    Esta função é chamada t segundos após o envio do comando para o microcontrolador,
    com o objetivo de rerificar se este recebeu corretamente o comando (quando isto ocorre
    o mc devolve o mesmo comando em uma string (eco), que é verificada pela
    função de leitura serial, alterando o estado das variáveis de controle da
    esteira e das resistências 1 a 6).
    Para esta verificação, é comparado o estado da variável de controle com o
    estado dos sliders de controle, que são alterados quando recebem o sinal de
    volta do microcontrolador
    '''
    # print 'DEBUG: funcao retorno', self.valor_resistencia01, self.valor_resistencia02,\
    # self.valor_resistencia03, self.valor_resistencia04, \
    # self.valor_resistencia05,self.valor_resistencia06, self.valor_esteira

    self.ui.horizontalSlider_esteira.setValue(self.valor_esteira)
    self.ui.lcdNumber_esteiraVelocidade.display(self.valor_esteira)
    self.ui.radioButton_esteiraFrente.setChecked(self.valor_esteira == 100)
    self.ui.radioButton_esteiraTras.setChecked(self.valor_esteira == -100)

    self.ui.horizontalSlider_r01.setValue(self.valor_resistencia01)
    self.ui.progressBar_r01.setValue(self.valor_resistencia01)

    self.ui.horizontalSlider_r02.setValue(self.valor_resistencia02)
    self.ui.progressBar_r02.setValue(self.valor_resistencia02)

    self.ui.horizontalSlider_r03.setValue(self.valor_resistencia03)
    self.ui.progressBar_r03.setValue(self.valor_resistencia03)

    self.ui.horizontalSlider_r04.setValue(self.valor_resistencia04)
    self.ui.progressBar_r04.setValue(self.valor_resistencia04)

    self.ui.horizontalSlider_r05.setValue(self.valor_resistencia05)
    self.ui.progressBar_r05.setValue(self.valor_resistencia05)

    self.ui.horizontalSlider_r06.setValue(self.valor_resistencia06)
    self.ui.progressBar_r06.setValue(self.valor_resistencia06)

# Testing md5 module
import warnings
warnings.filterwarnings("ignore", "the md5 module is deprecated.*",
                        DeprecationWarning)

import unittest
from md5 import md5
from test import test_support

def hexstr(s):
    import string
    h = string.hexdigits
    r = ''
    for c in s:
        i = ord(c)
        r = r + h[(i >> 4) & 0xF] + h[i & 0xF]
    return r

class MD5_Test(unittest.TestCase):

    def md5test(self, s, expected):
        self.assertEqual(hexstr(md5(s).digest()), expected)
        self.assertEqual(md5(s).hexdigest(), expected)

    def test_basics(self):
        eq = self.md5test
        eq('', 'd41d8cd98f00b204e9800998ecf8427e')
        eq('a', '0cc175b9c0f1b6a831c399e269772661')
        eq('abc', '900150983cd24fb0d6963f7d28e17f72')
        eq('message digest', 'f96b697d7cb7938d525a2f31aaf161d0')
        eq('abcdefghijklmnopqrstuvwxyz', 'c3fcd3d76192e4007dfb496cca67e13b')
        eq('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
           'd174ab98d277d9f5a5611c2c9f419d9f')
        eq('12345678901234567890123456789012345678901234567890123456789012345678901234567890',
           '57edf4a22be3c955ac49da2e2107b67a')

    def test_hexdigest(self):
        # hexdigest is new with Python 2.0
        m = md5('testing the hexdigest method')
        h = m.hexdigest()
        self.assertEqual(hexstr(m.digest()), h)

    def test_large_update(self):
        aas = 'a' * 64
        bees = 'b' * 64
        cees = 'c' * 64

        m1 = md5()
        m1.update(aas)
        m1.update(bees)
        m1.update(cees)

        m2 = md5()
        m2.update(aas + bees + cees)
        self.assertEqual(m1.digest(), m2.digest())

def test_main():
    test_support.run_unittest(MD5_Test)

if __name__ == '__main__':
    test_main()

# -*- coding: utf-8 -*-

#  Copyright (c) 2017 Citrix Systems
#
# This code is part of Ansible, but is an independent component.
# This particular file snippet, and this file snippet only, is BSD licensed.
# Modules you write using this snippet, which is embedded dynamically by Ansible
# still belong to the author of the module, and may assign their own license
# to the complete work.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
#    * Redistributions of source code must retain the above copyright
#      notice, this list of conditions and the following disclaimer.
#    * Redistributions in binary form must reproduce the above copyright notice,
#      this list of conditions and the following disclaimer in the documentation
#      and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

import json
import re
import sys

from ansible.module_utils.basic import env_fallback
from ansible.module_utils.six import binary_type, text_type
from ansible.module_utils._text import to_native


class ConfigProxy(object):

    def __init__(self, actual, client, attribute_values_dict, readwrite_attrs, transforms=None, readonly_attrs=None, immutable_attrs=None, json_encodes=None):
        transforms = {} if transforms is None else transforms
        readonly_attrs = [] if readonly_attrs is None else readonly_attrs
        immutable_attrs = [] if immutable_attrs is None else immutable_attrs
        json_encodes = [] if json_encodes is None else json_encodes

        # Actual config object from nitro sdk
        self.actual = actual

        # nitro client
        self.client = client

        # ansible attribute_values_dict
        self.attribute_values_dict = attribute_values_dict

        self.readwrite_attrs = readwrite_attrs
        self.readonly_attrs = readonly_attrs
        self.immutable_attrs = immutable_attrs
        self.json_encodes = json_encodes
        self.transforms = transforms

        self.attribute_values_processed = {}
        for attribute, value in self.attribute_values_dict.items():
            if value is None:
                continue
            if attribute in transforms:
                for transform in self.transforms[attribute]:
                    if transform == 'bool_yes_no':
                        if value is True:
                            value = 'YES'
                        elif value is False:
                            value = 'NO'
                    elif transform == 'bool_on_off':
                        if value is True:
                            value = 'ON'
                        elif value is False:
                            value = 'OFF'
                    elif callable(transform):
                        value = transform(value)
                    else:
                        raise Exception('Invalid transform %s' % transform)
            self.attribute_values_processed[attribute] = value

        self._copy_attributes_to_actual()

    def _copy_attributes_to_actual(self):
        for attribute in self.readwrite_attrs:
            if attribute in self.attribute_values_processed:
                attribute_value = self.attribute_values_processed[attribute]

                if attribute_value is None:
                    continue

                # Fallthrough
                if attribute in self.json_encodes:
                    attribute_value = json.JSONEncoder().encode(attribute_value).strip('"')
                setattr(self.actual, attribute, attribute_value)

    def __getattr__(self, name):
        if name in self.attribute_values_dict:
            return self.attribute_values_dict[name]
        else:
            raise AttributeError('No attribute %s found' % name)

    def add(self):
        self.actual.__class__.add(self.client, self.actual)

    def update(self):
        return self.actual.__class__.update(self.client, self.actual)

    def delete(self):
        self.actual.__class__.delete(self.client, self.actual)

    def get(self, *args, **kwargs):
        result = self.actual.__class__.get(self.client, *args, **kwargs)

        return result

    def has_equal_attributes(self, other):
        if self.diff_object(other) == {}:
            return True
        else:
            return False

    def diff_object(self, other):
        diff_dict = {}
        for attribute in self.attribute_values_processed:
            # Skip readonly attributes
            if attribute not in self.readwrite_attrs:
                continue

            # Skip attributes not present in module arguments
            if self.attribute_values_processed[attribute] is None:
                continue

            # Check existence
            if hasattr(other, attribute):
                attribute_value = getattr(other, attribute)
            else:
                diff_dict[attribute] = 'missing from other'
                continue

            # Compare values
            param_type = self.attribute_values_processed[attribute].__class__
            if attribute_value is None or param_type(attribute_value) != self.attribute_values_processed[attribute]:
                str_tuple = (
                    type(self.attribute_values_processed[attribute]),
                    self.attribute_values_processed[attribute],
                    type(attribute_value),
                    attribute_value,
                )
                diff_dict[attribute] = 'difference. ours: (%s) %s other: (%s) %s' % str_tuple
        return diff_dict

    def get_actual_rw_attributes(self, filter='name'):
        if self.actual.__class__.count_filtered(self.client, '%s:%s' % (filter, self.attribute_values_dict[filter])) == 0:
            return {}
        server_list = self.actual.__class__.get_filtered(self.client, '%s:%s' % (filter, self.attribute_values_dict[filter]))
        actual_instance = server_list[0]
        ret_val = {}
        for attribute in self.readwrite_attrs:
            if not hasattr(actual_instance, attribute):
                continue
            ret_val[attribute] = getattr(actual_instance, attribute)
        return ret_val

    def get_actual_ro_attributes(self, filter='name'):
        if self.actual.__class__.count_filtered(self.client, '%s:%s' % (filter, self.attribute_values_dict[filter])) == 0:
            return {}
        server_list = self.actual.__class__.get_filtered(self.client, '%s:%s' % (filter, self.attribute_values_dict[filter]))
        actual_instance = server_list[0]
        ret_val = {}
        for attribute in self.readonly_attrs:
            if not hasattr(actual_instance, attribute):
                continue
            ret_val[attribute] = getattr(actual_instance, attribute)
        return ret_val

    def get_missing_rw_attributes(self):
        return list(set(self.readwrite_attrs) - set(self.get_actual_rw_attributes().keys()))

    def get_missing_ro_attributes(self):
        return list(set(self.readonly_attrs) - set(self.get_actual_ro_attributes().keys()))


def get_immutables_intersection(config_proxy, keys):
    immutables_set = set(config_proxy.immutable_attrs)
    keys_set = set(keys)
    # Return list of sets' intersection
    return list(immutables_set & keys_set)


def ensure_feature_is_enabled(client, feature_str):
    enabled_features = client.get_enabled_features()

    if enabled_features is None:
        enabled_features = []

    if feature_str not in enabled_features:
        client.enable_features(feature_str)
        client.save_config()


def get_nitro_client(module):
    from nssrc.com.citrix.netscaler.nitro.service.nitro_service import nitro_service

    client = nitro_service(module.params['nsip'], module.params['nitro_protocol'])
    client.set_credential(module.params['nitro_user'], module.params['nitro_pass'])
    client.timeout = float(module.params['nitro_timeout'])
    client.certvalidation = module.params['validate_certs']
    return client


netscaler_common_arguments = dict(
    nsip=dict(
        required=True,
        fallback=(env_fallback, ['NETSCALER_NSIP']),
    ),
    nitro_user=dict(
        required=True,
        fallback=(env_fallback, ['NETSCALER_NITRO_USER']),
        no_log=True
    ),
    nitro_pass=dict(
        required=True,
        fallback=(env_fallback, ['NETSCALER_NITRO_PASS']),
        no_log=True
    ),
    nitro_protocol=dict(
        choices=['http', 'https'],
        fallback=(env_fallback, ['NETSCALER_NITRO_PROTOCOL']),
        default='http'
    ),
    validate_certs=dict(
        default=True,
        type='bool'
    ),
    nitro_timeout=dict(default=310, type='float'),
    state=dict(
        choices=[
            'present',
            'absent',
        ],
        default='present',
    ),
    save_config=dict(
        type='bool',
        default=True,
    ),
)


loglines = []


def complete_missing_attributes(actual, attrs_list, fill_value=None):
    for attribute in attrs_list:
        if not hasattr(actual, attribute):
            setattr(actual, attribute, fill_value)


def log(msg):
    loglines.append(msg)


def get_ns_version(client):
    from nssrc.com.citrix.netscaler.nitro.resource.config.ns.nsversion import nsversion
    result = nsversion.get(client)
    m = re.match(r'^.*NS(\d+)\.(\d+).*$', result[0].version)
    if m is None:
        return None
    else:
        return int(m.group(1)), int(m.group(2))


def get_ns_hardware(client):
    from nssrc.com.citrix.netscaler.nitro.resource.config.ns.nshardware import nshardware
    result = nshardware.get(client)
    return result


def monkey_patch_nitro_api():

    from nssrc.com.citrix.netscaler.nitro.resource.base.Json import Json

    def new_resource_to_string_convert(self, resrc):
        # Line below is the actual patch
        dict_valid_values = dict((k.replace('_', '', 1), v) for k, v in resrc.__dict__.items() if v)
        return json.dumps(dict_valid_values)
    Json.resource_to_string_convert = new_resource_to_string_convert

    from nssrc.com.citrix.netscaler.nitro.util.nitro_util import nitro_util

    @classmethod
    def object_to_string_new(cls, obj):
        output = []
        flds = obj.__dict__
        for k, v in ((k.replace('_', '', 1), v) for k, v in flds.items() if v):
            if isinstance(v, bool):
                output.append('"%s":%s' % (k, v))
            elif isinstance(v, (binary_type, text_type)):
                v = to_native(v, errors='surrogate_or_strict')
                output.append('"%s":"%s"' % (k, v))
            elif isinstance(v, int):
                output.append('"%s":"%s"' % (k, v))
        return ','.join(output)

    @classmethod
    def object_to_string_withoutquotes_new(cls, obj):
        output = []
        flds = obj.__dict__
        for k, v in ((k.replace('_', '', 1), v) for k, v in flds.items() if v):
            if isinstance(v, (int, bool)):
                output.append('%s:%s' % (k, v))
            elif isinstance(v, (binary_type, text_type)):
                v = to_native(v, errors='surrogate_or_strict')
                output.append('%s:%s' % (k, cls.encode(v)))
        return ','.join(output)

    nitro_util.object_to_string = object_to_string_new
    nitro_util.object_to_string_withoutquotes = object_to_string_withoutquotes_new

#!/usr/bin/python2.7
# Copyright 2011 Google Inc. All Rights Reserved.
#
#  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.

"""Tests for gwt_generator."""

__author__ = 'yanivi@google.com (Yaniv Inbar)'



from google.apputils import basetest
from googleapis.codegen import gwt_generator


class GwtApiTest(basetest.TestCase):

  def testGetCodeTypeFromDictionary(self):
    """Test mapping of JSON schema types to GWT/Java class names."""
    language_model = gwt_generator.GwtLanguageModel()

    test_cases = [
        ['String', {'type': 'string', 'format': 'byte'}],
        ['String', {'type': 'string', 'format': 'date-time'}],
        ['Double', {'type': 'number', 'format': 'double'}],
        ['Float', {'type': 'number', 'format': 'float'}],
        ['Short', {'type': 'integer', 'format': 'int16'}],
        ['Integer', {'type': 'integer', 'format': 'int32'}],
        ['Long', {'type': 'string', 'format': 'int64'}],
        ['String', {'type': 'any'}],
        ['Boolean', {'type': 'boolean'}],
        ['String', {'type': 'string'}],
        ['Long', {'type': 'integer', 'format': 'uint32'}],
        ['BigInteger', {'type': 'string', 'format': 'uint64'}],
    ]

    for test_case in test_cases:
      self.assertEquals(
          test_case[0],
          language_model.GetCodeTypeFromDictionary(test_case[1]))
      # TODO(user) Create Property objects, make sure they have the right
      # langauge model and see that prop.codeType == test_case[0]

  # TODO(user): Add tests for import side effects on properties that
  # require extra handling.


if __name__ == '__main__':
  basetest.main()

'''
Update the transformation files of active transformations given an InputDataQuery fetched from the Transformation Service.

Possibility to speedup the query time by only fetching files that were added since the last iteration.
Use the CS option RefreshOnly (False by default) and set the DateKey (empty by default) to the meta data
key set in the DIRAC FileCatalog.
'''

import time
import datetime

from DIRAC                                                   import S_OK, gLogger
from DIRAC.FrameworkSystem.Client.MonitoringClient           import gMonitor
from DIRAC.Core.Base.AgentModule                             import AgentModule
from DIRAC.TransformationSystem.Client.TransformationClient  import TransformationClient
from DIRAC.Resources.Catalog.FileCatalogClient               import FileCatalogClient
from DIRAC.ConfigurationSystem.Client.Helpers.Operations     import Operations

__RCSID__ = "$Id$"

AGENT_NAME = 'Transformation/InputDataAgent'

class InputDataAgent( AgentModule ):

  def __init__( self, *args, **kwargs ):
    ''' c'tor
    '''
    AgentModule.__init__( self, *args, **kwargs )

    self.fileLog = {}
    self.timeLog = {}
    self.fullTimeLog = {}

    self.pollingTime = self.am_getOption( 'PollingTime', 120 )
    self.fullUpdatePeriod = self.am_getOption( 'FullUpdatePeriod', 86400 )
    self.refreshonly = self.am_getOption( 'RefreshOnly', False )
    self.dateKey = self.am_getOption( 'DateKey', None )

    self.transClient = TransformationClient()
    self.metadataClient = FileCatalogClient()
    self.transformationTypes = None

  #############################################################################
  def initialize( self ):
    ''' Make the necessary initializations
    '''
    gMonitor.registerActivity( "Iteration", "Agent Loops", AGENT_NAME, "Loops/min", gMonitor.OP_SUM )
    agentTSTypes = self.am_getOption( 'TransformationTypes', [] )
    if agentTSTypes:
      self.transformationTypes = sorted( agentTSTypes )
    else:
      dataProc = Operations().getValue( 'Transformations/DataProcessing', ['MCSimulation', 'Merge'] )
      dataManip = Operations().getValue( 'Transformations/DataManipulation', ['Replication', 'Removal'] )
      self.transformationTypes = sorted( dataProc + dataManip )
    extendables = Operations().getValue( 'Transformations/ExtendableTransfTypes', [] )
    if extendables:
      for extendable in extendables:
        if extendable in self.transformationTypes:
          self.transformationTypes.remove( extendable )
          # This is because the Extendables do not use this Agent (have no Input data query)

    return S_OK()

  ##############################################################################
  def execute( self ):
    ''' Main execution method
    '''

    gMonitor.addMark( 'Iteration', 1 )
    # Get all the transformations
    result = self.transClient.getTransformations( {'Status' : 'Active',
                                                   'Type' : self.transformationTypes } )
    if not result['OK']:
      gLogger.error( "InputDataAgent.execute: Failed to get transformations.", result['Message'] )
      return S_OK()

    # Process each transformation
    for transDict in result['Value']:
      transID = long( transDict['TransformationID'] )
      res = self.transClient.getTransformationInputDataQuery( transID )
      if not res['OK']:
        if res['Message'] == 'No InputDataQuery found for transformation':
          gLogger.info( "InputDataAgent.execute: No input data query found for transformation %d" % transID )
        else:
          gLogger.error( "InputDataAgent.execute: Failed to get input data query for %d" % transID, res['Message'] )
        continue
      inputDataQuery = res['Value']

      if self.refreshonly:
        # Determine the correct time stamp to use for this transformation
        if transID in self.timeLog:
          if transID in self.fullTimeLog:
            # If it is more than a day since the last reduced query, make a full query just in case
            if ( datetime.datetime.utcnow() - self.fullTimeLog[transID] ) < datetime.timedelta( seconds = self.fullUpdatePeriod ):
              timeStamp = self.timeLog[transID]
              if self.dateKey:
                inputDataQuery[self.dateKey] = ( timeStamp - datetime.timedelta( seconds = 10 ) ).strftime( '%Y-%m-%d %H:%M:%S' )
              else:
                gLogger.error( "DateKey was not set in the CS, cannot use the RefreshOnly" )
            else:
              self.fullTimeLog[transID] = datetime.datetime.utcnow()
        self.timeLog[transID] = datetime.datetime.utcnow()
        if transID not in self.fullTimeLog:
          self.fullTimeLog[transID] = datetime.datetime.utcnow()

      # Perform the query to the metadata catalog
      gLogger.verbose( "Using input data query for transformation %d: %s" % ( transID, str( inputDataQuery ) ) )
      start = time.time()
      result = self.metadataClient.findFilesByMetadata( inputDataQuery )
      rtime = time.time() - start
      gLogger.verbose( "Metadata catalog query time: %.2f seconds." % ( rtime ) )
      if not result['OK']:
        gLogger.error( "InputDataAgent.execute: Failed to get response from the metadata catalog", result['Message'] )
        continue
      lfnList = result['Value']

      # Check if the number of files has changed since the last cycle
      nlfns = len( lfnList )
      gLogger.info( "%d files returned for transformation %d from the metadata catalog" % ( nlfns, int( transID ) ) )
      if nlfns == self.fileLog.get( transID ):
        gLogger.verbose( 'No new files in metadata catalog since last check' )
      self.fileLog[transID] = nlfns

      # Add any new files to the transformation
      addedLfns = []
      if lfnList:
        gLogger.verbose( 'Processing %d lfns for transformation %d' % ( len( lfnList ), transID ) )
        # Add the files to the transformation
        gLogger.verbose( 'Adding %d lfns for transformation %d' % ( len( lfnList ), transID ) )
        result = self.transClient.addFilesToTransformation( transID, sorted( lfnList ) )
        if not result['OK']:
          gLogger.warn( "InputDataAgent.execute: failed to add lfns to transformation", result['Message'] )
          self.fileLog[transID] = 0
        else:
          if result['Value']['Failed']:
            for lfn, error in res['Value']['Failed'].items():
              gLogger.warn( "InputDataAgent.execute: Failed to add %s to transformation" % lfn, error )
          if result['Value']['Successful']:
            for lfn, status in result['Value']['Successful'].items():
              if status == 'Added':
                addedLfns.append( lfn )
            gLogger.info( "InputDataAgent.execute: Added %d files to transformation" % len( addedLfns ) )

    return S_OK()

"""Administrator interface to score_mgr."""
from django.contrib import admin
from apps.managers.challenge_mgr import challenge_mgr

from apps.managers.score_mgr.models import ScoreSetting, ScoreboardEntry, PointsTransaction, \
    ReferralSetting
from apps.admin.admin import challenge_designer_site, challenge_manager_site, developer_site


class PointsTransactionAdmin(admin.ModelAdmin):
    """PointsTransaction administrator interface definition."""
    list_display = ["user", "transaction_date", "points", "message"]
    search_fields = ["user__username", "message"]
    date_hierarchy = "transaction_date"

admin.site.register(PointsTransaction, PointsTransactionAdmin)
challenge_designer_site.register(PointsTransaction, PointsTransactionAdmin)
challenge_manager_site.register(PointsTransaction, PointsTransactionAdmin)
developer_site.register(PointsTransaction, PointsTransactionAdmin)


class ScoreboardEntryAdmin(admin.ModelAdmin):
    """PointsTransaction administrator interface definition."""
    list_display = ["round_name", "profile", "points", "last_awarded_submission"]
    search_fields = ["profile__name", "profile__user__username"]
    list_filter = ["round_name"]

admin.site.register(ScoreboardEntry, ScoreboardEntryAdmin)
challenge_designer_site.register(ScoreboardEntry, ScoreboardEntryAdmin)
challenge_manager_site.register(ScoreboardEntry, ScoreboardEntryAdmin)
developer_site.register(ScoreboardEntry, ScoreboardEntryAdmin)


class ScoreSettingAdmin(admin.ModelAdmin):
    """PointsTransaction administrator interface definition."""
    list_display = ["name", ]
    list_display_links = ["name", ]
    page_text = "There must only be one Score Setting.  You can edit the amount" + \
    " of points awarded for completing the various actions and how many points are " + \
    "needed for a player to be 'active'."

    def has_add_permission(self, request):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

admin.site.register(ScoreSetting, ScoreSettingAdmin)
challenge_designer_site.register(ScoreSetting, ScoreSettingAdmin)
challenge_manager_site.register(ScoreSetting, ScoreSettingAdmin)
developer_site.register(ScoreSetting, ScoreSettingAdmin)


class ReferralSettingAdmin(admin.ModelAdmin):
    """PointsTransaction administrator interface definition."""
    list_display = ["normal_referral_points", "super_referral_points",
                    "mega_referral_points", "start_dynamic_bonus", ]
    list_display_links = ["normal_referral_points", "super_referral_points",
                    "mega_referral_points", "start_dynamic_bonus", ]

    def has_add_permission(self, request):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

admin.site.register(ReferralSetting, ReferralSettingAdmin)
challenge_designer_site.register(ReferralSetting, ReferralSettingAdmin)
challenge_manager_site.register(ReferralSetting, ReferralSettingAdmin)
developer_site.register(ReferralSetting, ReferralSettingAdmin)


challenge_mgr.register_designer_challenge_info_model("Challenge", 1, ScoreSetting, 3)
challenge_mgr.register_designer_game_info_model("Referral Game Mechanics", ReferralSetting)
challenge_mgr.register_admin_challenge_info_model("Status", 1, PointsTransaction, 4)
challenge_mgr.register_admin_challenge_info_model("Status", 1, ScoreboardEntry, 5)
challenge_mgr.register_developer_challenge_info_model("Challenge", 1, ScoreSetting, 3)
challenge_mgr.register_developer_challenge_info_model("Status", 4, PointsTransaction, 2)
challenge_mgr.register_developer_challenge_info_model("Status", 4, ScoreboardEntry, 3)
challenge_mgr.register_developer_game_info_model("Referral Game Mechanics", ReferralSetting)

import json
import os
import socket
import threading
import time
import traceback

from .base import (Protocol,
                   BaseProtocolPart,
                   RefTestExecutor,
                   RefTestImplementation,
                   TestharnessExecutor,
                   strip_server)
from ..testrunner import Stop
from ..webdriver_server import wait_for_service

webdriver = None
ServoCommandExtensions = None

here = os.path.join(os.path.split(__file__)[0])

extra_timeout = 5


def do_delayed_imports():
    global webdriver
    import webdriver

    global ServoCommandExtensions

    class ServoCommandExtensions(object):
        def __init__(self, session):
            self.session = session

        @webdriver.client.command
        def get_prefs(self, *prefs):
            body = {"prefs": list(prefs)}
            return self.session.send_session_command("POST", "servo/prefs/get", body)

        @webdriver.client.command
        def set_prefs(self, prefs):
            body = {"prefs": prefs}
            return self.session.send_session_command("POST", "servo/prefs/set", body)

        @webdriver.client.command
        def reset_prefs(self, *prefs):
            body = {"prefs": list(prefs)}
            return self.session.send_session_command("POST", "servo/prefs/reset", body)

        def change_prefs(self, old_prefs, new_prefs):
            # Servo interprets reset with an empty list as reset everything
            if old_prefs:
                self.reset_prefs(*old_prefs.keys())
            self.set_prefs({k: parse_pref_value(v) for k, v in new_prefs.items()})


# See parse_pref_from_command_line() in components/config/opts.rs
def parse_pref_value(value):
    if value == "true":
        return True
    if value == "false":
        return False
    try:
        return float(value)
    except ValueError:
        return value


class ServoBaseProtocolPart(BaseProtocolPart):
    def execute_script(self, script, asynchronous=False):
        pass

    def set_timeout(self, timeout):
        pass

    def wait(self):
        pass

    def set_window(self, handle):
        pass


class ServoWebDriverProtocol(Protocol):
    implements = [ServoBaseProtocolPart]

    def __init__(self, executor, browser, capabilities, **kwargs):
        do_delayed_imports()
        Protocol.__init__(self, executor, browser)
        self.capabilities = capabilities
        self.host = browser.webdriver_host
        self.port = browser.webdriver_port
        self.init_timeout = browser.init_timeout
        self.session = None

    def connect(self):
        """Connect to browser via WebDriver."""
        wait_for_service((self.host, self.port), timeout=self.init_timeout)

        self.session = webdriver.Session(self.host, self.port, extension=ServoCommandExtensions)
        self.session.start()

    def after_connect(self):
        pass

    def teardown(self):
        self.logger.debug("Hanging up on WebDriver session")
        try:
            self.session.end()
        except Exception:
            pass

    def is_alive(self):
        try:
            # Get a simple property over the connection
            self.session.window_handle
        # TODO what exception?
        except Exception:
            return False
        return True

    def wait(self):
        while True:
            try:
                self.session.execute_async_script("")
            except webdriver.TimeoutException:
                pass
            except (socket.timeout, IOError):
                break
            except Exception as e:
                self.logger.error(traceback.format_exc(e))
                break


class ServoWebDriverRun(object):
    def __init__(self, func, session, url, timeout, current_timeout=None):
        self.func = func
        self.result = None
        self.session = session
        self.url = url
        self.timeout = timeout
        self.result_flag = threading.Event()

    def run(self):
        executor = threading.Thread(target=self._run)
        executor.start()

        flag = self.result_flag.wait(self.timeout + extra_timeout)
        if self.result is None:
            assert not flag
            self.result = False, ("EXTERNAL-TIMEOUT", None)

        return self.result

    def _run(self):
        try:
            self.result = True, self.func(self.session, self.url, self.timeout)
        except webdriver.TimeoutException:
            self.result = False, ("EXTERNAL-TIMEOUT", None)
        except (socket.timeout, IOError):
            self.result = False, ("CRASH", None)
        except Exception as e:
            message = getattr(e, "message", "")
            if message:
                message += "\n"
            message += traceback.format_exc(e)
            self.result = False, ("INTERNAL-ERROR", e)
        finally:
            self.result_flag.set()


def timeout_func(timeout):
    if timeout:
        t0 = time.time()
        return lambda: time.time() - t0 > timeout + extra_timeout
    else:
        return lambda: False


class ServoWebDriverTestharnessExecutor(TestharnessExecutor):
    supports_testdriver = True

    def __init__(self, browser, server_config, timeout_multiplier=1,
                 close_after_done=True, capabilities=None, debug_info=None,
                 **kwargs):
        TestharnessExecutor.__init__(self, browser, server_config, timeout_multiplier=1,
                                     debug_info=None)
        self.protocol = ServoWebDriverProtocol(self, browser, capabilities=capabilities)
        with open(os.path.join(here, "testharness_servodriver.js")) as f:
            self.script = f.read()
        self.timeout = None

    def on_protocol_change(self, new_protocol):
        pass

    def is_alive(self):
        return self.protocol.is_alive()

    def do_test(self, test):
        url = self.test_url(test)

        timeout = test.timeout * self.timeout_multiplier + extra_timeout

        if timeout != self.timeout:
            try:
                self.protocol.session.timeouts.script = timeout
                self.timeout = timeout
            except IOError:
                self.logger.error("Lost webdriver connection")
                return Stop

        success, data = ServoWebDriverRun(self.do_testharness,
                                          self.protocol.session,
                                          url,
                                          timeout).run()

        if success:
            return self.convert_result(test, data)

        return (test.result_cls(*data), [])

    def do_testharness(self, session, url, timeout):
        session.url = url
        result = json.loads(
            session.execute_async_script(
                self.script % {"abs_url": url,
                               "url": strip_server(url),
                               "timeout_multiplier": self.timeout_multiplier,
                               "timeout": timeout * 1000}))
        # Prevent leaking every page in history until Servo develops a more sane
        # page cache
        session.back()
        return result

    def on_environment_change(self, new_environment):
        self.protocol.session.extension.change_prefs(
            self.last_environment.get("prefs", {}),
            new_environment.get("prefs", {})
        )


class TimeoutError(Exception):
    pass


class ServoWebDriverRefTestExecutor(RefTestExecutor):
    def __init__(self, browser, server_config, timeout_multiplier=1,
                 screenshot_cache=None, capabilities=None, debug_info=None,
                 **kwargs):
        """Selenium WebDriver-based executor for reftests"""
        RefTestExecutor.__init__(self,
                                 browser,
                                 server_config,
                                 screenshot_cache=screenshot_cache,
                                 timeout_multiplier=timeout_multiplier,
                                 debug_info=debug_info)
        self.protocol = ServoWebDriverProtocol(self, browser,
                                               capabilities=capabilities)
        self.implementation = RefTestImplementation(self)
        self.timeout = None
        with open(os.path.join(here, "reftest-wait_webdriver.js")) as f:
            self.wait_script = f.read()

    def reset(self):
        self.implementation.reset()

    def is_alive(self):
        return self.protocol.is_alive()

    def do_test(self, test):
        try:
            result = self.implementation.run_test(test)
            return self.convert_result(test, result)
        except IOError:
            return test.result_cls("CRASH", None), []
        except TimeoutError:
            return test.result_cls("TIMEOUT", None), []
        except Exception as e:
            message = getattr(e, "message", "")
            if message:
                message += "\n"
            message += traceback.format_exc(e)
            return test.result_cls("INTERNAL-ERROR", message), []

    def screenshot(self, test, viewport_size, dpi):
        # https://github.com/w3c/wptrunner/issues/166
        assert viewport_size is None
        assert dpi is None

        timeout = (test.timeout * self.timeout_multiplier + extra_timeout
                   if self.debug_info is None else None)

        if self.timeout != timeout:
            try:
                self.protocol.session.timeouts.script = timeout
                self.timeout = timeout
            except IOError:
                self.logger.error("Lost webdriver connection")
                return Stop

        return ServoWebDriverRun(self._screenshot,
                                 self.protocol.session,
                                 self.test_url(test),
                                 timeout).run()

    def _screenshot(self, session, url, timeout):
        session.url = url
        session.execute_async_script(self.wait_script)
        return session.screenshot()

    def on_environment_change(self, new_environment):
        self.protocol.session.extension.change_prefs(
            self.last_environment.get("prefs", {}),
            new_environment.get("prefs", {})
        )

##
#    Copyright (C) 2013, 2014, 2015 Jessica Tallon & Matt Molyneaux
#
#    This file is part of Inboxen.
#
#    Inboxen is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    Inboxen is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with Inboxen.  If not, see <http://www.gnu.org/licenses/>.
##

from datetime import timedelta
import os.path
import re

from annoying.fields import AutoOneToOneField, JSONField
from django.conf import settings
from django.contrib.postgres.indexes import GinIndex
from django.db import models
from django.utils import timezone
from django.utils.encoding import smart_str
from django.utils.functional import cached_property
from django.utils.translation import gettext as _
from mptt.models import MPTTModel, TreeForeignKey

from inboxen import validators
from inboxen.managers import BodyQuerySet, DomainQuerySet, EmailQuerySet, HeaderQuerySet, InboxQuerySet
from inboxen.search.models import SearchableAbstract
from inboxen.utils.email import unicode_damnit

HEADER_PARAMS = re.compile(r'([a-zA-Z0-9]+)=["\']?([^"\';=]+)["\']?[;]?')


class UserProfile(models.Model):
    """User profile

    Auto-created when accessed via a RelatedManager
    """
    # display image options
    ASK = 0
    DISPLAY = 1
    NO_DISPLAY = 2
    IMAGE_OPTIONS = (
        (ASK, _("Always ask to display images")),
        (DISPLAY, _("Always display images")),
        (NO_DISPLAY, _("Never display images")),
    )

    # what to do when the user hits their quota (if a quota exists)
    REJECT_MAIL = 0
    DELETE_MAIL = 1
    QUOTA_OPTIONS = (
        (REJECT_MAIL, _("Reject new emails")),
        (DELETE_MAIL, _("Delete old emails")),
    )

    user = AutoOneToOneField(settings.AUTH_USER_MODEL, primary_key=True, related_name="inboxenprofile",
                             on_delete=models.CASCADE)
    prefered_domain = models.ForeignKey("inboxen.Domain", null=True, blank=True, on_delete=models.CASCADE,
                                        help_text=_("Prefer a particular domain when adding a new Inbox"))
    prefer_html_email = models.BooleanField(default=True, verbose_name=_("Prefer HTML emails"))
    unified_has_new_messages = models.BooleanField(default=False)
    auto_delete = models.BooleanField(
        default=False,
        verbose_name=_("Auto-delete emails"),
        help_text=_("Delete emails after %(days)s days. Emails that have been marked as important will not be deleted."
                    ) % {"days": settings.INBOX_AUTO_DELETE_TIME},
    )
    display_images = models.PositiveSmallIntegerField(
        choices=IMAGE_OPTIONS, default=ASK,
        verbose_name=_("Display options for HTML emails"),
        help_text=_("Warning: Images in HTML emails can be used to track if you read an email!"),
    )

    quota_options = models.PositiveSmallIntegerField(
        choices=QUOTA_OPTIONS, default=REJECT_MAIL,
        verbose_name=_("What happens once your email quota is reached?"),
    )
    quota_percent_usage = models.PositiveSmallIntegerField(default=0)
    receiving_emails = models.BooleanField(default=True)

    def get_bools_for_labels(self):
        yield ("new", self.unified_has_new_messages)

    def __str__(self):
        return u"Profile for %s" % self.user


class Statistic(models.Model):
    """Statistics about users"""
    date = models.DateTimeField('date', auto_now_add=True, db_index=True)

    users = JSONField()
    emails = JSONField()
    inboxes = JSONField()

    def __str__(self):
        return str(self.date)


class Liberation(models.Model):
    """Liberation data

    `async_result` is the UUID of Celery result object, which may or may not be valid
    `_path` is relative to settings.SENDFILE_ROOT
    """
    user = AutoOneToOneField(settings.AUTH_USER_MODEL, primary_key=True, on_delete=models.CASCADE)
    content_type = models.PositiveSmallIntegerField(default=0)
    async_result = models.UUIDField(null=True)
    started = models.DateTimeField(null=True)
    last_finished = models.DateTimeField(null=True)
    _path = models.CharField(max_length=255, null=True, unique=True,
                             validators=[validators.ProhibitNullCharactersValidator()])

    running = models.BooleanField(default=False)
    errored = models.BooleanField(default=False)

    TIME_BETWEEN = timedelta(days=7)

    @property
    def path(self):
        if self._path is None:
            return None
        return os.path.join(settings.SENDFILE_ROOT, self._path)

    @path.setter
    def path(self, path):
        assert path[0] != "/", "path should be relative, not absolute"
        self._path = os.path.join(settings.SENDFILE_ROOT, path)

    @property
    def can_request_another(self):
        if self.running:
            return False
        elif self.started is None or self.last_finished is None:
            return True

        now = timezone.now()
        return now - self.started > self.TIME_BETWEEN and now - self.last_finished > self.TIME_BETWEEN

    def __str__(self):
        return u"Liberation for %s" % self.user


##
# Inbox models
##


class Domain(models.Model):
    """Domain model

    `owner` is the user who controls the domain
    """
    domain = models.CharField(max_length=253, unique=True, validators=[validators.ProhibitNullCharactersValidator()])
    enabled = models.BooleanField(default=True)
    owner = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True, default=None, on_delete=models.PROTECT)

    objects = DomainQuerySet.as_manager()

    def __str__(self):
        return self.domain


class Inbox(SearchableAbstract):
    """Inbox model

    Object manager has a custom create() method to generate a random local part
    and a from_string() method to grab an Inbox object from the database given
    a string "inbox@domain"
    """
    inbox = models.CharField(max_length=64, validators=[validators.ProhibitNullCharactersValidator()])
    domain = models.ForeignKey(Domain, on_delete=models.PROTECT)
    user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete=models.SET_NULL)
    created = models.DateTimeField('Created')
    description = models.CharField(max_length=256, null=True, blank=True,
                                   validators=[validators.ProhibitNullCharactersValidator()])

    deleted = models.BooleanField(default=False)
    new = models.BooleanField(default=False)
    exclude_from_unified = models.BooleanField(default=False, verbose_name=_("Exclude from Unified Inbox"))
    disabled = models.BooleanField(default=False, verbose_name=_("Disable Inbox"),
                                   help_text=_("This Inbox will no longer receive emails."))
    pinned = models.BooleanField(default=False, verbose_name=_("Pin Inbox to top"))

    objects = InboxQuerySet.as_manager()

    _bool_label_order = ["new", "disabled", "pinned"]

    def get_bools_for_labels(self):
        for key in self._bool_label_order:
            yield (key, getattr(self, key))

    def __str__(self):
        return u"%s@%s" % (self.inbox, self.domain.domain)

    def __repr__(self):
        u_rep = str(self)
        if self.deleted:
            u_rep = "%s (deleted)" % u_rep
        return smart_str(u'<%s: %s>' % (self.__class__.__name__, u_rep), errors="replace")

    def index_search_a(self):
        return self.description or ""

    def index_search_b(self):
        return str(self)

    class Meta:
        verbose_name_plural = "Inboxes"
        unique_together = (('inbox', 'domain'),)
        indexes = [GinIndex(fields=["search_tsv"])]

##
# Email models
##


class Email(SearchableAbstract):
    """Email model

    eid is a convience property that outputs a hexidec ID

    The body and headers can be found in the root of the PartList tree on Email.parts
    """
    inbox = models.ForeignKey(Inbox, on_delete=models.CASCADE)
    received_date = models.DateTimeField(db_index=True)

    deleted = models.BooleanField(default=False)
    read = models.BooleanField(default=False)
    seen = models.BooleanField(default=False)
    important = models.BooleanField(default=False)
    view_all_headers = models.BooleanField(default=False)

    objects = EmailQuerySet.as_manager()

    @property
    def eid(self):
        """Return a hexidecimal version of ID"""
        return hex(self.id)[2:].rstrip("L")

    _bool_label_order = ["read", "seen", "important"]

    def get_bools_for_labels(self):
        for key in self._bool_label_order:
            yield (key, getattr(self, key))

    def __str__(self):
        return u"{0}".format(self.eid)

    def get_parts(self):
        """Fetches the MIME tree of the email and returns the root part.

        All subsequent calls to `part.parent` or `part.get_children()` will not
        cause additional database queries
        """
        root_parts = self.parts.all().get_cached_trees()

        assert len(root_parts) <= 1, "Expected to find a single part, found %s" % len(root_parts)

        try:
            return root_parts[0]
        except IndexError:
            return None

    def index_search_a(self):
        try:
            subject = HeaderData.objects.filter(
                header__part__parent__isnull=True,
                header__name__name="Subject",
                header__part__email__id=self.id,
            ).first()

            return unicode_damnit(subject.data)
        except AttributeError:
            return ""

    def index_search_b(self):
        try:
            from_header = HeaderData.objects.filter(
                header__part__parent__isnull=True,
                header__name__name="From",
                header__part__email__id=self.id,
            ).first()

            return unicode_damnit(from_header.data)
        except AttributeError:
            return ""

    class Meta:
        indexes = [GinIndex(fields=["search_tsv"])]


class Body(models.Model):
    """Body model

    Object manager has a get_or_create() method that deals with duplicated
    bodies.

    This model expects and returns binary data, converting to and from str happens elsewhere
    """
    hashed = models.CharField(max_length=80, unique=True,
                              validators=[validators.ProhibitNullCharactersValidator()])  # <algo>:<hash>
    data = models.BinaryField(default=b"")

    objects = BodyQuerySet.as_manager()

    def __str__(self):
        return self.hashed


class PartList(MPTTModel):
    """Part model

    non-MIME part or MIME part(s)

    See MPTT docs on how to use this model

    email is passed to Email as a workaround for https://github.com/django-mptt/django-mptt/issues/189
    """
    email = models.ForeignKey(Email, related_name='parts', on_delete=models.CASCADE)
    body = models.ForeignKey(Body, on_delete=models.PROTECT)
    parent = TreeForeignKey('self', null=True, blank=True, related_name='children', on_delete=models.CASCADE)

    def __str__(self):
        return str(self.id)

    @cached_property
    def _content_headers_cache(self):
        """Fetch Content-Type and Content-Disposition headers and split them
        out into useful bits, e.g. filename, charset, etc.

        Properties content_type, filename, and charset use this cached property.
        """
        data = {}
        part_headers = self.header_set.get_many("Content-Type", "Content-Disposition")

        # split off the parameters from the actual content type
        content_header = part_headers.pop("Content-Type", u"").split(";", 1)
        data['content_type'] = content_header[0]
        content_params = content_header[1] if len(content_header) > 1 else u""

        if not self.is_leaf_node():
            # only leaf nodes will have things like charsets and filenames
            return data

        dispos = part_headers.pop("Content-Disposition", u"")

        params = dict(HEADER_PARAMS.findall(content_params))
        params.update(dict(HEADER_PARAMS.findall(dispos)))

        # find filename, could be anywhere, could be nothing
        data["filename"] = params.get("filename") or params.get("name") or u""

        # grab charset
        data["charset"] = params.get("charset", u"utf-8")

        return data

    @property
    def content_type(self):
        return self._content_headers_cache.get("content_type")

    @property
    def filename(self):
        return self._content_headers_cache.get("filename")

    @property
    def charset(self):
        return self._content_headers_cache.get("charset")


class HeaderName(models.Model):
    """Header name model

    Limited to 78 characters
    """
    name = models.CharField(max_length=78, unique=True, validators=[validators.ProhibitNullCharactersValidator()])

    def __str__(self):
        return self.name


class HeaderData(models.Model):
    """Header data model

    RFC 2822 implies that header data may be infinite, may as well support it!
    """
    hashed = models.CharField(max_length=80, unique=True,
                              validators=[validators.ProhibitNullCharactersValidator()])  # <algo>:<hash>
    data = models.TextField(validators=[validators.ProhibitNullCharactersValidator()])

    def __str__(self):
        return self.hashed


class Header(models.Model):
    """Header model

    ordinal preserves the order of headers as in the original message

    Object manager has a create() method that accepts name and data, it deals
    with duplicated header names/data behind the scenes
    """
    name = models.ForeignKey(HeaderName, on_delete=models.PROTECT)
    data = models.ForeignKey(HeaderData, on_delete=models.PROTECT)
    part = models.ForeignKey(PartList, on_delete=models.CASCADE)
    ordinal = models.IntegerField()

    objects = HeaderQuerySet.as_manager()

    def __str__(self):
        return u"{0}".format(self.name.name)

# 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.

from oslo_config import cfg
from stevedore import named

from barbican.common import config
from barbican.common import utils
from barbican import i18n as u
from barbican.plugin.crypto import crypto
from barbican.plugin.interface import secret_store
from barbican.plugin.util import utils as plugin_utils


_PLUGIN_MANAGER = None

CONF = config.new_config()

DEFAULT_PLUGIN_NAMESPACE = 'barbican.crypto.plugin'
DEFAULT_PLUGINS = ['simple_crypto']

crypto_opt_group = cfg.OptGroup(name='crypto',
                                title='Crypto Plugin Options')
crypto_opts = [
    cfg.StrOpt('namespace',
               default=DEFAULT_PLUGIN_NAMESPACE,
               help=u._('Extension namespace to search for plugins.')
               ),
    cfg.MultiStrOpt('enabled_crypto_plugins',
                    default=DEFAULT_PLUGINS,
                    help=u._('List of crypto plugins to load.')
                    )
]
CONF.register_group(crypto_opt_group)
CONF.register_opts(crypto_opts, group=crypto_opt_group)
config.parse_args(CONF)


class _CryptoPluginManager(named.NamedExtensionManager):
    def __init__(self, conf=CONF, invoke_args=(), invoke_kwargs={}):
        """Crypto Plugin Manager

        Each time this class is initialized it will load a new instance
        of each enabled crypto plugin. This is undesirable, so rather than
        initializing a new instance of this class use the PLUGIN_MANAGER
        at the module level.
        """
        super(_CryptoPluginManager, self).__init__(
            conf.crypto.namespace,
            conf.crypto.enabled_crypto_plugins,
            invoke_on_load=False,  # Defer creating plugins to utility below.
            invoke_args=invoke_args,
            invoke_kwds=invoke_kwargs
        )

        plugin_utils.instantiate_plugins(
            self, invoke_args, invoke_kwargs)

    def get_plugin_store_generate(self, type_needed, algorithm=None,
                                  bit_length=None, mode=None):
        """Gets a secret store or generate plugin that supports provided type.

        :param type_needed: PluginSupportTypes that contains details on the
        type of plugin required
        :returns: CryptoPluginBase plugin implementation
        """
        active_plugins = plugin_utils.get_active_plugins(self)

        if len(active_plugins) < 1:
            raise crypto.CryptoPluginNotFound()

        for generating_plugin in active_plugins:
            if generating_plugin.supports(
                    type_needed, algorithm, bit_length, mode):
                break
        else:
            raise secret_store.SecretStorePluginNotFound()

        return generating_plugin

    def get_plugin_retrieve(self, plugin_name_for_store):
        """Gets a secret retrieve plugin that supports the provided type.

        :param type_needed: PluginSupportTypes that contains details on the
        type of plugin required
        :returns: CryptoPluginBase plugin implementation
        """
        active_plugins = plugin_utils.get_active_plugins(self)

        if len(active_plugins) < 1:
            raise crypto.CryptoPluginNotFound()

        for decrypting_plugin in active_plugins:
            plugin_name = utils.generate_fullname_for(decrypting_plugin)
            if plugin_name == plugin_name_for_store:
                break
        else:
            raise secret_store.SecretStorePluginNotFound()

        return decrypting_plugin


def get_manager():
    """Return a singleton crypto plugin manager."""
    global _PLUGIN_MANAGER
    if not _PLUGIN_MANAGER:
        _PLUGIN_MANAGER = _CryptoPluginManager()
    return _PLUGIN_MANAGER

###############################################################################
##
##  Copyright (C) 2014 Tavendo GmbH
##
##  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.
##
###############################################################################

from __future__ import absolute_import

import sys

if sys.version_info < (2,7):
   import unittest2 as unittest
else:
   #from twisted.trial import unittest
   import unittest

from autobahn import wamp
from autobahn.wamp import message
from autobahn.wamp import exception
from autobahn.wamp import protocol



class TestPeerExceptions(unittest.TestCase):

   def test_exception_from_message(self):
      session = protocol.BaseSession()

      @wamp.error("com.myapp.error1")
      class AppError1(Exception):
         pass

      @wamp.error("com.myapp.error2")
      class AppError2(Exception):
         pass

      session.define(AppError1)
      session.define(AppError2)

      ## map defined errors to user exceptions
      ##
      emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error1')
      exc = session._exception_from_message(emsg)
      self.assertIsInstance(exc, AppError1)
      self.assertEqual(exc.args, ())

      emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error2')
      exc = session._exception_from_message(emsg)
      self.assertIsInstance(exc, AppError2)
      self.assertEqual(exc.args, ())

      ## map undefined error to (generic) exception
      ##
      emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error3')
      exc = session._exception_from_message(emsg)
      self.assertIsInstance(exc, exception.ApplicationError)
      self.assertEqual(exc.error, u'com.myapp.error3')
      self.assertEqual(exc.args, ())
      self.assertEqual(exc.kwargs, {})

      emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error3', args = [1, 2, u'hello'])
      exc = session._exception_from_message(emsg)
      self.assertIsInstance(exc, exception.ApplicationError)
      self.assertEqual(exc.error, u'com.myapp.error3')
      self.assertEqual(exc.args, (1, 2, u'hello'))
      self.assertEqual(exc.kwargs, {})

      emsg = message.Error(message.Call.MESSAGE_TYPE, 123456, u'com.myapp.error3', args = [1, 2, u'hello'], kwargs = {u'foo': 23, u'bar': u'baz'})
      exc = session._exception_from_message(emsg)
      self.assertIsInstance(exc, exception.ApplicationError)
      self.assertEqual(exc.error, u'com.myapp.error3')
      self.assertEqual(exc.args, (1, 2, u'hello'))
      self.assertEqual(exc.kwargs, {u'foo': 23, u'bar': u'baz'})


   def test_message_from_exception(self):
      session = protocol.BaseSession()

      @wamp.error("com.myapp.error1")
      class AppError1(Exception):
         pass

      @wamp.error("com.myapp.error2")
      class AppError2(Exception):
         pass

      session.define(AppError1)
      session.define(AppError2)

      exc = AppError1()
      msg = session._message_from_exception(message.Call.MESSAGE_TYPE, 123456, exc)

      self.assertEqual(msg.marshal(), [message.Error.MESSAGE_TYPE, message.Call.MESSAGE_TYPE, 123456, {}, "com.myapp.error1"])


if __name__ == '__main__':
   unittest.main()

#!/usr/bin/env python
#
# Copyright 2013 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING.  If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#

from gnuradio import gr, blocks
from gnuradio.eng_option import eng_option
from optparse import OptionParser
import os, sys

try:
    from gnuradio import qtgui
    from PyQt4 import QtGui, QtCore
    import sip
except ImportError:
    print "Error: Program requires PyQt4 and gr-qtgui."
    sys.exit(1)

try:
    import scipy
except ImportError:
    print "Error: Scipy required (www.scipy.org)."
    sys.exit(1)

try:
    from gnuradio.qtgui.plot_form import *
    from gnuradio.qtgui.plot_base import *
except ImportError:
    from plot_form import *
    from plot_base import *

class plot_base(gr.top_block):
    def __init__(self, filelist, fc, samp_rate, psdsize, start,
                 nsamples, max_nsamples, avg=1.0):
        gr.top_block.__init__(self)

        self._filelist = filelist
        self._center_freq = fc
        self._samp_rate = samp_rate
        self._psd_size = psdsize
        self._start = start
        self._max_nsamps = max_nsamples
        self._nsigs = len(self._filelist)
        self._avg = avg
        self._nsamps = nsamples
        self._auto_scale = False

        self._y_min = -200
        self._y_max = 400
        self._y_range = 130
        self._y_value = 10

        self._is_setup = False

        self.qapp = QtGui.QApplication(sys.argv)

    def setup(self):
        self.skip = blocks.skiphead(self.dsize, self._start)

        n = 0
        self.srcs = list()
        self._data_min = sys.maxint
        self._data_max = -sys.maxint - 1
        for f in self._filelist:
            data,_min,_max = self.read_samples(f, self._start,
                                               self._nsamps, self._psd_size)
            if(_min < self._data_min):
                self._data_min = _min
            if(_max > self._data_max):
                self._data_max = _max

            self.srcs.append(self.src_type(data))

            # Set default labels based on file names
            fname = f.split("/")[-1]
            self.gui_snk.set_line_label(n, "{0}".format(fname))
            n += 1

        self.connect(self.srcs[0], self.skip)
        self.connect(self.skip, (self.gui_snk, 0))

        for i,s in enumerate(self.srcs[1:]):
            self.connect(s, (self.gui_snk, i+1))

        self.gui_snk.set_update_time(0)
        self.gui_snk.enable_menu(False)

        # Get Python Qt references
        pyQt  = self.gui_snk.pyqwidget()
        self.pyWin = sip.wrapinstance(pyQt, QtGui.QWidget)

        self._is_setup = True

    def is_setup(self):
        return self._is_setup

    def set_y_axis(self, y_min, y_max):
        self.gui_snk.set_y_axis(y_min, y_max)
        return y_min, y_max

    def get_gui(self):
        if(self.is_setup()):
            return self.pyWin
        else:
            return None

    def reset(self, newstart, newnsamps):
        self.stop()
        self.wait()

        self._start = newstart

        self._data_min = sys.maxint
        self._data_max = -sys.maxint - 1
        for s,f in zip(self.srcs, self._filelist):
            data,_min,_max = self.read_samples(f, self._start, newnsamps, self._psd_size)
            if(_min < self._data_min):
                self._data_min = _min
            if(_max > self._data_max):
                self._data_max = _max

            s.set_data(data)

        self.start()

def setup_options(desc):
    parser = OptionParser(option_class=eng_option, description=desc,
                          conflict_handler="resolve")
    parser.add_option("-N", "--nsamples", type="int", default=1000000,
                      help="Set the number of samples to display [default=prints entire file]")
    parser.add_option("-S", "--start", type="int", default=0,
                      help="Starting sample number [default=%default]")
    parser.add_option("-L", "--psd-size", type="int", default=2048,
                      help="Set the FFT size of the PSD [default=%default]")
    parser.add_option("-f", "--center-frequency", type="eng_float", default=0.0,
                      help="Set the center frequency of the signal [default=%default]")
    parser.add_option("-r", "--sample-rate", type="eng_float", default=1.0,
                      help="Set the sample rate of the signal [default=%default]")
    parser.add_option("-a", "--average", type="float", default=1.0,
                      help="Set amount of averaging (smaller=more averaging) [default=%default]")
    (options, args) = parser.parse_args()

    if(len(args) < 1):
        parser.print_help()
        sys.exit(0)
    return (options,args)

"""
Shim to maintain backwards compatibility with old frontend imports.

We have moved all contents of the old `frontend` subpackage into top-level
subpackages (`html`, `qt` and `terminal`), and flattened the notebook into
just `IPython.html`, formerly `IPython.frontend.html.notebook`.

This will let code that was making `from IPython.frontend...` calls continue
working, though a warning will be printed.
"""

# Copyright (c) IPython Development Team.
# Distributed under the terms of the Modified BSD License.

import sys
from warnings import warn

from IPython.utils.shimmodule import ShimModule, ShimWarning

warn("The top-level `frontend` package has been deprecated. "
     "All its subpackages have been moved to the top `IPython` level.", ShimWarning)

# Unconditionally insert the shim into sys.modules so that further import calls
# trigger the custom attribute access above

sys.modules['IPython.frontend.html.notebook'] = ShimModule(
    src='IPython.frontend.html.notebook', mirror='IPython.html')
sys.modules['IPython.frontend'] = ShimModule(
    src='IPython.frontend', mirror='IPython')

"""
=================================
Gaussian Mixture Model Selection
=================================

This example shows that model selection can be performed with
Gaussian Mixture Models using information-theoretic criteria (BIC).
Model selection concerns both the covariance type
and the number of components in the model.
In that case, AIC also provides the right result (not shown to save time),
but BIC is better suited if the problem is to identify the right model.
Unlike Bayesian procedures, such inferences are prior-free.

In that case, the model with 2 components and full covariance
(which corresponds to the true generative model) is selected.
"""
print(__doc__)

import itertools

import numpy as np
from scipy import linalg
import matplotlib.pyplot as plt
import matplotlib as mpl

from sklearn import mixture

# Number of samples per component
n_samples = 500

# Generate random sample, two components
np.random.seed(0)
C = np.array([[0., -0.1], [1.7, .4]])
X = np.r_[np.dot(np.random.randn(n_samples, 2), C),
          .7 * np.random.randn(n_samples, 2) + np.array([-6, 3])]

lowest_bic = np.infty
bic = []
n_components_range = range(1, 7)
cv_types = ['spherical', 'tied', 'diag', 'full']
for cv_type in cv_types:
    for n_components in n_components_range:
        # Fit a mixture of Gaussians with EM
        gmm = mixture.GMM(n_components=n_components, covariance_type=cv_type)
        gmm.fit(X)
        bic.append(gmm.bic(X))
        if bic[-1] < lowest_bic:
            lowest_bic = bic[-1]
            best_gmm = gmm

bic = np.array(bic)
color_iter = itertools.cycle(['k', 'r', 'g', 'b', 'c', 'm', 'y'])
clf = best_gmm
bars = []

# Plot the BIC scores
spl = plt.subplot(2, 1, 1)
for i, (cv_type, color) in enumerate(zip(cv_types, color_iter)):
    xpos = np.array(n_components_range) + .2 * (i - 2)
    bars.append(plt.bar(xpos, bic[i * len(n_components_range):
                                  (i + 1) * len(n_components_range)],
                        width=.2, color=color))
plt.xticks(n_components_range)
plt.ylim([bic.min() * 1.01 - .01 * bic.max(), bic.max()])
plt.title('BIC score per model')
xpos = np.mod(bic.argmin(), len(n_components_range)) + .65 +\
    .2 * np.floor(bic.argmin() / len(n_components_range))
plt.text(xpos, bic.min() * 0.97 + .03 * bic.max(), '*', fontsize=14)
spl.set_xlabel('Number of components')
spl.legend([b[0] for b in bars], cv_types)

# Plot the winner
splot = plt.subplot(2, 1, 2)
Y_ = clf.predict(X)
for i, (mean, covar, color) in enumerate(zip(clf.means_, clf.covars_,
                                             color_iter)):
    v, w = linalg.eigh(covar)
    if not np.any(Y_ == i):
        continue
    plt.scatter(X[Y_ == i, 0], X[Y_ == i, 1], .8, color=color)

    # Plot an ellipse to show the Gaussian component
    angle = np.arctan2(w[0][1], w[0][0])
    angle = 180 * angle / np.pi  # convert to degrees
    v *= 4
    ell = mpl.patches.Ellipse(mean, v[0], v[1], 180 + angle, color=color)
    ell.set_clip_box(splot.bbox)
    ell.set_alpha(.5)
    splot.add_artist(ell)

plt.xlim(-10, 10)
plt.ylim(-3, 6)
plt.xticks(())
plt.yticks(())
plt.title('Selected GMM: full model, 2 components')
plt.subplots_adjust(hspace=.35, bottom=.02)
plt.show()

from __future__ import absolute_import, division, print_function, unicode_literals

import math

from pyparsing import Expressions
from pyparsing.pyparsing import ParseException
from echomesh.util.TestCase import TestCase

class ParsingTest(TestCase):
    def assertParse(self, s, expected):
        try:
            result = Expressions.evaluate(s)
        except ParseException as pe:
            result = 'failed parse: ' + str(pe)
        except Exception as e:
            result = 'failed eval: ' + str(e)
        self.assertEqual(result, expected)

    def test_simple(self):
        self.assertParse('9', 9)

    def test_minus(self):
        self.assertParse('-9', -9)

    def test_minus_minus(self):
        self.assertParse('--9', 9)

    def test_minus_e(self):
        self.assertParse('-E', -2.718281828459045)

    def test_add(self):
        self.assertParse('9 + 3 + 6', 18)

    def test_add_div(self):
        self.assertParse('9 + 3 / 11', 9.272727272727273)

    def test_paren(self):
        self.assertParse('(9 + 3)', 12)

    def test_paren_div(self):
        self.assertParse('(9+3) / 11', 1.0909090909090908)

    def test_triple(self):
        self.assertParse('9 - 12 - 6', -9)

    def test_triple_paren(self):
        self.assertParse('9 - (12 - 6)', 3)

    def test_const(self):
        self.assertParse('2*3.14159', 6.28318)

    def test_bigmult(self):
        self.assertParse('3.1415926535*3.1415926535 / 10', 0.9869604400525172)

    def test_pisq(self):
        self.assertParse('PI * PI / 10', 0.9869604401089358)

    def test_pisq_2(self):
        self.assertParse('PI*PI/10', 0.9869604401089358)

    def test_pisq_3(self):
        self.assertParse('PI^2', 9.869604401089358)

    def test_pisq_4(self):
        self.assertParse('round(PI^2)', 10.0)

    def test_scientific(self):
        self.assertParse('6.02E23 * 8.048', 4.844896e+24)

    def test_e(self):
        self.assertParse('e / 3', 0.9060939428196817)

    def test_pi3(self):
        self.assertParse('sin(PI/2)', 1.0)

    def test_trunc_e(self):
        self.assertParse('trunc(E)', 2)

    def test_trunc_e_minus(self):
        self.assertParse('trunc(-E)', -2)

    def test_round(self):
        self.assertParse('round(E)', 3.0)

    def test_round_minus(self):
        self.assertParse('round(-E)', -3.0)

    def test_e_pi(self):
        self.assertParse('E^PI', 23.140692632779263)

    def test_powers(self):
        self.assertParse('2^3^2', 512)

    def test_power_assoc(self):
        self.assertParse('2^3+2', 10)

    def test_power_assoc2(self):
        self.assertParse('2^3+5', 13)

    def test_power3(self):
        self.assertParse('2^9', 512)

    def test_sgn_minus(self):
        self.assertParse('sgn(-2)', -1)

    def test_sgn_zero(self):
        self.assertParse('sgn(0)', 0)

    def test_fail1(self):
        self.assertParse('foo(0.1)', u'failed eval: invalid identifier "foo"')

    def test_sign_plus(self):
        self.assertParse('sgn(0.1)', 1)

# >>> test_parse('0x01')
# 1
#
# >>> test_parse('0xff')  # Doesn't yet work.
# 255

import mock
import pytest
pytestmark = pytest.mark.guitest


@pytest.yield_fixture
def mock_msgbox():
    with mock.patch('spreadsplug.gui.gui.QtGui.QMessageBox') as msgbox:
        msgbox.exec_.return_value = True
        yield msgbox


@pytest.fixture
def wizard(config):
    import spreadsplug.gui.gui as gui
    wizard = gui.SpreadsWizard(config)
    wizard.show()
    return wizard


@pytest.fixture
def workflow(config, tmpdir):
    from spreads.workflow import Workflow
    wf = Workflow(path=unicode(tmpdir), config=config)
    return wf


def test_intro_page(wizard, tmpdir):
    page = wizard.page(0)
    page.initializePage()
    page.line_edit.setText(unicode(tmpdir))
    assert 'device' in page.plugin_widgets
    assert page.validatePage()
    assert unicode(wizard.workflow.path) == unicode(tmpdir)
    # TODO: Check plugin options


def test_intro_page_nopath(wizard, mock_msgbox):
    page = wizard.page(0)
    page.initializePage()
    assert not page.validatePage()


def test_capture_page(wizard, workflow):
    wizard.workflow = workflow
    with mock.patch.multiple("spreadsplug.gui.gui.QtGui", QImage=mock.DEFAULT,
                             QPixmap=mock.DEFAULT) as values:
        values["QPixmap"].fromImage = mock.Mock(
            return_value=values["QImage"]())
        page = wizard.page(1)
        page.initializePage()
        # TODO: Test capture triggering, logbox updates, etc
        assert page.validatePage()


def test_postprocess_page(wizard, workflow):
    wizard.workflow = workflow
    page = wizard.page(2)
    page.initializePage()
    # TODO: See that logbox works, postprocess is executed
    assert page.validatePage()


def test_output_page(wizard, workflow):
    wizard.workflow = workflow
    page = wizard.page(3)
    page.initializePage()
    # TODO: See that logbox works, postprocess is executed
    assert page.validatePage()

"""Test the errno module
   Roger E. Masse
"""

import errno
from test import test_support
import unittest

std_c_errors = frozenset(['EDOM', 'ERANGE'])

class ErrnoAttributeTests(unittest.TestCase):

    def test_for_improper_attributes(self):
        # No unexpected attributes should be on the module.
        for error_code in std_c_errors:
            self.assertTrue(hasattr(errno, error_code),
                            "errno is missing %s" % error_code)

    def test_using_errorcode(self):
        # Every key value in errno.errorcode should be on the module.
        for value in errno.errorcode.itervalues():
            self.assertTrue(hasattr(errno, value), 'no %s attr in errno' % value)


class ErrorcodeTests(unittest.TestCase):

    def test_attributes_in_errorcode(self):
        for attribute in errno.__dict__.iterkeys():
            if attribute.isupper():
                self.assertIn(getattr(errno, attribute), errno.errorcode,
                              'no %s attr in errno.errorcode' % attribute)


def test_main():
    test_support.run_unittest(ErrnoAttributeTests, ErrorcodeTests)


if __name__ == '__main__':
    test_main()

# Copyright 2013 Cloudbase Solutions Srl
#
#    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.

import os
import unittest

try:
    import unittest.mock as mock
except ImportError:
    import mock

from cloudbaseinit.osutils import factory


class OSUtilsFactory(unittest.TestCase):

    @mock.patch('cloudbaseinit.utils.classloader.ClassLoader.load_class')
    def _test_get_os_utils(self, mock_load_class, fake_name):
        os.name = fake_name
        factory.get_os_utils()
        if fake_name == 'nt':
            mock_load_class.assert_called_with(
                'cloudbaseinit.osutils.windows.WindowsUtils')
        elif fake_name == 'posix':
            mock_load_class.assert_called_with(
                'cloudbaseinit.osutils.posix.PosixUtils')

    def test_get_os_utils_windows(self):
        self._test_get_os_utils(fake_name='nt')

    def test_get_os_utils_posix(self):
        self._test_get_os_utils(fake_name='posix')

import warnings

from functools import wraps

from flask import current_app, url_for, g

from social.utils import module_member, setting_name
from social.strategies.utils import get_strategy
from social.backends.utils import get_backend


DEFAULTS = {
    'STORAGE': 'social.apps.flask_app.default.models.FlaskStorage',
    'STRATEGY': 'social.strategies.flask_strategy.FlaskStrategy'
}


def get_helper(name, do_import=False):
    config = current_app.config.get(setting_name(name),
                                    DEFAULTS.get(name, None))
    return do_import and module_member(config) or config


def load_strategy():
    strategy = get_helper('STRATEGY')
    storage = get_helper('STORAGE')
    return get_strategy(strategy, storage)


def load_backend(strategy, name, redirect_uri, *args, **kwargs):
    backends = get_helper('AUTHENTICATION_BACKENDS')
    Backend = get_backend(backends, name)
    return Backend(strategy=strategy, redirect_uri=redirect_uri)


def psa(redirect_uri=None):
    def decorator(func):
        @wraps(func)
        def wrapper(backend, *args, **kwargs):
            uri = redirect_uri
            if uri and not uri.startswith('/'):
                uri = url_for(uri, backend=backend)
            g.strategy = load_strategy()
            g.backend = load_backend(g.strategy, backend, redirect_uri=uri,
                                     *args, **kwargs)
            return func(backend, *args, **kwargs)
        return wrapper
    return decorator


def strategy(*args, **kwargs):
    warnings.warn('@strategy decorator is deprecated, use @psa instead')
    return psa(*args, **kwargs)

#!/usr/bin/env python
#
# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Installs an APK.

"""

import optparse
import os
import re
import sys

from util import build_device
from util import build_utils
from util import md5_check

BUILD_ANDROID_DIR = os.path.join(os.path.dirname(__file__), '..')
sys.path.append(BUILD_ANDROID_DIR)

from pylib import constants
from pylib.utils import apk_helper

_DPI_TO_DENSITY = {
    120: 'ldpi',
    160: 'mdpi',
    240: 'hdpi',
    320: 'xhdpi',
    480: 'xxhdpi',
    }


def RetrieveDeviceConfig(device):
  """Probes the given device for its split-select config.

  For example: en-rUS-xhdpi:armeabi-v7a
  Run "split-select --help" for more info about the format.
  """
  language = device.GetProp('persist.sys.language')
  country = device.GetProp('persist.sys.country')
  density_dpi = int(device.GetProp('ro.sf.lcd_density'))
  density = _DPI_TO_DENSITY.get(density_dpi, 'tvdpi')
  abi = device.product_cpu_abi
  return '%s-r%s-%s:%s' % (language, country, density, abi)


def GetNewMetadata(device, apk_package):
  """Gets the metadata on the device for the apk_package apk."""
  output = device.RunShellCommand('ls -l /data/app/')
  # Matches lines like:
  # -rw-r--r-- system   system    7376582 2013-04-19 16:34 \
  # org.chromium.chrome.shell.apk
  # -rw-r--r-- system   system    7376582 2013-04-19 16:34 \
  # org.chromium.chrome.shell-1.apk
  apk_matcher = lambda s: re.match('.*%s(-[0-9]*)?(.apk)?$' % apk_package, s)
  matches = filter(apk_matcher, output)
  return matches[0] if matches else None

def HasInstallMetadataChanged(device, apk_package, metadata_path):
  """Checks if the metadata on the device for apk_package has changed."""
  if not os.path.exists(metadata_path):
    return True

  with open(metadata_path, 'r') as expected_file:
    return expected_file.read() != device.GetInstallMetadata(apk_package)


def RecordInstallMetadata(device, apk_package, metadata_path):
  """Records the metadata from the device for apk_package."""
  metadata = GetNewMetadata(device, apk_package)
  if not metadata:
    raise Exception('APK install failed unexpectedly.')

  with open(metadata_path, 'w') as outfile:
    outfile.write(metadata)


def main():
  parser = optparse.OptionParser()
  parser.add_option('--apk-path',
      help='Path to .apk to install.')
  parser.add_option('--split-apk-path',
      help='Path to .apk splits (can specify multiple times, causes '
      '--install-multiple to be used.',
      action='append')
  parser.add_option('--android-sdk-tools',
      help='Path to the Android SDK build tools folder. ' +
           'Required when using --split-apk-path.')
  parser.add_option('--install-record',
      help='Path to install record (touched only when APK is installed).')
  parser.add_option('--build-device-configuration',
      help='Path to build device configuration.')
  parser.add_option('--stamp',
      help='Path to touch on success.')
  parser.add_option('--configuration-name',
      help='The build CONFIGURATION_NAME')
  options, _ = parser.parse_args()

  device = build_device.GetBuildDeviceFromPath(
      options.build_device_configuration)
  if not device:
    return

  constants.SetBuildType(options.configuration_name)

  serial_number = device.GetSerialNumber()
  apk_package = apk_helper.GetPackageName(options.apk_path)

  metadata_path = '%s.%s.device.time.stamp' % (options.apk_path, serial_number)

  # If the APK on the device does not match the one that was last installed by
  # the build, then the APK has to be installed (regardless of the md5 record).
  force_install = HasInstallMetadataChanged(device, apk_package, metadata_path)

  def SelectSplits(target_config, base_apk, split_apks, android_sdk_tools):
    cmd = [os.path.join(android_sdk_tools, 'split-select'),
           '--target', target_config,
           '--base', base_apk,
           ]
    for split in split_apks:
      cmd.extend(('--split', split))

    # split-select outputs one path per line and a blank line at the end.
    output = build_utils.CheckOutput(cmd)
    return [x for x in output.split('\n') if x]

  def Install():
    if options.split_apk_path:
      requiredSdkVersion = constants.ANDROID_SDK_VERSION_CODES.LOLLIPOP
      actualSdkVersion = device.device.build_version_sdk
      if actualSdkVersion < requiredSdkVersion:
        raise Exception(('--split-apk-path requires sdk version %s. Device has '
                         'version %s') % (requiredSdkVersion, actualSdkVersion))
      device_config = RetrieveDeviceConfig(device.device)
      active_splits = SelectSplits(
          device_config,
          options.apk_path,
          options.split_apk_path,
          options.android_sdk_tools)

      all_apks = [options.apk_path] + active_splits
      device.device.adb.InstallMultiple(all_apks, reinstall=True)
    else:
      device.Install(options.apk_path, reinstall=True)

    RecordInstallMetadata(device, apk_package, metadata_path)
    build_utils.Touch(options.install_record)


  record_path = '%s.%s.md5.stamp' % (options.apk_path, serial_number)
  md5_check.CallAndRecordIfStale(
      Install,
      record_path=record_path,
      input_paths=[options.apk_path],
      force=force_install)

  if options.stamp:
    build_utils.Touch(options.stamp)


if __name__ == '__main__':
  sys.exit(main())

from django.core.urlresolvers import reverse
from django.db.models import Q, Max, Count
from django.http import Http404
from django.utils import timezone
from django.utils.functional import lazy
from django.utils.translation import ugettext as _
from django.views.generic import ListView

from judge.comments import CommentedDetailView
from judge.models import BlogPost, Comment, Problem, Contest, Profile, Submission, Language, ProblemClarification
from judge.models import Ticket
from judge.utils.diggpaginator import DiggPaginator
from judge.utils.problems import user_completed_ids
from judge.utils.tickets import filter_visible_tickets
from judge.utils.views import TitleMixin


class PostList(ListView):
    model = BlogPost
    paginate_by = 10
    context_object_name = 'posts'
    template_name = 'blog/list.html'
    title = None

    def get_paginator(self, queryset, per_page, orphans=0,
                      allow_empty_first_page=True, **kwargs):
        return DiggPaginator(queryset, per_page, body=6, padding=2,
                             orphans=orphans, allow_empty_first_page=allow_empty_first_page, **kwargs)

    def get_queryset(self):
        return (BlogPost.objects.filter(visible=True, publish_on__lte=timezone.now()).order_by('-sticky', '-publish_on')
                        .prefetch_related('authors__user'))

    def get_context_data(self, **kwargs):
        context = super(PostList, self).get_context_data(**kwargs)
        context['title'] = self.title or _('Page %d of Posts') % context['page_obj'].number
        context['first_page_href'] = reverse('home')
        context['page_prefix'] = reverse('blog_post_list')
        context['comments'] = Comment.most_recent(self.request.user, 10)
        context['new_problems'] = Problem.objects.filter(is_public=True).order_by('-date', '-id')[:7]

        context['has_clarifications'] = False
        if self.request.user.is_authenticated:
            participation = self.request.user.profile.current_contest
            if participation:
                clarifications = ProblemClarification.objects.filter(problem__in=participation.contest.problems.all())
                context['has_clarifications'] = clarifications.count() > 0
                context['clarifications'] = clarifications.order_by('-date')

        context['user_count'] = lazy(Profile.objects.count, int, long)
        context['problem_count'] = lazy(Problem.objects.filter(is_public=True).count, int, long)
        context['submission_count'] = lazy(Submission.objects.count, int, long)
        context['language_count'] = lazy(Language.objects.count, int, long)

        context['post_comment_counts'] = {
            int(page[2:]): count for page, count in
            Comment.objects
                .filter(page__in=['b:%d' % post.id for post in context['posts']])
                .values_list('page').annotate(count=Count('page')).order_by()
        }

        now = timezone.now()

        # Dashboard stuff
        if self.request.user.is_authenticated:
            user = self.request.user.profile
            context['recently_attempted_problems'] = (Submission.objects.filter(user=user)
                                                      .exclude(problem__id__in=user_completed_ids(user))
                                                      .values_list('problem__code', 'problem__name', 'problem__points')
                                                      .annotate(points=Max('points'), latest=Max('date'))
                                                      .order_by('-latest'))[:7]

        visible_contests = Contest.objects.filter(is_public=True).order_by('start_time')
        q = Q(is_private=False)
        if self.request.user.is_authenticated:
            q |= Q(organizations__in=user.organizations.all())
        visible_contests = visible_contests.filter(q)
        context['current_contests'] = visible_contests.filter(start_time__lte=now, end_time__gt=now)
        context['future_contests'] = visible_contests.filter(start_time__gt=now)

        if self.request.user.is_authenticated:
            profile = self.request.user.profile
            context['own_open_tickets'] = (Ticket.objects.filter(user=profile, is_open=True).order_by('-id')
                                           .prefetch_related('linked_item').select_related('user__user'))
        else:
            profile = None
            context['own_open_tickets'] = []

        # Superusers better be staffs, not the spell-casting kind either.
        if self.request.user.is_staff:
            tickets = (Ticket.objects.order_by('-id').filter(is_open=True).prefetch_related('linked_item')
                             .select_related('user__user'))
            context['open_tickets'] = filter_visible_tickets(tickets, self.request.user, profile)[:10]
        else:
            context['open_tickets'] = []
        return context


class PostView(TitleMixin, CommentedDetailView):
    model = BlogPost
    pk_url_kwarg = 'id'
    context_object_name = 'post'
    template_name = 'blog/content.html'

    def get_title(self):
        return self.object.title

    def get_comment_page(self):
        return 'b:%s' % self.object.id

    def get_context_data(self, **kwargs):
        context = super(PostView, self).get_context_data(**kwargs)
        context['og_image'] = self.object.og_image
        return context

    def get_object(self, queryset=None):
        post = super(PostView, self).get_object(queryset)
        if not post.can_see(self.request.user):
            raise Http404()
        return post

"""The tests for mqtt camera component."""
from unittest.mock import ANY

from homeassistant.components import camera, mqtt
from homeassistant.components.mqtt.discovery import async_start
from homeassistant.setup import async_setup_component

from tests.common import (
    MockConfigEntry,
    async_fire_mqtt_message,
    async_mock_mqtt_component,
    mock_registry,
)


async def test_run_camera_setup(hass, aiohttp_client):
    """Test that it fetches the given payload."""
    topic = "test/camera"
    await async_mock_mqtt_component(hass)
    await async_setup_component(
        hass,
        "camera",
        {"camera": {"platform": "mqtt", "topic": topic, "name": "Test Camera"}},
    )

    url = hass.states.get("camera.test_camera").attributes["entity_picture"]

    async_fire_mqtt_message(hass, topic, "beer")

    client = await aiohttp_client(hass.http.app)
    resp = await client.get(url)
    assert resp.status == 200
    body = await resp.text()
    assert body == "beer"


async def test_unique_id(hass):
    """Test unique id option only creates one camera per unique_id."""
    await async_mock_mqtt_component(hass)
    await async_setup_component(
        hass,
        "camera",
        {
            "camera": [
                {
                    "platform": "mqtt",
                    "name": "Test Camera 1",
                    "topic": "test-topic",
                    "unique_id": "TOTALLY_UNIQUE",
                },
                {
                    "platform": "mqtt",
                    "name": "Test Camera 2",
                    "topic": "test-topic",
                    "unique_id": "TOTALLY_UNIQUE",
                },
            ]
        },
    )

    async_fire_mqtt_message(hass, "test-topic", "payload")
    assert len(hass.states.async_all()) == 1


async def test_discovery_removal_camera(hass, mqtt_mock, caplog):
    """Test removal of discovered camera."""
    entry = MockConfigEntry(domain=mqtt.DOMAIN)
    await async_start(hass, "homeassistant", {}, entry)

    data = '{ "name": "Beer",' '  "topic": "test_topic"}'

    async_fire_mqtt_message(hass, "homeassistant/camera/bla/config", data)
    await hass.async_block_till_done()

    state = hass.states.get("camera.beer")
    assert state is not None
    assert state.name == "Beer"

    async_fire_mqtt_message(hass, "homeassistant/camera/bla/config", "")
    await hass.async_block_till_done()

    state = hass.states.get("camera.beer")
    assert state is None


async def test_discovery_update_camera(hass, mqtt_mock, caplog):
    """Test update of discovered camera."""
    entry = MockConfigEntry(domain=mqtt.DOMAIN)
    await async_start(hass, "homeassistant", {}, entry)

    data1 = '{ "name": "Beer",' '  "topic": "test_topic"}'
    data2 = '{ "name": "Milk",' '  "topic": "test_topic"}'

    async_fire_mqtt_message(hass, "homeassistant/camera/bla/config", data1)
    await hass.async_block_till_done()

    state = hass.states.get("camera.beer")
    assert state is not None
    assert state.name == "Beer"

    async_fire_mqtt_message(hass, "homeassistant/camera/bla/config", data2)
    await hass.async_block_till_done()

    state = hass.states.get("camera.beer")
    assert state is not None
    assert state.name == "Milk"
    state = hass.states.get("camera.milk")
    assert state is None


async def test_discovery_broken(hass, mqtt_mock, caplog):
    """Test handling of bad discovery message."""
    entry = MockConfigEntry(domain=mqtt.DOMAIN)
    await async_start(hass, "homeassistant", {}, entry)

    data1 = '{ "name": "Beer" }'
    data2 = '{ "name": "Milk",' '  "topic": "test_topic"}'

    async_fire_mqtt_message(hass, "homeassistant/camera/bla/config", data1)
    await hass.async_block_till_done()

    state = hass.states.get("camera.beer")
    assert state is None

    async_fire_mqtt_message(hass, "homeassistant/camera/bla/config", data2)
    await hass.async_block_till_done()

    state = hass.states.get("camera.milk")
    assert state is not None
    assert state.name == "Milk"
    state = hass.states.get("camera.beer")
    assert state is None


async def test_entity_id_update(hass, mqtt_mock):
    """Test MQTT subscriptions are managed when entity_id is updated."""
    registry = mock_registry(hass, {})
    mock_mqtt = await async_mock_mqtt_component(hass)
    assert await async_setup_component(
        hass,
        camera.DOMAIN,
        {
            camera.DOMAIN: [
                {
                    "platform": "mqtt",
                    "name": "beer",
                    "topic": "test-topic",
                    "unique_id": "TOTALLY_UNIQUE",
                }
            ]
        },
    )

    state = hass.states.get("camera.beer")
    assert state is not None
    assert mock_mqtt.async_subscribe.call_count == 1
    mock_mqtt.async_subscribe.assert_any_call("test-topic", ANY, 0, None)
    mock_mqtt.async_subscribe.reset_mock()

    registry.async_update_entity("camera.beer", new_entity_id="camera.milk")
    await hass.async_block_till_done()

    state = hass.states.get("camera.beer")
    assert state is None

    state = hass.states.get("camera.milk")
    assert state is not None
    assert mock_mqtt.async_subscribe.call_count == 1
    mock_mqtt.async_subscribe.assert_any_call("test-topic", ANY, 0, None)

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (c) 2016 Red Hat, Inc.
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#

ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['preview'],
                    'supported_by': 'community'}


DOCUMENTATION = '''
---
module: ovirt_user_facts
short_description: Retrieve facts about one or more oVirt/RHV users
author: "Ondra Machacek (@machacekondra)"
version_added: "2.3"
description:
    - "Retrieve facts about one or more oVirt/RHV users."
notes:
    - "This module creates a new top-level C(ovirt_users) fact, which
       contains a list of users."
options:
    pattern:
      description:
        - "Search term which is accepted by oVirt/RHV search backend."
        - "For example to search user X use following pattern: name=X"
extends_documentation_fragment: ovirt_facts
'''

EXAMPLES = '''
# Examples don't contain auth parameter for simplicity,
# look at ovirt_auth module to see how to reuse authentication:

# Gather facts about all users which first names start with C(john):
- ovirt_user_facts:
    pattern: name=john*
- debug:
    var: ovirt_users
'''

RETURN = '''
ovirt_users:
    description: "List of dictionaries describing the users. User attributes are mapped to dictionary keys,
                  all users attributes can be found at following url: http://ovirt.github.io/ovirt-engine-api-model/master/#types/user."
    returned: On success.
    type: list
'''

import traceback

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.ovirt import (
    check_sdk,
    create_connection,
    get_dict_of_struct,
    ovirt_facts_full_argument_spec,
)


def main():
    argument_spec = ovirt_facts_full_argument_spec(
        pattern=dict(default='', required=False),
    )
    module = AnsibleModule(argument_spec)

    check_sdk(module)

    try:
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        users_service = connection.system_service().users_service()
        users = users_service.list(search=module.params['pattern'])
        module.exit_json(
            changed=False,
            ansible_facts=dict(
                ovirt_users=[
                    get_dict_of_struct(
                        struct=c,
                        connection=connection,
                        fetch_nested=module.params.get('fetch_nested'),
                        attributes=module.params.get('nested_attributes'),
                    ) for c in users
                ],
            ),
        )
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)


if __name__ == '__main__':
    main()

# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------

from msrest.serialization import Model


class Operation(Model):
    """REST API operation definition.

    Variables are only populated by the server, and will be ignored when
    sending a request.

    :ivar name: The name of the operation being performed on this particular
     object.
    :vartype name: str
    :ivar display: The localized display information for this particular
     operation or action.
    :vartype display: ~azure.mgmt.rdbms.mysql.models.OperationDisplay
    :ivar origin: The intended executor of the operation. Possible values
     include: 'NotSpecified', 'user', 'system'
    :vartype origin: str or ~azure.mgmt.rdbms.mysql.models.OperationOrigin
    :ivar properties: Additional descriptions for the operation.
    :vartype properties: dict[str, object]
    """

    _validation = {
        'name': {'readonly': True},
        'display': {'readonly': True},
        'origin': {'readonly': True},
        'properties': {'readonly': True},
    }

    _attribute_map = {
        'name': {'key': 'name', 'type': 'str'},
        'display': {'key': 'display', 'type': 'OperationDisplay'},
        'origin': {'key': 'origin', 'type': 'str'},
        'properties': {'key': 'properties', 'type': '{object}'},
    }

    def __init__(self, **kwargs) -> None:
        super(Operation, self).__init__(**kwargs)
        self.name = None
        self.display = None
        self.origin = None
        self.properties = None

# -*- coding: utf-8 -*-
##############################################################################
# For copyright and license notices, see __openerp__.py file in root directory
##############################################################################
from openerp import models, fields, api, exceptions, _


class StockProductionLot(models.Model):
    _name = 'stock.production.lot'
    _inherit = ['stock.production.lot', 'mail.thread']

    _mail_post_access = 'read'
    _track = {
        'locked': {
            'stock_lock_lot.mt_lock_lot': lambda self, cr, uid, obj,
            ctx=None: obj.locked,
            'stock_lock_lot.mt_unlock_lot': lambda self, cr, uid, obj,
            ctx=None: not obj.locked,
        },
    }

    def _get_product_locked(self, product):
        """Should create locked? (including categories and parents)

        @param product: browse-record for product.product
        @return True when the category of the product or one of the parents
                demand new lots to be locked"""
        _locked = product.categ_id.lot_default_locked
        categ = product.categ_id.parent_id
        while categ and not _locked:
            _locked = categ.lot_default_locked
            categ = categ.parent_id
        return _locked

    @api.one
    def _get_locked_value(self):
        return self._get_product_locked(self.product_id)

    locked = fields.Boolean(string='Blocked', default='_get_locked_value',
                            readonly=True)

    @api.one
    @api.onchange('product_id')
    def onchange_product_id(self):
        self.locked = self._get_product_locked(self.product_id)

    @api.multi
    def button_lock(self):
        stock_quant_obj = self.env['stock.quant']
        for lot in self:
            cond = [('lot_id', '=', lot.id),
                    ('reservation_id', '!=', False)]
            for quant in stock_quant_obj.search(cond):
                if quant.reservation_id.state not in ('cancel', 'done'):
                    raise exceptions.Warning(
                        _('Error! Serial Number/Lot "%s" currently has '
                          'reservations.')
                        % (lot.name))
        return self.write({'locked': True})

    @api.multi
    def button_unlock(self):
        return self.write({'locked': False})

    @api.model
    def create(self, vals):
        product = self.env['product.product'].browse(vals.get('product_id'))
        vals['locked'] = self._get_product_locked(product)
        return super(StockProductionLot, self).create(vals)

    @api.one
    def write(self, values):
        if 'product_id' in values:
            product = self.env['product.product'].browse(
                values.get('product_id'))
            values['locked'] = self._get_product_locked(product)
        return super(StockProductionLot, self).write(values)

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright: (c) 2017, F5 Networks Inc.
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['stableinterface'],
                    'supported_by': 'certified'}

DOCUMENTATION = r'''
---
module: bigip_wait
short_description: Wait for a BIG-IP condition before continuing
description:
  - You can wait for BIG-IP to be "ready". By "ready", we mean that BIG-IP is ready
    to accept configuration.
  - This module can take into account situations where the device is in the middle
    of rebooting due to a configuration change.
version_added: 2.5
options:
  timeout:
    description:
      - Maximum number of seconds to wait for.
      - When used without other conditions it is equivalent of just sleeping.
      - The default timeout is deliberately set to 2 hours because no individual
        REST API.
    type: int
    default: 7200
  delay:
    description:
      - Number of seconds to wait before starting to poll.
    type: int
    default: 0
  sleep:
    description:
      - Number of seconds to sleep between checks, before 2.3 this was hardcoded to 1 second.
    type: int
    default: 1
  msg:
    description:
      - This overrides the normal error message from a failure to meet the required conditions.
    type: str
extends_documentation_fragment: f5
author:
  - Tim Rupp (@caphrim007)
'''

EXAMPLES = r'''
- name: Wait for BIG-IP to be ready to take configuration
  bigip_wait:
    provider:
      password: secret
      server: lb.mydomain.com
      user: admin
  delegate_to: localhost

- name: Wait a maximum of 300 seconds for BIG-IP to be ready to take configuration
  bigip_wait:
    timeout: 300
    provider:
      password: secret
      server: lb.mydomain.com
      user: admin
  delegate_to: localhost

- name: Wait for BIG-IP to be ready, don't start checking for 10 seconds
  bigip_wait:
    delay: 10
    provider:
      password: secret
      server: lb.mydomain.com
      user: admin
  delegate_to: localhost
'''

RETURN = r'''
# only common fields returned
'''

import datetime
import signal
import time

from ansible.module_utils.basic import AnsibleModule

try:
    from library.module_utils.network.f5.bigip import F5RestClient
    from library.module_utils.network.f5.common import F5ModuleError
    from library.module_utils.network.f5.common import AnsibleF5Parameters
    from library.module_utils.network.f5.common import f5_argument_spec
except ImportError:
    from ansible.module_utils.network.f5.bigip import F5RestClient
    from ansible.module_utils.network.f5.common import F5ModuleError
    from ansible.module_utils.network.f5.common import AnsibleF5Parameters
    from ansible.module_utils.network.f5.common import f5_argument_spec


def hard_timeout(module, want, start):
    elapsed = datetime.datetime.utcnow() - start
    module.fail_json(
        msg=want.msg or "Timeout when waiting for BIG-IP", elapsed=elapsed.seconds
    )


class Parameters(AnsibleF5Parameters):
    returnables = [
        'elapsed'
    ]

    def to_return(self):
        result = {}
        try:
            for returnable in self.returnables:
                result[returnable] = getattr(self, returnable)
            result = self._filter_params(result)
        except Exception:
            pass
        return result

    @property
    def delay(self):
        if self._values['delay'] is None:
            return None
        return int(self._values['delay'])

    @property
    def timeout(self):
        if self._values['timeout'] is None:
            return None
        return int(self._values['timeout'])

    @property
    def sleep(self):
        if self._values['sleep'] is None:
            return None
        return int(self._values['sleep'])


class Changes(Parameters):
    pass


class ModuleManager(object):
    def __init__(self, *args, **kwargs):
        self.module = kwargs.get('module', None)
        self.client = F5RestClient(**self.module.params)
        self.have = None
        self.want = Parameters(params=self.module.params)
        self.changes = Parameters()

    def exec_module(self):
        result = dict()

        changed = self.execute()

        changes = self.changes.to_return()
        result.update(**changes)
        result.update(dict(changed=changed))
        self._announce_deprecations(result)
        return result

    def _announce_deprecations(self, result):
        warnings = result.pop('__warnings', [])
        for warning in warnings:
            self.module.deprecate(
                msg=warning['msg'],
                version=warning['version']
            )

    def _get_client_connection(self):
        return F5RestClient(**self.module.params)

    def execute(self):
        signal.signal(
            signal.SIGALRM,
            lambda sig, frame: hard_timeout(self.module, self.want, start)
        )

        # setup handler before scheduling signal, to eliminate a race
        signal.alarm(int(self.want.timeout))

        start = datetime.datetime.utcnow()
        if self.want.delay:
            time.sleep(float(self.want.delay))
        end = start + datetime.timedelta(seconds=int(self.want.timeout))
        while datetime.datetime.utcnow() < end:
            time.sleep(int(self.want.sleep))
            try:
                # The first test verifies that the REST API is available; this is done
                # by repeatedly trying to login to it.
                self.client = self._get_client_connection()
                if not self.client:
                    continue

                if self._device_is_rebooting():
                    # Wait for the reboot to happen and then start from the beginning
                    # of the waiting.
                    continue

                if self._is_mprov_running_on_device():
                    self._wait_for_module_provisioning()
                break
            except Exception as ex:
                if 'Failed to validate the SSL' in str(ex):
                    raise F5ModuleError(str(ex))

                # The types of exception's we're handling here are "REST API is not
                # ready" exceptions.
                #
                # For example,
                #
                # Typically caused by device starting up:
                #
                #   icontrol.exceptions.iControlUnexpectedHTTPError: 404 Unexpected Error:
                #       Not Found for uri: https://localhost:10443/mgmt/tm/sys/
                #   icontrol.exceptions.iControlUnexpectedHTTPError: 503 Unexpected Error:
                #       Service Temporarily Unavailable for uri: https://localhost:10443/mgmt/tm/sys/
                #
                #
                # Typically caused by a device being down
                #
                #   requests.exceptions.SSLError: HTTPSConnectionPool(host='localhost', port=10443):
                #       Max retries exceeded with url: /mgmt/tm/sys/ (Caused by SSLError(
                #       SSLError("bad handshake: SysCallError(-1, 'Unexpected EOF')",),))
                #
                #
                # Typically caused by device still booting
                #
                #   raise SSLError(e, request=request)\nrequests.exceptions.SSLError:
                #   HTTPSConnectionPool(host='localhost', port=10443): Max retries
                #   exceeded with url: /mgmt/shared/authn/login (Caused by
                #   SSLError(SSLError(\"bad handshake: SysCallError(-1, 'Unexpected EOF')\",),)),
                continue
        else:
            elapsed = datetime.datetime.utcnow() - start
            self.module.fail_json(
                msg=self.want.msg or "Timeout when waiting for BIG-IP", elapsed=elapsed.seconds
            )
        elapsed = datetime.datetime.utcnow() - start
        self.changes.update({'elapsed': elapsed.seconds})
        return False

    def _device_is_rebooting(self):
        params = {
            "command": "run",
            "utilCmdArgs": '-c "runlevel"'
        }
        uri = "https://{0}:{1}/mgmt/tm/util/bash".format(
            self.client.provider['server'],
            self.client.provider['server_port']
        )
        resp = self.client.api.post(uri, json=params)
        try:
            response = resp.json()
        except ValueError as ex:
            raise F5ModuleError(str(ex))
        if 'code' in response and response['code'] in [400, 403]:
            if 'message' in response:
                raise F5ModuleError(response['message'])
            else:
                raise F5ModuleError(resp.content)

        if 'commandResult' in response and '6' in response['commandResult']:
            return True
        return False

    def _wait_for_module_provisioning(self):
        # To prevent things from running forever, the hack is to check
        # for mprov's status twice. If mprov is finished, then in most
        # cases (not ASM) the provisioning is probably ready.
        nops = 0
        # Sleep a little to let provisioning settle and begin properly
        time.sleep(5)
        while nops < 4:
            try:
                if not self._is_mprov_running_on_device():
                    nops += 1
                else:
                    nops = 0
            except Exception as ex:
                # This can be caused by restjavad restarting.
                pass
            time.sleep(10)

    def _is_mprov_running_on_device(self):
        params = {
            "command": "run",
            "utilCmdArgs": '-c "ps aux | grep \'[m]prov\'"'
        }
        uri = "https://{0}:{1}/mgmt/tm/util/bash".format(
            self.client.provider['server'],
            self.client.provider['server_port']
        )
        resp = self.client.api.post(uri, json=params)
        try:
            response = resp.json()
        except ValueError as ex:
            raise F5ModuleError(str(ex))
        if 'code' in response and response['code'] in [400, 403]:
            if 'message' in response:
                raise F5ModuleError(response['message'])
            else:
                raise F5ModuleError(resp.content)

        if 'commandResult' in response:
            return True
        return False


class ArgumentSpec(object):
    def __init__(self):
        self.supports_check_mode = True
        argument_spec = dict(
            timeout=dict(default=7200, type='int'),
            delay=dict(default=0, type='int'),
            sleep=dict(default=1, type='int'),
            msg=dict()
        )
        self.argument_spec = {}
        self.argument_spec.update(f5_argument_spec)
        self.argument_spec.update(argument_spec)


def main():
    spec = ArgumentSpec()

    module = AnsibleModule(
        argument_spec=spec.argument_spec,
        supports_check_mode=spec.supports_check_mode
    )

    try:
        mm = ModuleManager(module=module)
        results = mm.exec_module()
        module.exit_json(**results)
    except F5ModuleError as ex:
        module.fail_json(msg=str(ex))


if __name__ == '__main__':
    main()

import math

from js_helper import _do_test_scope, _do_test_raw


INFINITY = float('inf')
NEG_INFINITY = float('-inf')


def test_abs():
    """Test that the abs() function works properly."""
    _do_test_scope("""
    var a = Math.abs(-5),
        b = Math.abs(5),
        c = Math.abs(-Infinity);
    """, {'a': 5,
          'b': 5,
          'c': INFINITY})

def test_exp():
    """Test that the exp() function works properly."""
    _do_test_scope("""
    var a = Math.exp(null),
        b = Math.exp(1) == Math.E,
        c = Math.exp(false),
        d = Math.exp('1') == Math.E,
        e = Math.exp('0'),
        f = Math.exp(0),
        g = Math.exp(-0),
        h = Math.exp(Infinity) == Infinity,
        i = Math.exp(-Infinity) == 0;

    """, {'a': 1,
          'b': True,
          'c': 1,
          'd': True,
          'e': 1,
          'f': 1,
          'g': 1,
          'h': True,
          'i': True})


def test_ceil():
    """Test that the feil() function works properly."""
    _do_test_scope("""
    var a = Math.ceil(null),
        b = Math.ceil(void 0),
        c = Math.ceil(true),
        d = Math.ceil(false),
        e = Math.ceil('1.1'),
        f = Math.ceil('-1.1'),
        g = Math.ceil('0.1'),
        h = Math.ceil('-0.1'),
        i = Math.ceil(0),
        // j = Math.ceil(-0),
        k = Math.ceil(-0) == -Math.floor(0),
        l = Math.ceil(Infinity),
        m = Math.ceil(Infinity) == -Math.floor(-Infinity),
        n = Math.ceil(-Infinity),
        o = Math.ceil(0.0000001),
        p = Math.ceil(-0.0000001);
    """, {'a': 0,
          'b': 0,
          'c': 1,
          'd': 0,
          'e': 2,
          'f': -1,
          'g': 1,
          'h': 0,
          'i': 0,
          # "j": -0,
          'k': True,
          'l': INFINITY,
          'm': True,
          'n': NEG_INFINITY,
          'o': 1,
          'p': 0})


def test_floor():
    """Test that the floor() function works properly."""
    _do_test_scope("""
    var a = Math.floor(null),
        b = Math.floor(void 0),
        c = Math.floor(true),
        d = Math.floor(false),
        e = Math.floor('1.1'),
        f = Math.floor('-1.1'),
        g = Math.floor('0.1'),
        h = Math.floor('-0.1'),
        i = Math.floor(0),
        // j = Math.floor(-0),
        k = Math.floor(-0) == -Math.ceil(0),
        l = Math.floor(Infinity),
        m = Math.floor(Infinity) == -Math.ceil(-Infinity),
        n = Math.floor(-Infinity),
        o = Math.floor(0.0000001),
        p = Math.floor(-0.0000001);
    """, {'a': 0,
          'b': 0,
          'c': 1,
          'd': 0,
          'e': 1,
          'f': -2,
          'g': 0,
          'h': -1,
          'i': 0,
          # "j": -0,
          'k': True,
          'l': INFINITY,
          'm': True,
          'n': NEG_INFINITY,
          'o': 0,
          'p': -1})


def test_trig():
    """Test the trigonometric functions."""

    _do_test_scope("""
    var pi = Math.PI;
    var cos_a = Math.cos(0),
        cos_b = Math.cos(Math.PI);
    var sin_a = Math.sin(0),
        sin_b = Math.sin(Math.PI);
    var tan_a = Math.tan(0),
        tan_b = Math.tan(Math.PI / 4);
    var acos_a = Math.acos(0) == Math.PI / 2,
        acos_b = Math.acos(1),
        acos_c = Math.acos(-1) == Math.PI;
    var asin_a = Math.asin(0),
        asin_b = Math.asin(1) == Math.PI / 2,
        asin_c = Math.asin(-1) == Math.PI / -2;
    var atan_a = Math.atan(0),
        atan_b = Math.atan(1) == Math.PI / 4,
        atan_c = Math.atan(Infinity) == Math.PI / 2;
    var atan2_a = Math.atan2(1, 0) == Math.PI / 2,
        atan2_b = Math.atan2(0, 0),
        atan2_c = Math.atan2(0, -1) == Math.PI;
    """, {'cos_a': 1,
          'cos_b': -1,
          'sin_a': 0,
          'sin_b': 0,
          'tan_a': 0,
          'tan_b': 1,
          'acos_a': True,
          'acos_b': 0,
          'acos_c': True,
          'asin_a': 0,
          'asin_b': True,
          'asin_c': True,
          'atan_a': 0,
          'atan_b': True,
          'atan_c': True,
          'atan2_a': True,
          'atan2_b': 0,
          'atan2_c': True})


def test_sqrt():
    """Test that the sqrt() function works properly."""

    _do_test_scope("""
    var a = Math.sqrt(10),
        b = Math.sqrt(4),
        c = Math.sqrt(3*3 + 4*4) == 5;
    """, {'a': round(math.sqrt(10), 5),
          'b': 2,
          'c': True})


def test_round():
    """Test that the round() function works properly."""

    _do_test_scope("""
    var a = Math.round('0.99999'),
        b = Math.round(0),
        c = Math.round(0.49),
        d = Math.round(0.5),
        e = Math.round(0.51),
        f = Math.round(-0.49),
        g = Math.round(-0.5),
        h = Math.round(-0.51),
        i = Math.round(Infinity) == Infinity,
        j = Math.round(-Infinity) == -Infinity;
    """, {'a': 1,
          'b': 0,
          'c': 0,
          'd': 1,
          'e': 1,
          'f': 0,
          'g': 0,
          'h': -1,
          'i': True,
          'j': True})


def test_random():
    """Test that the random() function works "properly"."""

    _do_test_scope("""
    var r = Math.random();
    """, {'r': 0.5})


def test_pow():
    """Test that the pow() function works properly."""

    _do_test_scope("""
    var a = Math.pow(true, false),
        b = Math.pow(2, 32),
        c = Math.pow(1.0000001, Infinity),
        d = Math.pow(1.0000001, -Infinity),
        e = Math.pow(123, 0);
    """, {'a': 1,
          'b': 4294967296,
          'c': INFINITY,
          'd': 0,
          'e': 1})


def test_log():
    """Test that the log() function works properly."""

    _do_test_scope("""
    var a = Math.log(1),
        b = Math.log(0),
        c = Math.log(Infinity),
        d = Math.log(-1);
    """, {'a': 0,
          'b': NEG_INFINITY,
          'c': INFINITY,
          'd': None})


def test_min_max():
    """Test that the min() and max() function works properly."""

    _do_test_scope("""
    var min_a = Math.min(Infinity, -Infinity),
        min_b = Math.min(1, -1);
    var max_a = Math.max(Infinity, -Infinity),
        max_b = Math.max(1, -1);
    """, {'min_a': NEG_INFINITY,
          'min_b': -1,
          'max_a': INFINITY,
          'max_b': 1})


def test_math_infinity():
    """Test for known tracebacks regarding math."""
    _do_test_raw("""
    var x = Infinity;
    x >>= 10;
    var y = Infinity;
    var z = 10 >> y;
    """)
    # We really don't care about the output here.


# -*- coding: utf-8 -*-
import datetime

from os.path import abspath, basename, dirname, join, normpath
from sys import path

from django.core.urlresolvers import reverse_lazy

from configurations import Configuration, values
from postgresify import postgresify


class Base(Configuration):
    # Path Configuration.
    # --------------------------------------------------------------------------
    DJANGO_ROOT = dirname(dirname(abspath(__file__)))
    PROJECT_ROOT = dirname(DJANGO_ROOT)
    PROJECT_NAME = basename(DJANGO_ROOT)

    # Installed Applications.
    # --------------------------------------------------------------------------
    DJANGO = [
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.humanize',
        'django.contrib.messages',
        'django.contrib.sessions',
        'django.contrib.sitemaps',
        'django.contrib.sites',
        'django.contrib.staticfiles',
    ]
    COMPONENTS = [
        'apps.accounts',
        'apps.appearances',
        'apps.correlations',
        'apps.events',
        'apps.prose',
        'apps.history',
        'apps.merchandise',
        'apps.merchandise.goods',
        'apps.merchandise.media',
        'apps.merchandise.music',
        'apps.merchandise.stores',
        'apps.news',
        'apps.people',
        'apps.social.twitter',
        'apps.social.youtube',
    ]
    PLUGINS = [
        'imagekit',
        'markdown_deux',
        'typogrify',
    ]
    ADMINISTRATION = [
        # 'grappelli.dashboard',
        'grappelli',
        'django.contrib.admin',
    ]
    INSTALLED_APPS = DJANGO + COMPONENTS + PLUGINS + ADMINISTRATION

    # Middleware Configuration.
    # --------------------------------------------------------------------------
    MIDDLEWARE_CLASSES = (
        'django.middleware.gzip.GZipMiddleware',
        'django.middleware.common.CommonMiddleware',
        'django.contrib.sessions.middleware.SessionMiddleware',
        'django.middleware.csrf.CsrfViewMiddleware',
        'django.contrib.auth.middleware.AuthenticationMiddleware',
        'django.contrib.messages.middleware.MessageMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',
    )

    # Debug Settings.
    # --------------------------------------------------------------------------
    DEBUG = values.BooleanValue(True)
    TEMPLATE_DEBUG = values.BooleanValue(DEBUG)

    # Secret Key Configuration.
    # --------------------------------------------------------------------------
    SECRET_KEY = '@5zyl)e#a#xmgzg*_%7=$m#kbvc%mi%j-+b(13yaml!dre7l!u'

    # Manager Configuration.
    # --------------------------------------------------------------------------
    ADMINS = [('Bryan Veloso', 'bryan@hello-base.com')]
    MANAGERS = [('Jennifer Veloso', 'jen@hello-base.com')]

    # Database Configuration.
    # --------------------------------------------------------------------------
    DATABASES = postgresify()

    # Caching Configuration.
    # --------------------------------------------------------------------------
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
            'LOCATION': ''
        }
    }

    # Session Configuration.
    # --------------------------------------------------------------------------
    SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'

    # General Configuration.
    # --------------------------------------------------------------------------
    DATE_FORMAT = 'Y/m/d'
    LANGUAGE_CODE = 'en-us'
    SITE_ID = 1
    TIME_ZONE = 'Asia/Tokyo'
    USE_I18N = True
    USE_L10N = True
    USE_TZ = True

    # Template Configuration.
    # --------------------------------------------------------------------------
    TEMPLATE_CONTEXT_PROCESSORS = (
        'django.contrib.auth.context_processors.auth',
        'django.core.context_processors.debug',
        'django.core.context_processors.i18n',
        'django.core.context_processors.media',
        'django.core.context_processors.static',
        'django.core.context_processors.request',
        'django.core.context_processors.tz',
        'django.contrib.messages.context_processors.messages',
    )
    TEMPLATE_DIRS = (normpath(join(PROJECT_ROOT, 'templates')),)
    TEMPLATE_LOADERS = (
        'django.template.loaders.filesystem.Loader',
        'django.template.loaders.app_directories.Loader',
    )

    # Static File Configuration.
    # --------------------------------------------------------------------------
    STATICFILES_STORAGE = 'whitenoise.django.GzipManifestStaticFilesStorage'
    STATIC_ROOT = 'staticfiles'
    STATIC_URL = '/static/'
    STATICFILES_DIRS = [normpath(join(PROJECT_ROOT, 'static'))]
    STATICFILES_FINDERS = (
        'django.contrib.staticfiles.finders.FileSystemFinder',
        'django.contrib.staticfiles.finders.AppDirectoriesFinder',
    )

    # Media Configuration.
    # --------------------------------------------------------------------------
    MEDIA_ROOT = 'media'
    MEDIA_URL = '/media/'

    # URL Configuration.
    # --------------------------------------------------------------------------
    ROOT_URLCONF = '%s.urls' % PROJECT_NAME
    WSGI_APPLICATION = 'wsgi.application'

    # Authentication Configuration.
    # --------------------------------------------------------------------------
    AUTHENTICATION_BACKENDS = (
        'apps.accounts.backends.HelloBaseIDBackend',
        'django.contrib.auth.backends.ModelBackend',
    )
    HELLO_BASE_CLIENT_ID = values.Value('', environ_prefix=None)
    HELLO_BASE_CLIENT_SECRET = values.Value('', environ_prefix=None)
    LOGIN_URL = reverse_lazy('oauth-authorize')
    # LOGOUT_URL = 'oauth-deauthorize'

    # Custom User Application Defaults.
    # --------------------------------------------------------------------------
    AUTH_USER_MODEL = 'accounts.editor'

    # Logging Configuration.
    # --------------------------------------------------------------------------
    # See: https://docs.djangoproject.com/en/dev/ref/settings/#logging
    # A sample logging configuration. The only tangible logging
    # performed by this configuration is to send an email to
    # the site admins on every HTTP 500 error when DEBUG=False.
    # See http://docs.djangoproject.com/en/dev/topics/logging for
    # more details on how to customize your logging configuration.
    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'filters': {
            'require_debug_false': {
                '()': 'django.utils.log.RequireDebugFalse'
            }
        },
        'handlers': {
            'mail_admins': {
                'level': 'ERROR',
                'filters': ['require_debug_false'],
                'class': 'django.utils.log.AdminEmailHandler'
            }
        },
        'loggers': {
            'django.request': {
                'handlers': ['mail_admins'],
                'level': 'ERROR',
                'propagate': True,
            },
        }
    }

    # django-celery.
    # --------------------------------------------------------------------------
    CELERY_ACCEPT_CONTENT = ['json']
    CELERY_TASK_SERIALIZER = 'json'
    CELERY_RESULT_SERIALIZER = 'json'
    CELERY_TASK_RESULT_EXPIRES = datetime.timedelta(minutes=30)  # http://celery.readthedocs.org/en/latest/configuration.html#celery-task-result-expires
    CELERY_CHORD_PROPAGATES = True  # http://docs.celeryproject.org/en/master/configuration.html#std:setting-CELERY_CHORD_PROPAGATES

    # django-grappelli.
    # --------------------------------------------------------------------------
    GRAPPELLI_ADMIN_TITLE = 'Hello! Base Administration'
    # GRAPPELLI_INDEX_DASHBOARD = 'apps.dashboard.CustomIndexDashboard'

    # django-haystack.
    # --------------------------------------------------------------------------
    INSTALLED_APPS += ['haystack']
    HAYSTACK_SEARCH_RESULTS_PER_PAGE = 25
    HAYSTACK_SIGNAL_PROCESSOR = 'haystack.signals.RealtimeSignalProcessor'

    # apps.socialize.
    # --------------------------------------------------------------------------
    TWITTER_CONSUMER_KEY = values.SecretValue(environ_prefix=None)
    TWITTER_CONSUMER_SECRET = values.SecretValue(environ_prefix=None)
    TWITTER_OAUTH_TOKEN = values.SecretValue(environ_prefix=None)
    TWITTER_OAUTH_SECRET = values.SecretValue(environ_prefix=None)
    YOUTUBE_DEVELOPER_KEY = values.SecretValue(environ_prefix=None)

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

import product_stock
import picking
import lot_overview_all
import report_stock
import report_stock_move
import stock_inventory_move_report
import lot_overview


# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

# (c) 2018 Extreme Networks Inc.
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os
import json

from units.modules.utils import AnsibleExitJson, AnsibleFailJson, ModuleTestCase


fixture_path = os.path.join(os.path.dirname(__file__), 'fixtures')
fixture_data = {}


def load_fixture(name):
    path = os.path.join(fixture_path, name)

    if path in fixture_data:
        return fixture_data[path]

    with open(path) as file_desc:
        data = file_desc.read()

    try:
        data = json.loads(data)
    except:
        pass

    fixture_data[path] = data
    return data


class TestExosModule(ModuleTestCase):

    def execute_module(self, failed=False, changed=False, commands=None, sort=True, defaults=False):

        self.load_fixtures(commands)

        if failed:
            result = self.failed()
            self.assertTrue(result['failed'], result)
        else:
            result = self.changed(changed)
            self.assertEqual(result['changed'], changed, result)

        if commands is not None:
            if sort:
                self.assertEqual(sorted(commands), sorted(result['commands']), result['commands'])
            else:
                self.assertEqual(commands, result['commands'], result['commands'])

        return result

    def failed(self):
        with self.assertRaises(AnsibleFailJson) as exc:
            self.module.main()

        result = exc.exception.args[0]
        self.assertTrue(result['failed'], result)
        return result

    def changed(self, changed=False):
        with self.assertRaises(AnsibleExitJson) as exc:
            self.module.main()

        result = exc.exception.args[0]
        self.assertEqual(result['changed'], changed, result)
        return result

    def load_fixtures(self, commands=None):
        pass

from __future__ import absolute_import

import six

from apscheduler.jobstores.base import BaseJobStore, JobLookupError, ConflictingIdError
from apscheduler.util import datetime_to_utc_timestamp, utc_timestamp_to_datetime
from apscheduler.job import Job

try:
    import cPickle as pickle
except ImportError:  # pragma: nocover
    import pickle

try:
    from redis import StrictRedis
except ImportError:  # pragma: nocover
    raise ImportError('RedisJobStore requires redis installed')


class RedisJobStore(BaseJobStore):
    """
    Stores jobs in a Redis database. Any leftover keyword arguments are directly passed to redis's StrictRedis.

    Plugin alias: ``redis``

    :param int db: the database number to store jobs in
    :param str jobs_key: key to store jobs in
    :param str run_times_key: key to store the jobs' run times in
    :param int pickle_protocol: pickle protocol level to use (for serialization), defaults to the highest available
    """

    def __init__(self, db=0, jobs_key='apscheduler.jobs', run_times_key='apscheduler.run_times',
                 pickle_protocol=pickle.HIGHEST_PROTOCOL, **connect_args):
        super(RedisJobStore, self).__init__()

        if db is None:
            raise ValueError('The "db" parameter must not be empty')
        if not jobs_key:
            raise ValueError('The "jobs_key" parameter must not be empty')
        if not run_times_key:
            raise ValueError('The "run_times_key" parameter must not be empty')

        self.pickle_protocol = pickle_protocol
        self.jobs_key = jobs_key
        self.run_times_key = run_times_key
        self.redis = StrictRedis(db=int(db), **connect_args)

    def lookup_job(self, job_id):
        job_state = self.redis.hget(self.jobs_key, job_id)
        return self._reconstitute_job(job_state) if job_state else None

    def get_due_jobs(self, now):
        timestamp = datetime_to_utc_timestamp(now)
        job_ids = self.redis.zrangebyscore(self.run_times_key, 0, timestamp)
        if job_ids:
            job_states = self.redis.hmget(self.jobs_key, *job_ids)
            return self._reconstitute_jobs(six.moves.zip(job_ids, job_states))
        return []

    def get_next_run_time(self):
        next_run_time = self.redis.zrange(self.run_times_key, 0, 0, withscores=True)
        if next_run_time:
            return utc_timestamp_to_datetime(next_run_time[0][1])

    def get_all_jobs(self):
        job_states = self.redis.hgetall(self.jobs_key)
        jobs = self._reconstitute_jobs(six.iteritems(job_states))
        return sorted(jobs, key=lambda job: job.next_run_time)

    def add_job(self, job):
        if self.redis.hexists(self.jobs_key, job.id):
            raise ConflictingIdError(job.id)

        with self.redis.pipeline() as pipe:
            pipe.multi()
            pipe.hset(self.jobs_key, job.id, pickle.dumps(job.__getstate__(), self.pickle_protocol))
            pipe.zadd(self.run_times_key, datetime_to_utc_timestamp(job.next_run_time), job.id)
            pipe.execute()

    def update_job(self, job):
        if not self.redis.hexists(self.jobs_key, job.id):
            raise JobLookupError(job.id)

        with self.redis.pipeline() as pipe:
            pipe.hset(self.jobs_key, job.id, pickle.dumps(job.__getstate__(), self.pickle_protocol))
            if job.next_run_time:
                pipe.zadd(self.run_times_key, datetime_to_utc_timestamp(job.next_run_time), job.id)
            else:
                pipe.zrem(self.run_times_key, job.id)
            pipe.execute()

    def remove_job(self, job_id):
        if not self.redis.hexists(self.jobs_key, job_id):
            raise JobLookupError(job_id)

        with self.redis.pipeline() as pipe:
            pipe.hdel(self.jobs_key, job_id)
            pipe.zrem(self.run_times_key, job_id)
            pipe.execute()

    def remove_all_jobs(self):
        with self.redis.pipeline() as pipe:
            pipe.delete(self.jobs_key)
            pipe.delete(self.run_times_key)
            pipe.execute()

    def shutdown(self):
        self.redis.connection_pool.disconnect()

    def _reconstitute_job(self, job_state):
        job_state = pickle.loads(job_state)
        job = Job.__new__(Job)
        job.__setstate__(job_state)
        job._scheduler = self._scheduler
        job._jobstore_alias = self._alias
        return job

    def _reconstitute_jobs(self, job_states):
        jobs = []
        failed_job_ids = []
        for job_id, job_state in job_states:
            try:
                jobs.append(self._reconstitute_job(job_state))
            except:
                self._logger.exception('Unable to restore job "%s" -- removing it', job_id)
                failed_job_ids.append(job_id)

        # Remove all the jobs we failed to restore
        if failed_job_ids:
            with self.redis.pipeline() as pipe:
                pipe.hdel(self.jobs_key, *failed_job_ids)
                pipe.zrem(self.run_times_key, *failed_job_ids)
                pipe.execute()

        return jobs

    def __repr__(self):
        return '<%s>' % self.__class__.__name__

#!/usr/bin/python
#
#  texture_builder.py
#  CSTest
#  Created by Scott Downie on 30/06/2014.
#
#  The MIT License (MIT)
#
#  Copyright (c) 2014 Tag Games Limited
#
#  Permission is hereby granted, free of charge, to any person obtaining a copy
#  of this software and associated documentation files (the "Software"), to deal
#  in the Software without restriction, including without limitation the rights
#  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
#  copies of the Software, and to permit persons to whom the Software is
#  furnished to do so, subject to the following conditions:
#
#  The above copyright notice and this permission notice shall be included in
#  all copies or substantial portions of the Software.
#
#  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
#  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
#  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
#  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
#  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
#  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
#  THE SOFTWARE.
#

import argparse
import os
import shutil
import subprocess
import sys

import file_system_utils

RELATIVE_TOOL_FILE_PATH = "../../ChilliSource/Tools/PNGToCSImage.jar"

#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
def build(input_directory_path, output_directory_path):
    """
    Walks the input directory and converts all pngs into csimages
    
    :Authors: S Downie
    
    :param input_directory_path: The input directory path.
    :param output_directory_path: The output directory path.
    """
    print("-----------------------------------------")
    print("           Building Textures")
    print("-----------------------------------------")

    file_system_utils.delete_directory(output_directory_path)

    for current_input_directory_path, sub_input_directory_paths, file_names in os.walk(input_directory_path):
        current_output_directory_path = os.path.join(output_directory_path, current_input_directory_path[len(input_directory_path):]);

        for file_name in file_names:
            if file_system_utils.has_extension(file_name, ".png"):
                if os.path.exists(current_output_directory_path) == False:
                    os.makedirs(current_output_directory_path);

                input_file_path = os.path.join(current_input_directory_path, file_name)
                output_file_path = os.path.splitext(os.path.join(current_output_directory_path, file_name))[0] + ".csimage"
                build_texture(input_file_path, output_file_path)

    print (" ")
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
def build_texture(input_file_path, output_file_path):
    """
    Converts a single PNG to a csimage
    
    :Authors: S Downie
    
    :param input_file_path: The input file path.
    :param output_file_path: The output file path.
    """
    print(output_file_path)

    tool_file_path = file_system_utils.get_path_from_here(RELATIVE_TOOL_FILE_PATH)
    tool_args = ["java", "-Djava.awt.headless=true", "-Xmx512m", "-jar", tool_file_path, "--input", input_file_path, "--output", output_file_path];
    subprocess.call(tool_args);
#------------------------------------------------------------------------------ 
#------------------------------------------------------------------------------ 
def parse_arguments():
    """
    Parses the given argument list.
    
    :Authors: Ian Copland
    
    :returns: A container for the parsed arguments.
    """
    script_desc = 'Converts all xls files in the input directory to cstext format and outputs them to the given output directory. Sub directories will be recursed.'
    
    parser = argparse.ArgumentParser(description=script_desc)
    parser.add_argument('-i', '--input', dest='input_directory_path', type=str, required=True, help="The input directory containing xls files.")
    parser.add_argument('-o', '--output', dest='output_directory_path', type=str, required=True, help="The output directory where the output cstext files should be saved.")
    
    return parser.parse_args()
#------------------------------------------------------------------------------ 
#------------------------------------------------------------------------------ 
if __name__ == "__main__":
    args = parse_arguments();
    build(args.input_directory_path, args.output_directory_path)


"""
PageRank Algorithm
"""
__author__="Utkarsh J"

from collections import defaultdict, OrderedDict
import itertools
import math
import pdb
import operator

IN_DICT = defaultdict(list) # default graph representation
OUT_DICT = defaultdict(int) # dictionary maintaining total unique outlinks
TOTALIL_DICT = defaultdict(int) # total inlink dictionary
PAGE_RANK = defaultdict(float) # Dictionary maintaining page ranks 
NEW_PAGE_RANK = defaultdict(float) # Dictionary maintaining temporary new page ranks
teleportation_factor = 0.85 
perplexity = [] # List maintaining perplexity 
sink_nodes =  [] # Sink nodes 

def get_outlinks():
	""" Gets page and generates hash for outlinks
	"""
	for page in IN_DICT.keys():
		OUT_DICT[page] = 0
	for page in IN_DICT.keys():
		for in_nodes in set(IN_DICT[page]): # set because we do not want duplicates
			OUT_DICT[in_nodes] += 1 

def get_perplexity():
	""" Calculates Perplexity for the current Page Ranks
	"""
	entropy = 0
	for page in PAGE_RANK.keys():
		entropy += PAGE_RANK[page]*math.log(1.0/PAGE_RANK[page],2)
	return 2 ** entropy

def is_converged():
	""" True if it converges , False otherwise
	"""
	first_diff = round(perplexity[-4]) 
	second_diff = round(perplexity[-3])
	third_diff = round(perplexity[-2])
	fourth_diff = round(perplexity[-1])
	return (first_diff == second_diff == third_diff == fourth_diff)

def main(file_path):
	"""
	Argument :
		file_path - path of file from which in link data is to be read
	"""
	# Read input and store it in adjacency list
	with open(file_path, 'r') as file_object:
		for line in file_object.readlines():
			in_elements =  line.strip().split(' ')
			# hashmap for in link dictionary
			# Approach 2 - remove self links 
			# if in_elements[0] in in_elements[1: ]:
			# 	temp_list = [x for x in in_elements[1:] if x != in_elements[0]]
			# else:
			temp_list = in_elements[1:]
			# this may contain duplicates
			IN_DICT[in_elements[0]] = temp_list

	# Calculate sources
	total_sources = 0
	for i in IN_DICT.keys():
		if len(IN_DICT[i]) == 0:
			total_sources += 1

	get_outlinks()

	# Calculate sinks
	for page in OUT_DICT:
		if OUT_DICT[page] == 0:
			sink_nodes.append(page)

	# Calculate total pages
	total_no_pages =  len(IN_DICT)

	# Assign initial page rank
	for page in IN_DICT.keys():
		PAGE_RANK[page] =  1.0/total_no_pages

	# FOR SMALL GRAPH GIVEN IN EXAMPLE
	# A D E F
	# B A F
	# C A B D
	# D B C
	# E B C D F
	# F A B D
	if file_path == "small_graph.txt":
		for i in range (1, 101):
			# calculate Sink PR
			sinkPR = 0
			for page in sink_nodes:
				sinkPR += PAGE_RANK[page]

			# teleportation and spread remaining sink PR evenly
			for page in IN_DICT.keys():
				NEW_PAGE_RANK[page] = (1.0 - teleportation_factor) / total_no_pages
				NEW_PAGE_RANK[page] += teleportation_factor * sinkPR / total_no_pages
				for in_node in IN_DICT[page]:			
					NEW_PAGE_RANK[page] += teleportation_factor * PAGE_RANK[in_node] / OUT_DICT[in_node]
			for page in IN_DICT.keys():
				PAGE_RANK[page] = NEW_PAGE_RANK[page]

			if i in [1, 10, 100]:
				with open('output_first.txt', 'a') as file_object:
					file_object.write('For ' + str(i) + '\n')
					for page in IN_DICT.keys():
						file_object.write('For ' + str(page) + ' page rank = ' + str(PAGE_RANK[page]) + '\n')
	else: # for the WT2g inlinks.
		def _should_continue():
			""" Checks if perplexity converges 
			"""
			if len(perplexity) < 5:
				return True
			else:
				return not is_converged()

		while(_should_continue()):
			# calculate Sink PR
			sinkPR = 0
			for page in sink_nodes:
				sinkPR += PAGE_RANK[page]

			# teleportation and spread remaining sink PR evenly
			for page, in_nodes in IN_DICT.iteritems():
				NEW_PAGE_RANK[page] = (1 - teleportation_factor) / total_no_pages
				NEW_PAGE_RANK[page] += teleportation_factor * sinkPR / total_no_pages
				for in_node in set(IN_DICT[page]):			
					NEW_PAGE_RANK[page] += teleportation_factor * PAGE_RANK[in_node]/ OUT_DICT[in_node]
			for page in IN_DICT.keys():
				PAGE_RANK[page] = NEW_PAGE_RANK[page]
			
			perplexity.append(get_perplexity())


		with open('output_second.txt', 'a') as file_object:
			file_object.write("A list of the perplexity values you obtain in each round until convergence \n")
			for value in perplexity:
				file_object.write(str(perplexity.index(value))+ " " + str(value) + "\n")

		with open('output_third.txt', 'a') as file_object:
			SortedPR = OrderedDict(sorted(PAGE_RANK.iteritems(), key=operator.itemgetter(1), reverse=True))
			file_object.write("A list of the document IDs of the top 50 pages as sorted by PageRank, together with their PageRank values \n")
			count = 1
			for page, value in SortedPR.items():
				file_object.write(str(count) + ". " + str(page) + " " + str(value) + "\n")
				count =  count + 1
				if count == 51:
					break

			file_object.write("\n\nA list of the document IDs of the top 50 pages as sorted by InLinks, together with their in links values \n")
			for page, value in IN_DICT.items():
				TOTALIL_DICT[page] = len(value)

			count = 1
			SortedIL = OrderedDict(sorted(TOTALIL_DICT.iteritems(), key=operator.itemgetter(1), reverse=True))
			for page, value in SortedIL.items():
				file_object.write(str(count) + ". " + str(page) + " " + str(value) + "\n")
				count  = count + 1
				if count == 51:
					break

			file_object.write("\n\n The proportion of pages with no in links\n")
			file_object.write("= " + str(total_sources) + "/" + str(total_no_pages) + " = " + str(float(total_sources)/float(total_no_pages)))

			file_object.write("\n\n The proportion of pages with no out links\n")
			file_object.write("= " + str(len(sink_nodes)) + "/" + str(total_no_pages) + " = " + str(float(len(sink_nodes))/float(total_no_pages)))

			initialPR = 1.0/total_no_pages
			temp_count = 0.0
			for page,value in PAGE_RANK.items():
				if value < initialPR:
					temp_count += 1
			
			file_object.write("\n\nthe proportion of pages whose PageRank is less than their initial uniform values \n")
			file_object.write("= " + str(temp_count) + "/" + str(total_no_pages) + " = " + str(temp_count/total_no_pages))

# Main call of the program				
main("small_graph.txt")
main('in_link.txt')
from rest_framework import viewsets
from rest_framework.decorators import list_route
from rest_framework.response import Response

from models import Allowance, Transaction
from serializers import TransactionSerializer, AllowanceTransactionSerializer


class TransactionViewSet(viewsets.ModelViewSet):
    '''
    Transactions not associated with an allowance
    '''
    queryset = Transaction.objects.without_allowance()
    serializer_class = TransactionSerializer

    def get_queryset(self, *args, **kwargs):
        return self.queryset.today()


class AllowanceTransactionViewSet(viewsets.ModelViewSet):
    '''
    Transactions associated with the current user's allowance
    '''
    queryset = Transaction.objects.with_allowance()
    serializer_class = AllowanceTransactionSerializer

    def get_users_allowance(self):
        return Allowance.objects.get(user=self.request.user)

    def get_queryset(self, *args, **kwargs):
        qs = super(AllowanceTransactionViewSet, self).get_queryset(*args, **
                                                                   kwargs)
        return qs.filter(allowance=self.get_users_allowance()).last_month()

    @list_route(methods=['get'])
    def total(self, *args, **kwargs):
        everything = self.queryset.filter(allowance=self.get_users_allowance())
        return Response({'balance': everything.total()})

#
# Author: Gregory Fleischer (gfleischer@gmail.com)
#
# Copyright (c) 2011 RAFT Team
#
# This file is part of RAFT.
#
# RAFT is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# RAFT is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with RAFT.  If not, see <http://www.gnu.org/licenses/>.
#

from .BaseExtractor import BaseExtractor
from .JSParser import JSParser
from .JSLiteParser import JSLiteParser
from urllib import parse as urlparse
import re

class JSParseResults():
    def __init__(self, baseurl, encoding):
        self.baseurl = baseurl
        self.encoding = encoding
        self.comments = []
        self.strings = []
        self.relative_links = []
        self.links = []

    def resolve_url(self, uri):
        splitted = urlparse.urlsplit(uri)
        if not splitted.scheme and splitted.path and not splitted.path.startswith('/'):
            if splitted.path not in self.relative_links:
                self.relative_links.append(splitted.path)
        # TODO: urljoin doesn't understand example.com/foo relative links
        resolved = urlparse.urljoin(self.baseurl, uri)
        return resolved

    def add_strings(self, strings):
        for string in strings:
            if not string in self.strings:
                self.strings.append(string)

    def add_comments(self, comments):
        for comment in comments:
            if not comment in self.comments:
                self.comments.append(comment)

    def add_relative_uri(self, uri):
        if '//' == uri:
            # ignore comments
            return
        if uri not in self.relative_links:
            self.relative_links.append(uri)

    def add_uri(self, uri):
        resolved = self.resolve_url(uri)
        if resolved not in self.links:
            self.links.append(resolved)


class JSExtractor(BaseExtractor):
    def __init__(self):
        BaseExtractor.__init__(self)
        self.jsParser = JSLiteParser()

    def process(self, script, baseurl, encoding = 'utf-8', results = None):

        if results is None:
            results = JSParseResults(script, baseurl)

        self.jsParser.parse_file(script, '', 0)
        comments = self.jsParser.comments()
        strings = self.jsParser.strings()
        results.add_comments(comments)
        results.add_strings(strings)

        for string in strings:
            for line in string.splitlines():
                match = self.re_full_url.search(line)
                if match:
                    results.add_uri(match.group(0))
                else:
                    match = self.re_relative_url.search(line)
                    if match:
                        results.add_relative_uri(match.group(0))

        for comment in comments:
            if comment.startswith('/*') or comment.startswith('//'):
                comment = comment[2:]
            for line in comment.splitlines():
                match = self.re_full_url.search(line)
                if match:
                    results.add_uri(match.group(0))
                else:
                    match = self.re_relative_url.search(line)
                    if match:
                        results.add_relative_uri(match.group(0))

        return results
        
if '__main__' == __name__:

    import sys
    filename = sys.argv[1]
    url = sys.argv[2]
    contents = open(filename).read()
    
    extractor = JSExtractor()
    results = extractor.process(contents, url)

    for link in results.links:
        print(('link: %s' % link))

    for link in results.relative_links:
        print(('relative link: %s' % link))


# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for ragged.size."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from absl.testing import parameterized

from tensorflow.python.framework import test_util
from tensorflow.python.ops.ragged import ragged_array_ops
from tensorflow.python.ops.ragged import ragged_factory_ops
from tensorflow.python.platform import googletest


@test_util.run_all_in_graph_and_eager_modes
class RaggedSizeOpTest(test_util.TensorFlowTestCase,
                       parameterized.TestCase):

  @parameterized.parameters([
      {'size': 1, 'test_input': 1},
      {'size': 0, 'test_input': []},
      {'size': 0, 'test_input': [], 'ragged_rank': 1},
      {'size': 3, 'test_input': [1, 1, 1]},
      {'size': 3, 'test_input': [[1, 1], [1]]},
      {'size': 5, 'test_input': [[[1, 1, 1], [1]], [[1]]]},
      {'size': 6, 'test_input': [[[1, 1], [1, 1]], [[1, 1]]], 'ragged_rank': 1},
  ])
  def testRaggedSize(self, test_input, size, ragged_rank=None):
    input_rt = ragged_factory_ops.constant(test_input, ragged_rank=ragged_rank)
    self.assertAllEqual(ragged_array_ops.size(input_rt), size)

if __name__ == '__main__':
  googletest.main()

# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------

from .databases_operations import DatabasesOperations
from .recoverable_databases_operations import RecoverableDatabasesOperations
from .restorable_dropped_databases_operations import RestorableDroppedDatabasesOperations
from .capabilities_operations import CapabilitiesOperations
from .servers_operations import ServersOperations
from .firewall_rules_operations import FirewallRulesOperations
from .elastic_pools_operations import ElasticPoolsOperations
from .operations import Operations
from .recommended_elastic_pools_operations import RecommendedElasticPoolsOperations
from .server_azure_ad_administrators_operations import ServerAzureADAdministratorsOperations
from .server_communication_links_operations import ServerCommunicationLinksOperations
from .failover_groups_operations import FailoverGroupsOperations
from .virtual_network_rules_operations import VirtualNetworkRulesOperations
from .server_keys_operations import ServerKeysOperations

__all__ = [
    'DatabasesOperations',
    'RecoverableDatabasesOperations',
    'RestorableDroppedDatabasesOperations',
    'CapabilitiesOperations',
    'ServersOperations',
    'FirewallRulesOperations',
    'ElasticPoolsOperations',
    'Operations',
    'RecommendedElasticPoolsOperations',
    'ServerAzureADAdministratorsOperations',
    'ServerCommunicationLinksOperations',
    'FailoverGroupsOperations',
    'VirtualNetworkRulesOperations',
    'ServerKeysOperations',
]

# Copyright (c) 2012 Mitch Garnaat http://garnaat.org/
# Copyright (c) 2012 Amazon.com, Inc. or its affiliates.
# All rights reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish, dis-
# tribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the fol-
# lowing conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.

"""
Check that all of the certs on all service endpoints validate.
"""
import unittest

from tests.integration import ServiceCertVerificationTest

import boto.dynamodb


class DynamoDBCertVerificationTest(unittest.TestCase, ServiceCertVerificationTest):
    dynamodb = True
    regions = boto.dynamodb.regions()

    def sample_service_call(self, conn):
        conn.layer1.list_tables()

# -*- encoding: utf-8 -*-
# This file is distributed under the same license as the Django package.
#
from __future__ import unicode_literals

# The *_FORMAT strings use the Django date format syntax,
# see http://docs.djangoproject.com/en/dev/ref/templates/builtins/#date
DATE_FORMAT = 'd. F Y'
TIME_FORMAT = 'H:i'
DATETIME_FORMAT = 'j. F Y. H:i'
YEAR_MONTH_FORMAT = 'F Y'
MONTH_DAY_FORMAT = 'j. F'
SHORT_DATE_FORMAT = 'j. M. Y'
SHORT_DATETIME_FORMAT = 'j.n.Y. H:i'
FIRST_DAY_OF_WEEK = 0

# The *_INPUT_FORMATS strings use the Python strftime format syntax,
# see http://docs.python.org/library/datetime.html#strftime-strptime-behavior
DATE_INPUT_FORMATS = [
    '%d.%m.%Y', '%d.%m.%y',         # '25.10.2006', '25.10.06'
    '%d-%m-%Y',                     # '25-10-2006'
    '%d. %m. %Y', '%d. %m. %y',     # '25. 10. 2006', '25. 10. 06'
]

DATETIME_INPUT_FORMATS = [
    '%d.%m.%Y %H:%M:%S',            # '25.10.2006 14:30:59'
    '%d.%m.%Y %H:%M:%S.%f',         # '25.10.2006 14:30:59.000200'
    '%d.%m.%Y %H:%M',               # '25.10.2006 14:30'
    '%d.%m.%Y',                     # '25.10.2006'
    '%d.%m.%y %H:%M:%S',            # '25.10.06 14:30:59'
    '%d.%m.%y %H:%M:%S.%f',         # '25.10.06 14:30:59.000200'
    '%d.%m.%y %H:%M',                # '25.10.06 14:30'
    '%d.%m.%y',                     # '25.10.06'
    '%d-%m-%Y %H:%M:%S',            # '25-10-2006 14:30:59'
    '%d-%m-%Y %H:%M:%S.%f',         # '25-10-2006 14:30:59.000200'
    '%d-%m-%Y %H:%M',               # '25-10-2006 14:30'
    '%d-%m-%Y',                     # '25-10-2006'
    '%d. %m. %Y %H:%M:%S',          # '25. 10. 2006 14:30:59'
    '%d. %m. %Y %H:%M:%S.%f',       # '25. 10. 2006 14:30:59.000200'
    '%d. %m. %Y %H:%M',             # '25. 10. 2006 14:30'
    '%d. %m. %Y',                   # '25. 10. 2006'
    '%d. %m. %y %H:%M:%S',          # '25. 10. 06 14:30:59'
    '%d. %m. %y %H:%M:%S.%f',       # '25. 10. 06 14:30:59.000200'
    '%d. %m. %y %H:%M',             # '25. 10. 06 14:30'
    '%d. %m. %y',                   # '25. 10. 06'
]

DECIMAL_SEPARATOR = ','
THOUSAND_SEPARATOR = '.'
NUMBER_GROUPING = 3

"""Support for De Lijn (Flemish public transport) information."""
import logging

from pydelijn.api import Passages
from pydelijn.common import HttpException
import voluptuous as vol

from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import ATTR_ATTRIBUTION, DEVICE_CLASS_TIMESTAMP
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity

_LOGGER = logging.getLogger(__name__)

ATTRIBUTION = "Data provided by data.delijn.be"

CONF_NEXT_DEPARTURE = "next_departure"
CONF_STOP_ID = "stop_id"
CONF_API_KEY = "api_key"
CONF_NUMBER_OF_DEPARTURES = "number_of_departures"

DEFAULT_NAME = "De Lijn"

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
    {
        vol.Required(CONF_API_KEY): cv.string,
        vol.Required(CONF_NEXT_DEPARTURE): [
            {
                vol.Required(CONF_STOP_ID): cv.string,
                vol.Optional(CONF_NUMBER_OF_DEPARTURES, default=5): cv.positive_int,
            }
        ],
    }
)


async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
    """Create the sensor."""
    api_key = config[CONF_API_KEY]

    session = async_get_clientsession(hass)

    sensors = []
    for nextpassage in config[CONF_NEXT_DEPARTURE]:
        sensors.append(
            DeLijnPublicTransportSensor(
                Passages(
                    hass.loop,
                    nextpassage[CONF_STOP_ID],
                    nextpassage[CONF_NUMBER_OF_DEPARTURES],
                    api_key,
                    session,
                    True,
                )
            )
        )

    async_add_entities(sensors, True)


class DeLijnPublicTransportSensor(Entity):
    """Representation of a Ruter sensor."""

    def __init__(self, line):
        """Initialize the sensor."""
        self.line = line
        self._attributes = {ATTR_ATTRIBUTION: ATTRIBUTION}
        self._name = None
        self._state = None
        self._available = True

    async def async_update(self):
        """Get the latest data from the De Lijn API."""
        try:
            await self.line.get_passages()
            self._name = await self.line.get_stopname()
        except HttpException:
            self._available = False
            _LOGGER.error("De Lijn http error")
            return

        self._attributes["stopname"] = self._name

        try:
            first = self.line.passages[0]
            if first["due_at_realtime"] is not None:
                first_passage = first["due_at_realtime"]
            else:
                first_passage = first["due_at_schedule"]
            self._state = first_passage
            self._attributes["line_number_public"] = first["line_number_public"]
            self._attributes["line_transport_type"] = first["line_transport_type"]
            self._attributes["final_destination"] = first["final_destination"]
            self._attributes["due_at_schedule"] = first["due_at_schedule"]
            self._attributes["due_at_realtime"] = first["due_at_realtime"]
            self._attributes["is_realtime"] = first["is_realtime"]
            self._attributes["next_passages"] = self.line.passages
            self._available = True
        except (KeyError, IndexError):
            _LOGGER.error("Invalid data received from De Lijn")
            self._available = False

    @property
    def available(self):
        """Return True if entity is available."""
        return self._available

    @property
    def device_class(self):
        """Return the device class."""
        return DEVICE_CLASS_TIMESTAMP

    @property
    def name(self):
        """Return the name of the sensor."""
        return self._name

    @property
    def state(self):
        """Return the state of the sensor."""
        return self._state

    @property
    def icon(self):
        """Return the icon of the sensor."""
        return "mdi:bus"

    @property
    def device_state_attributes(self):
        """Return attributes for the sensor."""
        return self._attributes

from core.himesis import Himesis
import uuid

class HMapHeirarchyOfStates2HeirarchyOfProcs(Himesis):
	def __init__(self):
		"""
		Creates the himesis graph representing the DSLTrans rule MapHeirarchyOfStates2HeirarchyOfProcs.
		"""
		# Flag this instance as compiled now
		self.is_compiled = True

		super(HMapHeirarchyOfStates2HeirarchyOfProcs, self).__init__(name='HMapHeirarchyOfStates2HeirarchyOfProcs', num_nodes=0, edges=[])

		# Set the graph attributes
		self["mm__"] = ['HimesisMM']
		self["name"] = """MapHeirarchyOfStates2HeirarchyOfProcs"""
		self["GUID__"] = uuid.uuid3(uuid.NAMESPACE_DNS,'MapHeirarchyOfStates2HeirarchyOfProcs')

		# match model. We only support one match model
		self.add_node()
		self.vs[0]["mm__"] = """MatchModel"""

		# apply model node
		self.add_node()
		self.vs[1]["mm__"] = """ApplyModel"""

		# paired with relation between match and apply models
		self.add_node()
		self.vs[2]["mm__"] = """paired_with"""
		self.vs[2]["attr1"] = """MapHeirarchyOfStates2HeirarchyOfProcs"""

		# match class State(3.1.m.0State) node
		self.add_node()
		self.vs[3]["mm__"] = """State"""
		self.vs[3]["attr1"] = """+"""

		# match class State(3.1.m.1State) node
		self.add_node()
		self.vs[4]["mm__"] = """State"""
		self.vs[4]["attr1"] = """+"""

		# apply class LocalDef(3.1.a.0LocalDef) node
		self.add_node()
		self.vs[5]["mm__"] = """LocalDef"""
		self.vs[5]["attr1"] = """1"""

		# apply class ProcDef(3.1.a.1ProcDef) node
		self.add_node()
		self.vs[6]["mm__"] = """ProcDef"""
		self.vs[6]["attr1"] = """1"""

		# match association State--states-->State node 
		self.add_node()
		self.vs[7]["attr1"] = """states"""
		self.vs[7]["mm__"] = """directLink_S"""

		# apply association LocalDef--def-->ProcDef node 
		self.add_node()
		self.vs[8]["attr1"] = """def"""
		self.vs[8]["mm__"] = """directLink_T"""

		# backward association LocalDef-->Statenode 
		self.add_node()
		self.vs[9]["mm__"] = """backward_link"""

		# backward association ProcDef-->Statenode 
		self.add_node()
		self.vs[10]["mm__"] = """backward_link"""

		# Add the edges
		self.add_edges([
			(0,3), # matchmodel -> match_class State(3.1.m.0State)
			(0,4), # matchmodel -> match_class State(3.1.m.1State)
			(1,5), # applymodel -> apply_classLocalDef(3.1.a.0LocalDef)
			(1,6), # applymodel -> apply_classProcDef(3.1.a.1ProcDef)
			(3,7), # match classState(3.1.m.0State) -> association states
			(7,4), # associationstates -> match_classState(3.1.m.1State)
			(5,8), # apply class LocalDef(3.1.a.0LocalDef) -> association def
			(8,6), # associationdef -> apply_classProcDef(3.1.a.1ProcDef)
			(5,9), # apply class LocalDef(3.1.m.0State) -> backward_association 
			(9,3), # backward_associationState -> match_class State(3.1.m.0State)
			(6,10), # apply class ProcDef(3.1.m.1State) -> backward_association 
			(10,4), # backward_associationState -> match_class State(3.1.m.1State)
			(0,2), # matchmodel -> pairedwith
			(2,1) # pairedwith -> applyModel
		])

		self["equations"] = []

import _surface
import chimera
try:
  import chimera.runCommand
except:
  pass
from VolumePath import markerset as ms
try:
  from VolumePath import Marker_Set, Link
  new_marker_set=Marker_Set
except:
  from VolumePath import volume_path_dialog
  d= volume_path_dialog(True)
  new_marker_set= d.new_marker_set
marker_sets={}
surf_sets={}
if "particle_0 geometry" not in marker_sets:
  s=new_marker_set('particle_0 geometry')
  marker_sets["particle_0 geometry"]=s
s= marker_sets["particle_0 geometry"]
mark=s.place_marker((-852.868, 3100.55, 2590.92), (0.7, 0.7, 0.7), 890.203)
if "particle_1 geometry" not in marker_sets:
  s=new_marker_set('particle_1 geometry')
  marker_sets["particle_1 geometry"]=s
s= marker_sets["particle_1 geometry"]
mark=s.place_marker((706.078, 3921.73, 2650.38), (0.7, 0.7, 0.7), 792.956)
if "particle_2 geometry" not in marker_sets:
  s=new_marker_set('particle_2 geometry')
  marker_sets["particle_2 geometry"]=s
s= marker_sets["particle_2 geometry"]
mark=s.place_marker((1872.02, 2782.39, 3636.66), (0.7, 0.7, 0.7), 856.786)
if "particle_3 geometry" not in marker_sets:
  s=new_marker_set('particle_3 geometry')
  marker_sets["particle_3 geometry"]=s
s= marker_sets["particle_3 geometry"]
mark=s.place_marker((404.335, 1110.36, 2695.89), (0.7, 0.7, 0.7), 963.679)
if "particle_4 geometry" not in marker_sets:
  s=new_marker_set('particle_4 geometry')
  marker_sets["particle_4 geometry"]=s
s= marker_sets["particle_4 geometry"]
mark=s.place_marker((927.221, -434.963, 3563.93), (0.7, 0.7, 0.7), 761.442)
if "particle_5 geometry" not in marker_sets:
  s=new_marker_set('particle_5 geometry')
  marker_sets["particle_5 geometry"]=s
s= marker_sets["particle_5 geometry"]
mark=s.place_marker((2531.76, 410.056, 5341.08), (0.7, 0.7, 0.7), 961.183)
if "particle_6 geometry" not in marker_sets:
  s=new_marker_set('particle_6 geometry')
  marker_sets["particle_6 geometry"]=s
s= marker_sets["particle_6 geometry"]
mark=s.place_marker((2986.67, 1047.55, 6854.06), (0.7, 0.7, 0.7), 753.151)
if "particle_7 geometry" not in marker_sets:
  s=new_marker_set('particle_7 geometry')
  marker_sets["particle_7 geometry"]=s
s= marker_sets["particle_7 geometry"]
mark=s.place_marker((2418.83, 452.593, 6578.82), (1, 0.7, 0), 1098.07)
if "particle_8 geometry" not in marker_sets:
  s=new_marker_set('particle_8 geometry')
  marker_sets["particle_8 geometry"]=s
s= marker_sets["particle_8 geometry"]
mark=s.place_marker((3626.43, 2316.71, 7999.21), (0.7, 0.7, 0.7), 1010.42)
if "particle_9 geometry" not in marker_sets:
  s=new_marker_set('particle_9 geometry')
  marker_sets["particle_9 geometry"]=s
s= marker_sets["particle_9 geometry"]
mark=s.place_marker((2757.01, 2780.4, 9362.23), (1, 0.7, 0), 821.043)
if "particle_10 geometry" not in marker_sets:
  s=new_marker_set('particle_10 geometry')
  marker_sets["particle_10 geometry"]=s
s= marker_sets["particle_10 geometry"]
mark=s.place_marker((3983.19, 4203.89, 9587.86), (0.7, 0.7, 0.7), 873.876)
if "particle_11 geometry" not in marker_sets:
  s=new_marker_set('particle_11 geometry')
  marker_sets["particle_11 geometry"]=s
s= marker_sets["particle_11 geometry"]
mark=s.place_marker((3799.75, 4867.23, 8710.6), (0.7, 0.7, 0.7), 625.532)
if "particle_12 geometry" not in marker_sets:
  s=new_marker_set('particle_12 geometry')
  marker_sets["particle_12 geometry"]=s
s= marker_sets["particle_12 geometry"]
mark=s.place_marker((4051.4, 6226.12, 8052.24), (0.7, 0.7, 0.7), 880.474)
if "particle_13 geometry" not in marker_sets:
  s=new_marker_set('particle_13 geometry')
  marker_sets["particle_13 geometry"]=s
s= marker_sets["particle_13 geometry"]
mark=s.place_marker((3229.01, 6229.06, 8096.16), (0.7, 0.7, 0.7), 659.161)
if "particle_14 geometry" not in marker_sets:
  s=new_marker_set('particle_14 geometry')
  marker_sets["particle_14 geometry"]=s
s= marker_sets["particle_14 geometry"]
mark=s.place_marker((2977.39, 8508.18, 8246.33), (0.7, 0.7, 0.7), 831.745)
if "particle_15 geometry" not in marker_sets:
  s=new_marker_set('particle_15 geometry')
  marker_sets["particle_15 geometry"]=s
s= marker_sets["particle_15 geometry"]
mark=s.place_marker((4180.27, 10749.2, 6524.67), (0.7, 0.7, 0.7), 803.065)
if "particle_16 geometry" not in marker_sets:
  s=new_marker_set('particle_16 geometry')
  marker_sets["particle_16 geometry"]=s
s= marker_sets["particle_16 geometry"]
mark=s.place_marker((5229.5, 9657.04, 5260.54), (0.7, 0.7, 0.7), 610.262)
if "particle_17 geometry" not in marker_sets:
  s=new_marker_set('particle_17 geometry')
  marker_sets["particle_17 geometry"]=s
s= marker_sets["particle_17 geometry"]
mark=s.place_marker((3909.88, 9453.83, 4998.84), (0.7, 0.7, 0.7), 741.265)
if "particle_18 geometry" not in marker_sets:
  s=new_marker_set('particle_18 geometry')
  marker_sets["particle_18 geometry"]=s
s= marker_sets["particle_18 geometry"]
mark=s.place_marker((3998.69, 8366.79, 6255.96), (0.7, 0.7, 0.7), 748.625)
if "particle_19 geometry" not in marker_sets:
  s=new_marker_set('particle_19 geometry')
  marker_sets["particle_19 geometry"]=s
s= marker_sets["particle_19 geometry"]
mark=s.place_marker((3799.47, 8546.6, 7682.9), (0.7, 0.7, 0.7), 677.181)
if "particle_20 geometry" not in marker_sets:
  s=new_marker_set('particle_20 geometry')
  marker_sets["particle_20 geometry"]=s
s= marker_sets["particle_20 geometry"]
mark=s.place_marker((4616.58, 6263.43, 7625.49), (0.7, 0.7, 0.7), 616.015)
if "particle_21 geometry" not in marker_sets:
  s=new_marker_set('particle_21 geometry')
  marker_sets["particle_21 geometry"]=s
s= marker_sets["particle_21 geometry"]
mark=s.place_marker((4296.48, 8206.62, 6999.95), (0.7, 0.7, 0.7), 653.154)
if "particle_22 geometry" not in marker_sets:
  s=new_marker_set('particle_22 geometry')
  marker_sets["particle_22 geometry"]=s
s= marker_sets["particle_22 geometry"]
mark=s.place_marker((4964.44, 8135.17, 6409.07), (0.7, 0.7, 0.7), 595.33)
if "particle_23 geometry" not in marker_sets:
  s=new_marker_set('particle_23 geometry')
  marker_sets["particle_23 geometry"]=s
s= marker_sets["particle_23 geometry"]
mark=s.place_marker((5020.29, 8887.44, 5379.47), (0.7, 0.7, 0.7), 627.901)
if "particle_24 geometry" not in marker_sets:
  s=new_marker_set('particle_24 geometry')
  marker_sets["particle_24 geometry"]=s
s= marker_sets["particle_24 geometry"]
mark=s.place_marker((3988.32, 8880.86, 4462.06), (0.7, 0.7, 0.7), 663.941)
if "particle_25 geometry" not in marker_sets:
  s=new_marker_set('particle_25 geometry')
  marker_sets["particle_25 geometry"]=s
s= marker_sets["particle_25 geometry"]
mark=s.place_marker((3021.93, 9799.05, 3737.37), (0.7, 0.7, 0.7), 663.899)
if "particle_26 geometry" not in marker_sets:
  s=new_marker_set('particle_26 geometry')
  marker_sets["particle_26 geometry"]=s
s= marker_sets["particle_26 geometry"]
mark=s.place_marker((3557.37, 8986.25, 4942.9), (0.7, 0.7, 0.7), 644.694)
if "particle_27 geometry" not in marker_sets:
  s=new_marker_set('particle_27 geometry')
  marker_sets["particle_27 geometry"]=s
s= marker_sets["particle_27 geometry"]
mark=s.place_marker((3320.76, 7003.29, 5823.86), (0.7, 0.7, 0.7), 896.802)
if "particle_28 geometry" not in marker_sets:
  s=new_marker_set('particle_28 geometry')
  marker_sets["particle_28 geometry"]=s
s= marker_sets["particle_28 geometry"]
mark=s.place_marker((4603.06, 7277.59, 6542.98), (0.7, 0.7, 0.7), 576.38)
if "particle_29 geometry" not in marker_sets:
  s=new_marker_set('particle_29 geometry')
  marker_sets["particle_29 geometry"]=s
s= marker_sets["particle_29 geometry"]
mark=s.place_marker((5106.82, 6617.64, 7545.43), (0.7, 0.7, 0.7), 635.092)
if "particle_30 geometry" not in marker_sets:
  s=new_marker_set('particle_30 geometry')
  marker_sets["particle_30 geometry"]=s
s= marker_sets["particle_30 geometry"]
mark=s.place_marker((5755.69, 6563.12, 6929.93), (0.7, 0.7, 0.7), 651.505)
if "particle_31 geometry" not in marker_sets:
  s=new_marker_set('particle_31 geometry')
  marker_sets["particle_31 geometry"]=s
s= marker_sets["particle_31 geometry"]
mark=s.place_marker((4622.85, 5705.69, 7933.2), (0.7, 0.7, 0.7), 718.042)
if "particle_32 geometry" not in marker_sets:
  s=new_marker_set('particle_32 geometry')
  marker_sets["particle_32 geometry"]=s
s= marker_sets["particle_32 geometry"]
mark=s.place_marker((5552.53, 7235.24, 8083.72), (0.7, 0.7, 0.7), 726.714)
if "particle_33 geometry" not in marker_sets:
  s=new_marker_set('particle_33 geometry')
  marker_sets["particle_33 geometry"]=s
s= marker_sets["particle_33 geometry"]
mark=s.place_marker((5833.92, 7589.64, 6653.26), (0.7, 0.7, 0.7), 673.585)
if "particle_34 geometry" not in marker_sets:
  s=new_marker_set('particle_34 geometry')
  marker_sets["particle_34 geometry"]=s
s= marker_sets["particle_34 geometry"]
mark=s.place_marker((4937.82, 8458.98, 6289.8), (0.7, 0.7, 0.7), 598.418)
if "particle_35 geometry" not in marker_sets:
  s=new_marker_set('particle_35 geometry')
  marker_sets["particle_35 geometry"]=s
s= marker_sets["particle_35 geometry"]
mark=s.place_marker((4355.88, 9709.11, 6220.67), (0.7, 0.7, 0.7), 693.382)
if "particle_36 geometry" not in marker_sets:
  s=new_marker_set('particle_36 geometry')
  marker_sets["particle_36 geometry"]=s
s= marker_sets["particle_36 geometry"]
mark=s.place_marker((4752.11, 7361.32, 6891.36), (0.7, 0.7, 0.7), 804.038)
if "particle_37 geometry" not in marker_sets:
  s=new_marker_set('particle_37 geometry')
  marker_sets["particle_37 geometry"]=s
s= marker_sets["particle_37 geometry"]
mark=s.place_marker((5497.72, 8974.7, 6291.85), (0.7, 0.7, 0.7), 816.178)
if "particle_38 geometry" not in marker_sets:
  s=new_marker_set('particle_38 geometry')
  marker_sets["particle_38 geometry"]=s
s= marker_sets["particle_38 geometry"]
mark=s.place_marker((5166.93, 7997.31, 5179.8), (0.7, 0.7, 0.7), 776.628)
if "particle_39 geometry" not in marker_sets:
  s=new_marker_set('particle_39 geometry')
  marker_sets["particle_39 geometry"]=s
s= marker_sets["particle_39 geometry"]
mark=s.place_marker((5422.46, 8954.06, 6444.04), (0.7, 0.7, 0.7), 750.656)
if "particle_40 geometry" not in marker_sets:
  s=new_marker_set('particle_40 geometry')
  marker_sets["particle_40 geometry"]=s
s= marker_sets["particle_40 geometry"]
mark=s.place_marker((6135.53, 7544.79, 7080.87), (0.7, 0.7, 0.7), 709.625)
if "particle_41 geometry" not in marker_sets:
  s=new_marker_set('particle_41 geometry')
  marker_sets["particle_41 geometry"]=s
s= marker_sets["particle_41 geometry"]
mark=s.place_marker((6659.59, 6977, 8797.4), (0.7, 0.7, 0.7), 927.681)
if "particle_42 geometry" not in marker_sets:
  s=new_marker_set('particle_42 geometry')
  marker_sets["particle_42 geometry"]=s
s= marker_sets["particle_42 geometry"]
mark=s.place_marker((8561.98, 8807.01, 8688.9), (0.7, 0.7, 0.7), 1088.21)
if "particle_43 geometry" not in marker_sets:
  s=new_marker_set('particle_43 geometry')
  marker_sets["particle_43 geometry"]=s
s= marker_sets["particle_43 geometry"]
mark=s.place_marker((8050.09, 7069.1, 9349.98), (0.7, 0.7, 0.7), 736.147)
if "particle_44 geometry" not in marker_sets:
  s=new_marker_set('particle_44 geometry')
  marker_sets["particle_44 geometry"]=s
s= marker_sets["particle_44 geometry"]
mark=s.place_marker((7258.99, 7613.41, 7976.34), (0.7, 0.7, 0.7), 861.101)
if "particle_45 geometry" not in marker_sets:
  s=new_marker_set('particle_45 geometry')
  marker_sets["particle_45 geometry"]=s
s= marker_sets["particle_45 geometry"]
mark=s.place_marker((6646.32, 5806.23, 7633.69), (0.7, 0.7, 0.7), 924.213)
if "particle_46 geometry" not in marker_sets:
  s=new_marker_set('particle_46 geometry')
  marker_sets["particle_46 geometry"]=s
s= marker_sets["particle_46 geometry"]
mark=s.place_marker((8234.99, 5781.64, 6465.61), (0.7, 0.7, 0.7), 881.828)
if "particle_47 geometry" not in marker_sets:
  s=new_marker_set('particle_47 geometry')
  marker_sets["particle_47 geometry"]=s
s= marker_sets["particle_47 geometry"]
mark=s.place_marker((9335.53, 7180.97, 7507.2), (0.7, 0.7, 0.7), 927.681)
if "particle_48 geometry" not in marker_sets:
  s=new_marker_set('particle_48 geometry')
  marker_sets["particle_48 geometry"]=s
s= marker_sets["particle_48 geometry"]
mark=s.place_marker((8891.29, 5522.37, 6784.81), (0.7, 0.7, 0.7), 831.576)
if "particle_49 geometry" not in marker_sets:
  s=new_marker_set('particle_49 geometry')
  marker_sets["particle_49 geometry"]=s
s= marker_sets["particle_49 geometry"]
mark=s.place_marker((7678.16, 4059, 6735.66), (0.7, 0.7, 0.7), 859.494)
if "particle_50 geometry" not in marker_sets:
  s=new_marker_set('particle_50 geometry')
  marker_sets["particle_50 geometry"]=s
s= marker_sets["particle_50 geometry"]
mark=s.place_marker((8645.86, 4124.7, 7880.12), (0.7, 0.7, 0.7), 704.845)
if "particle_51 geometry" not in marker_sets:
  s=new_marker_set('particle_51 geometry')
  marker_sets["particle_51 geometry"]=s
s= marker_sets["particle_51 geometry"]
mark=s.place_marker((6952.87, 3863.23, 7800.65), (0.7, 0.7, 0.7), 804.461)
if "particle_52 geometry" not in marker_sets:
  s=new_marker_set('particle_52 geometry')
  marker_sets["particle_52 geometry"]=s
s= marker_sets["particle_52 geometry"]
mark=s.place_marker((5249.09, 3539.73, 7219.8), (0.7, 0.7, 0.7), 934.111)
if "particle_53 geometry" not in marker_sets:
  s=new_marker_set('particle_53 geometry')
  marker_sets["particle_53 geometry"]=s
s= marker_sets["particle_53 geometry"]
mark=s.place_marker((5104.03, 2315.49, 8134.04), (0.7, 0.7, 0.7), 988.339)
if "particle_54 geometry" not in marker_sets:
  s=new_marker_set('particle_54 geometry')
  marker_sets["particle_54 geometry"]=s
s= marker_sets["particle_54 geometry"]
mark=s.place_marker((5911.28, 2116.95, 8305.81), (1, 0.7, 0), 803.7)
if "particle_55 geometry" not in marker_sets:
  s=new_marker_set('particle_55 geometry')
  marker_sets["particle_55 geometry"]=s
s= marker_sets["particle_55 geometry"]
mark=s.place_marker((6768.16, 3363.37, 6849.15), (0.7, 0.7, 0.7), 812.118)
if "particle_56 geometry" not in marker_sets:
  s=new_marker_set('particle_56 geometry')
  marker_sets["particle_56 geometry"]=s
s= marker_sets["particle_56 geometry"]
mark=s.place_marker((6490.54, 2362.14, 4928.76), (0.7, 0.7, 0.7), 1177.93)
if "particle_57 geometry" not in marker_sets:
  s=new_marker_set('particle_57 geometry')
  marker_sets["particle_57 geometry"]=s
s= marker_sets["particle_57 geometry"]
mark=s.place_marker((7376.53, 2458.37, 2553.2), (0.7, 0.7, 0.7), 1038.21)
if "particle_58 geometry" not in marker_sets:
  s=new_marker_set('particle_58 geometry')
  marker_sets["particle_58 geometry"]=s
s= marker_sets["particle_58 geometry"]
mark=s.place_marker((7567.46, 2564.15, 2010.31), (1, 0.7, 0), 758.016)
if "particle_59 geometry" not in marker_sets:
  s=new_marker_set('particle_59 geometry')
  marker_sets["particle_59 geometry"]=s
s= marker_sets["particle_59 geometry"]
mark=s.place_marker((7476.58, 1734.39, 2062.53), (0.7, 0.7, 0.7), 824.046)
if "particle_60 geometry" not in marker_sets:
  s=new_marker_set('particle_60 geometry')
  marker_sets["particle_60 geometry"]=s
s= marker_sets["particle_60 geometry"]
mark=s.place_marker((7651.9, 2294.24, 2796.01), (0.7, 0.7, 0.7), 793.379)
if "particle_61 geometry" not in marker_sets:
  s=new_marker_set('particle_61 geometry')
  marker_sets["particle_61 geometry"]=s
s= marker_sets["particle_61 geometry"]
mark=s.place_marker((8221.36, 1647.65, 2705.16), (0.7, 0.7, 0.7), 1011.56)
if "particle_62 geometry" not in marker_sets:
  s=new_marker_set('particle_62 geometry')
  marker_sets["particle_62 geometry"]=s
s= marker_sets["particle_62 geometry"]
mark=s.place_marker((6933.2, 2417.83, 3847.38), (0.7, 0.7, 0.7), 1097.01)
if "particle_63 geometry" not in marker_sets:
  s=new_marker_set('particle_63 geometry')
  marker_sets["particle_63 geometry"]=s
s= marker_sets["particle_63 geometry"]
mark=s.place_marker((6821.38, 3825.38, 2570.41), (0.7, 0.7, 0.7), 851.626)
if "particle_64 geometry" not in marker_sets:
  s=new_marker_set('particle_64 geometry')
  marker_sets["particle_64 geometry"]=s
s= marker_sets["particle_64 geometry"]
mark=s.place_marker((6765.25, 5038.46, 1070.39), (0.7, 0.7, 0.7), 869.434)
if "particle_65 geometry" not in marker_sets:
  s=new_marker_set('particle_65 geometry')
  marker_sets["particle_65 geometry"]=s
s= marker_sets["particle_65 geometry"]
mark=s.place_marker((7799.56, 5351.25, 2553.22), (0.7, 0.7, 0.7), 818.463)
if "particle_66 geometry" not in marker_sets:
  s=new_marker_set('particle_66 geometry')
  marker_sets["particle_66 geometry"]=s
s= marker_sets["particle_66 geometry"]
mark=s.place_marker((9237.09, 5063.6, 1561.89), (0.7, 0.7, 0.7), 759.539)
if "particle_67 geometry" not in marker_sets:
  s=new_marker_set('particle_67 geometry')
  marker_sets["particle_67 geometry"]=s
s= marker_sets["particle_67 geometry"]
mark=s.place_marker((8361.15, 3550.39, 3257.75), (0.7, 0.7, 0.7), 1088.59)
if "particle_68 geometry" not in marker_sets:
  s=new_marker_set('particle_68 geometry')
  marker_sets["particle_68 geometry"]=s
s= marker_sets["particle_68 geometry"]
mark=s.place_marker((9587.69, 2474.38, 1760.15), (0.7, 0.7, 0.7), 822.312)
if "particle_69 geometry" not in marker_sets:
  s=new_marker_set('particle_69 geometry')
  marker_sets["particle_69 geometry"]=s
s= marker_sets["particle_69 geometry"]
mark=s.place_marker((10144.6, 3918.75, 1154.71), (0.7, 0.7, 0.7), 749.81)
if "particle_70 geometry" not in marker_sets:
  s=new_marker_set('particle_70 geometry')
  marker_sets["particle_70 geometry"]=s
s= marker_sets["particle_70 geometry"]
mark=s.place_marker((8736.76, 4492.45, 1432.51), (0.7, 0.7, 0.7), 764.488)
for k in surf_sets.keys():
  chimera.openModels.add([surf_sets[k]])

#!/usr/bin/python

import argparse
import json
import logging
import os
import subprocess
import sys
from ConfigParser import SafeConfigParser

logging.basicConfig()
# Get absolute path of ../config from the current script location (not the
# current folder)
config_folder = os.path.abspath(
    os.path.join(os.path.dirname(__file__), os.pardir, 'config'))

# Read Transvision's configuration file from ../config/config.ini
# If not available use a default storage folder to store data
config_file = os.path.join(config_folder, 'config.ini')
if not os.path.isfile(config_file):
    print('Configuration file /app/config/config.ini is missing. '
          'Default settings will be used.')
    root_folder = os.path.abspath(
        os.path.join(os.path.dirname(__file__), os.pardir))
    library_path = os.path.join(root_folder, 'libraries')
else:
    config_parser = SafeConfigParser()
    config_parser.read(config_file)
    library_path = config_parser.get('config', 'libraries')
    storage_path = os.path.join(config_parser.get('config', 'root'), 'TMX')

# Import compare-locales (http://hg.mozilla.org/l10n/compare-locales/)
# and add it to the system's path
compare_locales_path = os.path.join(library_path, 'compare-locales')
if not os.path.isdir(compare_locales_path):
    try:
        print('Cloning compare-locales...')
        cmd_status = subprocess.check_output(
            ['hg', 'clone', 'https://hg.mozilla.org/l10n/compare-locales',
                compare_locales_path, '-u', 'RELEASE_1_2_1'],
            stderr=subprocess.STDOUT,
            shell=False)
        print(cmd_status)
    except Exception as e:
        print(e)
sys.path.insert(0, compare_locales_path)

try:
    from compare_locales import parser
except ImportError:
    print('Error importing compare-locales library')
    sys.exit(1)


class StringExtraction():

    def __init__(self, storage_path, locale, reference_locale, repository_name):
        ''' Initialize object '''

        # Set defaults
        self.supported_formats = ['.dtd', '.properties', '.ini', '.inc']
        self.storage_mode = ''
        self.storage_prefix = ''
        self.file_list = []
        self.translations = {}

        # Set instance variables
        self.storage_path = storage_path
        self.locale = locale
        self.reference_locale = reference_locale

        # Define the locale storage filenames
        self.storage_file = os.path.join(
            storage_path, locale,
            'cache_{0}_{1}'.format(locale, repository_name))

        self.reference_storage_file = os.path.join(
            storage_path, reference_locale,
            'cache_{0}_{1}'.format(reference_locale, repository_name))

    def setRepositoryPath(self, path):
        ''' Set path to repository '''

        # Strip trailing '/' from repository path
        self.repository_path = path.rstrip(os.path.sep)

    def setStorageMode(self, mode, prefix):
        ''' Set storage mode and prefix. Currently supported '''

        self.storage_mode = mode
        # Strip trailing '/' from storage_prefix
        self.storage_prefix = prefix.rstrip(os.path.sep)

    def extractFileList(self):
        ''' Extract the list of supported files '''

        for root, dirs, files in os.walk(self.repository_path, followlinks=True):
            for file in files:
                for supported_format in self.supported_formats:
                    if file.endswith(supported_format):
                        self.file_list.append(os.path.join(root, file))
        self.file_list.sort()

    def getRelativePath(self, file_name):
        ''' Get the relative path of a filename, prepend prefix_storage if
        defined '''

        relative_path = file_name[len(self.repository_path) + 1:]
        # Prepend storage_prefix if defined
        if self.storage_prefix != '':
            relative_path = '{0}/{1}'.format(self.storage_prefix,
                                             relative_path)
        # Hack to work around Transvision symlink mess
        relative_path = relative_path.replace(
            'locales/en-US/en-US/', '')

        return relative_path

    def extractStrings(self):
        ''' Extract strings from all files '''

        # If storage_mode is append, read existing translations (if available)
        # before overriding them
        if self.storage_mode == 'append':
            file_name = self.storage_file + '.json'
            if os.path.isfile(file_name):
                with open(file_name) as f:
                    self.translations = json.load(f)
                f.close()

        # Create a list of files to analyze
        self.extractFileList()

        for file_name in self.file_list:
            file_extension = os.path.splitext(file_name)[1]

            file_parser = parser.getParser(file_extension)
            file_parser.readFile(file_name)
            try:
                entities, map = file_parser.parse()
                for entity in entities:
                    string_id = u'{0}:{1}'.format(
                        self.getRelativePath(file_name), unicode(entity))
                    if not isinstance(entity, parser.Junk):
                        self.translations[string_id] = entity.raw_val
            except Exception as e:
                print 'Error parsing file: {0}'.format(file_name)
                print e

        # Remove extra strings from locale
        if self.reference_locale != self.locale:
            # Read the JSON cache for reference locale if available
            file_name = self.reference_storage_file + '.json'
            if os.path.isfile(file_name):
                with open(file_name) as f:
                    reference_strings = json.load(f)
                f.close()

                for string_id in self.translations.keys():
                    if string_id not in reference_strings:
                        del(self.translations[string_id])

    def storeTranslations(self, output_format):
        '''
            Store translations on file.
            If no format is specified, both JSON and PHP formats will
            be stored on file.
        '''

        if output_format != 'php':
            # Store translations in JSON format
            f = open(self.storage_file + '.json', 'w')
            f.write(json.dumps(self.translations, sort_keys=True))
            f.close()

        if output_format != 'json':
            # Store translations in PHP format (array)
            string_ids = self.translations.keys()
            string_ids.sort()

            f = open(self.storage_file + '.php', 'w')
            f.write('<?php\n$tmx = [\n')
            for string_id in string_ids:
                translation = self.escape(
                    self.translations[string_id].encode('utf-8'))
                string_id = self.escape(string_id.encode('utf-8'))
                line = "'{0}' => '{1}',\n".format(string_id, translation)
                f.write(line)
            f.write('];\n')
            f.close()

    def escape(self, translation):
        '''
            Escape quotes and backslahes in translation. There are two issues:
            * Internal Python escaping: the string "this is a \", has an internal
              representation as "this is a \\".
              Also, "\\ test" is equivalent to r"\ test" (raw string).
            * We need to print these strings into a file, with the format of a
              PHP array delimited by single quotes ('id' => 'translation'). Hence
              we need to escape single quotes, but also escape backslashes.
              "this is a 'test'" => "this is a \'test\'"
              "this is a \'test\'" => "this is a \\\'test\\\'"
        '''

        # Escape slashes
        escaped_translation = translation.replace('\\', '\\\\')
        # Escape single quotes
        escaped_translation = escaped_translation.replace('\'', '\\\'')

        return escaped_translation


def main():
    # Read command line input parameters
    parser = argparse.ArgumentParser()
    parser.add_argument('repo_path', help='Path to locale files')
    parser.add_argument('locale_code', help='Locale language code')
    parser.add_argument('reference_code', help='Reference language code')
    parser.add_argument('repository_name', help='Repository name')
    parser.add_argument('--output', nargs='?', type=str, choices=['json', 'php'],
                        help='Store only one type of output.', default='')
    parser.add_argument('storage_mode', nargs='?',
                        help='If set to \'append\', translations will be added to an existing cache file', default='')
    parser.add_argument('storage_prefix', nargs='?',
                        help='This prefix will be prependended to the identified path in string IDs (e.g. extensions/irc for Chatzilla)', default='')
    args = parser.parse_args()

    extracted_strings = StringExtraction(
        storage_path, args.locale_code, args.reference_code, args.repository_name)

    extracted_strings.setRepositoryPath(args.repo_path.rstrip('/'))
    if args.storage_mode == 'append':
        extracted_strings.setStorageMode('append', args.storage_prefix)

    extracted_strings.extractStrings()
    extracted_strings.storeTranslations(args.output)


if __name__ == '__main__':
    main()

import os

from nxdrive.client import LocalClient
from nxdrive.client.common import LOCALLY_EDITED_FOLDER_NAME
from nxdrive.tests.common_unit_test import UnitTestCase
from nxdrive.engine.engine import Engine

DRIVE_EDIT_XATTR_NAMES = ['ndrive', 'nxdriveedit', 'nxdriveeditdigest', 'nxdriveeditname']

class MockUrlTestEngine(Engine):
    def __init__(self, url):
        self._url = url

    def get_binder(self):
        from nxdrive.manager import ServerBindingSettings
        return ServerBindingSettings(server_url=self._url,
                        web_authentication=None,
                        server_version=None,
                        username='Administrator',
                        local_folder='/',
                        initialized=True,
                        pwd_update_required=False)


class TestDriveEdit(UnitTestCase):

    locally_edited_path = ('/default-domain/UserWorkspaces/'
                           + 'nuxeoDriveTestUser-user-1/Collections/'
                           + LOCALLY_EDITED_FOLDER_NAME)

    def setUpApp(self):
        super(TestDriveEdit, self).setUpApp()
        self.drive_edit = self.manager_1.get_drive_edit()
        self.drive_edit.driveEditUploadCompleted.connect(self.app.sync_completed)
        self.drive_edit.start()

        self.remote = self.remote_document_client_1
        self.local = LocalClient(os.path.join(self.nxdrive_conf_folder_1, 'edit'))

    def tearDownApp(self):
        self.drive_edit.stop()
        super(TestDriveEdit, self).tearDownApp()

    def test_url_resolver(self):
        self.assertIsNotNone(self.drive_edit._get_engine("http://localhost:8080/nuxeo", self.user_1))
        self.assertIsNone(self.drive_edit._get_engine("http://localhost:8080/nuxeo", u'Administrator'))
        self.manager_1._engine_types['NXDRIVETESTURL'] = MockUrlTestEngine
        # HTTP EXPLICIT
        self.manager_1._engines['0'] = MockUrlTestEngine('http://localhost:80/nuxeo')
        self.assertIsNone(self.drive_edit._get_engine("http://localhost:8080/nuxeo", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("http://localhost:80/nuxeo", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("http://localhost/nuxeo/", u'Administrator'))
        # HTTP IMPLICIT
        self.manager_1._engines['0'] = MockUrlTestEngine('http://localhost/nuxeo')
        self.assertIsNone(self.drive_edit._get_engine("http://localhost:8080/nuxeo", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("http://localhost:80/nuxeo/", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("http://localhost/nuxeo", u'Administrator'))
        # HTTPS EXPLICIT
        self.manager_1._engines['0'] = MockUrlTestEngine('https://localhost:443/nuxeo')
        self.assertIsNone(self.drive_edit._get_engine("http://localhost:8080/nuxeo", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("https://localhost:443/nuxeo", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("https://localhost/nuxeo/", u'Administrator'))
        # HTTPS IMPLICIT
        self.manager_1._engines['0'] = MockUrlTestEngine('https://localhost/nuxeo')
        self.assertIsNone(self.drive_edit._get_engine("http://localhost:8080/nuxeo", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("https://localhost:443/nuxeo/", u'Administrator'))
        self.assertIsNotNone(self.drive_edit._get_engine("https://localhost/nuxeo", u'Administrator'))

    def test_note_edit(self):
        remote_fs_client = self.remote_file_system_client_1
        toplevel_folder_info = remote_fs_client.get_filesystem_root_info()
        workspace_id = remote_fs_client.get_children_info(
            toplevel_folder_info.uid)[0].uid
        file_1_id = remote_fs_client.make_file(workspace_id, u'Mode op\xe9ratoire.txt',
                                               "Content of file 1 Avec des accents h\xe9h\xe9.").uid
        doc_id = file_1_id.split('#')[-1]
        self._drive_edit_update(doc_id, u'Mode op\xe9ratoire.txt', 'Atol de PomPom Gali')

    def test_filename_encoding(self):
        filename = u'Mode op\xe9ratoire.txt'
        doc_id = self.remote.make_file('/', filename, 'Some content.')
        self._drive_edit_update(doc_id, filename, 'Test')

    def _office_locker(self, path):
        return os.path.join(os.path.dirname(path), "~$" + os.path.basename(path)[2:])

    def _openoffice_locker(self, path):
        return os.path.join(os.path.dirname(path), ".~lock." + os.path.basename(path)[2:])

#     def test_autolock_office(self):
#         self._autolock(self._office_locker)

#     def test_autolock_openoffice(self):
#      LibreOffice as well
#         self._autolock(self._openoffice_locker)

    def _autolock(self, locker):
        global called_open, lock_file
        called_open = False
        filename = u'Document.docx'
        doc_id = self.remote.make_file('/', filename, 'Some content.')

        def open_local_file(path):
            global called_open, lock_file
            called_open = True
            # Lock file
            lock_file = locker(path)
            with open(lock_file, 'w') as f:
                f.write("plop")

        self.manager_1.open_local_file = open_local_file
        self.manager_1.set_drive_edit_auto_lock(1)
        self.drive_edit._manager.open_local_file = open_local_file
        self.drive_edit.edit(self.nuxeo_url, doc_id, filename=filename, user=self.user_1)
        self.wait_sync(timeout=2, fail_if_timeout=False)
        self.assertTrue(called_open, "Should have called open_local_file")
        # Should be able to test lock
        self.assertTrue(self.remote_restapi_client_1.is_locked(doc_id))
        os.remove(lock_file)
        self.wait_sync(timeout=2, fail_if_timeout=False)
        # Should be unlock
        self.assertFalse(self.remote_restapi_client_1.is_locked(doc_id))
        self.manager_1.set_drive_edit_auto_lock(0)
        with open(lock_file, 'w') as f:
            f.write("plop")
        self.wait_sync(timeout=2, fail_if_timeout=False)
        self.assertFalse(self.remote_restapi_client_1.is_locked(doc_id))

    def _drive_edit_update(self, doc_id, filename, content, url=None):
        # Download file
        local_path = u'/%s/%s' % (doc_id, filename)

        def open_local_file(path):
            pass

        self.manager_1.open_local_file = open_local_file
        if url is None:
            self.drive_edit._prepare_edit(self.nuxeo_url, doc_id)
        else:
            self.drive_edit.handle_url(url)
        self.assertTrue(self.local.exists(local_path))
        self.wait_sync(timeout=2, fail_if_timeout=False)
        self.local.delete_final(local_path)

        # Update file content
        self.local.update_content(local_path, content)
        self.wait_sync()
        self.assertEquals(self.remote.get_blob(self.remote.get_info(doc_id)), content)

        # Update file content twice
        update_content = content + ' updated'
        self.local.update_content(local_path, update_content)
        self.wait_sync()
        self.assertEquals(self.remote.get_blob(self.remote.get_info(doc_id)), update_content)

# -*- coding: utf-8 -*-
# Tests for the contrib/localflavor/ CZ Form Fields

tests = r"""
# CZPostalCodeField #########################################################

>>> from django.contrib.localflavor.cz.forms import CZPostalCodeField
>>> f = CZPostalCodeField()
>>> f.clean('84545x')
Traceback (most recent call last):
...
ValidationError: [u'Enter a postal code in the format XXXXX or XXX XX.']
>>> f.clean('91909')
u'91909'
>>> f.clean('917 01')
u'91701'
>>> f.clean('12345')
u'12345'
>>> f.clean('123456')
Traceback (most recent call last):
...
ValidationError: [u'Enter a postal code in the format XXXXX or XXX XX.']
>>> f.clean('1234')
Traceback (most recent call last):
...
ValidationError: [u'Enter a postal code in the format XXXXX or XXX XX.']
>>> f.clean('123 4')
Traceback (most recent call last):
...
ValidationError: [u'Enter a postal code in the format XXXXX or XXX XX.']

# CZRegionSelect ############################################################

>>> from django.contrib.localflavor.cz.forms import CZRegionSelect
>>> w = CZRegionSelect()
>>> w.render('regions', 'TT')
u'<select name="regions">\n<option value="PR">Prague</option>\n<option value="CE">Central Bohemian Region</option>\n<option value="SO">South Bohemian Region</option>\n<option value="PI">Pilsen Region</option>\n<option value="CA">Carlsbad Region</option>\n<option value="US">Usti Region</option>\n<option value="LB">Liberec Region</option>\n<option value="HK">Hradec Region</option>\n<option value="PA">Pardubice Region</option>\n<option value="VY">Vysocina Region</option>\n<option value="SM">South Moravian Region</option>\n<option value="OL">Olomouc Region</option>\n<option value="ZL">Zlin Region</option>\n<option value="MS">Moravian-Silesian Region</option>\n</select>'

# CZBirthNumberField ########################################################

>>> from django.contrib.localflavor.cz.forms import CZBirthNumberField
>>> f = CZBirthNumberField()
>>> f.clean('880523/1237')
u'880523/1237'
>>> f.clean('8805231237')
u'8805231237'
>>> f.clean('880523/000')
u'880523/000'
>>> f.clean('880523000')
u'880523000'
>>> f.clean('882101/0011')
u'882101/0011'
>>> f.clean('880523/1237', 'm')
u'880523/1237'
>>> f.clean('885523/1231', 'f')
u'885523/1231'
>>> f.clean('123456/12')
Traceback (most recent call last):
...
ValidationError: [u'Enter a birth number in the format XXXXXX/XXXX or XXXXXXXXXX.']
>>> f.clean('123456/12345')
Traceback (most recent call last):
...
ValidationError: [u'Enter a birth number in the format XXXXXX/XXXX or XXXXXXXXXX.']
>>> f.clean('12345612')
Traceback (most recent call last):
...
ValidationError: [u'Enter a birth number in the format XXXXXX/XXXX or XXXXXXXXXX.']
>>> f.clean('12345612345')
Traceback (most recent call last):
...
ValidationError: [u'Enter a birth number in the format XXXXXX/XXXX or XXXXXXXXXX.']
>>> f.clean('881523/0000', 'm')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid birth number.']
>>> f.clean('885223/0000', 'm')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid birth number.']
>>> f.clean('881223/0000', 'f')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid birth number.']
>>> f.clean('886523/0000', 'f')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid birth number.']
>>> f.clean('880523/1239')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid birth number.']
>>> f.clean('8805231239')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid birth number.']
>>> f.clean('990101/0011')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid birth number.']

# CZICNumberField ########################################################

>>> from django.contrib.localflavor.cz.forms import CZICNumberField
>>> f = CZICNumberField()
>>> f.clean('12345679')
u'12345679'
>>> f.clean('12345601')
u'12345601'
>>> f.clean('12345661')
u'12345661'
>>> f.clean('12345610')
u'12345610'
>>> f.clean('1234567')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid IC number.']
>>> f.clean('12345660')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid IC number.']
>>> f.clean('12345600')
Traceback (most recent call last):
...
ValidationError: [u'Enter a valid IC number.']
"""

import logging
from collections import defaultdict

from mw import Namespace, Timestamp, api

import yamlconf

from .. import dependencies
from ..datasources import (Datasource, RevisionMetadata, UserInfo,
                           parent_revision, revision, site, user)
from ..errors import RevisionDocumentNotFound
from ..languages import Language
from .extractor import Extractor

logger = logging.getLogger('revscoring.extractors.api')

revision_doc = Datasource("revision.doc")
parent_revision_doc = Datasource("parent_revision.doc")
previous_user_revision_doc = Datasource("previous_user_revision.doc")
page_creation_doc = Datasource("page_creation.doc")
user_doc = Datasource("user.doc")
site_doc = Datasource("site.doc")

class APIExtractor(Extractor):
    """
    Implements a :class:`~revscoring.extractor.extractor.Extractor` using a
    MediaWiki API.

    :Parameters:
        session : :class:`mw.api.Session`
            An API session to use
        language : :class:`~revscoring.languages.language.Language`
            A language context to use when extracting
        context : `dict` | `iterable`
            A collection of `~revscoring.dependencies.dependent.Dependent` to
            inject when extracting.
        cache : `dict`
            A collection of pre-computed values to inject when extracting
    """
    def __init__(self, session, language=None, context=None, cache=None):
        cache = cache or {}
        context = dependencies.normalize_context(context)

        self.session = session
        self.language = language

        local_cache = {
            site.namespace_map: self.get_namespace_map()
        }
        local_context = {d:d for d in [
            Datasource("revision.doc", self.process_revision_doc,
                       depends_on=[revision.id]),
            Datasource("revision.metadata", self.process_revision_metadata,
                       depends_on=[revision_doc]),
            Datasource("revision.text", self.process_revision_text,
                       depends_on=[revision_doc]),
            Datasource("parent_revision.doc", self.process_parent_revision_doc,
                       depends_on=[revision.metadata]),
            Datasource("parent_revision.metadata",
                       self.process_revision_metadata_if_exists,
                       depends_on=[parent_revision_doc]),
            Datasource("parent_revision.text",
                       self.process_revision_text,
                       depends_on=[parent_revision_doc]),
            Datasource("previous_user_revision.doc",
                       self.process_previous_user_revision_doc,
                       depends_on=[revision.metadata]),
            Datasource("previous_user_revision.metadata",
                       self.process_revision_metadata_if_exists,
                       depends_on=[previous_user_revision_doc]),
            Datasource("page_creation.doc",
                       self.process_page_creation_doc,
                       depends_on=[revision.metadata]),
            Datasource("page_creation.metadata",
                       self.process_revision_metadata,
                       depends_on=[page_creation_doc]),
            Datasource("user.doc",
                       self.process_user_doc,
                       depends_on=[revision.metadata]),
            Datasource("user.info",
                       self.process_user_info,
                       depends_on=[user_doc])
        ]}
        if self.language != None:
            local_context.update(self.language.context)

        local_context.update(context)
        local_cache.update(cache)

        super().__init__(local_context, local_cache)

    def extract(self, rev_ids, dependents, context=None, caches=None):
        """
        Extracts a values for a set of
        :class:`~revscoring.dependents.dependent.Dependent` (e.g.
        :class:`~revscoring.features.feature.Feature` or
        :class:`~revscoring.datasources.datasource.Datasource`) for a revision
        or a set of revisions

        :Parameters:
            rev_ids : int | `iterable`
                Either a single rev_id or an `iterable` of rev_ids
            dependents : :class:`~revscoring.dependents.dependent.Dependent`
                A set of dependents to extract values for
            context : `dict` | `iterable`
                A set of call-specific
                :class:`~revscoring.dependents.dependent.Dependent` to inject
            cache : `dict`
                A set of call-specific pre-computed values to inject

        :Returns:
            An generator of extracted values if a single rev_id was provided or
            a genetator of (error, values) pairs where error is `None` if no
            error occured during extraction.
        """
        caches = caches or {}
        context = dependencies.normalize_context(context)

        if hasattr(rev_ids, "__iter__"):
            return self._extract_many(rev_ids, dependents, context, caches)
        else:
            rev_id = rev_ids
            cache = caches
            return self._extract(rev_id, dependents, context, caches)

    def _extract_many(self, rev_ids, dependents, context, caches):
        all_dependents = set(dependencies.expand(dependents))

        # Prime caches
        extract_caches = defaultdict(dict)
        for rev_id in caches:
            extract_caches[rev_id].update(caches[rev_id])

        # Build up caches for data that can be queried in batch
        if revision.metadata in all_dependents or \
           revision.text in all_dependents:
            rev_ids_missing_data = [
                rid for rid in rev_ids
                if rid not in extract_caches or
                   revision.text not in extract_caches[rid] or
                   revision.metadata not in extract_caches[rid] or
                   revision_doc not in extract_caches[rid]
            ]
            rev_docs = self.get_rev_doc_map(rev_ids)

            for rev_id in rev_ids:
                extract_caches[rev_id][revision_doc] = rev_docs.get(rev_id)

            if parent_revision.metadata in all_dependents or \
               parent_revision.text in all_dependents:

                parent_ids = [r.get('parentid') for r in rev_docs.values()
                              if r.get('parentid', 0) > 0]

                parent_rev_docs = self.get_rev_doc_map(parent_ids)

                for rev_doc in rev_docs.values():
                    extract_caches[rev_doc['revid']][parent_revision_doc] = \
                            parent_rev_docs.get(rev_doc['parentid'])

            if user.info in all_dependents:
                user_texts = [r.get('user') for r in rev_docs.values()]
                user_docs = self.get_user_doc_map(user_texts)

                for rev_doc in rev_docs.values():
                    extract_caches[rev_doc['revid']][user_doc] = \
                            user_docs.get(rev_doc.get('user'))

        # Now extract dependent values one-by-one
        for rev_id in rev_ids:
            try:
                values = self._extract(rev_id, dependents, context=context,
                                       cache=extract_caches[rev_id])
                yield None, list(values)
            except Exception as e:
                yield e, None

    def _extract(self, rev_id, dependents, cache, context):
        extract_cache = {revision.id: rev_id}
        extract_cache.update(cache)
        return self.solve(dependents, context=context, cache=extract_cache)

    def get_namespace_map(self):
        logger.info("Requesting site info from the API")
        doc = self.session.site_info.query(
            properties={'general', 'namespaces', 'namespacealiases'}
        )

        return self.namespace_map_from_doc(doc)

    def get_rev_doc_map(self, rev_ids, props={'ids', 'user', 'timestamp',
                                              'userid', 'comment', 'content',
                                              'flags', 'size'}):
        if len(rev_ids) == 0: return {}
        logger.info("Batch requesting {0} revisions from the API" \
                    .format(len(rev_ids)))
        return {rd['revid']:rd
                for rd in self.session.revisions.query(
                    revids=rev_ids,
                    properties=props
                )}

    def get_user_doc_map(self, user_texts, props={'blockinfo', 'implicitgroups',
                                                  'groups', 'registration',
                                                  'emailable', 'editcount',
                                                  'gender'}):
        if len(user_texts) == 0: return {}
        logger.info("Batch requesting {0} users from the API" \
                    .format(len(user_texts)))
        return {ud['name']:ud
                for ud in self.session.users.query(
                    users=user_texts,
                    properties=props
                )}

    def process_revision_doc(self, rev_id):
        logger.info("Requesting a revision ({0}) from the API".format(rev_id))
        props = {'ids', 'user', 'timestamp', 'userid', 'comment',
                 'content', 'flags', 'size'}
        return self.session.revisions.get(rev_id=rev_id, properties=props)

    def process_parent_revision_doc(self, revision_metadata):
        props = {'ids', 'user', 'timestamp', 'userid', 'comment',
                 'content', 'flags', 'size'}
        if revision_metadata.parent_id is not None and \
            revision_metadata.parent_id > 0:
            rev_id = revision_metadata.parent_id
            try:
                logger.info("Requesting a parent revision ({0}) from the API" \
                            .format(rev_id))
                return self.session.revisions.get(
                    rev_id=rev_id,
                    properties=props
                )
            except KeyError:
                return None
        else:
            return None

    def process_previous_user_revision_doc(self, revision_metadata):
        if revision_metadata.user_text is not None:
            logger.info("Requesting previous user revision ({0}) from the API" \
                        .format(revision_metadata.user_text))
            docs = self.session.user_contribs.query(
                user={revision_metadata.user_text},
                properties={'ids', 'timestamp'},
                limit=1,
                direction="older",
                start=revision_metadata.timestamp-1
            )
            docs = list(docs)

            if len(docs) > 0:
                return docs[0]
            else:
                return None
        else:
            return None

    def process_page_creation_doc(self, revision_metadata):
        logger.info("Requesting page creation ({0}) from the API" \
                    .format(revision_metadata.page_id))
        docs = self.session.revisions.query(
            pageids={revision_metadata.page_id},
            direction="newer",
            limit=1,
            properties={'ids', 'user', 'timestamp', 'userid', 'comment',
                        'flags', 'size'}
        )
        docs = list(docs)

        if len(docs) == 1:
            return docs[0]
        else:
            raise RevisionDocumentNotFound(
                {'page_id': revision_metadata.page_id}
            )

    def process_user_doc(self, revision_metadata):
        logger.info("Requesting user info ({0}) from the API" \
                    .format(revision_metadata.user_text))
        user_docs = self.session.users.query(
            users={revision_metadata.user_text},
            properties={'blockinfo', 'implicitgroups', 'groups', 'registration',
                        'emailable', 'editcount', 'gender'}
        )

        user_docs = list(user_docs)

        if len(user_docs) >= 1:
            return user_docs[0]
        else:
            return None

    @classmethod
    def process_revision_metadata(cls, revision_doc):
        if revision_doc is None:
            raise RevisionDocumentNotFound()
        return cls.revision_metadata_from_doc(revision_doc)

    @classmethod
    def process_revision_metadata_if_exists(cls, revision_doc):
        if revision_doc is None:
            return None
        else:
            return cls.revision_metadata_from_doc(revision_doc)

    @classmethod
    def process_user_info(cls, user_doc):
        return cls.user_info_from_doc(user_doc)

    @classmethod
    def process_revision_text(cls, revision_doc):
        if revision_doc is None: return None
        return revision_doc.get('*', "")

    @classmethod
    def revision_metadata_from_doc(cls, rev_doc):
        if rev_doc is None: return None
        try:
            timestamp = Timestamp(rev_doc.get('timestamp'))
        except ValueError:
            timestamp = None

        return RevisionMetadata(rev_doc.get('revid'),
                                rev_doc.get('parentid'),
                                rev_doc.get('user'),
                                rev_doc.get('userid'),
                                timestamp,
                                rev_doc.get('comment'),
                                rev_doc.get('page', {}).get('pageid'),
                                rev_doc.get('page', {}).get('ns'),
                                rev_doc.get('page', {}).get('title'),
                                rev_doc.get('size'),
                                'minor' in rev_doc)

    @classmethod
    def user_info_from_doc(cls, user_doc):
        if user_doc is None: return None
        try:
            registration = Timestamp(user_doc.get('registration'))
        except ValueError:
            registration = None

        return UserInfo(
            user_doc.get('userid'),
            user_doc.get('name'),
            user_doc.get('editcount'),
            registration,
            user_doc.get('groups', []),
            user_doc.get('implicitgroups', []),
            "emailable" in user_doc,
            user_doc.get('gender'),
            user_doc.get('blockid'),
            user_doc.get('blockedby'),
            user_doc.get('blockedbyid'),
            user_doc.get('blockedtimestamp'),
            user_doc.get('blockreason'),
            user_doc.get('blockexpiry')
        )

    @classmethod
    def namespace_map_from_doc(cls, site_doc):
        aliases = site_doc.get('namespacealiases', [])
        alias_map = {}
        for alias_doc in aliases:
            prev_list = alias_map.get(alias_doc['id'], [])
            prev_list.append(alias_doc['*'])
            alias_map[alias_doc['id']] = prev_list

        namespace_map = {}
        for ns_doc in site_doc.get('namespaces', {}).values():
            namespace = Namespace.from_doc(ns_doc, aliases=alias_map)
            namespace_map[namespace.id] = namespace

        return namespace_map

    @classmethod
    def from_config(cls, config, name, section_key="extractors"):
        section = config[section_key][name]
        session = api.Session(section['url'],
                              user_agent=section['user_agent'])

        language = Language.from_config(config, section['language'])

        return cls(session, language)

#    Copyright 2014 Objectif Libre
#    Copyright 2015 DotHill Systems
#
#    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.
#

from oslo_log import log as logging

import cinder.volume.driver
from cinder.volume.drivers.dothill import dothill_common
from cinder.volume.drivers.san import san
from cinder.zonemanager import utils as fczm_utils

LOG = logging.getLogger(__name__)


class DotHillFCDriver(cinder.volume.driver.FibreChannelDriver):
    """Openstack Fibre Channel cinder drivers for DotHill Arrays.

    Version history:
        0.1    - Base version developed for HPMSA FC drivers:
                    "https://github.com/openstack/cinder/tree/stable/juno/
                     cinder/volume/drivers/san/hp"
        1.0    - Version developed for DotHill arrays with the following
                 modifications:
                     - added support for v3 API(realstor feature)
                     - added support for retype volume
                     - added support for manage/unmanage volume
                     - added initiator target mapping in FC zoning
                     - added https support

    """

    VERSION = "1.0"

    def __init__(self, *args, **kwargs):
        super(DotHillFCDriver, self).__init__(*args, **kwargs)
        self.common = None
        self.configuration.append_config_values(dothill_common.common_opt)
        self.configuration.append_config_values(san.san_opts)
        self.lookup_service = fczm_utils.create_lookup_service()

    def _init_common(self):
        return dothill_common.DotHillCommon(self.configuration)

    def _check_flags(self):
        required_flags = ['san_ip', 'san_login', 'san_password']
        self.common.check_flags(self.configuration, required_flags)

    def do_setup(self, context):
        self.common = self._init_common()
        self._check_flags()
        self.common.do_setup(context)

    def check_for_setup_error(self):
        self._check_flags()

    def create_volume(self, volume):
        return {'metadata': self.common.create_volume(volume)}

    def create_volume_from_snapshot(self, volume, src_vref):
        self.common.create_volume_from_snapshot(volume, src_vref)

    def create_cloned_volume(self, volume, src_vref):
        return {'metadata': self.common.create_cloned_volume(volume, src_vref)}

    def delete_volume(self, volume):
        self.common.delete_volume(volume)

    @fczm_utils.AddFCZone
    def initialize_connection(self, volume, connector):
        self.common.client_login()
        try:
            data = {}
            data['target_lun'] = self.common.map_volume(volume,
                                                        connector,
                                                        'wwpns')

            ports, init_targ_map = self.get_init_targ_map(connector)
            data['target_discovered'] = True
            data['target_wwn'] = ports
            data['initiator_target_map'] = init_targ_map
            info = {'driver_volume_type': 'fibre_channel',
                    'data': data}
            return info
        finally:
            self.common.client_logout()

    @fczm_utils.RemoveFCZone
    def terminate_connection(self, volume, connector, **kwargs):
        self.common.unmap_volume(volume, connector, 'wwpns')
        info = {'driver_volume_type': 'fibre_channel', 'data': {}}
        if not self.common.client.list_luns_for_host(connector['wwpns'][0]):
            ports, init_targ_map = self.get_init_targ_map(connector)
            info['data'] = {'target_wwn': ports,
                            'initiator_target_map': init_targ_map}
        return info

    def get_init_targ_map(self, connector):
        init_targ_map = {}
        target_wwns = []
        ports = self.common.get_active_fc_target_ports()
        if self.lookup_service is not None:
            dev_map = self.lookup_service.get_device_mapping_from_network(
                connector['wwpns'],
                ports)
            for fabric_name in dev_map:
                fabric = dev_map[fabric_name]
                target_wwns += fabric['target_port_wwn_list']
                for initiator in fabric['initiator_port_wwn_list']:
                    if initiator not in init_targ_map:
                        init_targ_map[initiator] = []
                    init_targ_map[initiator] += fabric['target_port_wwn_list']
                    init_targ_map[initiator] = list(set(
                                                    init_targ_map[initiator]))
            target_wwns = list(set(target_wwns))
        else:
            initiator_wwns = connector['wwpns']
            target_wwns = ports
            for initiator in initiator_wwns:
                init_targ_map[initiator] = target_wwns

        return target_wwns, init_targ_map

    def get_volume_stats(self, refresh=False):
        stats = self.common.get_volume_stats(refresh)
        stats['storage_protocol'] = 'FC'
        stats['driver_version'] = self.VERSION
        backend_name = self.configuration.safe_get('volume_backend_name')
        stats['volume_backend_name'] = (backend_name or
                                        self.__class__.__name__)
        return stats

    def create_export(self, context, volume, connector):
        pass

    def ensure_export(self, context, volume):
        pass

    def remove_export(self, context, volume):
        pass

    def create_snapshot(self, snapshot):
        self.common.create_snapshot(snapshot)

    def delete_snapshot(self, snapshot):
        self.common.delete_snapshot(snapshot)

    def extend_volume(self, volume, new_size):
        self.common.extend_volume(volume, new_size)

    def retype(self, context, volume, new_type, diff, host):
        return self.common.retype(volume, new_type, diff, host)

    def manage_existing(self, volume, existing_ref):
        self.common.manage_existing(volume, existing_ref)

    def manage_existing_get_size(self, volume, existing_ref):
        return self.common.manage_existing_get_size(volume, existing_ref)

    def unmanage(self, volume):
        pass

#
# setup.py
#
# Copyright (C) 2009 Damien Churchill <damoxc@gmail.com>
#
# Basic plugin template created by:
# Copyright (C) 2008 Martijn Voncken <mvoncken@gmail.com>
# Copyright (C) 2007-2009 Andrew Resch <andrewresch@gmail.com>
#
# Deluge is free software.
#
# You may redistribute it and/or modify it under the terms of the
# GNU General Public License, as published by the Free Software
# Foundation; either version 3 of the License, or (at your option)
# any later version.
#
# deluge is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with deluge.    If not, write to:
# 	The Free Software Foundation, Inc.,
# 	51 Franklin Street, Fifth Floor
# 	Boston, MA  02110-1301, USA.
#
#    In addition, as a special exception, the copyright holders give
#    permission to link the code of portions of this program with the OpenSSL
#    library.
#    You must obey the GNU General Public License in all respects for all of
#    the code used other than OpenSSL. If you modify file(s) with this
#    exception, you may extend this exception to your version of the file(s),
#    but you are not obligated to do so. If you do not wish to do so, delete
#    this exception statement from your version. If you delete this exception
#    statement from all source files in the program, then also delete it here.
#

from setuptools import setup

__plugin_name__ = "WebUi"
__author__ = "Damien Churchill"
__author_email__ = "damoxc@gmail.com"
__version__ = "0.1"
__url__ = "http://deluge-torrent.org"
__license__ = "GPLv3"
__description__ = "Allows starting the web interface within the daemon."
__long_description__ = """"""
__pkg_data__ = {__plugin_name__.lower(): ["template/*", "data/*"]}

setup(
    name=__plugin_name__,
    version=__version__,
    description=__description__,
    author=__author__,
    author_email=__author_email__,
    url=__url__,
    license=__license__,
    long_description=__long_description__ if __long_description__ else __description__,

    packages=[__plugin_name__.lower()],
    package_data = __pkg_data__,

    entry_points="""
    [deluge.plugin.core]
    %s = %s:CorePlugin
    [deluge.plugin.gtkui]
    %s = %s:GtkUIPlugin
    """ % ((__plugin_name__, __plugin_name__.lower())*2)
)

######################################################################
##
## Copyright (C) 2007,  Blekinge Institute of Technology
##
## Filename:      parse.py
## Author:        Simon Kagstrom <ska@bth.se>
## Description:   Parsing-related stuff for the peephole optimizer
##
## $Id: parse.py 14173 2007-03-11 14:52:39Z ska $
##
######################################################################
from classes import *
import template
import re, sys
import emit

from templates import unused_label, goto_next_line, const_store_aload, push_store_inc, const_and_inc, jal_return, jal_arguments, double_stores, double_pop, getstatic_v1_pop, putstatic_getstatic, dup_pop, const_and_pop

FUNCTION_NAME="([A-Z,a-z,0-9,_,\(,\)]+)"

function_name = re.compile(FUNCTION_NAME)
method_declaration = re.compile(".method [public|private]+ static " + FUNCTION_NAME)
method_end = re.compile(".end method")
label_definition = re.compile("[ ,\t]*([A-Z,a-z,0-9,_]+):")
comment = re.compile("[ ,\t]*;([A-Z,a-z,0-9,_,\(,\), ]+):")

ins_goto = re.compile("[ ,\t]*goto[ ,\t]([A-Z,a-z,0-9,_]+)")
ins_iload = re.compile("[ ,\t]*iload[_, ]([0-9]+)")   # iload_0, iload 15
ins_istore = re.compile("[ ,\t]*istore[_, ]([0-9]+)") # istore_2, istore 15
ins_aload = re.compile("[ ,\t]*aload[_, ]([0-9]+)")   # iload_0, iload 15
ins_astore = re.compile("[ ,\t]*astore[_, ]([0-9]+)") # istore_2, istore 15
ins_getstatic_reg = re.compile("[ ,\t]*getstatic (CRunTime/[hl][io]) I")
ins_getstatic_reg_v1 = re.compile("[ ,\t]*getstatic (CRunTime/saved_v1) I")
ins_putstatic_reg = re.compile("[ ,\t]*putstatic (CRunTime/[hl][io]) I")
ins_putstatic_reg_v1 = re.compile("[ ,\t]*putstatic (CRunTime/saved_v1) I")
ins_iinc = re.compile("[ ,\t]*iinc ([0-9]+) ([-]*[0-9]+)")    # iinc reg val
ins_ipush = re.compile("[ ,\t]*[bs]ipush ([-]*[0-9]+)")
ins_ldc_int = re.compile("[ ,\t]*ldc ([-]*[0-9]+)")
ins_iconst = re.compile("[ ,\t]*iconst_([0-5]+)")
ins_iconst_m1 = re.compile("[ ,\t]*iconst_m1")
ins_cond_branch_two = re.compile("[ ,\t]*if_icmp[ne][qe][ ,\t]([A-Z,a-z,0-9,_]+)")
ins_cond_branch_one = re.compile("[ ,\t]*if[glne][etq][ ,\t]([A-Z,a-z,0-9,_]+)")
ins_invokestatic = re.compile("[ ,\t]*invokestatic[ ,\t]([A-Z,a-z,0-9,_]+)")

instruction = re.compile("\t([A-Z,a-z,0-9,_,\(,\), ]+)")

def matchComment(line):
    if comment.match(line):
	return Comment(line)
    return None

def matchGoto(line):
    if ins_goto.match(line):
	match = ins_goto.match(line)
	return Goto(line, match.group(1))
    return None

def matchInvokestatic(line):
    if ins_invokestatic.match(line):
	match = ins_invokestatic.match(line)
	return Invokestatic(line, match.group(1))
    return None

def matchCondBranch(line):
    if ins_cond_branch_one.match(line):
	match = ins_cond_branch_one.match(line)
	return ConditionalBranchOne(line, match.group(1))
    if ins_cond_branch_two.match(line):
	match = ins_cond_branch_two.match(line)
	return ConditionalBranchTwo(line, match.group(1))
    return None

def matchIinc(line):
    if ins_iinc.match(line):
	match = ins_iinc.match(line)
	return Iinc(line, match.group(1), match.group(2))
    return None

def matchIstore(line):
    if ins_istore.match(line):
	match = ins_istore.match(line)
	return Istore(line, match.group(1))
    return None

def matchIload(line):
    if ins_iload.match(line):
	match = ins_iload.match(line)
	return Iload(line, match.group(1))
    return None

def matchAstore(line):
    if ins_astore.match(line):
	match = ins_astore.match(line)
	return Astore(line, match.group(1))
    return None

def matchAload(line):
    if ins_aload.match(line):
	match = ins_aload.match(line)
	return Aload(line, match.group(1))
    return None

def matchGetstatic(line):
    if ins_getstatic_reg.match(line):
	match = ins_getstatic_reg.match(line)
	return Getstatic(line, match.group(1))
    if ins_getstatic_reg_v1.match(line):
	match = ins_getstatic_reg_v1.match(line)
	return Getstatic(line, match.group(1))
    return None

def matchPutstatic(line):
    if ins_putstatic_reg.match(line):
	match = ins_putstatic_reg.match(line)
	return Putstatic(line, match.group(1))
    if ins_putstatic_reg_v1.match(line):
	match = ins_putstatic_reg_v1.match(line)
	return Putstatic(line, match.group(1))
    return None

def matchConst(line):
    for regexp in (ins_ipush, ins_ldc_int, ins_iconst):
	if regexp.match(line):
	    match = regexp.match(line)
	    return Const(match.group(1), line)
    if ins_iconst_m1.match(line):
	return Const(-1, line)
    return None

def matchLabel(line):
    if label_definition.match(line):
	match = label_definition.match(line)
	return Label(line, match.group(1))
    return None

def matchInstruction(line):
    for fn in (matchGoto, matchConst, matchIinc, matchIstore, matchAstore, matchIload, matchAload, matchCondBranch, matchInvokestatic, matchGetstatic, matchPutstatic):
	m = fn(line)
	if m:
	    return m
    match = instruction.match(line)
    if match:
	# Check for arithmetic instructions
	if match.group(1) in ("imul", "idiv", "iadd", "isub", "ishl", "ishr", "iushr", "ixor", "iand", "ior",\
                              "irem", "lmul", "ldiv", "lrem" "fmul", "fdiv", "fadd", "fsub"):
	    return ArithmeticInstructionPopTwo(line)
	if match.group(1) in ("ineg", "fneg"):
	    return ArithmeticInstructionPopOne(line)
	if match.group(1) == "ireturn":
	    return Ireturn(line)
	return Instruction(line)
    return False


def readFile(filename):
    f = open(filename)
    lines = f.readlines()
    f.close()

    all = []

    curfn = []
    curStackTop = 0
    cur = None
    fn = False
    fnLine = ""

    for line in lines:
	com = matchComment(line)
	lab = matchLabel(line)
	ins = matchInstruction(line)

	if com:
	    cur = com
	elif lab:
	    cur = lab
	elif ins:
	    cur = ins
	    curStackTop = curStackTop + cur.stackSize
	    ins.stackTop = curStackTop
	elif method_declaration.match(line):
	    match = method_declaration.match(line)
	    fn = match.group(1)
	    fnLine = line
	    curfn = []
	    curStackTop = 0
	    all.append(Base("\n"))
	    continue
	elif method_end.match(line):
	    cur = Function(fnLine, fn, curfn)
	    fn = False
	else:
	    cur = Base(line)

	# Append cur to the current function
	if fn:
	    curfn.append(cur)
	else:
	    # Append to everything
	    all.append(cur)

    return all

def optimize(num, all):
    for item in all:
        if isinstance(item, Function):
            for n in range(0, num):
		applied = 0
		for t in template.getTemplates():
		    applied = applied + t.apply(item)
		if applied==0:
		    # No need to try again if nothing got changed
		    break

    for item in all:
	item.emit()

def run(num, infile, outfile):
    all = readFile(infile)
    print "Optimizing "+infile
    emit.out = open(outfile, "w")
    optimize(num, all)
    emit.out.close()

if __name__ == "__main__":
    run(sys.argv[1], "a.j")

#-----------------------------------------------------------------------------
# Copyright (c) 2014, Ryan Volz
# All rights reserved.
#
# Distributed under the terms of the BSD 3-Clause ("BSD New") license.
#
# The full license is in the LICENSE file, distributed with this software.
#-----------------------------------------------------------------------------

"""A module for working with dates/times that have precise sub-second resolution.


Exported Classes:

FixedTimezone -- Fixed timezone defined by timezone offset and DST flag.

SubSecTimeDelta -- Class representing relative times with sub-second resolution.

SubSecTime -- Class representing absolute times with sub-second resolution.


@author: Ryan Volz

"""
from __future__ import division as _division
import datetime as _datetime
import calendar as _calendar
import warnings as _warnings
import math as _math
import re as _re

##TODO
# __slots__ to save space per object?


class FixedTimezone(_datetime.tzinfo):
    """Fixed timezone defined by timezone offset and DST flag."""

    def __init__(self, tz_offset=0, DST=False, name=None):
        """Initialize fixed offset timezone.


        Arguments:

        tz_offset -- Timezone hours from UTC (+ for East, - for West).

        DST -- Boolean indicating whether Daylight Savings Time offset
            should be included.

        name -- String giving the timezone name.

        """
        self._offset = _datetime.timedelta(hours=tz_offset + DST)
        self._DST = DST
        self._name = name

    def utcoffset(self, dt):
        return self._offset

    def tzname(self, dt):
        return self._name

    def dst(self, dt):
        return _datetime.timedelta(hours=self._DST)


class SubSecTimeDelta(object):
    """A class for representing relative times with sub-second resolution.


    Public Attributes:

    seconds -- Integer giving the number of seconds.

    subseconds -- Integer giving the number of subseconds.


    Public Methods:

    total_seconds -- Return the time as a float in seconds.

    total_subseconds -- Return the total time as an integer in subseconds.

    """
    def __new__(cls, secs=0, ssecs=0, factor=1000000):
        """Initialize SubSecTimeDelta from seconds and subseconds integers.


        Arguments:

        secs -- Integer giving the number of seconds.

        ssecs -- Integer giving the number of subseconds.

        factor -- Integer giving conversion factor from subseconds to seconds.

        The total time is given by (secs + ssecs/factor) seconds.

        """
        self = cls.nofix(int(secs), int(ssecs), int(factor))

        # make sure ssecs is valid (absolute value less than factor)
        secs, ssecs = divmod(self._ssecs, self._factor)
        secs = secs + self._secs

        # make nsecs lie between 0 and factor-1 (inclusive) if secs > 0
        # and between -(factor-1) and 0 (inclusive) if secs < 0
        # (nsecs is already >= 0 from the divmod above)
        if secs < 0 and ssecs > 0:
            secs += 1
            ssecs -= self._factor

        self._secs = secs
        self._ssecs = ssecs

        return self

    @classmethod
    def nofix(cls, secs=0, ssecs=0, factor=1000000):
        self = object.__new__(cls)

        self._secs = secs
        self._ssecs = ssecs
        self._factor = factor

        return self

    @classmethod
    def from_seconds(cls, seconds, factor=1000000):
        factor = int(factor)
        if seconds >= 0:
            secs = int(seconds)
            ssecs = int(round((seconds % 1)*factor))
            return cls.nofix(secs=secs, ssecs=ssecs, factor=factor)
        else:
            secs = -int(-seconds)
            ssecs = -int(round((-seconds % 1)*factor))
            return cls.nofix(secs=secs, ssecs=ssecs, factor=factor)

    @property
    def seconds(self):
        """Get seconds."""
        return self._secs

    @property
    def subseconds(self):
        """Get subseconds."""
        return self._ssecs

    @property
    def factor(self):
        """Get subsecond factor."""
        return self._factor

    def total_seconds(self):
        """Return the time as a float in seconds."""
        return self._secs + self._ssecs/self._factor

    def total_subseconds(self):
        """Return the total time as an integer in subseconds."""
        return self._ssecs + self._secs*self._factor

    def make_special(self):
        factor = self._factor
        if factor == 1000:
            return MilliTimeDelta.nofix(self._secs, self._ssecs, factor)
        elif factor == 1000000:
            return MicroTimeDelta.nofix(self._secs, self._ssecs, factor)
        elif factor == 1000000000:
            return NanoTimeDelta.nofix(self._secs, self._ssecs, factor)
        elif factor == 1000000000000:
            return PicoTimeDelta.nofix(self._secs, self._ssecs, factor)
        return self

    def change_factor(self, factor):
        """Change the subsecond factor to the one provided."""
        if factor == self._factor:
            return self
        changed = SubSecTimeDelta(self._secs, self._ssecs*factor//self._factor,
                                  factor)
        return changed

    def equalize_factors(self, other):
        """Equalize factors for two SubSecTimeDelta objects to their maximum."""
        if self._factor == other._factor:
            return self, other
        max_factor = max(self._factor, other._factor)
        return self.change_factor(max_factor), other.change_factor(max_factor)

    def fractional_digits(self, precision=12):
        dec_exp = _math.log10(self._factor)
        if dec_exp.is_integer():
            fstr = '{0:0' + str(int(dec_exp)) + '}'
            return fstr.format(self._ssecs).rstrip('0')
        else:
            fstr = '{0:.' + str(precision) + 'f}'
            fracstring = fstr.format(float(self._ssecs)/self._factor
                                    ).split('.')[1].rstrip('0')
        if fracstring == '':
            fracstring = '0'
        return fracstring

    def __repr__(self):
        return '{0}({1}, {2}, {3})'.format(self.__class__.__name__, self._secs,
                                           self._ssecs, self._factor)

    def __str__(self):
        s = str(self._secs) + '.' + self.fractional_digits()
        # remove decimal point if no fractional digits
        s = s.rstrip('0').rstrip('.')
        return s

    def __float__(self):
        return self.total_seconds()

    def __add__(self, other):
        if isinstance(other, SubSecTimeDelta):
            s, o = self.equalize_factors(other)
            secs = s._secs + o._secs
            ssecs = s._ssecs + o._ssecs
            if isinstance(other, SubSecTime):
                return type(other)(secs, ssecs, o._factor)
            return type(self)(secs, ssecs, s._factor)
        elif isinstance(other, (int, long, float)):
            # assume other represents seconds
            return self + SubSecTimeDelta.from_seconds(other, factor=self._factor)
        return NotImplemented

    __radd__ = __add__

    def __sub__(self, other):
        return SubSecTimeDelta.__add__(self, -other)

    def __rsub__(self, other):
        return SubSecTimeDelta.__add__(-self, other)

    def __pos__(self):
        return self

    def __neg__(self):
        return type(self).nofix(-self._secs, -self._ssecs, self._factor)

    def __abs__(self):
        return type(self).nofix(abs(self._secs), abs(self._ssecs), self._factor)

    def __mul__(self, other):
        if isinstance(other, (int, long)):
            return type(self)(self._secs*other, self._ssecs*other, self._factor)
        if isinstance(other, float):
            a, b = other.as_integer_ratio()
            return self * a / b
        return NotImplemented

    __rmul__ = __mul__

    def __divmod__(self, other):
        if isinstance(other, SubSecTimeDelta):
            s, o = self.equalize_factors(other)
            div, rem = divmod(s.total_subseconds(),
                              o.total_subseconds())
            mod = type(other).nofix(0, rem, o.factor)
            return div, mod
        return NotImplemented

    def __floordiv__(self, other):
        if isinstance(other, SubSecTimeDelta):
            s, o = self.equalize_factors(other)
            return s.total_subseconds() // o.total_subseconds()
        elif isinstance(other, (int, long)):
            return type(self)(0, self.total_subseconds() // other,
                              self._factor)
        return NotImplemented

    def __mod__(self, other):
        if isinstance(other, SubSecTimeDelta):
            s, o = self.equalize_factors(other)
            return type(other)(0, (s.total_subseconds()
                                   % o.total_subseconds()), o._factor)
        return NotImplemented

    def __truediv__(self, other):
        if isinstance(other, SubSecTimeDelta):
            s, o = self.equalize_factors(other)
            return s.total_subseconds() / o.total_subseconds()
        elif isinstance(other, (int, long, float)):
            return type(self)(0, self.total_subseconds() / other,
                              self._factor)
        return NotImplemented

    __div__ = __truediv__

    def __cmp__(self, other):
        if isinstance(other, SubSecTimeDelta):
            s, o = self.equalize_factors(other)
            return cmp((s._secs, s._ssecs), (o._secs, o._ssecs))
        elif isinstance(other, (int, long, float)):
            # assume other represents seconds
            return cmp(self, type(self).from_seconds(other, self._factor))
        return NotImplemented

    def __hash__(self):
        return hash((self._secs, self._ssecs, self._factor))


class SubSecTime(SubSecTimeDelta):
    """A class for representing absolute times with subsecond resolution.

    The time represents the seconds and subseconds in UTC from epoch.

    Derived from SubSecTimeDelta, so provides all of its functionality.


    Additional methods:

    from_datetime -- Create a SubSecTime object from a datetime object.

    to_datetime -- Convert SubSecTime object to a datetime object.

    Addition or subtraction with a SubSecTimeDelta produces a new SubSecTime
    object. Otherwise, operations are defined as with SubSecTimeDelta.

    """
    _fromstring_compiled_re = None

    @classmethod
    def from_string(cls, timestr):
        """Create SubSecTime from str in strftime format '%Y-%m-%d %H:%M:%S.%f'.

        Converting a SubSecTime to and from a string is possible so that
        sst == SubSecTime.from_string(str(sst)).

        """
        if cls._fromstring_compiled_re is None:
            pat = '(?P<Y>\d\d\d\d)' \
                  + '-(?P<m>1[0-2]|0[1-9]|[1-9])' \
                  + '-(?P<d>3[0-1]|[1-2]\d|0[1-9]|[1-9]| [1-9])' \
                  + '\s+(?P<H>2[0-3]|[0-1]\d|\d)' \
                  + ':(?P<M>[0-5]\d|\d)' \
                  + ':(?P<S>6[0-1]|[0-5]\d|\d)' \
                  + '\.(?P<f>[0-9]+)'
            cls._fromstring_compiled_re = _re.compile(pat, _re.IGNORECASE)

        v = cls._fromstring_compiled_re.match(timestr).groupdict()
        secsdt = _datetime.datetime(int(v['Y']), int(v['m']), int(v['d']),
                                    int(v['H']), int(v['M']), int(v['S']))
        secs = _calendar.timegm(secsdt.utctimetuple())
        ssecs = int(v['f'])
        digits = len(v['f'])
        factor = 10**digits

        return cls(secs, ssecs, factor)

    @classmethod
    def from_datetime(cls, dt):
        """Create a SubSecTime object from a datetime object.


        Arguments:

        dt -- Datetime object to be converted to a SubSecTime object.

        Returns:

        A SubSecTime object giving the time from epoch in UTC.

        """
        secs = _calendar.timegm(dt.utctimetuple())
        ssecs = dt.microsecond
        factor = 1000000
        return cls(secs, ssecs, factor)

    def to_datetime(self, tz=None):
        """Convert SubSecTime object to a datetime object.

        Precision may be lost in the conversion since datetimes are only
        accurate to microseconds.


        Arguments:

        tz -- Timezone given by a _datetime.tzinfo object within which the
            datetime will be given.
            If None, timezone representing UTC will be used.


        Returns:

        A datetime object representing the same time as the SubSecTime object.

        """
        if tz is None:
            tz = FixedTimezone(tz_offset=0, DST=0, name='UTC')

        return _datetime.datetime.fromtimestamp(self.total_seconds(), tz)

    def make_special(self):
        factor = self._factor
        if factor == 1000:
            return MilliTime.nofix(self._secs, self._ssecs, factor)
        elif factor == 1000000:
            return MicroTime.nofix(self._secs, self._ssecs, factor)
        elif factor == 1000000000:
            return NanoTime.nofix(self._secs, self._ssecs, factor)
        elif factor == 1000000000000:
            return PicoTime.nofix(self._secs, self._ssecs, factor)
        return self

    def change_factor(self, factor):
        """Change the subsecond factor to the one provided."""
        if factor == self._factor:
            return self
        changed = SubSecTime(self._secs, self._ssecs*factor//self._factor,
                             factor)
        return changed

    def strftime(self, fstr, precision=12):
        """Like datetime strftime, but '%f' is replaced with fractional
        subsecond digits.

        """
        dtfstr = fstr.replace('%f', self.fractional_digits(precision))
        return self.to_datetime().strftime(dtfstr)

    def __str__(self):
        return self.strftime('%Y-%m-%d %H:%M:%S.%f').rstrip('0').rstrip('.')

    def __add__(self, other):
        if isinstance(other, SubSecTime):
            return NotImplemented
        return SubSecTimeDelta.__add__(self, other)

    __radd__ = __add__

    def __sub__(self, other):
        if isinstance(other, SubSecTime):
            # need to handle this specially to get SubSecTimeDelta as output
            s, o = self.equalize_factors(other)
            secs = s._secs - o._secs
            ssecs = s._ssecs - o._ssecs
            deltaclass = o.__class__.__bases__[0] # to keep specialized type
            return deltaclass(secs, ssecs, s._factor)
        return SubSecTimeDelta.__sub__(self, other)


class MilliTimeDelta(SubSecTimeDelta):
    # needed to set default factor
    def __new__(cls, secs=0, ssecs=0, factor=1000):
        return SubSecTimeDelta.__new__(cls, secs, ssecs, factor)

    @classmethod
    def nofix(cls, secs=0, ssecs=0, factor=1000):
        if factor != 1000:
            _warnings.warn('Converting subseconds to new factor', RuntimeWarning)
            ssecs = (ssecs*1000) // factor
            if (factor > 1000) and (((ssecs*1000) % factor) != 0):
                _warnings.warn('Precision lost in conversion to new subsecond factor',
                               RuntimeWarning)
        return super(MilliTimeDelta, cls).nofix(secs, ssecs, 1000)

    @classmethod
    def from_seconds(cls, seconds):
        factor = 1000
        return super(MilliTimeDelta, cls).from_seconds(seconds, factor)

    @property
    def milliseconds(self):
        """Get milliseconds."""
        return self.subseconds

    def total_milliseconds(self):
        """Return the total time as an integer in milliseconds."""
        return self.total_subseconds()

    def __repr__(self):
        return '{0}({1}, {2})'.format(self.__class__.__name__, self._secs,
                                      self._ssecs)


class MilliTime(MilliTimeDelta, SubSecTime):
    pass


class MicroTimeDelta(SubSecTimeDelta):
    # needed to set default factor
    def __new__(cls, secs=0, ssecs=0, factor=1000000):
        return SubSecTimeDelta.__new__(cls, secs, ssecs, factor)

    @classmethod
    def nofix(cls, secs=0, ssecs=0, factor=1000000):
        if factor != 1000000:
            _warnings.warn('Converting subseconds to new factor', RuntimeWarning)
            ssecs = (ssecs*1000000) // factor
            if (factor > 1000000) and (((ssecs*1000000) % factor) != 0):
                _warnings.warn('Precision lost in conversion to new subsecond factor',
                               RuntimeWarning)
        return super(MicroTimeDelta, cls).nofix(secs, ssecs, 1000000)

    @classmethod
    def from_seconds(cls, seconds):
        factor = 1000000
        return super(MicroTimeDelta, cls).from_seconds(seconds, factor)

    @property
    def microseconds(self):
        """Get microseconds."""
        return self.subseconds

    def total_microseconds(self):
        """Return the total time as an integer in microseconds."""
        return self.total_subseconds()

    def __repr__(self):
        return '{0}({1}, {2})'.format(self.__class__.__name__, self._secs,
                                      self._ssecs)


class MicroTime(MicroTimeDelta, SubSecTime):
    pass


class NanoTimeDelta(SubSecTimeDelta):
    # needed to set default factor
    def __new__(cls, secs=0, ssecs=0, factor=1000000000):
        return SubSecTimeDelta.__new__(cls, secs, ssecs, factor)

    @classmethod
    def nofix(cls, secs=0, ssecs=0, factor=1000000000):
        if factor != 1000000000:
            _warnings.warn('Converting subseconds to new factor', RuntimeWarning)
            ssecs = (ssecs*1000000000) // factor
            if (factor > 1000000000) and (((ssecs*1000000000) % factor) != 0):
                _warnings.warn('Precision lost in conversion to new subsecond factor',
                               RuntimeWarning)
        return super(NanoTimeDelta, cls).nofix(secs,
                                               ssecs,
                                               1000000000)

    @classmethod
    def from_seconds(cls, seconds):
        factor = 1000000000
        return super(NanoTimeDelta, cls).from_seconds(seconds, factor)

    @property
    def nanoseconds(self):
        """Get nanoseconds."""
        return self.subseconds

    def total_nanoseconds(self):
        """Return the total time as an integer in nanoseconds."""
        return self.total_subseconds()

    def __repr__(self):
        return '{0}({1}, {2})'.format(self.__class__.__name__, self._secs,
                                      self._ssecs)


class NanoTime(NanoTimeDelta, SubSecTime):
    pass


class PicoTimeDelta(SubSecTimeDelta):
    # needed to set default factor
    def __new__(cls, secs=0, ssecs=0, factor=1000000000000):
        return SubSecTimeDelta.__new__(cls, secs, ssecs, factor)

    @classmethod
    def nofix(cls, secs=0, ssecs=0, factor=1000000000000):
        if factor != 1000000000000:
            _warnings.warn('Converting subseconds to new factor', RuntimeWarning)
            ssecs = (ssecs*1000000000000) // factor
            if (factor > 1000000000000) and (((ssecs*1000000000000) % factor) != 0):
                _warnings.warn('Precision lost in conversion to new subsecond factor',
                               RuntimeWarning)
        return super(PicoTimeDelta, cls).nofix(secs,
                                               ssecs,
                                               1000000000000)

    @classmethod
    def from_seconds(cls, seconds):
        factor = 1000000000000
        return super(PicoTimeDelta, cls).from_seconds(seconds, factor)

    @property
    def picoseconds(self):
        """Get picoseconds."""
        return self.subseconds

    def total_picoseconds(self):
        """Return the total time as an integer in picoseconds."""
        return self.total_subseconds()

    def __repr__(self):
        return '{0}({1}, {2})'.format(self.__class__.__name__, self._secs,
                                      self._ssecs)


class PicoTime(PicoTimeDelta, SubSecTime):
    pass

# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.


{
    'name': 'Create Tasks from SO',
    'version': '1.0',
    'category': 'Project',
    'description': """
Automatically creates project tasks from procurement lines.
===========================================================

This module will automatically create a new task for each procurement order line
(e.g. for sale order lines), if the corresponding product meets the following
characteristics:

    * Product Type = Service
    * Create Task Automatically = True

If on top of that a project is specified on the product form (in the Procurement
tab), then the new task will be created in that specific project. Otherwise, the
new task will not belong to any project, and may be added to a project manually
later.

When the project task is completed or cancelled, the corresponding procurement
is updated accordingly. For example, if this procurement corresponds to a sale
order line, the sale order line will be considered delivered when the task is
completed.
""",
    'website': 'https://www.odoo.com/page/crm',
    'depends': ['project', 'sale', 'project_timesheet', 'sale_timesheet'],
    'data': ['views/sale_service_view.xml'],
    'demo': ['demo/sale_service_demo.xml'],
    'installable': True,
    'auto_install': True,
}

# Copyright 2011 OpenStack Foundation
# All Rights Reserved.
#
#    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.

from lxml import etree
import webob

from nova.api.openstack.compute.contrib import extended_availability_zone
from nova import availability_zones
from nova import compute
from nova.compute import vm_states
from nova import db
from nova import exception
from nova.objects import instance as instance_obj
from nova.openstack.common import jsonutils
from nova import test
from nova.tests.api.openstack import fakes
from nova.tests import fake_instance

UUID1 = '00000000-0000-0000-0000-000000000001'
UUID2 = '00000000-0000-0000-0000-000000000002'
UUID3 = '00000000-0000-0000-0000-000000000003'


def fake_compute_get_az(*args, **kwargs):
    inst = fakes.stub_instance(1, uuid=UUID3, host="get-host",
                               vm_state=vm_states.ACTIVE,
                               availability_zone='fakeaz')
    return fake_instance.fake_instance_obj(args[1], **inst)


def fake_compute_get_empty(*args, **kwargs):
    inst = fakes.stub_instance(1, uuid=UUID3, host="",
                               vm_state=vm_states.ACTIVE,
                               availability_zone='fakeaz')
    return fake_instance.fake_instance_obj(args[1], **inst)


def fake_compute_get(*args, **kwargs):
    inst = fakes.stub_instance(1, uuid=UUID3, host="get-host",
                               vm_state=vm_states.ACTIVE)
    return fake_instance.fake_instance_obj(args[1], **inst)


def fake_compute_get_all(*args, **kwargs):
    inst1 = fakes.stub_instance(1, uuid=UUID1, host="all-host",
                                vm_state=vm_states.ACTIVE)
    inst2 = fakes.stub_instance(2, uuid=UUID2, host="all-host",
                                vm_state=vm_states.ACTIVE)
    db_list = [inst1, inst2]
    fields = instance_obj.INSTANCE_DEFAULT_FIELDS
    return instance_obj._make_instance_list(args[1],
                                            instance_obj.InstanceList(),
                                            db_list, fields)


def fake_get_host_availability_zone(context, host):
    return host


def fake_get_no_host_availability_zone(context, host):
    return None


class ExtendedAvailabilityZoneTest(test.TestCase):
    content_type = 'application/json'
    prefix = 'OS-EXT-AZ:'

    def setUp(self):
        super(ExtendedAvailabilityZoneTest, self).setUp()
        availability_zones.reset_cache()
        fakes.stub_out_nw_api(self.stubs)
        self.stubs.Set(compute.api.API, 'get', fake_compute_get)
        self.stubs.Set(compute.api.API, 'get_all', fake_compute_get_all)
        self.stubs.Set(availability_zones, 'get_host_availability_zone',
                       fake_get_host_availability_zone)
        return_server = fakes.fake_instance_get()
        self.stubs.Set(db, 'instance_get_by_uuid', return_server)

        self.flags(
            osapi_compute_extension=[
                'nova.api.openstack.compute.contrib.select_extensions'],
            osapi_compute_ext_list=['Extended_availability_zone'])

    def _make_request(self, url):
        req = webob.Request.blank(url)
        req.headers['Accept'] = self.content_type
        res = req.get_response(fakes.wsgi_app(init_only=('servers',)))
        return res

    def _get_server(self, body):
        return jsonutils.loads(body).get('server')

    def _get_servers(self, body):
        return jsonutils.loads(body).get('servers')

    def assertAvailabilityZone(self, server, az):
        self.assertEqual(server.get('%savailability_zone' % self.prefix),
                         az)

    def test_show_no_host_az(self):
        self.stubs.Set(compute.api.API, 'get', fake_compute_get_az)
        self.stubs.Set(availability_zones, 'get_host_availability_zone',
                       fake_get_no_host_availability_zone)

        url = '/v2/fake/servers/%s' % UUID3
        res = self._make_request(url)

        self.assertEqual(res.status_int, 200)
        self.assertAvailabilityZone(self._get_server(res.body), 'fakeaz')

    def test_show_empty_host_az(self):
        self.stubs.Set(compute.api.API, 'get', fake_compute_get_empty)
        self.stubs.Set(availability_zones, 'get_host_availability_zone',
                       fake_get_no_host_availability_zone)

        url = '/v2/fake/servers/%s' % UUID3
        res = self._make_request(url)

        self.assertEqual(res.status_int, 200)
        self.assertAvailabilityZone(self._get_server(res.body), 'fakeaz')

    def test_show(self):
        url = '/v2/fake/servers/%s' % UUID3
        res = self._make_request(url)

        self.assertEqual(res.status_int, 200)
        self.assertAvailabilityZone(self._get_server(res.body), 'get-host')

    def test_detail(self):
        url = '/v2/fake/servers/detail'
        res = self._make_request(url)

        self.assertEqual(res.status_int, 200)
        for i, server in enumerate(self._get_servers(res.body)):
            self.assertAvailabilityZone(server, 'all-host')

    def test_no_instance_passthrough_404(self):

        def fake_compute_get(*args, **kwargs):
            raise exception.InstanceNotFound(instance_id='fake')

        self.stubs.Set(compute.api.API, 'get', fake_compute_get)
        url = '/v2/fake/servers/70f6db34-de8d-4fbd-aafb-4065bdfa6115'
        res = self._make_request(url)

        self.assertEqual(res.status_int, 404)


class ExtendedAvailabilityZoneXmlTest(ExtendedAvailabilityZoneTest):
    content_type = 'application/xml'
    prefix = '{%s}' % extended_availability_zone.\
                        Extended_availability_zone.namespace

    def _get_server(self, body):
        return etree.XML(body)

    def _get_servers(self, body):
        return etree.XML(body).getchildren()

import unittest, StringIO, robotparser
from test import test_support

class RobotTestCase(unittest.TestCase):
    def __init__(self, index, parser, url, good, agent):
        unittest.TestCase.__init__(self)
        if good:
            self.str = "RobotTest(%d, good, %s)" % (index, url)
        else:
            self.str = "RobotTest(%d, bad, %s)" % (index, url)
        self.parser = parser
        self.url = url
        self.good = good
        self.agent = agent

    def runTest(self):
        if isinstance(self.url, tuple):
            agent, url = self.url
        else:
            url = self.url
            agent = self.agent
        if self.good:
            self.failUnless(self.parser.can_fetch(agent, url))
        else:
            self.failIf(self.parser.can_fetch(agent, url))

    def __str__(self):
        return self.str

tests = unittest.TestSuite()

def RobotTest(index, robots_txt, good_urls, bad_urls,
              agent="test_robotparser"):

    lines = StringIO.StringIO(robots_txt).readlines()
    parser = robotparser.RobotFileParser()
    parser.parse(lines)
    for url in good_urls:
        tests.addTest(RobotTestCase(index, parser, url, 1, agent))
    for url in bad_urls:
        tests.addTest(RobotTestCase(index, parser, url, 0, agent))

# Examples from http://www.robotstxt.org/wc/norobots.html (fetched 2002)

# 1.
doc = """
User-agent: *
Disallow: /cyberworld/map/ # This is an infinite virtual URL space
Disallow: /tmp/ # these will soon disappear
Disallow: /foo.html
"""

good = ['/','/test.html']
bad = ['/cyberworld/map/index.html','/tmp/xxx','/foo.html']

RobotTest(1, doc, good, bad)

# 2.
doc = """
# robots.txt for http://www.example.com/

User-agent: *
Disallow: /cyberworld/map/ # This is an infinite virtual URL space

# Cybermapper knows where to go.
User-agent: cybermapper
Disallow:

"""

good = ['/','/test.html',('cybermapper','/cyberworld/map/index.html')]
bad = ['/cyberworld/map/index.html']

RobotTest(2, doc, good, bad)

# 3.
doc = """
# go away
User-agent: *
Disallow: /
"""

good = []
bad = ['/cyberworld/map/index.html','/','/tmp/']

RobotTest(3, doc, good, bad)

# Examples from http://www.robotstxt.org/wc/norobots-rfc.html (fetched 2002)

# 4.
doc = """
User-agent: figtree
Disallow: /tmp
Disallow: /a%3cd.html
Disallow: /a%2fb.html
Disallow: /%7ejoe/index.html
"""

good = [] # XFAIL '/a/b.html'
bad = ['/tmp','/tmp.html','/tmp/a.html',
       '/a%3cd.html','/a%3Cd.html','/a%2fb.html',
       '/~joe/index.html'
       ]

RobotTest(4, doc, good, bad, 'figtree')
RobotTest(5, doc, good, bad, 'FigTree Robot libwww-perl/5.04')

# 6.
doc = """
User-agent: *
Disallow: /tmp/
Disallow: /a%3Cd.html
Disallow: /a/b.html
Disallow: /%7ejoe/index.html
"""

good = ['/tmp',] # XFAIL: '/a%2fb.html'
bad = ['/tmp/','/tmp/a.html',
       '/a%3cd.html','/a%3Cd.html',"/a/b.html",
       '/%7Ejoe/index.html']

RobotTest(6, doc, good, bad)

# From bug report #523041

# 7.
doc = """
User-Agent: *
Disallow: /.
"""

good = ['/foo.html']
bad = [] # Bug report says "/" should be denied, but that is not in the RFC

RobotTest(7, doc, good, bad)

def test_main():
    test_support.run_suite(tests)

if __name__=='__main__':
    test_support.Verbose = 1
    test_support.run_suite(tests)

# Copyright 2011 Eldar Nugaev
# All Rights Reserved.
#
#    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.

from nova.api.openstack import compute
from nova.compute import api as compute_api
from nova import exception
from nova.openstack.common import jsonutils
from nova import test
from nova.tests.api.openstack import fakes


UUID = 'abc'


def fake_get_diagnostics(self, _context, instance_uuid):
    return {'data': 'Some diagnostic info'}


def fake_instance_get(self, _context, instance_uuid, want_objects=False):
    if instance_uuid != UUID:
        raise Exception("Invalid UUID")
    return {'uuid': instance_uuid}


def fake_instance_get_instance_not_found(self, _context, instance_uuid,
        want_objects=False):
    raise exception.InstanceNotFound(instance_id=instance_uuid)


class ServerDiagnosticsTest(test.NoDBTestCase):

    def setUp(self):
        super(ServerDiagnosticsTest, self).setUp()
        self.stubs.Set(compute_api.API, 'get_diagnostics',
                       fake_get_diagnostics)
        self.stubs.Set(compute_api.API, 'get', fake_instance_get)

        self.router = compute.APIRouterV3(init_only=('servers',
                                                     'os-server-diagnostics'))

    def test_get_diagnostics(self):
        req = fakes.HTTPRequestV3.blank(
            '/servers/%s/os-server-diagnostics' % UUID)
        res = req.get_response(self.router)
        output = jsonutils.loads(res.body)
        self.assertEqual(output, {'data': 'Some diagnostic info'})

    def test_get_diagnostics_with_non_existed_instance(self):
        req = fakes.HTTPRequestV3.blank(
            '/servers/%s/os-server-diagnostics' % UUID)
        self.stubs.Set(compute_api.API, 'get',
                       fake_instance_get_instance_not_found)
        res = req.get_response(self.router)
        self.assertEqual(res.status_int, 404)

# -*- coding: ascii -*-
#
# Copyright 2007 - 2013
# Andr\xe9 Malo or his licensors, as applicable
#
# 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.
"""
===================
 Main setup runner
===================

This module provides a wrapper around the distutils core setup.
"""
__author__ = u"Andr\xe9 Malo"
__docformat__ = "restructuredtext en"

import ConfigParser as _config_parser
from distutils import core as _core
import os as _os
import posixpath as _posixpath
import sys as _sys

from _setup import commands as _commands
from _setup import data as _data
from _setup import ext as _ext
from _setup import util as _util
from _setup import shell as _shell


def check_python_version(impl, version_min, version_max):
    """ Check python version """
    if impl == 'python':
        version_info = _sys.version_info
    elif impl == 'pypy':
        version_info = getattr(_sys, 'pypy_version_info', None)
        if not version_info:
            return
    elif impl == 'jython':
        if not 'java' in _sys.platform.lower():
            return
        version_info = _sys.version_info
    else:
        raise AssertionError("impl not in ('python', 'pypy', 'jython')")

    pyversion = map(int, version_info[:3])
    if version_min:
        min_required = \
            map(int, '.'.join((version_min, '0.0.0')).split('.')[:3])
        if pyversion < min_required:
            raise EnvironmentError("Need at least %s %s (vs. %s)" % (
                impl, version_min, '.'.join(map(str, pyversion))
            ))
    if version_max:
        max_required = map(int, version_max.split('.'))
        max_required[-1] += 1
        if pyversion >= max_required:
            raise EnvironmentError("Need at max %s %s (vs. %s)" % (
                impl,
                version_max,
                '.'.join(map(str, pyversion))
            ))


def find_description(docs):
    """
    Determine the package description from DESCRIPTION

    :Parameters:
      `docs` : ``dict``
        Docs config section

    :Return: Tuple of summary, description and license
             (``('summary', 'description', 'license')``)
             (all may be ``None``)
    :Rtype: ``tuple``
    """
    summary = None
    filename = docs.get('meta.summary', 'SUMMARY').strip()
    if filename and _os.path.isfile(filename):
        fp = open(filename)
        try:
            try:
                summary = fp.read().strip().splitlines()[0].rstrip()
            except IndexError:
                summary = ''
        finally:
            fp.close()

    description = None
    filename = docs.get('meta.description', 'DESCRIPTION').strip()
    if filename and _os.path.isfile(filename):
        fp = open(filename)
        try:
            description = fp.read().rstrip()
        finally:
            fp.close()

        if summary is None and description:
            from docutils import core
            summary = core.publish_parts(
                source=description,
                source_path=filename,
                writer_name='html',
            )['title'].encode('utf-8')

    return summary, description


def find_classifiers(docs):
    """
    Determine classifiers from CLASSIFIERS

    :return: List of classifiers (``['classifier', ...]``)
    :rtype: ``list``
    """
    filename = docs.get('meta.classifiers', 'CLASSIFIERS').strip()
    if filename and _os.path.isfile(filename):
        fp = open(filename)
        try:
            content = fp.read()
        finally:
            fp.close()
        content = [item.strip() for item in content.splitlines()]
        return [item for item in content if item and not item.startswith('#')]
    return []


def find_provides(docs):
    """
    Determine provides from PROVIDES

    :return: List of provides (``['provides', ...]``)
    :rtype: ``list``
    """
    filename = docs.get('meta.provides', 'PROVIDES').strip()
    if filename and _os.path.isfile(filename):
        fp = open(filename)
        try:
            content = fp.read()
        finally:
            fp.close()
        content = [item.strip() for item in content.splitlines()]
        return [item for item in content if item and not item.startswith('#')]
    return []


def find_license(docs):
    """
    Determine license from LICENSE

    :return: License text
    :rtype: ``str``
    """
    filename = docs.get('meta.license', 'LICENSE').strip()
    if filename and _os.path.isfile(filename):
        fp = open(filename)
        try:
            return fp.read().rstrip()
        finally:
            fp.close()
    return None


def find_packages(manifest):
    """ Determine packages and subpackages """
    packages = {}
    collect = manifest.get('packages.collect', '').split()
    lib = manifest.get('packages.lib', '.')
    try:
        sep = _os.path.sep
    except AttributeError:
        sep = _os.path.join('1', '2')[1:-1]
    for root in collect:
        for dirpath, _, filenames in _shell.walk(_os.path.join(lib, root)):
            if dirpath.find('.svn') >= 0 or dirpath.find('.git') >= 0:
                continue
            if '__init__.py' in filenames:
                packages[
                    _os.path.normpath(dirpath).replace(sep, '.')
                ] = None
    packages = packages.keys()
    packages.sort()
    return packages


def find_data(name, docs):
    """ Determine data files """
    result = []
    if docs.get('extra', '').strip():
        result.append(_data.Documentation(docs['extra'].split(),
            prefix='share/doc/%s' % name,
        ))
    if docs.get('examples.dir', '').strip():
        tpl = ['recursive-include %s *' % docs['examples.dir']]
        if docs.get('examples.ignore', '').strip():
            tpl.extend(["global-exclude %s" % item
                for item in docs['examples.ignore'].split()
            ])
        strip = int(docs.get('examples.strip', '') or 0)
        result.append(_data.Documentation.from_templates(*tpl, **{
            'strip': strip,
            'prefix': 'share/doc/%s' % name,
            'preserve': 1,
        }))
    if docs.get('userdoc.dir', '').strip():
        tpl = ['recursive-include %s *' % docs['userdoc.dir']]
        if docs.get('userdoc.ignore', '').strip():
            tpl.extend(["global-exclude %s" % item
                for item in docs['userdoc.ignore'].split()
            ])
        strip = int(docs.get('userdoc.strip', '') or 0)
        result.append(_data.Documentation.from_templates(*tpl, **{
            'strip': strip,
            'prefix': 'share/doc/%s' % name,
            'preserve': 1,
        }))
    if docs.get('apidoc.dir', '').strip():
        tpl = ['recursive-include %s *' % docs['apidoc.dir']]
        if docs.get('apidoc.ignore', '').strip():
            tpl.extend(["global-exclude %s" % item
                for item in docs['apidoc.ignore'].split()
            ])
        strip = int(docs.get('apidoc.strip', '') or 0)
        result.append(_data.Documentation.from_templates(*tpl, **{
            'strip': strip,
            'prefix': 'share/doc/%s' % name,
            'preserve': 1,
        }))
    if docs.get('man', '').strip():
        result.extend(_data.Manpages.dispatch(docs['man'].split()))
    return result


def make_manifest(manifest, config, docs, kwargs):
    """ Create file list to pack up """
    # pylint: disable = R0912
    kwargs = kwargs.copy()
    kwargs['script_args'] = ['install']
    kwargs['packages'] = list(kwargs.get('packages') or ()) + [
        '_setup', '_setup.py2', '_setup.py3',
    ] + list(manifest.get('packages.extra', '').split() or ())
    _core._setup_stop_after = "commandline"
    try:
        dist = _core.setup(**kwargs)
    finally:
        _core._setup_stop_after = None

    result = ['MANIFEST', 'PKG-INFO', 'setup.py'] + list(config)
    # TODO: work with default values:
    for key in ('classifiers', 'description', 'summary', 'provides',
                'license'):
        filename = docs.get('meta.' + key, '').strip()
        if filename and _os.path.isfile(filename):
            result.append(filename)

    cmd = dist.get_command_obj("build_py")
    cmd.ensure_finalized()
    #from pprint import pprint; pprint(("build_py", cmd.get_source_files()))
    for item in cmd.get_source_files():
        result.append(_posixpath.sep.join(
            _os.path.normpath(item).split(_os.path.sep)
        ))

    cmd = dist.get_command_obj("build_ext")
    cmd.ensure_finalized()
    #from pprint import pprint; pprint(("build_ext", cmd.get_source_files()))
    for item in cmd.get_source_files():
        result.append(_posixpath.sep.join(
            _os.path.normpath(item).split(_os.path.sep)
        ))
    for ext in cmd.extensions:
        if ext.depends:
            result.extend([_posixpath.sep.join(
                _os.path.normpath(item).split(_os.path.sep)
            ) for item in ext.depends])

    cmd = dist.get_command_obj("build_clib")
    cmd.ensure_finalized()
    if cmd.libraries:
        #import pprint; pprint.pprint(("build_clib", cmd.get_source_files()))
        for item in cmd.get_source_files():
            result.append(_posixpath.sep.join(
                _os.path.normpath(item).split(_os.path.sep)
            ))
        for lib in cmd.libraries:
            if lib[1].get('depends'):
                result.extend([_posixpath.sep.join(
                    _os.path.normpath(item).split(_os.path.sep)
                ) for item in lib[1]['depends']])

    cmd = dist.get_command_obj("build_scripts")
    cmd.ensure_finalized()
    #import pprint; pprint.pprint(("build_scripts", cmd.get_source_files()))
    if cmd.get_source_files():
        for item in cmd.get_source_files():
            result.append(_posixpath.sep.join(
                _os.path.normpath(item).split(_os.path.sep)
            ))

    cmd = dist.get_command_obj("install_data")
    cmd.ensure_finalized()
    #from pprint import pprint; pprint(("install_data", cmd.get_inputs()))
    try:
        strings = basestring
    except NameError:
        strings = (str, unicode)

    for item in cmd.get_inputs():
        if isinstance(item, strings):
            result.append(item)
        else:
            result.extend(item[1])

    for item in manifest.get('dist', '').split():
        result.append(item)
        if _os.path.isdir(item):
            for filename in _shell.files(item):
                result.append(filename)

    result = dict([(item, None) for item in result]).keys()
    result.sort()
    return result


def run(config=('package.cfg',), ext=None, script_args=None, manifest_only=0):
    """ Main runner """
    if ext is None:
        ext = []

    cfg = _util.SafeConfigParser()
    cfg.read(config)
    pkg = dict(cfg.items('package'))
    python_min = pkg.get('python.min') or None
    python_max = pkg.get('python.max') or None
    check_python_version('python', python_min, python_max)
    pypy_min = pkg.get('pypy.min') or None
    pypy_max = pkg.get('pypy.max') or None
    check_python_version('pypy', pypy_min, pypy_max)
    jython_min = pkg.get('jython.min') or None
    jython_max = pkg.get('jython.max') or None
    check_python_version('jython', jython_min, jython_max)

    manifest = dict(cfg.items('manifest'))
    try:
        docs = dict(cfg.items('docs'))
    except _config_parser.NoSectionError:
        docs = {}

    summary, description = find_description(docs)
    scripts = manifest.get('scripts', '').strip() or None
    if scripts:
        scripts = scripts.split()
    modules = manifest.get('modules', '').strip() or None
    if modules:
        modules = modules.split()
    keywords = docs.get('meta.keywords', '').strip() or None
    if keywords:
        keywords = keywords.split()
    revision = pkg.get('version.revision', '').strip()
    if revision:
        revision = int(revision)
    else:
        revision = 0

    kwargs = {
        'name': pkg['name'],
        'version': "%s%s" % (
            pkg['version.number'],
            ["", ".dev%d" % (revision,)][_util.humanbool(
                'version.dev', pkg.get('version.dev', 'false')
            )],
        ),
        'provides': find_provides(docs),
        'description': summary,
        'long_description': description,
        'classifiers': find_classifiers(docs),
        'keywords': keywords,
        'author': pkg['author.name'],
        'author_email': pkg['author.email'],
        'maintainer': pkg.get('maintainer.name'),
        'maintainer_email': pkg.get('maintainer.email'),
        'url': pkg.get('url.homepage'),
        'download_url': pkg.get('url.download'),
        'license': find_license(docs),
        'package_dir': {'': manifest.get('packages.lib', '.')},
        'packages': find_packages(manifest),
        'py_modules': modules,
        'ext_modules': ext,
        'scripts': scripts,
        'script_args': script_args,
        'data_files': find_data(pkg['name'], docs),
        'cmdclass': {
            'build'       : _commands.Build,
            'build_ext'   : _commands.BuildExt,
            'install'     : _commands.Install,
            'install_data': _commands.InstallData,
            'install_lib' : _commands.InstallLib,
        }
    }
    for key in ('provides',):
        if key not in _core.setup_keywords:
            del kwargs[key]

    if manifest_only:
        return make_manifest(manifest, config, docs, kwargs)

    # monkey-patch crappy manifest writer away.
    from distutils.command import sdist
    sdist.sdist.get_file_list = sdist.sdist.read_manifest

    return _core.setup(**kwargs)

# Copyright 2012,2013 James McCauley
#
# This file is part of POX.
#
# POX is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# POX is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with POX.  If not, see <http://www.gnu.org/licenses/>.

"""
Creates a spanning tree.

This component uses the discovery component to build a view of the network
topology, constructs a spanning tree, and then disables flooding on switch
ports that aren't on the tree by setting their NO_FLOOD bit.  The result
is that topologies with loops no longer turn your network into useless
hot packet soup.

This component is inspired by and roughly based on the description of
Glenn Gibb's spanning tree module for NOX:
  http://www.openflow.org/wk/index.php/Basic_Spanning_Tree

Note that this does not have much of a relationship to Spanning Tree
Protocol.  They have similar purposes, but this is a rather different way
of going about it.
"""

from pox.core import core
import pox.openflow.libopenflow_01 as of
from pox.lib.revent import *
from collections import defaultdict
from pox.openflow.discovery import Discovery
from pox.lib.util import dpidToStr
from pox.lib.recoco import Timer
import time

log = core.getLogger()

# Might be nice if we made this accessible on core...
#_adj = defaultdict(lambda:defaultdict(lambda:[]))

def _calc_spanning_tree ():
  """
  Calculates the actual spanning tree

  Returns it as dictionary where the keys are DPID1, and the
  values are tuples of (DPID2, port-num), where port-num
  is the port on DPID1 connecting to DPID2.
  """
  def flip (link):
    return Discovery.Link(link[2],link[3], link[0],link[1])

  adj = defaultdict(lambda:defaultdict(lambda:[]))
  switches = set()
  # Add all links and switches
  for l in core.openflow_discovery.adjacency:
    adj[l.dpid1][l.dpid2].append(l)
    switches.add(l.dpid1)
    switches.add(l.dpid2)

  # Cull links -- we want a single symmetric link connecting nodes
  for s1 in switches:
    for s2 in switches:
      if s2 not in adj[s1]:
        continue
      if not isinstance(adj[s1][s2], list):
        continue
      assert s1 is not s2
      good = False
      for l in adj[s1][s2]:
        if flip(l) in core.openflow_discovery.adjacency:
          # This is a good one
          adj[s1][s2] = l.port1
          adj[s2][s1] = l.port2
          good = True
          break
      if not good:
        del adj[s1][s2]
        if s1 in adj[s2]:
          # Delete the other way too
          del adj[s2][s1]

  q = []
  more = set(switches)

  done = set()

  tree = defaultdict(set)

  while True:
    q = sorted(list(more)) + q
    more.clear()
    if len(q) == 0: break
    v = q.pop(False)
    if v in done: continue
    done.add(v)
    for w,p in adj[v].iteritems():
      if w in tree: continue
      more.add(w)
      tree[v].add((w,p))
      tree[w].add((v,adj[w][v]))

  if False:
    log.debug("*** SPANNING TREE ***")
    for sw,ports in tree.iteritems():
      #print " ", dpidToStr(sw), ":", sorted(list(ports))
      #print " ", sw, ":", [l[0] for l in sorted(list(ports))]
      log.debug((" %i : " % sw) + " ".join([str(l[0]) for l in
                                           sorted(list(ports))]))
    log.debug("*********************")

  return tree


# Keep a list of previous port states so that we can skip some port mods
# If other things mess with port states, these may not be correct.  We
# could also refer to Connection.ports, but those are not guaranteed to
# be up to date.
_prev = defaultdict(lambda : defaultdict(lambda : None))

# If True, we set ports down when a switch connects
_noflood_by_default = False

# If True, don't allow turning off flood bits until a complete discovery
# cycle should have completed (mostly makes sense with _noflood_by_default).
_hold_down = False


def _handle_ConnectionUp (event):
  # When a switch connects, forget about previous port states
  _prev[event.dpid].clear()

  if _noflood_by_default:
    con = event.connection
    log.debug("Disabling flooding for %i ports", len(con.ports))
    for p in con.ports.itervalues():
      if p.port_no >= of.OFPP_MAX: continue
      _prev[con.dpid][p.port_no] = False
      pm = of.ofp_port_mod(port_no=p.port_no,
                          hw_addr=p.hw_addr,
                          config = of.OFPPC_NO_FLOOD,
                          mask = of.OFPPC_NO_FLOOD)
      con.send(pm)
    _invalidate_ports(con.dpid)

  if _hold_down:
    t = Timer(core.openflow_discovery.send_cycle_time + 1, _update_tree,
              kw={'force_dpid':event.dpid})


def _handle_LinkEvent (event):
  # When links change, update spanning tree
  _update_tree()


def _update_tree (force_dpid = None):
  """
  Update spanning tree

  force_dpid specifies a switch we want to update even if we are supposed
  to be holding down changes.
  """

  # Get a spanning tree
  tree = _calc_spanning_tree()
  log.debug("Spanning tree updated")

  # Connections born before this time are old enough that a complete
  # discovery cycle should have completed (and, thus, all of their
  # links should have been discovered).
  enable_time = time.time() - core.openflow_discovery.send_cycle_time - 1

  # Now modify ports as needed
  try:
    change_count = 0
    for sw, ports in tree.iteritems():
      con = core.openflow.getConnection(sw)
      if con is None: continue # Must have disconnected
      if con.connect_time is None: continue # Not fully connected

      if _hold_down:
        if con.connect_time > enable_time:
          # Too young -- we should hold down changes.
          if force_dpid is not None and sw == force_dpid:
            # .. but we'll allow it anyway
            pass
          else:
            continue

      tree_ports = [p[1] for p in ports]
      for p in con.ports.itervalues():
        if p.port_no < of.OFPP_MAX:
          flood = p.port_no in tree_ports
          if not flood:
            if core.openflow_discovery.is_edge_port(sw, p.port_no):
              flood = True
          if _prev[sw][p.port_no] is flood:
            #print sw,p.port_no,"skip","(",flood,")"
            continue # Skip
          change_count += 1
          _prev[sw][p.port_no] = flood
          #print sw,p.port_no,flood
          #TODO: Check results

          pm = of.ofp_port_mod(port_no=p.port_no,
                               hw_addr=p.hw_addr,
                               config = 0 if flood else of.OFPPC_NO_FLOOD,
                               mask = of.OFPPC_NO_FLOOD)
          con.send(pm)

          _invalidate_ports(con.dpid)
    if change_count:
      log.info("%i ports changed", change_count)
  except:
    _prev.clear()
    log.exception("Couldn't push spanning tree")


_dirty_switches = {} # A map dpid_with_dirty_ports->Timer
_coalesce_period = 2 # Seconds to wait between features requests

def _invalidate_ports (dpid):
  """
  Registers the fact that port info for dpid may be out of date

  When the spanning tree adjusts the port flags, the port config bits
  we keep in the Connection become out of date.  We don't want to just
  set them locally because an in-flight port status message could
  overwrite them.  We also might not want to assume they get set the
  way we want them.  SO, we do send a features request, but we wait a
  moment before sending it so that we can potentially coalesce several.

  TLDR: Port information for this switch may be out of date for around
        _coalesce_period seconds.
  """
  if dpid in _dirty_switches:
    # We're already planning to check
    return
  t = Timer(_coalesce_period, _check_ports, args=(dpid,))
  _dirty_switches[dpid] = t

def _check_ports (dpid):
  """
  Sends a features request to the given dpid
  """
  _dirty_switches.pop(dpid,None)
  con = core.openflow.getConnection(dpid)
  if con is None: return
  con.send(of.ofp_barrier_request())
  con.send(of.ofp_features_request())
  log.debug("Requested switch features for %s", str(con))


def launch (no_flood = False, hold_down = False):
  global _noflood_by_default, _hold_down
  if no_flood is True:
    _noflood_by_default = True
  if hold_down is True:
    _hold_down = True

  def start_spanning_tree ():
    core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
    core.openflow_discovery.addListenerByName("LinkEvent", _handle_LinkEvent)
    log.debug("Spanning tree component ready")
  core.call_when_ready(start_spanning_tree, "openflow_discovery")


# Copyright (C) 2014-2016 Cuckoo Foundation.
# This file is part of Cuckoo Sandbox - http://www.cuckoosandbox.org
# See the file 'docs/LICENSE' for copying permission.
# Originally contributed by Check Point Software Technologies, Ltd.

import time
import logging
import StringIO
from threading import Thread
from lib.common.abstracts import Auxiliary
from lib.common.results import NetlogFile
from lib.api.adb import take_screenshot
from lib.api.screenshot import Screenshot

log = logging.getLogger(__name__)
SHOT_DELAY = 2

class Screenshots(Auxiliary, Thread):
    """Take screenshots."""

    def __init__(self):
        Thread.__init__(self)
        self.do_run = True

    def stop(self):
        """Stop screenshotting."""
        self.do_run = False

    def run(self):
        """Run screenshotting.
        @return: operation status.
        """
        img_counter = 0
        img_last = None

        while self.do_run:
            time.sleep(SHOT_DELAY)

            try:
                filename = "screenshot%s.jpg" % str(img_counter)
                img_current = take_screenshot(filename)
                if img_last:
                    if Screenshot().equal(img_last, img_current):
                        continue

                file = open(img_current, 'r')
                tmpio = StringIO.StringIO(file.read())
                # now upload to host from the StringIO
                nf = NetlogFile("shots/%s.jpg" % str(img_counter).rjust(4, "0"))

                for chunk in tmpio:
                    nf.sock.sendall(chunk)

                nf.close()
                file.close()
                img_counter += 1
                img_last = img_current

            except IOError as e:
                log.error("Cannot take screenshot: %s", e)
                continue

        return True

#coding=utf-8

import os
import sys
import time
import argparse
import distutils.util
import gzip
import numpy as np

import paddle.v2 as paddle
from model import conv_seq2seq
import reader


def parse_args():
    parser = argparse.ArgumentParser(
        description="PaddlePaddle Convolutional Seq2Seq")
    parser.add_argument(
        '--train_data_path',
        type=str,
        required=True,
        help="Path of the training set")
    parser.add_argument(
        '--test_data_path', type=str, help='Path of the test set')
    parser.add_argument(
        '--src_dict_path',
        type=str,
        required=True,
        help='Path of source dictionary')
    parser.add_argument(
        '--trg_dict_path',
        type=str,
        required=True,
        help='Path of target dictionary')
    parser.add_argument(
        '--enc_blocks', type=str, help='Convolution blocks of the encoder')
    parser.add_argument(
        '--dec_blocks', type=str, help='Convolution blocks of the decoder')
    parser.add_argument(
        '--emb_size',
        type=int,
        default=256,
        help='Dimension of word embedding. (default: %(default)s)')
    parser.add_argument(
        '--pos_size',
        type=int,
        default=200,
        help='Total number of the position indexes. (default: %(default)s)')
    parser.add_argument(
        '--drop_rate',
        type=float,
        default=0.,
        help='Dropout rate. (default: %(default)s)')
    parser.add_argument(
        "--use_bn",
        default=False,
        type=distutils.util.strtobool,
        help="Use batch normalization or not. (default: %(default)s)")
    parser.add_argument(
        "--use_gpu",
        default=False,
        type=distutils.util.strtobool,
        help="Use gpu or not. (default: %(default)s)")
    parser.add_argument(
        "--trainer_count",
        default=1,
        type=int,
        help="Trainer number. (default: %(default)s)")
    parser.add_argument(
        '--batch_size',
        type=int,
        default=32,
        help="Size of a mini-batch. (default: %(default)s)")
    parser.add_argument(
        '--num_passes',
        type=int,
        default=15,
        help="Number of passes to train. (default: %(default)s)")
    return parser.parse_args()


def create_reader(padding_num,
                  train_data_path,
                  test_data_path=None,
                  src_dict=None,
                  trg_dict=None,
                  pos_size=200,
                  batch_size=32):

    train_reader = paddle.batch(
        reader=paddle.reader.shuffle(
            reader=reader.data_reader(
                data_file=train_data_path,
                src_dict=src_dict,
                trg_dict=trg_dict,
                pos_size=pos_size,
                padding_num=padding_num),
            buf_size=10240),
        batch_size=batch_size)

    test_reader = None
    if test_data_path:
        test_reader = paddle.batch(
            reader=paddle.reader.shuffle(
                reader=reader.data_reader(
                    data_file=test_data_path,
                    src_dict=src_dict,
                    trg_dict=trg_dict,
                    pos_size=pos_size,
                    padding_num=padding_num),
                buf_size=10240),
            batch_size=batch_size)

    return train_reader, test_reader


def train(train_data_path,
          test_data_path,
          src_dict_path,
          trg_dict_path,
          enc_conv_blocks,
          dec_conv_blocks,
          emb_dim=256,
          pos_size=200,
          drop_rate=0.,
          use_bn=False,
          batch_size=32,
          num_passes=15):
    """
    Train the convolution sequence-to-sequence model.    

    :param train_data_path: The path of the training set.
    :type train_data_path: str
    :param test_data_path: The path of the test set.
    :type test_data_path: str
    :param src_dict_path: The path of the source dictionary.
    :type src_dict_path: str
    :param trg_dict_path: The path of the target dictionary.
    :type trg_dict_path: str
    :param enc_conv_blocks: The scale list of the encoder's convolution blocks. And each element of
                            the list contains output dimension and context length of the corresponding
                            convolution block.
    :type enc_conv_blocks: list of tuple
    :param dec_conv_blocks: The scale list of the decoder's convolution blocks. And each element of
                            the list contains output dimension and context length of the corresponding
                            convolution block.
    :type dec_conv_blocks: list of tuple
    :param emb_dim: The dimension of the embedding vector.
    :type emb_dim: int
    :param pos_size: The total number of the position indexes, which means
                     the maximum value of the index is pos_size - 1.
    :type pos_size: int
    :param drop_rate: Dropout rate.
    :type drop_rate: float
    :param use_bn: Whether to use batch normalization or not. False is the default value.
    :type use_bn: bool
    :param batch_size: The size of a mini-batch.
    :type batch_size: int
    :param num_passes: The total number of the passes to train.
    :type num_passes: int
    """
    # load dict
    src_dict = reader.load_dict(src_dict_path)
    trg_dict = reader.load_dict(trg_dict_path)
    src_dict_size = src_dict.__len__()
    trg_dict_size = trg_dict.__len__()

    optimizer = paddle.optimizer.Adam(learning_rate=1e-3, )

    cost = conv_seq2seq(
        src_dict_size=src_dict_size,
        trg_dict_size=trg_dict_size,
        pos_size=pos_size,
        emb_dim=emb_dim,
        enc_conv_blocks=enc_conv_blocks,
        dec_conv_blocks=dec_conv_blocks,
        drop_rate=drop_rate,
        with_bn=use_bn,
        is_infer=False)

    # create parameters and trainer
    parameters = paddle.parameters.create(cost)
    trainer = paddle.trainer.SGD(cost=cost,
                                 parameters=parameters,
                                 update_equation=optimizer)

    padding_list = [context_len - 1 for (size, context_len) in dec_conv_blocks]
    padding_num = reduce(lambda x, y: x + y, padding_list)
    train_reader, test_reader = create_reader(
        padding_num=padding_num,
        train_data_path=train_data_path,
        test_data_path=test_data_path,
        src_dict=src_dict,
        trg_dict=trg_dict,
        pos_size=pos_size,
        batch_size=batch_size)

    feeding = {
        'src_word': 0,
        'src_word_pos': 1,
        'trg_word': 2,
        'trg_word_pos': 3,
        'trg_next_word': 4
    }

    # create event handler
    def event_handler(event):
        if isinstance(event, paddle.event.EndIteration):
            if event.batch_id % 20 == 0:
                cur_time = time.strftime('%Y.%m.%d %H:%M:%S', time.localtime())
                print "[%s]: Pass: %d, Batch: %d, TrainCost: %f, %s" % (
                    cur_time, event.pass_id, event.batch_id, event.cost,
                    event.metrics)
                sys.stdout.flush()

        if isinstance(event, paddle.event.EndPass):
            if test_reader is not None:
                cur_time = time.strftime('%Y.%m.%d %H:%M:%S', time.localtime())
                result = trainer.test(reader=test_reader, feeding=feeding)
                print "[%s]: Pass: %d, TestCost: %f, %s" % (
                    cur_time, event.pass_id, result.cost, result.metrics)
                sys.stdout.flush()
            with gzip.open("output/params.pass-%d.tar.gz" % event.pass_id,
                           'w') as f:
                trainer.save_parameter_to_tar(f)

    if not os.path.exists('output'):
        os.mkdir('output')

    trainer.train(
        reader=train_reader,
        event_handler=event_handler,
        num_passes=num_passes,
        feeding=feeding)


def main():
    args = parse_args()
    enc_conv_blocks = eval(args.enc_blocks)
    dec_conv_blocks = eval(args.dec_blocks)

    sys.setrecursionlimit(10000)

    paddle.init(use_gpu=args.use_gpu, trainer_count=args.trainer_count)

    train(
        train_data_path=args.train_data_path,
        test_data_path=args.test_data_path,
        src_dict_path=args.src_dict_path,
        trg_dict_path=args.trg_dict_path,
        enc_conv_blocks=enc_conv_blocks,
        dec_conv_blocks=dec_conv_blocks,
        emb_dim=args.emb_size,
        pos_size=args.pos_size,
        drop_rate=args.drop_rate,
        use_bn=args.use_bn,
        batch_size=args.batch_size,
        num_passes=args.num_passes)


if __name__ == '__main__':
    main()

# Painting Hashcode 2016

import sys
import numpy as np
from operator import itemgetter

def check_square(R,C,S,matrix, verbose=False):
    if R - S < 0:
        if verbose:  print 'R < S! Can\'t square'
        return False
    if R + S >= np.shape(matrix)[0]:
        if verbose:  print 'R + S > Size! Can\'t square'
        return False
    if C - S < 0:
        if verbose:  print 'C < S! Can\'t square'
        return False
    if C + S >= np.shape(matrix)[1]:
        if verbose:  print 'C + S > Size! Can\'t square'
        return False
    return True

def PAINT_SQUARE(R,C,S,matrix):
    matrix[R-S:R+S+1, C-S:C+S+1] = 1

def PAINT_LINE(R1,C1,R2,C2,matrix):
    matrix[R1:R2+1, C1:C2+1] = 1

def ERASE_CELL(R,C,matrix):
    if 0 <= R < np.shape(matrix)[0] and 0 <= R < np.shape(matrix)[1]:
        matrix[R,C] = 0
    else:
        print 'Bad coordinates'
        raise


def sym2ones(aList):
    return [1 if i == '#' else 0 for i in aList]

def read_image(path):
    matrix = []
    with open(path, 'r') as f:
        next(f)
        for line in f:
            matrix.append(sym2ones(list(line.rstrip())))
    f.close()
    return np.asarray(matrix)



def next_cell(m_in, m_work, R, C):
    for i in xrange(R, np.shape(m_in)[0]):
        for j in xrange(C, np.shape(m_in)[1]):
            if m_in[i,j] and not m_work[i,j]:
                return (i,j)
        C = 0
    return None


def algo(m_in, m_work, delta=0.22):
    R = 0
    C = 0
    all_commands = []
    while True:
        cell = next_cell(m_in, m_work, R, C)
        if cell == None:
            break
        sq = square(m_in, cell[0], cell[1], delta)
        hl = h_line(m_in, cell[0], cell[1])
        vl = v_line(m_in, cell[0], cell[1])


        if hl[0] >= vl[0]:
            choice = hl
        else:
            choice = vl

        if choice[0] < sq[0]:
            choice = sq

        for c in choice[1]: #parse commands
            if c[0] == 'PAINT_SQUARE':
                PAINT_SQUARE(c[1], c[2], c[3], m_work)
            elif c[0] == 'ERASE_CELL':
                ERASE_CELL(c[1], c[2], m_work)
            elif c[0] == 'PAINT_LINE':
                PAINT_LINE(c[1], c[2], c[3], c[4], m_work)
        all_commands += choice[1]

    if not (m_in==m_work).all():
        print 'ERROR! MATRICES DID NOT MATCH!'

    return m_work, all_commands

# returns (numwrittencells, [commands])
def square(m_in, R, C, delta=0.22):
    S = 0
    prev_dots = []
    while True:
        if check_square(R+S,C+S,S,m_in):
            rows = R + 2*S+1
            cols = C + 2*S+1
            dots = []
            for i in xrange(R, rows):
                for j in xrange(C, cols):
                    if m_in[i,j] == 0:
                        dots.append((i,j))
            if len(dots) >= (delta * ((2*S+1)**2)):
                break
            else:
                prev_dots = dots
                S += 1
        else:
            break

    commands = [('PAINT_SQUARE', R+S-1, C+S-1, S-1)]
    for i in prev_dots:
        commands.append(('ERASE_CELL', i[0], i[1]))
    return ((2*(S-1)+1)**2) - len(prev_dots), commands


def check_line(R1,C1,R2,C2,matrix, verbose=False):
    if R1 < 0 or R2 >= np.shape(matrix)[0] or C1 < 0 or C2 >= np.shape(matrix)[1]:
        if verbose:  print 'Out of bound'
        return False
    if R1 > R2 or C1 > C2:
        if verbose:  print 'Inverted indexes'
        return False
    if R1==R2 or C1==C2:
        return True
    return False

def h_line(m_in, R, C):
    S = 0
    while check_line(R,C,R,C + S,m_in):
        if m_in[R,C+S] == 1:
            S += 1
        else:
            break
    return S, [('PAINT_LINE', R, C, R, C+S-1)]


def v_line(m_in, R, C):
    S = 0
    while check_line(R,C,R + S,C,m_in):
        if m_in[R+S,C] == 1:
            S += 1
        else:
            break
    return S, [('PAINT_LINE', R, C, R+S-1, C)]

from locust import HttpLocust, TaskSet, task

'''
To use you must have python2 with pipinstalled locustion.
This script is not integrated with encoded or snovault python distribution
see http://locust.io
'''


def login(l):
    l.client.post("/login", {"username":"ellen_key", "password":"education"})


class UserBehavior(TaskSet):

    def on_start(self):
        # login(self)
        pass

    @task(1)
    def index(l):
        l.client.get("/")

    @task(2)
    def search(l):
        l.client.get("/search")

    @task(3)
    def demo_1(l):
        l.client.get("/search/?searchTerm=skin")
        l.client.get("/search/?searchTerm=skin&type=Experiment")
        l.client.get("/search/?searchTerm=skin&type=Experiment&award.project=ENCODE")

    @task(4)
    def demo_2(l):
        l.client.get("/search")
        l.client.get("/search/?type=Annotation&organ_slims=skin+of+body")

    @task(5)
    def demo_3(l):
        l.client.get("/search/?searchTerm=skin")
        l.client.get("/search/?searchTerm=skin&type=Experiment")
        l.client.get("/search/?searchTerm=skin&type=Experiment&award.project=ENCODE")
        l.client.get("/search/?searchTerm=skin&type=Experiment&award.project=ENCODE&assay_title=total+RNA-seq")
        l.client.get("/search/?searchTerm=skin&type=Experiment&award.project=ENCODE&assay_title=total+RNA-seq&replicates.library.biosample.life_stage=adult")

class WebsiteUser(HttpLocust):
    task_set = UserBehavior
    min_wait = 5000
    max_wait = 9000

# coding=utf-8
# This file is part of SickRage.
#
# URL: https://SickRage.GitHub.io
# Git: https://github.com/SickRage/SickRage.git
#
# SickRage is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# SickRage is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with SickRage. If not, see <http://www.gnu.org/licenses/>.

"""
Test ShowPoster
"""

from generic_media_tests import GenericMediaTests

import os
import sys
import unittest

sys.path.insert(1, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../../lib')))
sys.path.insert(1, os.path.abspath(os.path.join(os.path.dirname(__file__), '../../..')))

from sickrage.media.ShowPoster import ShowPoster


class ShowPosterTests(GenericMediaTests):
    """
    Test ShowPoster
    """

    def test_get_default_media_name(self):
        """
        Test get_default_media_name
        """

        self.assertEqual(ShowPoster(0, '').get_default_media_name(), 'poster.png')


if __name__ == '__main__':
    print('=====> Testing {0}'.format(__file__))

    SUITE = unittest.TestLoader().loadTestsFromTestCase(ShowPosterTests)
    unittest.TextTestRunner(verbosity=2).run(SUITE)

#!/usr/bin/python

####    Hierarchy
##      Creators: Adam Stiles and Ryan McKay
##      July 2016
##      Made in Python

## Heirarchy is a game of survival that urges the player to discover what it means to be Human.

# libraries
import pygame as pg
import logging
# hierarchy.py

from structure import button
from state import game_state
from tools import print_attr, wrap_text
from settings import config_obj, config

##
#
#
class gui(object):
    #the object that prints to the screen
    def set_res(self):
        res = config.get_res()
        self.display = pg.display.set_mode(res)
        pg.display.set_caption('Hierarchy')

    def set_subsurface(self, ss_dim):
        return self.display.subsurface(ss_dim)

    def fill_rect(self, location, color):
        ## this function can be hardware accellerated sometimes,
        # draw_rect() can't
        ## draws a colored rectangle on this gui at location
        ## pass location as Rect, color as string
        ## if location = None, whole surface will be filled
        color_rgb = config.get_color(color)
        ## fill(color, Rect)
        self.display.fill(color_rgb, location)

    def draw_rect(self, location, color, width):
        # draws a rectangle border on this gui at location,
        # with color and width
        # pass location as Rect, color as string, width as int
        # if width == 0, area will be filled
        color_rgb = config.get_color(color)

        # pg.draw.rect(surface, color, rect, width)
        pg.draw.rect(self.display, color_rgb, location, width)

    def fill_color(self, screen, color, position):
        screen.fill(config.get_color(color))
        self.display.blit(screen, position)

    def draw_gui_text(self):
        for loc in self.text:
            text, color, size = self.text[loc]
            self.draw_text(size, text, color, loc)

    def draw_text(self, size, message, color, location):
        font = pg.font.Font(None, size)
        text = font.render(message, 1, config.get_color(color))
        textpos = text.get_rect()
        textpos.topleft = location
        self.display.blit(text, textpos)
        return textpos

    def get_btns(self):
        return self.cur_btns

    def draw_gui_btns(self):
        for loc in self.cur_btns:
            dest, color, border, size, text = self.cur_btns[loc]
            if text:
                text_loc = (loc[0], loc[1])
                loc = self.draw_text(size, text, color, text_loc)

            self.draw_rect(loc, color, border)


##
#
#
class intro_gui(gui):

    def __init__(self):
        self.gui = 'intro_gui'
        self.set_res()

        # create dict of intro_gui buttons
        self.cur_btns = config.get_btns(self.gui)

        # entire intro screen
        self.main_surface = self.get_intro_ss()

        # draw text
        self.text = config.get_text(self.gui)
        self.draw_gui_text()

        self.draw_gui_btns()
        pg.display.flip()

    def get_intro_ss(self):
        ss_pos = (0, 0)
        intro_ss = pg.Surface(config.get_res())
        self.fill_color(intro_ss, 'black', ss_pos)
        return intro_ss



##
#
#
class map_gui(gui):

    def __init__(self, game_map):
        self.gui = 'map_gui'
        self.set_res()
        self.cur_btns = config.get_btns(self.gui)
        self.text = config.get_text(self.gui)

        # gui subsurface map block
        map_ss = self.get_map_ss()

        # active portion of game_map
        active_map = self.get_active_map(game_map)

        # portion of active_map rendered to map_ss
        map_seg = self.get_map_seg(game_map, active_map, map_ss)

        # surface (stats_panel) to render on stats_ss
        stats_ss = self.get_stats_ss(map_ss)
        pos = (0,0)
        map_ss.blit(map_seg, pos)

        # update display
        pg.display.flip()

    #Divide Map
    def get_map_ss(self):
        map_ss_x, map_ss_y = config.get_dim('map_ss')
        map_ss_dim = pg.Rect(0, 0, map_ss_x, map_ss_y)
        return self.set_subsurface(map_ss_dim)

    def get_active_map(self, game_map):
        # gen_map() // tbc
        active_map_dim = config.get_dim('active_map')
        active_map = pg.Surface(active_map_dim)
        #fill some_color
        pos = (0,0)
        self.fill_color(active_map, 'white', pos)
        return active_map

    #Get map segment from active map
    def get_map_seg(self, game_map, active_map, map_ss):
        map_seg_dim = pg.Rect(0, 0, map_ss.get_width(), map_ss.get_height())
        loc = (0,0)
        return game_map.get_map_seg(active_map, map_seg_dim, loc)

    # get stats_panel and render to stats
    def get_stats_ss(self, map_ss):
        stats_ss_x, stats_ss_y = config.get_dim('stats_ss')
        stats_ss_rect = pg.Rect(map_ss.get_width(), 0, stats_ss_x, stats_ss_y)
        return self.set_subsurface(stats_ss_rect)



##
#
#
class button(object):
    # tc
    pass

import _surface
import chimera
try:
  import chimera.runCommand
except:
  pass
from VolumePath import markerset as ms
try:
  from VolumePath import Marker_Set, Link
  new_marker_set=Marker_Set
except:
  from VolumePath import volume_path_dialog
  d= volume_path_dialog(True)
  new_marker_set= d.new_marker_set
marker_sets={}
surf_sets={}
if "particle_0 geometry" not in marker_sets:
  s=new_marker_set('particle_0 geometry')
  marker_sets["particle_0 geometry"]=s
s= marker_sets["particle_0 geometry"]
mark=s.place_marker((9990.63, 5107.75, 321.611), (0.7, 0.7, 0.7), 890.203)
if "particle_1 geometry" not in marker_sets:
  s=new_marker_set('particle_1 geometry')
  marker_sets["particle_1 geometry"]=s
s= marker_sets["particle_1 geometry"]
mark=s.place_marker((9423.73, 5140.28, 2016.91), (0.7, 0.7, 0.7), 792.956)
if "particle_2 geometry" not in marker_sets:
  s=new_marker_set('particle_2 geometry')
  marker_sets["particle_2 geometry"]=s
s= marker_sets["particle_2 geometry"]
mark=s.place_marker((8196.4, 6562.93, 2374.75), (0.7, 0.7, 0.7), 856.786)
if "particle_3 geometry" not in marker_sets:
  s=new_marker_set('particle_3 geometry')
  marker_sets["particle_3 geometry"]=s
s= marker_sets["particle_3 geometry"]
mark=s.place_marker((9759.62, 7317.33, 798.609), (0.7, 0.7, 0.7), 963.679)
if "particle_4 geometry" not in marker_sets:
  s=new_marker_set('particle_4 geometry')
  marker_sets["particle_4 geometry"]=s
s= marker_sets["particle_4 geometry"]
mark=s.place_marker((8811.83, 8676.34, 242.861), (0.7, 0.7, 0.7), 761.442)
if "particle_5 geometry" not in marker_sets:
  s=new_marker_set('particle_5 geometry')
  marker_sets["particle_5 geometry"]=s
s= marker_sets["particle_5 geometry"]
mark=s.place_marker((6591.52, 8736.36, 1368.13), (0.7, 0.7, 0.7), 961.183)
if "particle_6 geometry" not in marker_sets:
  s=new_marker_set('particle_6 geometry')
  marker_sets["particle_6 geometry"]=s
s= marker_sets["particle_6 geometry"]
mark=s.place_marker((4924.67, 8333.89, 1553.61), (0.7, 0.7, 0.7), 753.151)
if "particle_7 geometry" not in marker_sets:
  s=new_marker_set('particle_7 geometry')
  marker_sets["particle_7 geometry"]=s
s= marker_sets["particle_7 geometry"]
mark=s.place_marker((5438.88, 8714.51, 910.048), (1, 0.7, 0), 1098.07)
if "particle_8 geometry" not in marker_sets:
  s=new_marker_set('particle_8 geometry')
  marker_sets["particle_8 geometry"]=s
s= marker_sets["particle_8 geometry"]
mark=s.place_marker((3587.5, 7295.41, 2248.17), (0.7, 0.7, 0.7), 1010.42)
if "particle_9 geometry" not in marker_sets:
  s=new_marker_set('particle_9 geometry')
  marker_sets["particle_9 geometry"]=s
s= marker_sets["particle_9 geometry"]
mark=s.place_marker((2531.58, 6377.06, 1312.88), (1, 0.7, 0), 821.043)
if "particle_10 geometry" not in marker_sets:
  s=new_marker_set('particle_10 geometry')
  marker_sets["particle_10 geometry"]=s
s= marker_sets["particle_10 geometry"]
mark=s.place_marker((1813.13, 5658.03, 2901.76), (0.7, 0.7, 0.7), 873.876)
if "particle_11 geometry" not in marker_sets:
  s=new_marker_set('particle_11 geometry')
  marker_sets["particle_11 geometry"]=s
s= marker_sets["particle_11 geometry"]
mark=s.place_marker((2912.62, 4857.5, 3166.76), (0.7, 0.7, 0.7), 625.532)
if "particle_12 geometry" not in marker_sets:
  s=new_marker_set('particle_12 geometry')
  marker_sets["particle_12 geometry"]=s
s= marker_sets["particle_12 geometry"]
mark=s.place_marker((3647.19, 3739.68, 3961.38), (0.7, 0.7, 0.7), 880.474)
if "particle_13 geometry" not in marker_sets:
  s=new_marker_set('particle_13 geometry')
  marker_sets["particle_13 geometry"]=s
s= marker_sets["particle_13 geometry"]
mark=s.place_marker((4525.62, 3591.82, 2690.06), (0.7, 0.7, 0.7), 659.161)
if "particle_14 geometry" not in marker_sets:
  s=new_marker_set('particle_14 geometry')
  marker_sets["particle_14 geometry"]=s
s= marker_sets["particle_14 geometry"]
mark=s.place_marker((5189.04, 1433.06, 2689.09), (0.7, 0.7, 0.7), 831.745)
if "particle_15 geometry" not in marker_sets:
  s=new_marker_set('particle_15 geometry')
  marker_sets["particle_15 geometry"]=s
s= marker_sets["particle_15 geometry"]
mark=s.place_marker((7254.49, -21.8927, 4499.36), (0.7, 0.7, 0.7), 803.065)
if "particle_16 geometry" not in marker_sets:
  s=new_marker_set('particle_16 geometry')
  marker_sets["particle_16 geometry"]=s
s= marker_sets["particle_16 geometry"]
mark=s.place_marker((7819.16, 1455.58, 5637.6), (0.7, 0.7, 0.7), 610.262)
if "particle_17 geometry" not in marker_sets:
  s=new_marker_set('particle_17 geometry')
  marker_sets["particle_17 geometry"]=s
s= marker_sets["particle_17 geometry"]
mark=s.place_marker((6566.46, 1207.71, 6118.95), (0.7, 0.7, 0.7), 741.265)
if "particle_18 geometry" not in marker_sets:
  s=new_marker_set('particle_18 geometry')
  marker_sets["particle_18 geometry"]=s
s= marker_sets["particle_18 geometry"]
mark=s.place_marker((5330.53, 2032.42, 5367.71), (0.7, 0.7, 0.7), 748.625)
if "particle_19 geometry" not in marker_sets:
  s=new_marker_set('particle_19 geometry')
  marker_sets["particle_19 geometry"]=s
s= marker_sets["particle_19 geometry"]
mark=s.place_marker((4003.37, 1605.12, 4904.8), (0.7, 0.7, 0.7), 677.181)
if "particle_20 geometry" not in marker_sets:
  s=new_marker_set('particle_20 geometry')
  marker_sets["particle_20 geometry"]=s
s= marker_sets["particle_20 geometry"]
mark=s.place_marker((3714.35, 4007.97, 4736.96), (0.7, 0.7, 0.7), 616.015)
if "particle_21 geometry" not in marker_sets:
  s=new_marker_set('particle_21 geometry')
  marker_sets["particle_21 geometry"]=s
s= marker_sets["particle_21 geometry"]
mark=s.place_marker((4419.11, 2198.89, 5414.09), (0.7, 0.7, 0.7), 653.154)
if "particle_22 geometry" not in marker_sets:
  s=new_marker_set('particle_22 geometry')
  marker_sets["particle_22 geometry"]=s
s= marker_sets["particle_22 geometry"]
mark=s.place_marker((4829.98, 2324.04, 5756.87), (0.7, 0.7, 0.7), 595.33)
if "particle_23 geometry" not in marker_sets:
  s=new_marker_set('particle_23 geometry')
  marker_sets["particle_23 geometry"]=s
s= marker_sets["particle_23 geometry"]
mark=s.place_marker((5658.31, 2057.58, 6706.04), (0.7, 0.7, 0.7), 627.901)
if "particle_24 geometry" not in marker_sets:
  s=new_marker_set('particle_24 geometry')
  marker_sets["particle_24 geometry"]=s
s= marker_sets["particle_24 geometry"]
mark=s.place_marker((6821.68, 1914.24, 6514.68), (0.7, 0.7, 0.7), 663.941)
if "particle_25 geometry" not in marker_sets:
  s=new_marker_set('particle_25 geometry')
  marker_sets["particle_25 geometry"]=s
s= marker_sets["particle_25 geometry"]
mark=s.place_marker((7675.13, 766.86, 6166.61), (0.7, 0.7, 0.7), 663.899)
if "particle_26 geometry" not in marker_sets:
  s=new_marker_set('particle_26 geometry')
  marker_sets["particle_26 geometry"]=s
s= marker_sets["particle_26 geometry"]
mark=s.place_marker((6354.45, 1523.29, 5887.43), (0.7, 0.7, 0.7), 644.694)
if "particle_27 geometry" not in marker_sets:
  s=new_marker_set('particle_27 geometry')
  marker_sets["particle_27 geometry"]=s
s= marker_sets["particle_27 geometry"]
mark=s.place_marker((5536.49, 3177.43, 4687.45), (0.7, 0.7, 0.7), 896.802)
if "particle_28 geometry" not in marker_sets:
  s=new_marker_set('particle_28 geometry')
  marker_sets["particle_28 geometry"]=s
s= marker_sets["particle_28 geometry"]
mark=s.place_marker((4442.47, 3306.4, 5733.6), (0.7, 0.7, 0.7), 576.38)
if "particle_29 geometry" not in marker_sets:
  s=new_marker_set('particle_29 geometry')
  marker_sets["particle_29 geometry"]=s
s= marker_sets["particle_29 geometry"]
mark=s.place_marker((3359.76, 3987.22, 5471.84), (0.7, 0.7, 0.7), 635.092)
if "particle_30 geometry" not in marker_sets:
  s=new_marker_set('particle_30 geometry')
  marker_sets["particle_30 geometry"]=s
s= marker_sets["particle_30 geometry"]
mark=s.place_marker((4131.03, 4169.74, 5982.02), (0.7, 0.7, 0.7), 651.505)
if "particle_31 geometry" not in marker_sets:
  s=new_marker_set('particle_31 geometry')
  marker_sets["particle_31 geometry"]=s
s= marker_sets["particle_31 geometry"]
mark=s.place_marker((3419.03, 4482.13, 4422.97), (0.7, 0.7, 0.7), 718.042)
if "particle_32 geometry" not in marker_sets:
  s=new_marker_set('particle_32 geometry')
  marker_sets["particle_32 geometry"]=s
s= marker_sets["particle_32 geometry"]
mark=s.place_marker((2929.97, 3401.2, 5774.27), (0.7, 0.7, 0.7), 726.714)
if "particle_33 geometry" not in marker_sets:
  s=new_marker_set('particle_33 geometry')
  marker_sets["particle_33 geometry"]=s
s= marker_sets["particle_33 geometry"]
mark=s.place_marker((4127.42, 3419.31, 6669.16), (0.7, 0.7, 0.7), 673.585)
if "particle_34 geometry" not in marker_sets:
  s=new_marker_set('particle_34 geometry')
  marker_sets["particle_34 geometry"]=s
s= marker_sets["particle_34 geometry"]
mark=s.place_marker((4791.03, 2343.87, 6363.38), (0.7, 0.7, 0.7), 598.418)
if "particle_35 geometry" not in marker_sets:
  s=new_marker_set('particle_35 geometry')
  marker_sets["particle_35 geometry"]=s
s= marker_sets["particle_35 geometry"]
mark=s.place_marker((4998.99, 968.791, 6391.16), (0.7, 0.7, 0.7), 693.382)
if "particle_36 geometry" not in marker_sets:
  s=new_marker_set('particle_36 geometry')
  marker_sets["particle_36 geometry"]=s
s= marker_sets["particle_36 geometry"]
mark=s.place_marker((4264.51, 3181.57, 5560.99), (0.7, 0.7, 0.7), 804.038)
if "particle_37 geometry" not in marker_sets:
  s=new_marker_set('particle_37 geometry')
  marker_sets["particle_37 geometry"]=s
s= marker_sets["particle_37 geometry"]
mark=s.place_marker((4841.53, 1965.05, 6870.29), (0.7, 0.7, 0.7), 816.178)
if "particle_38 geometry" not in marker_sets:
  s=new_marker_set('particle_38 geometry')
  marker_sets["particle_38 geometry"]=s
s= marker_sets["particle_38 geometry"]
mark=s.place_marker((5690.94, 2655.15, 6296.77), (0.7, 0.7, 0.7), 776.628)
if "particle_39 geometry" not in marker_sets:
  s=new_marker_set('particle_39 geometry')
  marker_sets["particle_39 geometry"]=s
s= marker_sets["particle_39 geometry"]
mark=s.place_marker((4399.11, 1909.71, 6714.31), (0.7, 0.7, 0.7), 750.656)
if "particle_40 geometry" not in marker_sets:
  s=new_marker_set('particle_40 geometry')
  marker_sets["particle_40 geometry"]=s
s= marker_sets["particle_40 geometry"]
mark=s.place_marker((3682.37, 3434.21, 6678.81), (0.7, 0.7, 0.7), 709.625)
if "particle_41 geometry" not in marker_sets:
  s=new_marker_set('particle_41 geometry')
  marker_sets["particle_41 geometry"]=s
s= marker_sets["particle_41 geometry"]
mark=s.place_marker((1881.33, 3931.57, 6448.42), (0.7, 0.7, 0.7), 927.681)
if "particle_42 geometry" not in marker_sets:
  s=new_marker_set('particle_42 geometry')
  marker_sets["particle_42 geometry"]=s
s= marker_sets["particle_42 geometry"]
mark=s.place_marker((1475.55, 2843.39, 8797.06), (0.7, 0.7, 0.7), 1088.21)
if "particle_43 geometry" not in marker_sets:
  s=new_marker_set('particle_43 geometry')
  marker_sets["particle_43 geometry"]=s
s= marker_sets["particle_43 geometry"]
mark=s.place_marker((891.546, 4236.73, 7534.75), (0.7, 0.7, 0.7), 736.147)
if "particle_44 geometry" not in marker_sets:
  s=new_marker_set('particle_44 geometry')
  marker_sets["particle_44 geometry"]=s
s= marker_sets["particle_44 geometry"]
mark=s.place_marker((2433.28, 3733.38, 7539.5), (0.7, 0.7, 0.7), 861.101)
if "particle_45 geometry" not in marker_sets:
  s=new_marker_set('particle_45 geometry')
  marker_sets["particle_45 geometry"]=s
s= marker_sets["particle_45 geometry"]
mark=s.place_marker((2907.99, 5201.55, 6372.95), (0.7, 0.7, 0.7), 924.213)
if "particle_46 geometry" not in marker_sets:
  s=new_marker_set('particle_46 geometry')
  marker_sets["particle_46 geometry"]=s
s= marker_sets["particle_46 geometry"]
mark=s.place_marker((3569.1, 5920.32, 8076.18), (0.7, 0.7, 0.7), 881.828)
if "particle_47 geometry" not in marker_sets:
  s=new_marker_set('particle_47 geometry')
  marker_sets["particle_47 geometry"]=s
s= marker_sets["particle_47 geometry"]
mark=s.place_marker((2235.26, 4879.35, 9249.04), (0.7, 0.7, 0.7), 927.681)
if "particle_48 geometry" not in marker_sets:
  s=new_marker_set('particle_48 geometry')
  marker_sets["particle_48 geometry"]=s
s= marker_sets["particle_48 geometry"]
mark=s.place_marker((2898.47, 6444.19, 8448.7), (0.7, 0.7, 0.7), 831.576)
if "particle_49 geometry" not in marker_sets:
  s=new_marker_set('particle_49 geometry')
  marker_sets["particle_49 geometry"]=s
s= marker_sets["particle_49 geometry"]
mark=s.place_marker((3411.78, 7332.92, 6851.94), (0.7, 0.7, 0.7), 859.494)
if "particle_50 geometry" not in marker_sets:
  s=new_marker_set('particle_50 geometry')
  marker_sets["particle_50 geometry"]=s
s= marker_sets["particle_50 geometry"]
mark=s.place_marker((2512.19, 7105.93, 7400.92), (0.7, 0.7, 0.7), 704.845)
if "particle_51 geometry" not in marker_sets:
  s=new_marker_set('particle_51 geometry')
  marker_sets["particle_51 geometry"]=s
s= marker_sets["particle_51 geometry"]
mark=s.place_marker((2915.68, 7067.06, 5800.25), (0.7, 0.7, 0.7), 804.461)
if "particle_52 geometry" not in marker_sets:
  s=new_marker_set('particle_52 geometry')
  marker_sets["particle_52 geometry"]=s
s= marker_sets["particle_52 geometry"]
mark=s.place_marker((3828.37, 6822.18, 4365.99), (0.7, 0.7, 0.7), 934.111)
if "particle_53 geometry" not in marker_sets:
  s=new_marker_set('particle_53 geometry')
  marker_sets["particle_53 geometry"]=s
s= marker_sets["particle_53 geometry"]
mark=s.place_marker((2987.38, 7780.77, 3493.22), (0.7, 0.7, 0.7), 988.339)
if "particle_54 geometry" not in marker_sets:
  s=new_marker_set('particle_54 geometry')
  marker_sets["particle_54 geometry"]=s
s= marker_sets["particle_54 geometry"]
mark=s.place_marker((2583.05, 8198.2, 4037.32), (1, 0.7, 0), 803.7)
if "particle_55 geometry" not in marker_sets:
  s=new_marker_set('particle_55 geometry')
  marker_sets["particle_55 geometry"]=s
s= marker_sets["particle_55 geometry"]
mark=s.place_marker((3611.7, 7627.36, 5770.06), (0.7, 0.7, 0.7), 812.118)
if "particle_56 geometry" not in marker_sets:
  s=new_marker_set('particle_56 geometry')
  marker_sets["particle_56 geometry"]=s
s= marker_sets["particle_56 geometry"]
mark=s.place_marker((5520.43, 8683.16, 5718.24), (0.7, 0.7, 0.7), 1177.93)
if "particle_57 geometry" not in marker_sets:
  s=new_marker_set('particle_57 geometry')
  marker_sets["particle_57 geometry"]=s
s= marker_sets["particle_57 geometry"]
mark=s.place_marker((7434.95, 9248.74, 7273.76), (0.7, 0.7, 0.7), 1038.21)
if "particle_58 geometry" not in marker_sets:
  s=new_marker_set('particle_58 geometry')
  marker_sets["particle_58 geometry"]=s
s= marker_sets["particle_58 geometry"]
mark=s.place_marker((7869.24, 9321.14, 7659.53), (1, 0.7, 0), 758.016)
if "particle_59 geometry" not in marker_sets:
  s=new_marker_set('particle_59 geometry')
  marker_sets["particle_59 geometry"]=s
s= marker_sets["particle_59 geometry"]
mark=s.place_marker((8135.49, 9828.52, 7073.8), (0.7, 0.7, 0.7), 824.046)
if "particle_60 geometry" not in marker_sets:
  s=new_marker_set('particle_60 geometry')
  marker_sets["particle_60 geometry"]=s
s= marker_sets["particle_60 geometry"]
mark=s.place_marker((7143.59, 9500.14, 7326.24), (0.7, 0.7, 0.7), 793.379)
if "particle_61 geometry" not in marker_sets:
  s=new_marker_set('particle_61 geometry')
  marker_sets["particle_61 geometry"]=s
s= marker_sets["particle_61 geometry"]
mark=s.place_marker((7027.17, 10295.7, 7609.62), (0.7, 0.7, 0.7), 1011.56)
if "particle_62 geometry" not in marker_sets:
  s=new_marker_set('particle_62 geometry')
  marker_sets["particle_62 geometry"]=s
s= marker_sets["particle_62 geometry"]
mark=s.place_marker((6377.65, 8943.07, 6467.41), (0.7, 0.7, 0.7), 1097.01)
if "particle_63 geometry" not in marker_sets:
  s=new_marker_set('particle_63 geometry')
  marker_sets["particle_63 geometry"]=s
s= marker_sets["particle_63 geometry"]
mark=s.place_marker((7499.64, 7790.29, 7415.3), (0.7, 0.7, 0.7), 851.626)
if "particle_64 geometry" not in marker_sets:
  s=new_marker_set('particle_64 geometry')
  marker_sets["particle_64 geometry"]=s
s= marker_sets["particle_64 geometry"]
mark=s.place_marker((8862.73, 6869.95, 8451.95), (0.7, 0.7, 0.7), 869.434)
if "particle_65 geometry" not in marker_sets:
  s=new_marker_set('particle_65 geometry')
  marker_sets["particle_65 geometry"]=s
s= marker_sets["particle_65 geometry"]
mark=s.place_marker((7085.27, 6937.99, 8967.09), (0.7, 0.7, 0.7), 818.463)
if "particle_66 geometry" not in marker_sets:
  s=new_marker_set('particle_66 geometry')
  marker_sets["particle_66 geometry"]=s
s= marker_sets["particle_66 geometry"]
mark=s.place_marker((7524.98, 8012.9, 10340.7), (0.7, 0.7, 0.7), 759.539)
if "particle_67 geometry" not in marker_sets:
  s=new_marker_set('particle_67 geometry')
  marker_sets["particle_67 geometry"]=s
s= marker_sets["particle_67 geometry"]
mark=s.place_marker((6326.36, 8844.84, 8361.16), (0.7, 0.7, 0.7), 1088.59)
if "particle_68 geometry" not in marker_sets:
  s=new_marker_set('particle_68 geometry')
  marker_sets["particle_68 geometry"]=s
s= marker_sets["particle_68 geometry"]
mark=s.place_marker((7423.22, 10712.2, 9147.91), (0.7, 0.7, 0.7), 822.312)
if "particle_69 geometry" not in marker_sets:
  s=new_marker_set('particle_69 geometry')
  marker_sets["particle_69 geometry"]=s
s= marker_sets["particle_69 geometry"]
mark=s.place_marker((8248.46, 10533.6, 10492.4), (0.7, 0.7, 0.7), 749.81)
if "particle_70 geometry" not in marker_sets:
  s=new_marker_set('particle_70 geometry')
  marker_sets["particle_70 geometry"]=s
s= marker_sets["particle_70 geometry"]
mark=s.place_marker((7119.67, 10254.7, 9676.81), (0.7, 0.7, 0.7), 764.488)
for k in surf_sets.keys():
  chimera.openModels.add([surf_sets[k]])

# -*- coding: utf-8 -*-
"""
    pygments.formatters.svg
    ~~~~~~~~~~~~~~~~~~~~~~~

    Formatter for SVG output.

    :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

from pygments.formatter import Formatter
from pygments.util import get_bool_opt, get_int_opt

__all__ = ['SvgFormatter']


def escape_html(text):
    """Escape &, <, > as well as single and double quotes for HTML."""
    return text.replace('&', '&amp;').  \
                replace('<', '&lt;').   \
                replace('>', '&gt;').   \
                replace('"', '&quot;'). \
                replace("'", '&#39;')


class2style = {}

class SvgFormatter(Formatter):
    """
    Format tokens as an SVG graphics file.  This formatter is still experimental.
    Each line of code is a ``<text>`` element with explicit ``x`` and ``y``
    coordinates containing ``<tspan>`` elements with the individual token styles.

    By default, this formatter outputs a full SVG document including doctype
    declaration and the ``<svg>`` root element.

    *New in Pygments 0.9.*

    Additional options accepted:

    `nowrap`
        Don't wrap the SVG ``<text>`` elements in ``<svg><g>`` elements and
        don't add a XML declaration and a doctype.  If true, the `fontfamily`
        and `fontsize` options are ignored.  Defaults to ``False``.

    `fontfamily`
        The value to give the wrapping ``<g>`` element's ``font-family``
        attribute, defaults to ``"monospace"``.

    `fontsize`
        The value to give the wrapping ``<g>`` element's ``font-size``
        attribute, defaults to ``"14px"``.

    `xoffset`
        Starting offset in X direction, defaults to ``0``.

    `yoffset`
        Starting offset in Y direction, defaults to the font size if it is given
        in pixels, or ``20`` else.  (This is necessary since text coordinates
        refer to the text baseline, not the top edge.)

    `ystep`
        Offset to add to the Y coordinate for each subsequent line.  This should
        roughly be the text size plus 5.  It defaults to that value if the text
        size is given in pixels, or ``25`` else.

    `spacehack`
        Convert spaces in the source to ``&#160;``, which are non-breaking
        spaces.  SVG provides the ``xml:space`` attribute to control how
        whitespace inside tags is handled, in theory, the ``preserve`` value
        could be used to keep all whitespace as-is.  However, many current SVG
        viewers don't obey that rule, so this option is provided as a workaround
        and defaults to ``True``.
    """
    name = 'SVG'
    aliases = ['svg']
    filenames = ['*.svg']

    def __init__(self, **options):
        # XXX outencoding
        Formatter.__init__(self, **options)
        self.nowrap = get_bool_opt(options, 'nowrap', False)
        self.fontfamily = options.get('fontfamily', 'monospace')
        self.fontsize = options.get('fontsize', '14px')
        self.xoffset = get_int_opt(options, 'xoffset', 0)
        fs = self.fontsize.strip()
        if fs.endswith('px'): fs = fs[:-2].strip()
        try:
            int_fs = int(fs)
        except:
            int_fs = 20
        self.yoffset = get_int_opt(options, 'yoffset', int_fs)
        self.ystep = get_int_opt(options, 'ystep', int_fs + 5)
        self.spacehack = get_bool_opt(options, 'spacehack', True)
        self._stylecache = {}

    def format_unencoded(self, tokensource, outfile):
        """
        Format ``tokensource``, an iterable of ``(tokentype, tokenstring)``
        tuples and write it into ``outfile``.

        For our implementation we put all lines in their own 'line group'.
        """
        x = self.xoffset
        y = self.yoffset
        if not self.nowrap:
            if self.encoding:
                outfile.write('<?xml version="1.0" encoding="%s"?>\n' %
                              self.encoding)
            else:
                outfile.write('<?xml version="1.0"?>\n')
            outfile.write('<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.0//EN" '
                          '"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/'
                          'svg10.dtd">\n')
            outfile.write('<svg xmlns="http://www.w3.org/2000/svg">\n')
            outfile.write('<g font-family="%s" font-size="%s">\n' %
                          (self.fontfamily, self.fontsize))
        outfile.write('<text x="%s" y="%s" xml:space="preserve">' % (x, y))
        for ttype, value in tokensource:
            style = self._get_style(ttype)
            tspan = style and '<tspan' + style + '>' or ''
            tspanend = tspan and '</tspan>' or ''
            value = escape_html(value)
            if self.spacehack:
                value = value.expandtabs().replace(' ', '&#160;')
            parts = value.split('\n')
            for part in parts[:-1]:
                outfile.write(tspan + part + tspanend)
                y += self.ystep
                outfile.write('</text>\n<text x="%s" y="%s" '
                              'xml:space="preserve">' % (x, y))
            outfile.write(tspan + parts[-1] + tspanend)
        outfile.write('</text>')

        if not self.nowrap:
            outfile.write('</g></svg>\n')

    def _get_style(self, tokentype):
        if tokentype in self._stylecache:
            return self._stylecache[tokentype]
        otokentype = tokentype
        while not self.style.styles_token(tokentype):
            tokentype = tokentype.parent
        value = self.style.style_for_token(tokentype)
        result = ''
        if value['color']:
            result = ' fill="#' + value['color'] + '"'
        if value['bold']:
            result += ' font-weight="bold"'
        if value['italic']:
            result += ' font-style="italic"'
        self._stylecache[otokentype] = result
        return result

from feedly.aggregators.base import RecentVerbAggregator
from feedly.tests.utils import FakeActivity
from feedly.verbs.base import Love as LoveVerb, Add as AddVerb
import datetime
import unittest


class AggregatorTest(unittest.TestCase):
    aggregator_class = None

    def setUp(self):
        id_seq = range(42, 999)
        if self.aggregator_class is None:
            return

        self.user_id = 42
        self.activity = FakeActivity(
            1, LoveVerb, 1, 1, datetime.datetime.now(), {})
        self.activities = []
        for x in range(2, 12):
            activity_time = datetime.datetime.now()
            find = x > 5
            activity = FakeActivity(
                x, LoveVerb, id_seq.pop(), x, activity_time, dict(find=find))
            self.activities.append(activity)
        self.add_activities = []
        for x in range(13, 38):
            activity_time = datetime.datetime.now() + datetime.timedelta(
                seconds=x)
            activity = FakeActivity(
                x, AddVerb, id_seq.pop(), x, activity_time, dict(x=x))
            self.add_activities.append(activity)
        self.aggregator = self.aggregator_class()


class RecentVerbAggregatorTest(AggregatorTest):
    aggregator_class = RecentVerbAggregator

    def test_aggregate(self):
        '''
        Verify that all the activities with the same verb and date are stuck
        together
        '''
        assert len(self.activities) == 10
        assert len(self.add_activities) == 25
        activities = self.activities + self.add_activities
        aggregated = self.aggregator.aggregate(activities)
        assert len(aggregated) == 2
        assert len(aggregated[0].activities) == 15
        assert len(aggregated[1].activities) == 10

    def test_empty_merge(self):
        activities = self.activities + self.add_activities
        new, changed, deleted = self.aggregator.merge([], activities)
        assert len(new) == 2
        assert len(new[0].activities) == 15
        assert len(new[1].activities) == 10

    def test_merge(self):
        first = self.aggregator.aggregate(self.activities[:5])
        new, changed, deleted = self.aggregator.merge(
            first, self.activities[5:])
        assert new == []

        old, updated = changed[0]
        assert len(old.activities) == 5
        assert len(updated.activities) == 10

# -*- coding: utf-8 -*-
import sys

if sys.version_info[0] > 2:
    PY3 = True
    string_types = (str,)
    text_type = str
    binary_type = bytes
    from json import loads
    from json import dumps
    from io import StringIO
    from io import BytesIO
    from urllib.parse import urlencode
    from urllib.parse import splittype
    from urllib.parse import splithost
    import urllib.parse as urlparse
    from http.client import HTTPConnection
    from http.client import CannotSendRequest
    from http.server import HTTPServer
    from http.server import SimpleHTTPRequestHandler
    from http.cookies import SimpleCookie, CookieError
    from http.cookies import _quote as cookie_quote

    def to_bytes(s):
        if isinstance(s, bytes):
            return s
        return s.encode('latin1')

    def to_string(s):
        if isinstance(s, str):
            return s
        return str(s, 'latin1')

    def join_bytes(sep, l):
        l = [to_bytes(e) for e in l]
        return to_bytes(sep).join(l)

else:
    PY3 = False
    string_types = basestring
    text_type = unicode
    binary_type = str
    from urllib import splittype
    from urllib import splithost
    from urllib import urlencode
    from httplib import HTTPConnection
    from httplib import CannotSendRequest
    from BaseHTTPServer import HTTPServer
    from SimpleHTTPServer import SimpleHTTPRequestHandler
    from Cookie import SimpleCookie, CookieError
    from Cookie import _quote as cookie_quote
    try:
        from cStringIO import StringIO
    except ImportError:
        from StringIO import StringIO
    BytesIO = StringIO
    import urlparse
    try:
        from json import loads
        from json import dumps
    except ImportError:
        try:
            from simplejson import loads
            from simplejson import dumps
        except ImportError:
            loads = None
            dumps = None

    def to_bytes(s):
        return str(s)

    def to_string(s):
        return str(s)

    def join_bytes(sep, l):
        l = [e for e in l]
        return sep.join(l)


def print_stderr(value):
    if PY3:
        exec('print(value, file=sys.stderr)')
    else:
        if isinstance(value, text_type):
            # not really clean but this must *never* fail
            try:
                value = value.encode('utf-8')
            except:
                value = repr(value)
        sys.stderr.write(value)

try:
    next = next
except NameError:
    # python < 2.6
    def next(iterator):
        return iterator.next()

try:
    from collections import OrderedDict
except ImportError:
    OrderedDict = dict

try:
    from unittest import TestCase
    from unittest import skipIf
except ImportError:
    try:
        from unittest2 import TestCase
        from unittest2 import skipIf
    except ImportError:
        from unittest import TestCase
        def skipIf(condition, message):
            if condition:
                return None
            def wrapper(func):
                return func
            return wrapper

from __future__ import division
import math, random
from collections import defaultdict, Counter
from linear_algebra import dot

users_interests = [
    ["Hadoop", "Big Data", "HBase", "Java", "Spark", "Storm", "Cassandra"],
    ["NoSQL", "MongoDB", "Cassandra", "HBase", "Postgres"],
    ["Python", "scikit-learn", "scipy", "numpy", "statsmodels", "pandas"],
    ["R", "Python", "statistics", "regression", "probability"],
    ["machine learning", "regression", "decision trees", "libsvm"],
    ["Python", "R", "Java", "C++", "Haskell", "programming languages"],
    ["statistics", "probability", "mathematics", "theory"],
    ["machine learning", "scikit-learn", "Mahout", "neural networks"],
    ["neural networks", "deep learning", "Big Data", "artificial intelligence"],
    ["Hadoop", "Java", "MapReduce", "Big Data"],
    ["statistics", "R", "statsmodels"],
    ["C++", "deep learning", "artificial intelligence", "probability"],
    ["pandas", "R", "Python"],
    ["databases", "HBase", "Postgres", "MySQL", "MongoDB"],
    ["libsvm", "regression", "support vector machines"]
]

popular_interests = Counter(interest
                            for user_interests in users_interests
                            for interest in user_interests).most_common()

def most_popular_new_interests(user_interests, max_results=5):
    suggestions = [(interest, frequency) 
                   for interest, frequency in popular_interests
                   if interest not in user_interests]
    return suggestions[:max_results]

#
# user-based filtering
#

def cosine_similarity(v, w):
    return dot(v, w) / math.sqrt(dot(v, v) * dot(w, w))

unique_interests = sorted(list({ interest 
                                 for user_interests in users_interests
                                 for interest in user_interests }))

def make_user_interest_vector(user_interests):
    """given a list of interests, produce a vector whose i-th element is 1
    if unique_interests[i] is in the list, 0 otherwise"""
    return [1 if interest in user_interests else 0
            for interest in unique_interests]

user_interest_matrix = map(make_user_interest_vector, users_interests)

user_similarities = [[cosine_similarity(interest_vector_i, interest_vector_j)
                      for interest_vector_j in user_interest_matrix]
                     for interest_vector_i in user_interest_matrix]

def most_similar_users_to(user_id):
    pairs = [(other_user_id, similarity)                      # find other
             for other_user_id, similarity in                 # users with
                enumerate(user_similarities[user_id])         # nonzero 
             if user_id != other_user_id and similarity > 0]  # similarity

    return sorted(pairs,                                      # sort them
                  key=lambda (_, similarity): similarity,     # most similar
                  reverse=True)                               # first


def user_based_suggestions(user_id, include_current_interests=False):
    # sum up the similarities
    suggestions = defaultdict(float)
    for other_user_id, similarity in most_similar_users_to(user_id):
        for interest in users_interests[other_user_id]:
            suggestions[interest] += similarity

    # convert them to a sorted list
    suggestions = sorted(suggestions.items(),
                         key=lambda (_, weight): weight,
                         reverse=True)

    # and (maybe) exclude already-interests
    if include_current_interests:
        return suggestions
    else:
        return [(suggestion, weight) 
                for suggestion, weight in suggestions
                if suggestion not in users_interests[user_id]]

#
# Item-Based Collaborative Filtering
#

interest_user_matrix = [[user_interest_vector[j]
                         for user_interest_vector in user_interest_matrix]
                        for j, _ in enumerate(unique_interests)]

interest_similarities = [[cosine_similarity(user_vector_i, user_vector_j)
                          for user_vector_j in interest_user_matrix]
                         for user_vector_i in interest_user_matrix]

def most_similar_interests_to(interest_id):
    similarities = interest_similarities[interest_id]
    pairs = [(unique_interests[other_interest_id], similarity)
             for other_interest_id, similarity in enumerate(similarities)
             if interest_id != other_interest_id and similarity > 0]
    return sorted(pairs,
                  key=lambda (_, similarity): similarity,
                  reverse=True)

def item_based_suggestions(user_id, include_current_interests=False):
    suggestions = defaultdict(float)
    user_interest_vector = user_interest_matrix[user_id]
    for interest_id, is_interested in enumerate(user_interest_vector):
        if is_interested == 1:
            similar_interests = most_similar_interests_to(interest_id)
            for interest, similarity in similar_interests:
                suggestions[interest] += similarity

    suggestions = sorted(suggestions.items(),
                         key=lambda (_, similarity): similarity,
                         reverse=True)

    if include_current_interests:
        return suggestions
    else:
        return [(suggestion, weight) 
                for suggestion, weight in suggestions
                if suggestion not in users_interests[user_id]]


if __name__ == "__main__":

    print "Popular Interests"
    print popular_interests
    print

    print "Most Popular New Interests"
    print "already like:", ["NoSQL", "MongoDB", "Cassandra", "HBase", "Postgres"]
    print most_popular_new_interests(["NoSQL", "MongoDB", "Cassandra", "HBase", "Postgres"])
    print
    print "already like:", ["R", "Python", "statistics", "regression", "probability"]
    print most_popular_new_interests(["R", "Python", "statistics", "regression", "probability"])
    print    

    print "User based similarity"
    print "most similar to 0"
    print most_similar_users_to(0)

    print "Suggestions for 0"
    print user_based_suggestions(0)
    print

    print "Item based similarity"
    print "most similar to 'Big Data'"
    print most_similar_interests_to(0)
    print

    print "suggestions for user 0"
    print item_based_suggestions(0)


r"""plistlib.py -- a tool to generate and parse MacOSX .plist files.

The PropertyList (.plist) file format is a simple XML pickle supporting
basic object types, like dictionaries, lists, numbers and strings.
Usually the top level object is a dictionary.

To write out a plist file, use the writePlist(rootObject, pathOrFile)
function. 'rootObject' is the top level object, 'pathOrFile' is a
filename or a (writable) file object.

To parse a plist from a file, use the readPlist(pathOrFile) function,
with a file name or a (readable) file object as the only argument. It
returns the top level object (again, usually a dictionary).

To work with plist data in strings, you can use readPlistFromString()
and writePlistToString().

Values can be strings, integers, floats, booleans, tuples, lists,
dictionaries, Data or datetime.datetime objects. String values (including
dictionary keys) may be unicode strings -- they will be written out as
UTF-8.

The <data> plist type is supported through the Data class. This is a
thin wrapper around a Python string.

Generate Plist example:

    pl = dict(
        aString="Doodah",
        aList=["A", "B", 12, 32.1, [1, 2, 3]],
        aFloat=0.1,
        anInt=728,
        aDict=dict(
            anotherString="<hello & hi there!>",
            aUnicodeValue=u'M\xe4ssig, Ma\xdf',
            aTrueValue=True,
            aFalseValue=False,
        ),
        someData=Data("<binary gunk>"),
        someMoreData=Data("<lots of binary gunk>" * 10),
        aDate=datetime.datetime.fromtimestamp(time.mktime(time.gmtime())),
    )
    # unicode keys are possible, but a little awkward to use:
    pl[u'\xc5benraa'] = "That was a unicode key."
    writePlist(pl, fileName)

Parse Plist example:

    pl = readPlist(pathOrFile)
    print pl["aKey"]
"""


__all__ = [
    "readPlist", "writePlist", "readPlistFromString", "writePlistToString",
    "readPlistFromResource", "writePlistToResource",
    "Plist", "Data", "Dict"
]
# Note: the Plist and Dict classes have been deprecated.

import binascii
import datetime
from cStringIO import StringIO
import re
import warnings


def readPlist(pathOrFile):
    """Read a .plist file. 'pathOrFile' may either be a file name or a
    (readable) file object. Return the unpacked root object (which
    usually is a dictionary).
    """
    didOpen = 0
    if isinstance(pathOrFile, (str, unicode)):
        pathOrFile = open(pathOrFile)
        didOpen = 1
    p = PlistParser()
    rootObject = p.parse(pathOrFile)
    if didOpen:
        pathOrFile.close()
    return rootObject


def writePlist(rootObject, pathOrFile):
    """Write 'rootObject' to a .plist file. 'pathOrFile' may either be a
    file name or a (writable) file object.
    """
    didOpen = 0
    if isinstance(pathOrFile, (str, unicode)):
        pathOrFile = open(pathOrFile, "w")
        didOpen = 1
    writer = PlistWriter(pathOrFile)
    writer.writeln("<plist version=\"1.0\">")
    writer.writeValue(rootObject)
    writer.writeln("</plist>")
    if didOpen:
        pathOrFile.close()


def readPlistFromString(data):
    """Read a plist data from a string. Return the root object.
    """
    return readPlist(StringIO(data))


def writePlistToString(rootObject):
    """Return 'rootObject' as a plist-formatted string.
    """
    f = StringIO()
    writePlist(rootObject, f)
    return f.getvalue()


def readPlistFromResource(path, restype='plst', resid=0):
    """Read plst resource from the resource fork of path.
    """
    warnings.warnpy3k("In 3.x, readPlistFromResource is removed.",
                      stacklevel=2)
    from Carbon.File import FSRef, FSGetResourceForkName
    from Carbon.Files import fsRdPerm
    from Carbon import Res
    fsRef = FSRef(path)
    resNum = Res.FSOpenResourceFile(fsRef, FSGetResourceForkName(), fsRdPerm)
    Res.UseResFile(resNum)
    plistData = Res.Get1Resource(restype, resid).data
    Res.CloseResFile(resNum)
    return readPlistFromString(plistData)


def writePlistToResource(rootObject, path, restype='plst', resid=0):
    """Write 'rootObject' as a plst resource to the resource fork of path.
    """
    warnings.warnpy3k("In 3.x, writePlistToResource is removed.", stacklevel=2)
    from Carbon.File import FSRef, FSGetResourceForkName
    from Carbon.Files import fsRdWrPerm
    from Carbon import Res
    plistData = writePlistToString(rootObject)
    fsRef = FSRef(path)
    resNum = Res.FSOpenResourceFile(fsRef, FSGetResourceForkName(), fsRdWrPerm)
    Res.UseResFile(resNum)
    try:
        Res.Get1Resource(restype, resid).RemoveResource()
    except Res.Error:
        pass
    res = Res.Resource(plistData)
    res.AddResource(restype, resid, '')
    res.WriteResource()
    Res.CloseResFile(resNum)


class DumbXMLWriter:

    def __init__(self, file, indentLevel=0, indent="\t"):
        self.file = file
        self.stack = []
        self.indentLevel = indentLevel
        self.indent = indent

    def beginElement(self, element):
        self.stack.append(element)
        self.writeln("<%s>" % element)
        self.indentLevel += 1

    def endElement(self, element):
        assert self.indentLevel > 0
        assert self.stack.pop() == element
        self.indentLevel -= 1
        self.writeln("</%s>" % element)

    def simpleElement(self, element, value=None):
        if value is not None:
            value = _escapeAndEncode(value)
            self.writeln("<%s>%s</%s>" % (element, value, element))
        else:
            self.writeln("<%s/>" % element)

    def writeln(self, line):
        if line:
            self.file.write(self.indentLevel * self.indent + line + "\n")
        else:
            self.file.write("\n")


# Contents should conform to a subset of ISO 8601
# (in particular, YYYY '-' MM '-' DD 'T' HH ':' MM ':' SS 'Z'.  Smaller units may be omitted with
#  a loss of precision)
_dateParser = re.compile(r"(?P<year>\d\d\d\d)(?:-(?P<month>\d\d)(?:-(?P<day>\d\d)(?:T(?P<hour>\d\d)(?::(?P<minute>\d\d)(?::(?P<second>\d\d))?)?)?)?)?Z")

def _dateFromString(s):
    order = ('year', 'month', 'day', 'hour', 'minute', 'second')
    gd = _dateParser.match(s).groupdict()
    lst = []
    for key in order:
        val = gd[key]
        if val is None:
            break
        lst.append(int(val))
    return datetime.datetime(*lst)

def _dateToString(d):
    return '%04d-%02d-%02dT%02d:%02d:%02dZ' % (
        d.year, d.month, d.day,
        d.hour, d.minute, d.second
    )


# Regex to find any control chars, except for \t \n and \r
_controlCharPat = re.compile(
    r"[\x00\x01\x02\x03\x04\x05\x06\x07\x08\x0b\x0c\x0e\x0f"
    r"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f]")

def _escapeAndEncode(text):
    m = _controlCharPat.search(text)
    if m is not None:
        raise ValueError("strings can't contains control characters; "
                         "use plistlib.Data instead")
    text = text.replace("\r\n", "\n")       # convert DOS line endings
    text = text.replace("\r", "\n")         # convert Mac line endings
    text = text.replace("&", "&amp;")       # escape '&'
    text = text.replace("<", "&lt;")        # escape '<'
    text = text.replace(">", "&gt;")        # escape '>'
    return text.encode("utf-8")             # encode as UTF-8


PLISTHEADER = """\
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
"""

class PlistWriter(DumbXMLWriter):

    def __init__(self, file, indentLevel=0, indent="\t", writeHeader=1):
        if writeHeader:
            file.write(PLISTHEADER)
        DumbXMLWriter.__init__(self, file, indentLevel, indent)

    def writeValue(self, value):
        if isinstance(value, (str, unicode)):
            self.simpleElement("string", value)
        elif isinstance(value, bool):
            # must switch for bool before int, as bool is a
            # subclass of int...
            if value:
                self.simpleElement("true")
            else:
                self.simpleElement("false")
        elif isinstance(value, (int, long)):
            self.simpleElement("integer", "%d" % value)
        elif isinstance(value, float):
            self.simpleElement("real", repr(value))
        elif isinstance(value, dict):
            self.writeDict(value)
        elif isinstance(value, Data):
            self.writeData(value)
        elif isinstance(value, datetime.datetime):
            self.simpleElement("date", _dateToString(value))
        elif isinstance(value, (tuple, list)):
            self.writeArray(value)
        else:
            raise TypeError("unsuported type: %s" % type(value))

    def writeData(self, data):
        self.beginElement("data")
        self.indentLevel -= 1
        maxlinelength = 76 - len(self.indent.replace("\t", " " * 8) *
                                 self.indentLevel)
        for line in data.asBase64(maxlinelength).split("\n"):
            if line:
                self.writeln(line)
        self.indentLevel += 1
        self.endElement("data")

    def writeDict(self, d):
        self.beginElement("dict")
        items = d.items()
        items.sort()
        for key, value in items:
            if not isinstance(key, (str, unicode)):
                raise TypeError("keys must be strings")
            self.simpleElement("key", key)
            self.writeValue(value)
        self.endElement("dict")

    def writeArray(self, array):
        self.beginElement("array")
        for value in array:
            self.writeValue(value)
        self.endElement("array")


class _InternalDict(dict):

    # This class is needed while Dict is scheduled for deprecation:
    # we only need to warn when a *user* instantiates Dict or when
    # the "attribute notation for dict keys" is used.

    def __getattr__(self, attr):
        try:
            value = self[attr]
        except KeyError:
            raise AttributeError, attr
        from warnings import warn
        warn("Attribute access from plist dicts is deprecated, use d[key] "
             "notation instead", PendingDeprecationWarning, 2)
        return value

    def __setattr__(self, attr, value):
        from warnings import warn
        warn("Attribute access from plist dicts is deprecated, use d[key] "
             "notation instead", PendingDeprecationWarning, 2)
        self[attr] = value

    def __delattr__(self, attr):
        try:
            del self[attr]
        except KeyError:
            raise AttributeError, attr
        from warnings import warn
        warn("Attribute access from plist dicts is deprecated, use d[key] "
             "notation instead", PendingDeprecationWarning, 2)

class Dict(_InternalDict):

    def __init__(self, **kwargs):
        from warnings import warn
        warn("The plistlib.Dict class is deprecated, use builtin dict instead",
             PendingDeprecationWarning, 2)
        super(Dict, self).__init__(**kwargs)


class Plist(_InternalDict):

    """This class has been deprecated. Use readPlist() and writePlist()
    functions instead, together with regular dict objects.
    """

    def __init__(self, **kwargs):
        from warnings import warn
        warn("The Plist class is deprecated, use the readPlist() and "
             "writePlist() functions instead", PendingDeprecationWarning, 2)
        super(Plist, self).__init__(**kwargs)

    def fromFile(cls, pathOrFile):
        """Deprecated. Use the readPlist() function instead."""
        rootObject = readPlist(pathOrFile)
        plist = cls()
        plist.update(rootObject)
        return plist
    fromFile = classmethod(fromFile)

    def write(self, pathOrFile):
        """Deprecated. Use the writePlist() function instead."""
        writePlist(self, pathOrFile)


def _encodeBase64(s, maxlinelength=76):
    # copied from base64.encodestring(), with added maxlinelength argument
    maxbinsize = (maxlinelength//4)*3
    pieces = []
    for i in range(0, len(s), maxbinsize):
        chunk = s[i : i + maxbinsize]
        pieces.append(binascii.b2a_base64(chunk))
    return "".join(pieces)

class Data:

    """Wrapper for binary data."""

    def __init__(self, data):
        self.data = data

    def fromBase64(cls, data):
        # base64.decodestring just calls binascii.a2b_base64;
        # it seems overkill to use both base64 and binascii.
        return cls(binascii.a2b_base64(data))
    fromBase64 = classmethod(fromBase64)

    def asBase64(self, maxlinelength=76):
        return _encodeBase64(self.data, maxlinelength)

    def __cmp__(self, other):
        if isinstance(other, self.__class__):
            return cmp(self.data, other.data)
        elif isinstance(other, str):
            return cmp(self.data, other)
        else:
            return cmp(id(self), id(other))

    def __repr__(self):
        return "%s(%s)" % (self.__class__.__name__, repr(self.data))


class PlistParser:

    def __init__(self):
        self.stack = []
        self.currentKey = None
        self.root = None

    def parse(self, fileobj):
        from xml.parsers.expat import ParserCreate
        parser = ParserCreate()
        parser.StartElementHandler = self.handleBeginElement
        parser.EndElementHandler = self.handleEndElement
        parser.CharacterDataHandler = self.handleData
        parser.ParseFile(fileobj)
        return self.root

    def handleBeginElement(self, element, attrs):
        self.data = []
        handler = getattr(self, "begin_" + element, None)
        if handler is not None:
            handler(attrs)

    def handleEndElement(self, element):
        handler = getattr(self, "end_" + element, None)
        if handler is not None:
            handler()

    def handleData(self, data):
        self.data.append(data)

    def addObject(self, value):
        if self.currentKey is not None:
            self.stack[-1][self.currentKey] = value
            self.currentKey = None
        elif not self.stack:
            # this is the root object
            self.root = value
        else:
            self.stack[-1].append(value)

    def getData(self):
        data = "".join(self.data)
        try:
            data = data.encode("ascii")
        except UnicodeError:
            pass
        self.data = []
        return data

    # element handlers

    def begin_dict(self, attrs):
        d = _InternalDict()
        self.addObject(d)
        self.stack.append(d)
    def end_dict(self):
        self.stack.pop()

    def end_key(self):
        self.currentKey = self.getData()

    def begin_array(self, attrs):
        a = []
        self.addObject(a)
        self.stack.append(a)
    def end_array(self):
        self.stack.pop()

    def end_true(self):
        self.addObject(True)
    def end_false(self):
        self.addObject(False)
    def end_integer(self):
        self.addObject(int(self.getData()))
    def end_real(self):
        self.addObject(float(self.getData()))
    def end_string(self):
        self.addObject(self.getData())
    def end_data(self):
        self.addObject(Data.fromBase64(self.getData()))
    def end_date(self):
        self.addObject(_dateFromString(self.getData()))

# Copyright (c) 2012 Santosh Philip
# =======================================================================
#  Distributed under the MIT License.
#  (See accompanying file LICENSE or copy at
#  http://opensource.org/licenses/MIT)
# =======================================================================

"""sample script - autosize all autosizable fields"""
# email to jason
# Jason,
#   Try out the attached script.
# (you might have to change file pathnames)
#
# I don't think you could have written it on your own :-(
# It became apparent to me that eppy needs functions that allows it to look
# into the idd structure for any object and field
# I'll put some thought into this and see how best to write this.
# If that functionality is done well, hopefully anyone should be able to write
# the equivalent code to what I wrote in the attached file.
#
#
# Santosh
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

import sys

pathnameto_eplusscripting = "../../"
sys.path.append(pathnameto_eplusscripting)

from eppy import modeleditor
from eppy.modeleditor import IDF
from eppy import bunch_subclass


def autosize_fieldname(idfobject):
    """return autsizeable field names in idfobject"""
    # undocumented stuff in this code
    return [
        fname
        for (fname, dct) in zip(idfobject.objls, idfobject["objidd"])
        if "autosizable" in dct
    ]


iddfile = "../resources/iddfiles/Energy+V8_0_0.idd"
fname1 = "../resources/idffiles/V8_0_0/5ZoneWaterLoopHeatPump.idf"

IDF.setiddname(iddfile)
idf = IDF(fname1)
idf.saveas("./a.idf")


allidfobjects = idf.idfobjects
for objname in list(allidfobjects.keys()):
    idfobjects = allidfobjects[objname]
    for idfobject in idfobjects:
        autofields = autosize_fieldname(idfobject)
        for autofield in autofields:
            idfobject[autofield] = "autosize"

idf.saveas("./b.idf")

# coding: utf-8

#-------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#--------------------------------------------------------------------------
import unittest

import azure.mgmt.authorization
from testutils.common_recordingtestcase import record
from tests.mgmt_testcase import HttpStatusCode, AzureMgmtTestCase


class MgmtAuthorizationTest(AzureMgmtTestCase):

    def setUp(self):
        super(MgmtAuthorizationTest, self).setUp()
        self.authorization_client = self.create_mgmt_client(
            azure.mgmt.authorization.AuthorizationManagementClient
        )
        if not self.is_playback():
            self.create_resource_group()

    @record
    def test_authorization(self):
        permissions = self.authorization_client.permissions.list_for_resource_group(
            self.group_name
        )
        
        permissions = list(permissions)
        self.assertEqual(len(permissions), 1)
        self.assertEqual(permissions[0].actions[0], '*')



#------------------------------------------------------------------------------
if __name__ == '__main__':
    unittest.main()

#
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#

__revision__ = "src/engine/SCons/Memoize.py 3842 2008/12/20 22:59:52 scons"

__doc__ = """Memoizer

A metaclass implementation to count hits and misses of the computed
values that various methods cache in memory.

Use of this modules assumes that wrapped methods be coded to cache their
values in a consistent way.  Here is an example of wrapping a method
that returns a computed value, with no input parameters:

    memoizer_counters = []                                      # Memoization

    memoizer_counters.append(SCons.Memoize.CountValue('foo'))   # Memoization

    def foo(self):

        try:                                                    # Memoization
            return self._memo['foo']                            # Memoization
        except KeyError:                                        # Memoization
            pass                                                # Memoization

        result = self.compute_foo_value()

        self._memo['foo'] = result                              # Memoization

        return result

Here is an example of wrapping a method that will return different values
based on one or more input arguments:

    def _bar_key(self, argument):                               # Memoization
        return argument                                         # Memoization

    memoizer_counters.append(SCons.Memoize.CountDict('bar', _bar_key)) # Memoization

    def bar(self, argument):

        memo_key = argument                                     # Memoization
        try:                                                    # Memoization
            memo_dict = self._memo['bar']                       # Memoization
        except KeyError:                                        # Memoization
            memo_dict = {}                                      # Memoization
            self._memo['dict'] = memo_dict                      # Memoization
        else:                                                   # Memoization
            try:                                                # Memoization
                return memo_dict[memo_key]                      # Memoization
            except KeyError:                                    # Memoization
                pass                                            # Memoization

        result = self.compute_bar_value(argument)

        memo_dict[memo_key] = result                            # Memoization

        return result

At one point we avoided replicating this sort of logic in all the methods
by putting it right into this module, but we've moved away from that at
present (see the "Historical Note," below.).

Deciding what to cache is tricky, because different configurations
can have radically different performance tradeoffs, and because the
tradeoffs involved are often so non-obvious.  Consequently, deciding
whether or not to cache a given method will likely be more of an art than
a science, but should still be based on available data from this module.
Here are some VERY GENERAL guidelines about deciding whether or not to
cache return values from a method that's being called a lot:

    --  The first question to ask is, "Can we change the calling code
        so this method isn't called so often?"  Sometimes this can be
        done by changing the algorithm.  Sometimes the *caller* should
        be memoized, not the method you're looking at.

    --  The memoized function should be timed with multiple configurations
        to make sure it doesn't inadvertently slow down some other
        configuration.

    --  When memoizing values based on a dictionary key composed of
        input arguments, you don't need to use all of the arguments
        if some of them don't affect the return values.

Historical Note:  The initial Memoizer implementation actually handled
the caching of values for the wrapped methods, based on a set of generic
algorithms for computing hashable values based on the method's arguments.
This collected caching logic nicely, but had two drawbacks:

    Running arguments through a generic key-conversion mechanism is slower
    (and less flexible) than just coding these things directly.  Since the
    methods that need memoized values are generally performance-critical,
    slowing them down in order to collect the logic isn't the right
    tradeoff.

    Use of the memoizer really obscured what was being called, because
    all the memoized methods were wrapped with re-used generic methods.
    This made it more difficult, for example, to use the Python profiler
    to figure out how to optimize the underlying methods.
"""

import new

# A flag controlling whether or not we actually use memoization.
use_memoizer = None

CounterList = []

class Counter:
    """
    Base class for counting memoization hits and misses.

    We expect that the metaclass initialization will have filled in
    the .name attribute that represents the name of the function
    being counted.
    """
    def __init__(self, method_name):
        """
        """
        self.method_name = method_name
        self.hit = 0
        self.miss = 0
        CounterList.append(self)
    def display(self):
        fmt = "    %7d hits %7d misses    %s()"
        print fmt % (self.hit, self.miss, self.name)
    def __cmp__(self, other):
        try:
            return cmp(self.name, other.name)
        except AttributeError:
            return 0

class CountValue(Counter):
    """
    A counter class for simple, atomic memoized values.

    A CountValue object should be instantiated in a class for each of
    the class's methods that memoizes its return value by simply storing
    the return value in its _memo dictionary.

    We expect that the metaclass initialization will fill in the
    .underlying_method attribute with the method that we're wrapping.
    We then call the underlying_method method after counting whether
    its memoized value has already been set (a hit) or not (a miss).
    """
    def __call__(self, *args, **kw):
        obj = args[0]
        if obj._memo.has_key(self.method_name):
            self.hit = self.hit + 1
        else:
            self.miss = self.miss + 1
        return apply(self.underlying_method, args, kw)

class CountDict(Counter):
    """
    A counter class for memoized values stored in a dictionary, with
    keys based on the method's input arguments.

    A CountDict object is instantiated in a class for each of the
    class's methods that memoizes its return value in a dictionary,
    indexed by some key that can be computed from one or more of
    its input arguments.

    We expect that the metaclass initialization will fill in the
    .underlying_method attribute with the method that we're wrapping.
    We then call the underlying_method method after counting whether the
    computed key value is already present in the memoization dictionary
    (a hit) or not (a miss).
    """
    def __init__(self, method_name, keymaker):
        """
        """
        Counter.__init__(self, method_name)
        self.keymaker = keymaker
    def __call__(self, *args, **kw):
        obj = args[0]
        try:
            memo_dict = obj._memo[self.method_name]
        except KeyError:
            self.miss = self.miss + 1
        else:
            key = apply(self.keymaker, args, kw)
            if memo_dict.has_key(key):
                self.hit = self.hit + 1
            else:
                self.miss = self.miss + 1
        return apply(self.underlying_method, args, kw)

class Memoizer:
    """Object which performs caching of method calls for its 'primary'
    instance."""

    def __init__(self):
        pass

# Find out if we support metaclasses (Python 2.2 and later).

class M:
    def __init__(cls, name, bases, cls_dict):
        cls.use_metaclass = 1
        def fake_method(self):
            pass
        new.instancemethod(fake_method, None, cls)

try:
    class A:
        __metaclass__ = M

    use_metaclass = A.use_metaclass
except AttributeError:
    use_metaclass = None
    reason = 'no metaclasses'
except TypeError:
    use_metaclass = None
    reason = 'new.instancemethod() bug'
else:
    del A

del M

if not use_metaclass:

    def Dump(title):
        pass

    try:
        class Memoized_Metaclass(type):
            # Just a place-holder so pre-metaclass Python versions don't
            # have to have special code for the Memoized classes.
            pass
    except TypeError:
        class Memoized_Metaclass:
            # A place-holder so pre-metaclass Python versions don't
            # have to have special code for the Memoized classes.
            pass

    def EnableMemoization():
        import SCons.Warnings
        msg = 'memoization is not supported in this version of Python (%s)'
        raise SCons.Warnings.NoMetaclassSupportWarning, msg % reason

else:

    def Dump(title=None):
        if title:
            print title
        CounterList.sort()
        for counter in CounterList:
            counter.display()

    class Memoized_Metaclass(type):
        def __init__(cls, name, bases, cls_dict):
            super(Memoized_Metaclass, cls).__init__(name, bases, cls_dict)

            for counter in cls_dict.get('memoizer_counters', []):
                method_name = counter.method_name

                counter.name = cls.__name__ + '.' + method_name
                counter.underlying_method = cls_dict[method_name]

                replacement_method = new.instancemethod(counter, None, cls)
                setattr(cls, method_name, replacement_method)

    def EnableMemoization():
        global use_memoizer
        use_memoizer = 1

# coding=utf-8

"""
Collect Memory usage and limit of LXCs

#### Dependencies
 * cgroup, I guess

"""

from diamond.collector import Collector
import diamond.convertor
import os


class MemoryLxcCollector(Collector):

    def get_default_config_help(self):
        """
        Return help text for collector configuration.
        """
        config_help = super(MemoryLxcCollector, self).get_default_config_help()
        config_help.update({
            "sys_path": "Defaults to '/sys/fs/cgroup/lxc'",
        })
        return config_help

    def get_default_config(self):
        """
        Returns default settings for collector.
        """
        config = super(MemoryLxcCollector, self).get_default_config()
        config.update({
            "path":     "lxc",
            "sys_path": "/sys/fs/cgroup/lxc",
        })
        return config

    def collect(self):
        """
        Collect memory stats of LXCs.
        """
        lxc_metrics = ["memory.usage_in_bytes", "memory.limit_in_bytes"]
        if os.path.isdir(self.config["sys_path"]) is False:
            self.log.debug("sys_path '%s' isn't directory.",
                           self.config["sys_path"])
            return {}

        collected = {}
        for item in os.listdir(self.config["sys_path"]):
            fpath = "%s/%s" % (self.config["sys_path"], item)
            if os.path.isdir(fpath) is False:
                continue

            for lxc_metric in lxc_metrics:
                filename = "%s/%s" % (fpath, lxc_metric)
                metric_name = "%s.%s" % (
                    item.replace(".", "_"),
                    lxc_metric.replace("_in_bytes", ""))
                self.log.debug("Trying to collect from %s", filename)
                collected[metric_name] = self._read_file(filename)

        for key in collected.keys():
            if collected[key] is None:
                continue

            for unit in self.config["byte_unit"]:
                value = diamond.convertor.binary.convert(
                    collected[key],
                    oldUnit="B",
                    newUnit=unit)
                new_key = "%s_in_%ss" % (key, unit)
                self.log.debug("Publishing '%s %s'", new_key, value)
                self.publish(new_key, value, metric_type="GAUGE")

    def _read_file(self, filename):
        """
        Read contents of given file.
        """
        try:
            with open(filename, "r") as fhandle:
                stats = float(fhandle.readline().rstrip("\n"))
        except Exception:
            stats = None

        return stats

import os
import unittest
from support import html5lib_test_files, TestData, test_dir

from html5lib import HTMLParser, inputstream

import re, unittest

class Html5EncodingTestCase(unittest.TestCase):
    def test_codec_name(self):
        self.assertEquals(inputstream.codecName("utf-8"), "utf-8")
        self.assertEquals(inputstream.codecName("utf8"), "utf-8")
        self.assertEquals(inputstream.codecName("  utf8  "), "utf-8")
        self.assertEquals(inputstream.codecName("ISO_8859--1"), "windows-1252")

def buildTestSuite():
    for filename in html5lib_test_files("encoding"):
        test_name = os.path.basename(filename).replace('.dat',''). \
            replace('-','')
        tests = TestData(filename, "data")
        for idx, test in enumerate(tests):
            def encodingTest(self, data=test['data'], 
                             encoding=test['encoding']):
                p = HTMLParser()
                t = p.parse(data, useChardet=False)
                
                errorMessage = ("Input:\n%s\nExpected:\n%s\nRecieved\n%s\n"%
                                (data, repr(encoding.lower()), 
                                 repr(p.tokenizer.stream.charEncoding)))
                self.assertEquals(encoding.lower(),
                                  p.tokenizer.stream.charEncoding[0], 
                                  errorMessage)
            setattr(Html5EncodingTestCase, 'test_%s_%d' % (test_name, idx+1),
                encodingTest)

    try:
        import chardet
        def test_chardet(self):
            data = open(os.path.join(test_dir, "encoding" , "chardet", "test_big5.txt")).read()
            encoding = inputstream.HTMLInputStream(data).charEncoding
            assert encoding[0].lower() == "big5"
        setattr(Html5EncodingTestCase, 'test_chardet', test_chardet)
    except ImportError:
        print "chardet not found, skipping chardet tests"
        

    return unittest.defaultTestLoader.loadTestsFromName(__name__)

def main():
    buildTestSuite()
    unittest.main()

if __name__ == "__main__":
    main()

"""
This file was generated with the customdashboard management command and
contains the class for the main dashboard.

To activate your index dashboard add the following to your settings.py::
    GRAPPELLI_INDEX_DASHBOARD = 'midnight.dashboard.CustomIndexDashboard'
"""

from django.utils.translation import ugettext_lazy as _
from django.core.urlresolvers import reverse

from grappelli.dashboard import modules, Dashboard
from grappelli.dashboard.utils import get_admin_site_name


class CustomIndexDashboard(Dashboard):
    """
    Custom index dashboard for www.
    """
    
    def init_with_context(self, context):
        site_name = get_admin_site_name(context)
        
        # append a group for "Administration" & "Applications"
        self.children.append(modules.Group(
            _('Applications'),
            column=1,
            collapsible=True,
            children = [
                modules.AppList(
                    _('Administration'),
                    column=1,
                    collapsible=False,
                    models=('django.contrib.*',),
                ),
                modules.AppList(
                    _('Applications'),
                    column=1,
                    css_classes=('collapse closed',),
                    exclude=('django.contrib.*', 'precise_bbcode.*'),
                )
            ]
        ))


        # append another link list module for "support".
        self.children.append(modules.LinkList(
            _('Media'),
            column=2,
            children=[
                {
                    'title': _('FileBrowser'),
                    'url': '/admin/filebrowser/browse/',
                    'external': False,
                },
            ]
        ))

        
        # append a recent actions module
        self.children.append(modules.RecentActions(
            _('Recent Actions'),
            limit=5,
            collapsible=False,
            column=3,
        ))



#!/usr/bin/env python
from numba import jit
import numpy as np
from src.crystallographic_calculations import euler2rotmat, rotmat2misor_angle
from src.symmetry_groups import get_sigma_variants_crit, get_symmetry_group

''' Identify General and special grain boundaries '''
def get_neighbor_direction(Grain_ID, NROWS, NCOLS_EVEN, NCOLS_ODD):
    NCOLS_EVEN_ODD = NCOLS_EVEN+NCOLS_ODD
    NCOLS_EVEN_EVEN = NCOLS_EVEN+NCOLS_EVEN
    if NROWS%2 == 1:
        TOPLEFT = int(NROWS/2)*(NCOLS_EVEN+NCOLS_ODD)
        TOPRIGHT= int(NROWS/2)*(NCOLS_EVEN+NCOLS_ODD)+NCOLS_EVEN
    else:
        TOPLEFT = int(NROWS/2)*(NCOLS_EVEN+NCOLS_ODD)-NCOLS_EVEN
        TOPRIGHT = int(NROWS/2)*(NCOLS_EVEN+NCOLS_ODD)-1
    neighbor_direction = [[1, NCOLS_ODD, NCOLS_EVEN]]*len(Grain_ID)
    boundaries = [[[1,2],[0,1] ,[-1,0]]]*len(Grain_ID)
    #Bottom left
    neighbor_direction[0] = [1, NCOLS_ODD]
    boundaries[0] = [[1,2],[0,1]]
    #Bottom right
    neighbor_direction[NCOLS_EVEN]=[NCOLS_EVEN]
    boundaries[NCOLS_EVEN] = [[-1,0]]
    LS_EVEN = [NCOLS_EVEN_ODD*x -NCOLS_EVEN for x in range(1,int(NROWS/2+1))]
    for i in LS_EVEN:
        neighbor_direction[i] = [1, NCOLS_ODD, NCOLS_EVEN]
        boundaries[i] = [[1,2],[0,1],[-1,0]]
    RS_EVEN = [NCOLS_EVEN_ODD*x-1 for x in range(1,int(NROWS/2+1))]
    for i in RS_EVEN:
        neighbor_direction[i] = [NCOLS_ODD, NCOLS_EVEN]
        boundaries[i]= [[0,1] ,[-1,0]]
    LS_ODD=[NCOLS_EVEN_ODD*x for x in range(1,int(NROWS/2))]
    for i in LS_ODD:
        neighbor_direction[i] = [1, NCOLS_ODD]
        boundaries[i] = [[1,2],[0,1]]
    RS_ODD = [NCOLS_EVEN_ODD*x+NCOLS_EVEN for x in range(1,int(NROWS/2))]
    for i in RS_ODD:
         neighbor_direction[i] = [NCOLS_EVEN]
         boundaries[i] = [[-1,0]]
    TOP = [x for x in range(TOPLEFT,TOPRIGHT)]
    for i in TOP:
        neighbor_direction[i] = [1]
        boundaries[i] = [[1,2]]    
    neighbor_direction[TOPRIGHT] = [0]
    boundaries[TOPRIGHT] = [[0]]
    return neighbor_direction, boundaries


def get_GB_IDs(Grain_ID, boundaries, neighbor_direction, GB_point_ID, GB_vert_ID1, GB_vert_ID2, GB_neighbor_ID):
    for i in range(len(Grain_ID)):
        for k in range(len(neighbor_direction[i])):
            if Grain_ID[i] != Grain_ID[i + neighbor_direction[i][k]]:                    
                    GB_point_ID.append(i)
                    GB_neighbor_ID.append(i+neighbor_direction[i][k])
                    GB_vert_ID1.append(boundaries[i][k][0])
                    GB_vert_ID2.append(boundaries[i][k][1])
    return GB_point_ID, GB_neighbor_ID, GB_vert_ID1, GB_vert_ID2

def identify_GBs(Data_GB, Grain_ID, NROWS, NCOLS_EVEN, NCOLS_ODD):
    neighbor_direction, boundaries = get_neighbor_direction(Grain_ID, NROWS, NCOLS_EVEN, NCOLS_ODD)
    GB_point_ID = []
    GB_neighbor_ID = []
    GB_vert_ID1 = []
    GB_vert_ID2 = []
    Data_GB['General_GB'] = get_GB_IDs(Grain_ID, boundaries, neighbor_direction, GB_point_ID, GB_vert_ID1, GB_vert_ID2, GB_neighbor_ID)
   
def get_disorientation(boundary_point, neighbor_point, phi1, Phi, phi2):
    g_point  = euler2rotmat([phi1[boundary_point], Phi[boundary_point], phi2[boundary_point]])
    g_neighbor = euler2rotmat([phi1[neighbor_point], Phi[neighbor_point], phi2[neighbor_point]])
    g = np.dot(g_point, g_neighbor.transpose())
    return g

def get_Sigma_GB_IDs(GB_data, phi1, Phi, phi2, Sigma_variants, Symmetry_group, Brandon_crit, Sigma_GB_point_ID, Sigma_GB_neighbor_ID, Sigma_GB_vert_ID1, Sigma_GB_vert_ID2):
    for i in  range(len(GB_data[0])):
        g = get_disorientation(GB_data[0][i], GB_data[1][i], phi1, Phi, phi2)           
        for n in Sigma_variants:             
            Theta = rotmat2misor_angle( np.dot(g, n.transpose()), Symmetry_group)
            if Theta < Brandon_crit:
                Sigma_GB_point_ID.append(GB_data[0][i])
                Sigma_GB_neighbor_ID.append(GB_data[1][i])
                Sigma_GB_vert_ID1.append(GB_data[2][i])
                Sigma_GB_vert_ID2.append(GB_data[3][i])
                break
    return Sigma_GB_point_ID, Sigma_GB_neighbor_ID, Sigma_GB_vert_ID1, Sigma_GB_vert_ID2


def identify_Sigma_GBs(Data_GB, Sigma_CSL, crit, crystal_sys, Bravais_lattice, phi1, Phi, phi2):
    Symmetry_group = get_symmetry_group(crystal_sys) 
    Sigma_variants, Brandon_crit = get_sigma_variants_crit(Sigma_CSL, crit, crystal_sys, Bravais_lattice)
    Sigma_GB_point_ID = []
    Sigma_GB_neighbor_ID = []
    Sigma_GB_vert_ID1 = []
    Sigma_GB_vert_ID2 = []
    GB_data = Data_GB['General_GB']
    Sigma_GB_point_ID, Sigma_GB_neighbor_ID, Sigma_GB_vert_ID1, Sigma_GB_vert_ID2 = get_Sigma_GB_IDs(GB_data, phi1, Phi, phi2, Sigma_variants, Symmetry_group, Brandon_crit, Sigma_GB_point_ID, Sigma_GB_neighbor_ID, Sigma_GB_vert_ID1, Sigma_GB_vert_ID2)
    Data_GB[Sigma_CSL] = [Sigma_GB_point_ID, Sigma_GB_neighbor_ID, Sigma_GB_vert_ID1, Sigma_GB_vert_ID2]


''' Identify General and special triple junctions '''

def identify_TJs(Data_GB, Data_TJ, Grain_ID, NCOLS_ODD, NCOLS_EVEN):
    TJ_point_ID = []
    TJ_neighbor_ID = []
    TJ_vert_ID = []
    GB_data = Data_GB['General_GB']
    for i in range(len(GB_data[0])-1):
        if ((GB_data[0][i] == GB_data[0][i + 1])
            and (Grain_ID[GB_data[0][i]] != Grain_ID[GB_data[1][i]])
            and (Grain_ID[GB_data[0][i+1]] != Grain_ID[GB_data[1][i + 1]])
            and (Grain_ID[GB_data[1][i]] != Grain_ID[GB_data[1][i + 1]])
            and (GB_data[1][i+1]-GB_data[1][i] == NCOLS_EVEN
                 or GB_data[1][i]-GB_data[1][i+1] == 1)):   
                    TJ_point_ID.append(GB_data[0][i])
                    TJ_neighbor_ID.append([GB_data[1][i], GB_data[1][i+1]])
                    TJ_vert_ID.append(GB_data[2][i])
    Data_TJ['General_TJ'] = [TJ_point_ID, TJ_neighbor_ID, TJ_vert_ID]

def get_disorientation_trip(triple_point, neighbor_point, phi1, Phi, phi2):
    g_point  = euler2rotmat([phi1[triple_point ],Phi[triple_point],phi2[triple_point]])
    g_neighbor1 = euler2rotmat([phi1[neighbor_point[0]],Phi[neighbor_point[0]],phi2[neighbor_point[0]]])
    g_neighbor2 = euler2rotmat([phi1[neighbor_point[1]],Phi[neighbor_point[1]],phi2[neighbor_point[1]]])
    g1 = np.dot(g_point, g_neighbor1.transpose())
    g2 = np.dot(g_point, g_neighbor2.transpose())
    g3 = np.dot(g_neighbor1, g_neighbor2.transpose())
    return g1, g2, g3



def identify_Sigma_TJs(Data_GB,
                       Data_TJ,
                       Triple_junction,
                       crit,
                       crystal_sys,
                       Bravais_lattice,
                       phi1, Phi, phi2):    
    Symmetry_group = get_symmetry_group(crystal_sys)
    Sigma_variants_crit = []
    for i in Triple_junction:
        Sigma_variants_crit.append(get_sigma_variants_crit(i,crit, crystal_sys, Bravais_lattice))

    Sigma_TJ_point_ID = []
    Sigma_TJ_neighbor_ID = []
    Sigma_TJ_vert_ID = []
    
    Sigma_Sigma_TJ_point_ID = []
    Sigma_Sigma_TJ_neighbor_ID = []
    Sigma_Sigma_TJ_vert_ID = []
    
    Sigma_Sigma_Sigma_TJ_point_ID = []
    Sigma_Sigma_Sigma_TJ_neighbor_ID = []
    Sigma_Sigma_Sigma_TJ_vert_ID = []
    
    TJ_data = Data_TJ['General_TJ']
    for i in  range(len(TJ_data[0])):
        g1, g2, g3 = get_disorientation_trip(TJ_data[0][i],TJ_data[1][i],phi1,Phi,phi2)
        g = [g1, g2, g3]
        tj = []
        boundary_no = []
        for j in range(len(Sigma_variants_crit)):
            for n in Sigma_variants_crit[j][0]:
                for k in range(len(g)):
                    rotmat_sym = g[k] * n.transpose()    
                    Theta = rotmat2misor_angle(rotmat_sym,Symmetry_group)
                    if Theta < Sigma_variants_crit[j][1] and k not in boundary_no:            
                        tj.append(Triple_junction[j])
                        boundary_no.append(k)
                        break
            if len(tj) < j:
                break
        if tj == [Triple_junction[0]]:
                Sigma_TJ_point_ID.append(TJ_data[0][i])               
                Sigma_TJ_neighbor_ID.append(TJ_data[1][i])
                Sigma_TJ_vert_ID.append(TJ_data[2][i])                
        if tj == [Triple_junction[0],Triple_junction[1]]:            
                Sigma_Sigma_TJ_point_ID.append(TJ_data[0][i])
                Sigma_Sigma_TJ_neighbor_ID.append(TJ_data[1][i])
                Sigma_Sigma_TJ_vert_ID.append(TJ_data[2][i])                
        if tj == [Triple_junction[0],Triple_junction[1],Triple_junction[2]]:
                Sigma_Sigma_Sigma_TJ_point_ID.append(TJ_data[0][i])
                Sigma_Sigma_Sigma_TJ_neighbor_ID.append(TJ_data[1][i])
                Sigma_Sigma_Sigma_TJ_vert_ID.append(TJ_data[2][i])
  
    Data_TJ[Triple_junction[0]] = [Sigma_TJ_point_ID, Sigma_TJ_neighbor_ID, Sigma_TJ_vert_ID]            
    Data_TJ[Triple_junction[0] + Triple_junction[1]] = [Sigma_Sigma_TJ_point_ID, Sigma_Sigma_TJ_neighbor_ID, Sigma_Sigma_TJ_vert_ID]
    Data_TJ[Triple_junction[0] + Triple_junction[1] + Triple_junction[2]] = [Sigma_Sigma_Sigma_TJ_point_ID,  Sigma_Sigma_Sigma_TJ_neighbor_ID, Sigma_Sigma_Sigma_TJ_vert_ID]

# This file is part of the Electron Orbital Explorer. The Electron
# Orbital Explorer is distributed under the Simplified BSD License
# (also called the "BSD 2-Clause License"), in hopes that these
# rendering techniques might be used by other programmers in
# applications such as scientific visualization, video gaming, and so
# on. If you find value in this software and use its technologies for
# another purpose, I would love to hear back from you at bjthinks (at)
# gmail (dot) com. If you improve this software and agree to release
# your modifications under the below license, I encourage you to fork
# the development tree on github and push your modifications. The
# Electron Orbital Explorer's development URL is:
# https://github.com/bjthinks/orbital-explorer
# (This paragraph is not part of the software license and may be
# removed.)
#
# Copyright (c) 2013, Brian W. Johnson
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# + Redistributions of source code must retain the above copyright
#   notice, this list of conditions and the following disclaimer.
#
# + Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in
#   the documentation and/or other materials provided with the
#   distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.


from sys import argv


def license(style):
    license_text = [
        'This file is part of the Electron Orbital Explorer. The Electron',
        'Orbital Explorer is distributed under the Simplified BSD License',
        '(also called the "BSD 2-Clause License"), in hopes that these',
        'rendering techniques might be used by other programmers in',
        'applications such as scientific visualization, video gaming, and so',
        'on. If you find value in this software and use its technologies for',
        'another purpose, I would love to hear back from you at bjthinks (at)',
        'gmail (dot) com. If you improve this software and agree to release',
        'your modifications under the below license, I encourage you to fork',
        'the development tree on github and push your modifications. The',
        'Electron Orbital Explorer\'s development URL is:',
        'https://github.com/bjthinks/orbital-explorer',
        '(This paragraph is not part of the software license and may be',
        'removed.)',
        '',
        'Copyright (c) 2013, Brian W. Johnson',
        'All rights reserved.',
        '',
        'Redistribution and use in source and binary forms, with or without',
        'modification, are permitted provided that the following conditions',
        'are met:',
        '',
        '+ Redistributions of source code must retain the above copyright',
        '  notice, this list of conditions and the following disclaimer.',
        '',
        '+ Redistributions in binary form must reproduce the above copyright',
        '  notice, this list of conditions and the following disclaimer in',
        '  the documentation and/or other materials provided with the',
        '  distribution.',
        '',
        'THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS',
        '"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT',
        'LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS',
        'FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE',
        'COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,',
        'INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,',
        'BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;',
        'LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER',
        'CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT',
        'LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN',
        'ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE',
        'POSSIBILITY OF SUCH DAMAGE.',
    ]

    header = []
    prefix = ''
    truncated_prefix = ''
    footer = []
    if style == 'c':
        header = ['/*']
        prefix = ' * '
        truncated_prefix = ' *'
        footer = [' */']
    elif style == 'hash':
        prefix = '# '
        truncated_prefix = '#'
    elif style == 'shell':
        header = ['#!/bin/sh', '#']
        prefix = '# '
        truncated_prefix = '#'
    else:
        # generate as plain text
        pass

    prefixed_license_text = []
    for s in license_text:
        if s == '':
            prefixed_license_text.append(truncated_prefix)
        else:
            prefixed_license_text.append(prefix + s)

    return header + prefixed_license_text + footer


if __name__ == '__main__':
    if len(argv) > 1:
        style = argv[1]
    else:
        style = 'text'
    for s in license(style):
        print(s)

#!/usr/bin/env python
# Copyright 2012 Cloudera Inc.
#
# 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.

# This script generates the FE calls to populate the builtins.
# To add a builtin, add an entry to impala_functions.py.

import sys
import os
from string import Template
import impala_functions

java_registry_preamble = '\
//  Copyright 2012 Cloudera Inc.\n\
// \n\
//  Licensed under the Apache License, Version 2.0 (the "License");\n\
//  you may not use this file except in compliance with the License.\n\
//  You may obtain a copy of the License at\n\
// \n\
//  http://www.apache.org/licenses/LICENSE-2.0\n\
// \n\
//  Unless required by applicable law or agreed to in writing, software\n\
//  distributed under the License is distributed on an "AS IS" BASIS,\n\
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n\
//  See the License for the specific language governing permissions and\n\
//  limitations under the License.\n\
\n\
// This is a generated file, DO NOT EDIT.\n\
// To add new functions, see the generator at\n\
// common/function-registry/gen_builtins_catalog.py or the function list at\n\
// common/function-registry/impala_functions.py.\n\
\n\
package com.cloudera.impala.builtins;\n\
\n\
import com.cloudera.impala.catalog.Type;\n\
import com.cloudera.impala.catalog.Db;\n\
\n\
public class ScalarBuiltins { \n\
  public static void initBuiltins(Db db) { \
\n'

java_registry_epilogue = '\
  }\n\
}\n'

FE_PATH = os.path.expandvars(
  "$IMPALA_HOME/fe/generated-sources/gen-java/com/cloudera/impala/builtins/")

# This contains all the metadata to describe all the builtins.
# Each meta data entry is itself a map to store all the meta data
#   - fn_name, ret_type, args, symbol, sql_names
meta_data_entries = []

# Read in the function and add it to the meta_data_entries map
def add_function(fn_meta_data, user_visible):
  assert 4 <= len(fn_meta_data) <= 6, \
         "Invalid function entry in impala_functions.py:\n\t" + repr(fn_meta_data)
  entry = {}
  entry["sql_names"] = fn_meta_data[0]
  entry["ret_type"] = fn_meta_data[1]
  entry["args"] = fn_meta_data[2]
  entry["symbol"] = fn_meta_data[3]
  if len(fn_meta_data) >= 5:
    entry["prepare"] = fn_meta_data[4]
  if len(fn_meta_data) >= 6:
    entry["close"] = fn_meta_data[5]
  entry["user_visible"] = user_visible
  meta_data_entries.append(entry)

def generate_fe_entry(entry, name):
  java_output = ""
  java_output += "\"" + name + "\""
  java_output += ", \"" + entry["symbol"] + "\""
  if entry["user_visible"]:
    java_output += ", true"
  else:
    java_output += ", false"

  if 'prepare' in entry:
    java_output += ', "%s"' % entry["prepare"]
    if 'close' in entry:
      java_output += ', "%s"' % entry["close"]
    else:
      java_output += ', null'

  # Check the last entry for varargs indicator.
  if entry["args"] and entry["args"][-1] == "...":
    entry["args"].pop()
    java_output += ", true"
  else:
    java_output += ", false"

  java_output += ", Type." + entry["ret_type"]
  for arg in entry["args"]:
    java_output += ", Type." + arg
  return java_output

# Generates the FE builtins init file that registers all the builtins.
def generate_fe_registry_init(filename):
  java_registry_file = open(filename, "w")
  java_registry_file.write(java_registry_preamble)

  for entry in meta_data_entries:
    for name in entry["sql_names"]:
      java_output = generate_fe_entry(entry, name)
      java_registry_file.write("    db.addScalarBuiltin(%s);\n" % java_output)

  java_registry_file.write("\n")
  java_registry_file.write(java_registry_epilogue)
  java_registry_file.close()

# Read the function metadata inputs
for function in impala_functions.visible_functions:
  add_function(function, True)
for function in impala_functions.invisible_functions:
  add_function(function, False)

if not os.path.exists(FE_PATH):
  os.makedirs(FE_PATH)

generate_fe_registry_init(FE_PATH + "ScalarBuiltins.java")


import click

from functools import wraps
from os import path, makedirs

from cses.cli import cli
from cses.api import API
from cses.db import DB
from cses.shorthand_group import ShorthandGroup
from cses.ui import clr


@cli.group(cls=ShorthandGroup)
@click.pass_context
def courses(ctx):
    "Stuff about courses"


def pass_course(f):
    @wraps(f)
    def wrapper(*args, **kwds):
        ctx = args[0]
        db = ctx.ensure_object(DB)
        api = ctx.ensure_object(API)

        course = db.course
        if course is None:
            ctx.invoke(select)
            course = db.course

        args = args + (course,)
        return f(*args, **kwds)
    return wrapper


def show_courses(courses, id=None):
    click.echo(clr("Courses"))
    for course in courses:
        click.echo("{}: {} {}".format(course["id"],
                                      course["name"],
                                      "(Selected)" if id is course["id"] else ""))


@courses.command()
@click.pass_context
def show(ctx):
    "Lists the various available courses"
    api = ctx.ensure_object(API)
    db = ctx.ensure_object(DB)
    show_courses(api.courses(), db.course)


@courses.command()
@click.pass_context
def select(ctx):
    "Allows you to select the current course"
    api = ctx.ensure_object(API)
    db = ctx.ensure_object(DB)

    id = db.course
    courses = api.courses()
    valid_ids = [x["id"] for x in courses]

    show_courses(courses, id)

    while 1:
        id = click.prompt(clr("Enter a course id"), default=id, type=int)
        if id not in valid_ids:
            if not click.confirm(clr("Invalid course id, try again"),
                                 default=True):
                ctx.fail(clr("Could not select a course"))
        else:
            break
    db.course = id

    if not db.paths:
        db.paths = {}
    if not db.files:
        db.files = {}
    if id not in db.files:
        db.files[id] = {}

    name = ""
    for i in courses:
        if i["id"] == id:
            name = i["nick"]
            break
    else:
        ctx.fail(clr("Could not field the course"))

    defpath = db.paths.get(id, path.join(path.expanduser("~"), "cses", name))
    defpath = click.prompt(clr("Default task path"), default=defpath)
    try:
        makedirs(defpath)
    except OSError as e:
        if e.errno != 17:
            raise
        pass
    db.paths[id] = defpath

"""Easy install Tests
"""
import sys
import os
import shutil
import tempfile
import unittest
import site
import contextlib
import textwrap
import tarfile
import logging
import distutils.core

from setuptools.compat import StringIO, BytesIO, next, urlparse
from setuptools.sandbox import run_setup, SandboxViolation
from setuptools.command.easy_install import (
    easy_install, fix_jython_executable, get_script_args, nt_quote_arg)
from setuptools.command.easy_install import PthDistributions
from setuptools.command import easy_install as easy_install_pkg
from setuptools.dist import Distribution
from pkg_resources import working_set, VersionConflict
from pkg_resources import Distribution as PRDistribution
import setuptools.tests.server
import pkg_resources
from .py26compat import skipIf

class FakeDist(object):
    def get_entry_map(self, group):
        if group != 'console_scripts':
            return {}
        return {'name': 'ep'}

    def as_requirement(self):
        return 'spec'

WANTED = """\
#!%s
# EASY-INSTALL-ENTRY-SCRIPT: 'spec','console_scripts','name'
__requires__ = 'spec'
import sys
from pkg_resources import load_entry_point

if __name__ == '__main__':
    sys.exit(
        load_entry_point('spec', 'console_scripts', 'name')()
    )
""" % nt_quote_arg(fix_jython_executable(sys.executable, ""))

SETUP_PY = """\
from setuptools import setup

setup(name='foo')
"""

class TestEasyInstallTest(unittest.TestCase):

    def test_install_site_py(self):
        dist = Distribution()
        cmd = easy_install(dist)
        cmd.sitepy_installed = False
        cmd.install_dir = tempfile.mkdtemp()
        try:
            cmd.install_site_py()
            sitepy = os.path.join(cmd.install_dir, 'site.py')
            self.assertTrue(os.path.exists(sitepy))
        finally:
            shutil.rmtree(cmd.install_dir)

    def test_get_script_args(self):
        dist = FakeDist()

        old_platform = sys.platform
        try:
            name, script = [i for i in next(get_script_args(dist))][0:2]
        finally:
            sys.platform = old_platform

        self.assertEqual(script, WANTED)

    def test_no_find_links(self):
        # new option '--no-find-links', that blocks find-links added at
        # the project level
        dist = Distribution()
        cmd = easy_install(dist)
        cmd.check_pth_processing = lambda: True
        cmd.no_find_links = True
        cmd.find_links = ['link1', 'link2']
        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
        cmd.args = ['ok']
        cmd.ensure_finalized()
        self.assertEqual(cmd.package_index.scanned_urls, {})

        # let's try without it (default behavior)
        cmd = easy_install(dist)
        cmd.check_pth_processing = lambda: True
        cmd.find_links = ['link1', 'link2']
        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
        cmd.args = ['ok']
        cmd.ensure_finalized()
        keys = sorted(cmd.package_index.scanned_urls.keys())
        self.assertEqual(keys, ['link1', 'link2'])


class TestPTHFileWriter(unittest.TestCase):
    def test_add_from_cwd_site_sets_dirty(self):
        '''a pth file manager should set dirty
        if a distribution is in site but also the cwd
        '''
        pth = PthDistributions('does-not_exist', [os.getcwd()])
        self.assertTrue(not pth.dirty)
        pth.add(PRDistribution(os.getcwd()))
        self.assertTrue(pth.dirty)

    def test_add_from_site_is_ignored(self):
        if os.name != 'nt':
            location = '/test/location/does-not-have-to-exist'
        else:
            location = 'c:\\does_not_exist'
        pth = PthDistributions('does-not_exist', [location, ])
        self.assertTrue(not pth.dirty)
        pth.add(PRDistribution(location))
        self.assertTrue(not pth.dirty)


class TestUserInstallTest(unittest.TestCase):

    def setUp(self):
        self.dir = tempfile.mkdtemp()
        setup = os.path.join(self.dir, 'setup.py')
        f = open(setup, 'w')
        f.write(SETUP_PY)
        f.close()
        self.old_cwd = os.getcwd()
        os.chdir(self.dir)

        self.old_enable_site = site.ENABLE_USER_SITE
        self.old_file = easy_install_pkg.__file__
        self.old_base = site.USER_BASE
        site.USER_BASE = tempfile.mkdtemp()
        self.old_site = site.USER_SITE
        site.USER_SITE = tempfile.mkdtemp()
        easy_install_pkg.__file__ = site.USER_SITE

    def tearDown(self):
        os.chdir(self.old_cwd)
        shutil.rmtree(self.dir)

        shutil.rmtree(site.USER_BASE)
        shutil.rmtree(site.USER_SITE)
        site.USER_BASE = self.old_base
        site.USER_SITE = self.old_site
        site.ENABLE_USER_SITE = self.old_enable_site
        easy_install_pkg.__file__ = self.old_file

    def test_user_install_implied(self):
        site.ENABLE_USER_SITE = True # disabled sometimes
        #XXX: replace with something meaningfull
        dist = Distribution()
        dist.script_name = 'setup.py'
        cmd = easy_install(dist)
        cmd.args = ['py']
        cmd.ensure_finalized()
        self.assertTrue(cmd.user, 'user should be implied')

    def test_multiproc_atexit(self):
        try:
            __import__('multiprocessing')
        except ImportError:
            # skip the test if multiprocessing is not available
            return

        log = logging.getLogger('test_easy_install')
        logging.basicConfig(level=logging.INFO, stream=sys.stderr)
        log.info('this should not break')

    def test_user_install_not_implied_without_usersite_enabled(self):
        site.ENABLE_USER_SITE = False # usually enabled
        #XXX: replace with something meaningfull
        dist = Distribution()
        dist.script_name = 'setup.py'
        cmd = easy_install(dist)
        cmd.args = ['py']
        cmd.initialize_options()
        self.assertFalse(cmd.user, 'NOT user should be implied')

    def test_local_index(self):
        # make sure the local index is used
        # when easy_install looks for installed
        # packages
        new_location = tempfile.mkdtemp()
        target = tempfile.mkdtemp()
        egg_file = os.path.join(new_location, 'foo-1.0.egg-info')
        f = open(egg_file, 'w')
        try:
            f.write('Name: foo\n')
        finally:
            f.close()

        sys.path.append(target)
        old_ppath = os.environ.get('PYTHONPATH')
        os.environ['PYTHONPATH'] = os.path.pathsep.join(sys.path)
        try:
            dist = Distribution()
            dist.script_name = 'setup.py'
            cmd = easy_install(dist)
            cmd.install_dir = target
            cmd.args = ['foo']
            cmd.ensure_finalized()
            cmd.local_index.scan([new_location])
            res = cmd.easy_install('foo')
            actual = os.path.normcase(os.path.realpath(res.location))
            expected = os.path.normcase(os.path.realpath(new_location))
            self.assertEqual(actual, expected)
        finally:
            sys.path.remove(target)
            for basedir in [new_location, target, ]:
                if not os.path.exists(basedir) or not os.path.isdir(basedir):
                    continue
                try:
                    shutil.rmtree(basedir)
                except:
                    pass
            if old_ppath is not None:
                os.environ['PYTHONPATH'] = old_ppath
            else:
                del os.environ['PYTHONPATH']

    def test_setup_requires(self):
        """Regression test for Distribute issue #318

        Ensure that a package with setup_requires can be installed when
        setuptools is installed in the user site-packages without causing a
        SandboxViolation.
        """

        test_pkg = create_setup_requires_package(self.dir)
        test_setup_py = os.path.join(test_pkg, 'setup.py')

        try:
            with quiet_context():
                with reset_setup_stop_context():
                    run_setup(test_setup_py, ['install'])
        except SandboxViolation:
            self.fail('Installation caused SandboxViolation')
        except IndexError:
            # Test fails in some cases due to bugs in Python
            # See https://bitbucket.org/pypa/setuptools/issue/201
            pass


class TestSetupRequires(unittest.TestCase):

    def test_setup_requires_honors_fetch_params(self):
        """
        When easy_install installs a source distribution which specifies
        setup_requires, it should honor the fetch parameters (such as
        allow-hosts, index-url, and find-links).
        """
        # set up a server which will simulate an alternate package index.
        p_index = setuptools.tests.server.MockServer()
        p_index.start()
        netloc = 1
        p_index_loc = urlparse(p_index.url)[netloc]
        if p_index_loc.endswith(':0'):
            # Some platforms (Jython) don't find a port to which to bind,
            #  so skip this test for them.
            return
        with quiet_context():
            # create an sdist that has a build-time dependency.
            with TestSetupRequires.create_sdist() as dist_file:
                with tempdir_context() as temp_install_dir:
                    with environment_context(PYTHONPATH=temp_install_dir):
                        ei_params = ['--index-url', p_index.url,
                            '--allow-hosts', p_index_loc,
                            '--exclude-scripts', '--install-dir', temp_install_dir,
                            dist_file]
                        with reset_setup_stop_context():
                            with argv_context(['easy_install']):
                                # attempt to install the dist. It should fail because
                                #  it doesn't exist.
                                self.assertRaises(SystemExit,
                                    easy_install_pkg.main, ei_params)
        # there should have been two or three requests to the server
        #  (three happens on Python 3.3a)
        self.assertTrue(2 <= len(p_index.requests) <= 3)
        self.assertEqual(p_index.requests[0].path, '/does-not-exist/')

    @staticmethod
    @contextlib.contextmanager
    def create_sdist():
        """
        Return an sdist with a setup_requires dependency (of something that
        doesn't exist)
        """
        with tempdir_context() as dir:
            dist_path = os.path.join(dir, 'setuptools-test-fetcher-1.0.tar.gz')
            make_trivial_sdist(
                dist_path,
                textwrap.dedent("""
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-fetcher",
                        version="1.0",
                        setup_requires = ['does-not-exist'],
                    )
                """).lstrip())
            yield dist_path

    def test_setup_requires_overrides_version_conflict(self):
        """
        Regression test for issue #323.

        Ensures that a distribution's setup_requires requirements can still be
        installed and used locally even if a conflicting version of that
        requirement is already on the path.
        """

        pr_state = pkg_resources.__getstate__()
        fake_dist = PRDistribution('does-not-matter', project_name='foobar',
                                   version='0.0')
        working_set.add(fake_dist)

        try:
            with tempdir_context() as temp_dir:
                test_pkg = create_setup_requires_package(temp_dir)
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                with quiet_context() as (stdout, stderr):
                    with reset_setup_stop_context():
                        try:
                            # Don't even need to install the package, just
                            # running the setup.py at all is sufficient
                            run_setup(test_setup_py, ['--name'])
                        except VersionConflict:
                            self.fail('Installing setup.py requirements '
                                'caused a VersionConflict')

                lines = stdout.readlines()
                self.assertTrue(len(lines) > 0)
                self.assertTrue(lines[-1].strip(), 'test_pkg')
        finally:
            pkg_resources.__setstate__(pr_state)


def create_setup_requires_package(path):
    """Creates a source tree under path for a trivial test package that has a
    single requirement in setup_requires--a tarball for that requirement is
    also created and added to the dependency_links argument.
    """

    test_setup_attrs = {
        'name': 'test_pkg', 'version': '0.0',
        'setup_requires': ['foobar==0.1'],
        'dependency_links': [os.path.abspath(path)]
    }

    test_pkg = os.path.join(path, 'test_pkg')
    test_setup_py = os.path.join(test_pkg, 'setup.py')
    os.mkdir(test_pkg)

    f = open(test_setup_py, 'w')
    f.write(textwrap.dedent("""\
        import setuptools
        setuptools.setup(**%r)
    """ % test_setup_attrs))
    f.close()

    foobar_path = os.path.join(path, 'foobar-0.1.tar.gz')
    make_trivial_sdist(
        foobar_path,
        textwrap.dedent("""\
            import setuptools
            setuptools.setup(
                name='foobar',
                version='0.1'
            )
        """))

    return test_pkg


def make_trivial_sdist(dist_path, setup_py):
    """Create a simple sdist tarball at dist_path, containing just a
    setup.py, the contents of which are provided by the setup_py string.
    """

    setup_py_file = tarfile.TarInfo(name='setup.py')
    try:
        # Python 3 (StringIO gets converted to io module)
        MemFile = BytesIO
    except AttributeError:
        MemFile = StringIO
    setup_py_bytes = MemFile(setup_py.encode('utf-8'))
    setup_py_file.size = len(setup_py_bytes.getvalue())
    dist = tarfile.open(dist_path, 'w:gz')
    try:
        dist.addfile(setup_py_file, fileobj=setup_py_bytes)
    finally:
        dist.close()


@contextlib.contextmanager
def tempdir_context(cd=lambda dir:None):
    temp_dir = tempfile.mkdtemp()
    orig_dir = os.getcwd()
    try:
        cd(temp_dir)
        yield temp_dir
    finally:
        cd(orig_dir)
        shutil.rmtree(temp_dir)

@contextlib.contextmanager
def environment_context(**updates):
    old_env = os.environ.copy()
    os.environ.update(updates)
    try:
        yield
    finally:
        for key in updates:
            del os.environ[key]
        os.environ.update(old_env)

@contextlib.contextmanager
def argv_context(repl):
    old_argv = sys.argv[:]
    sys.argv[:] = repl
    yield
    sys.argv[:] = old_argv

@contextlib.contextmanager
def reset_setup_stop_context():
    """
    When the setuptools tests are run using setup.py test, and then
    one wants to invoke another setup() command (such as easy_install)
    within those tests, it's necessary to reset the global variable
    in distutils.core so that the setup() command will run naturally.
    """
    setup_stop_after = distutils.core._setup_stop_after
    distutils.core._setup_stop_after = None
    yield
    distutils.core._setup_stop_after = setup_stop_after


@contextlib.contextmanager
def quiet_context():
    """
    Redirect stdout/stderr to StringIO objects to prevent console output from
    distutils commands.
    """

    old_stdout = sys.stdout
    old_stderr = sys.stderr
    new_stdout = sys.stdout = StringIO()
    new_stderr = sys.stderr = StringIO()
    try:
        yield new_stdout, new_stderr
    finally:
        new_stdout.seek(0)
        new_stderr.seek(0)
        sys.stdout = old_stdout
        sys.stderr = old_stderr

"""test the current state of the hasparent() flag."""


from sqlalchemy.testing import assert_raises, assert_raises_message
from sqlalchemy import Integer, String, ForeignKey, Sequence, \
    exc as sa_exc
from sqlalchemy.testing.schema import Table, Column
from sqlalchemy.orm import mapper, relationship, create_session, \
    sessionmaker, class_mapper, backref, Session
from sqlalchemy.orm import attributes, exc as orm_exc
from sqlalchemy import testing
from sqlalchemy.testing import eq_
from sqlalchemy.testing import fixtures
from test.orm import _fixtures
from sqlalchemy.testing.util import gc_collect


class ParentRemovalTest(fixtures.MappedTest):
    """Test that the 'hasparent' flag gets flipped to False
    only if we're sure this object is the real parent.

    In ambiguous cases a stale data exception is
    raised.

    """
    run_inserts = None

    @classmethod
    def define_tables(cls, metadata):
        if testing.against('oracle'):
            fk_args = dict(deferrable=True, initially='deferred')
        elif testing.against('mysql'):
            fk_args = {}
        else:
            fk_args = dict(onupdate='cascade')

        Table('users', metadata,
              Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
        )
        Table('addresses', metadata,
              Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
              Column('user_id', Integer, ForeignKey('users.id', **fk_args)),
        )

    @classmethod
    def setup_classes(cls):
        class User(cls.Comparable):
            pass
        class Address(cls.Comparable):
            pass

    @classmethod
    def setup_mappers(cls):
        mapper(cls.classes.Address, cls.tables.addresses)
        mapper(cls.classes.User, cls.tables.users, properties={
           'addresses':relationship(cls.classes.Address,
                            cascade='all, delete-orphan'),

        })

    def _assert_hasparent(self, a1):
        assert attributes.has_parent(
                    self.classes.User, a1, "addresses")

    def _assert_not_hasparent(self, a1):
        assert not attributes.has_parent(
                    self.classes.User, a1, "addresses")

    def _fixture(self):
        User, Address = self.classes.User, self.classes.Address

        s = Session()

        u1 = User()
        a1 = Address()
        u1.addresses.append(a1)
        s.add(u1)
        s.flush()
        return s, u1, a1

    def test_stale_state_positive(self):
        User = self.classes.User
        s, u1, a1 = self._fixture()

        s.expunge(u1)

        u1 = s.query(User).first()
        u1.addresses.remove(a1)

        self._assert_not_hasparent(a1)

    @testing.requires.predictable_gc
    def test_stale_state_positive_gc(self):
        User = self.classes.User
        s, u1, a1 = self._fixture()

        s.expunge(u1)
        del u1
        gc_collect()

        u1 = s.query(User).first()
        u1.addresses.remove(a1)

        self._assert_not_hasparent(a1)

    @testing.requires.predictable_gc
    def test_stale_state_positive_pk_change(self):
        """Illustrate that we can't easily link a
        stale state to a fresh one if the fresh one has
        a PK change  (unless we a. tracked all the previous PKs,
        wasteful, or b. recycled states - time consuming,
        breaks lots of edge cases, destabilizes the code)

        """

        User = self.classes.User
        s, u1, a1 = self._fixture()

        s._expunge_states([attributes.instance_state(u1)])
        del u1
        gc_collect()

        u1 = s.query(User).first()

        # primary key change.  now we
        # can't rely on state.key as the
        # identifier.
        u1.id = 5
        a1.user_id = 5
        s.flush()

        assert_raises_message(
            orm_exc.StaleDataError,
            "can't be sure this is the most recent parent.",
            u1.addresses.remove, a1
        )

        # unfortunately, u1.addresses was impacted
        # here
        assert u1.addresses == []

        # expire all and we can continue
        s.expire_all()
        u1.addresses.remove(a1)

        self._assert_not_hasparent(a1)

    def test_stale_state_negative_child_expired(self):
        """illustrate the current behavior of
        expiration on the child.

        there's some uncertainty here in how
        this use case should work.

        """
        User = self.classes.User
        s, u1, a1 = self._fixture()

        u2 = User(addresses=[a1])

        s.expire(a1)
        u1.addresses.remove(a1)

        # controversy here.  The action is
        # to expire one object, not the other, and remove;
        # this is pretty abusive in any case. for now
        # we are expiring away the 'parents' collection
        # so the remove will unset the hasparent flag.
        # this is what has occurred historically in any case.
        self._assert_not_hasparent(a1)
        #self._assert_hasparent(a1)

    @testing.requires.predictable_gc
    def test_stale_state_negative(self):
        User = self.classes.User
        s, u1, a1 = self._fixture()

        u2 = User(addresses=[a1])
        s.add(u2)
        s.flush()
        s._expunge_states([attributes.instance_state(u2)])
        del u2
        gc_collect()

        assert_raises_message(
            orm_exc.StaleDataError,
            "can't be sure this is the most recent parent.",
            u1.addresses.remove, a1
        )

        s.flush()
        self._assert_hasparent(a1)

    def test_fresh_state_positive(self):
        User = self.classes.User
        s, u1, a1 = self._fixture()

        self._assert_hasparent(a1)

    def test_fresh_state_negative(self):
        User = self.classes.User
        s, u1, a1 = self._fixture()

        u1.addresses.remove(a1)

        self._assert_not_hasparent(a1)



# python3
# Copyright 2018 DeepMind Technologies Limited. All rights reserved.
#
# 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.

"""Core Acme interfaces.

This file specifies and documents the notions of `Actor` and `Learner`.
"""

import abc
import itertools
from typing import Generic, List, Optional, Sequence, TypeVar

from acme import types
from acme.utils import metrics
import dm_env

T = TypeVar('T')


@metrics.record_class_usage
class Actor(abc.ABC):
  """Interface for an agent that can act.

  This interface defines an API for an Actor to interact with an EnvironmentLoop
  (see acme.environment_loop), e.g. a simple RL loop where each step is of the
  form:

    # Make the first observation.
    timestep = env.reset()
    actor.observe_first(timestep.observation)

    # Take a step and observe.
    action = actor.select_action(timestep.observation)
    next_timestep = env.step(action)
    actor.observe(action, next_timestep)

    # Update the actor policy/parameters.
    actor.update()
  """

  @abc.abstractmethod
  def select_action(self, observation: types.NestedArray) -> types.NestedArray:
    """Samples from the policy and returns an action."""

  @abc.abstractmethod
  def observe_first(self, timestep: dm_env.TimeStep):
    """Make a first observation from the environment.

    Note that this need not be an initial state, it is merely beginning the
    recording of a trajectory.

    Args:
      timestep: first timestep.
    """

  @abc.abstractmethod
  def observe(
      self,
      action: types.NestedArray,
      next_timestep: dm_env.TimeStep,
  ):
    """Make an observation of timestep data from the environment.

    Args:
      action: action taken in the environment.
      next_timestep: timestep produced by the environment given the action.
    """

  @abc.abstractmethod
  def update(self, wait: bool = False):
    """Perform an update of the actor parameters from past observations.

    Args:
      wait: if True, the update will be blocking.
    """


class VariableSource(abc.ABC):
  """Abstract source of variables.

  Objects which implement this interface provide a source of variables, returned
  as a collection of (nested) numpy arrays. Generally this will be used to
  provide variables to some learned policy/etc.
  """

  @abc.abstractmethod
  def get_variables(self, names: Sequence[str]) -> List[types.NestedArray]:
    """Return the named variables as a collection of (nested) numpy arrays.

    Args:
      names: args where each name is a string identifying a predefined subset of
        the variables.

    Returns:
      A list of (nested) numpy arrays `variables` such that `variables[i]`
      corresponds to the collection named by `names[i]`.
    """


@metrics.record_class_usage
class Worker(abc.ABC):
  """An interface for (potentially) distributed workers."""

  @abc.abstractmethod
  def run(self):
    """Runs the worker."""


class Saveable(abc.ABC, Generic[T]):
  """An interface for saveable objects."""

  @abc.abstractmethod
  def save(self) -> T:
    """Returns the state from the object to be saved."""

  @abc.abstractmethod
  def restore(self, state: T):
    """Given the state, restores the object."""


class Learner(VariableSource, Worker, Saveable):
  """Abstract learner object.

  This corresponds to an object which implements a learning loop. A single step
  of learning should be implemented via the `step` method and this step
  is generally interacted with via the `run` method which runs update
  continuously.

  All objects implementing this interface should also be able to take in an
  external dataset (see acme.datasets) and run updates using data from this
  dataset. This can be accomplished by explicitly running `learner.step()`
  inside a for/while loop or by using the `learner.run()` convenience function.
  Data will be read from this dataset asynchronously and this is primarily
  useful when the dataset is filled by an external process.
  """

  @abc.abstractmethod
  def step(self):
    """Perform an update step of the learner's parameters."""

  def run(self, num_steps: Optional[int] = None) -> None:
    """Run the update loop; typically an infinite loop which calls step."""

    iterator = range(num_steps) if num_steps is not None else itertools.count()

    for _ in iterator:
      self.step()

  def save(self):
    raise NotImplementedError('Method "save" is not implemented.')

  def restore(self, state):
    raise NotImplementedError('Method "restore" is not implemented.')

from django.shortcuts import render
import os
from django.http import HttpResponse
from django.shortcuts import render_to_response
import json
# Create your views here.



def index(request):
    return render_to_response("sys.html")




def sysinfo(request):
    print " i come into info sysinfo"

    mem_usage=get_mem()
    net_usage=get_netstat("eth0") 
    cpu_usage=get_cpu_usage()
    info={"mem_usage":mem_usage,"net_usage":net_usage,"cpu_usage":cpu_usage}

    data = json.dumps(info)     
    response=HttpResponse(data)
    response['Content-Type'] = "text/javascript"
    return response

def infonet(request):
    net_state=get_netstat("eth0")
    print net_state
    return HttpResponse(net_state)



def index(request):
    return render_to_response("sys.html")


def get_mem():
    """
    Get memory usage
    """
    mem_usage={}
    try:
        pipe = os.popen(
            "free -tmo | " + "grep 'Mem' | " + "awk '{print $2,$4,$6,$7}'")
        data = pipe.read().strip().split()
        pipe.close()

        allmem = int(data[0])
        freemem = int(data[1])
        buffers = int(data[2])
        cachedmem = int(data[3])

        # Memory in buffers + cached is actually available, so we count it
        # as free. See http://www.linuxatemyram.com/ for details
        freemem += buffers + cachedmem

        percent = (100 - ((freemem * 100) / allmem))
        usage = (allmem - freemem)

        mem_usage = {'usage': usage, 'buffers': buffers, 'cached': cachedmem, 'free': freemem, 'percent': percent}

    except Exception as err:
        pass
    return mem_usage



def get_cpu_usage():
    """
    Get the CPU usage and running processes
    """
    cpu_usage={}
    try:

        pipe = os.popen("  top -bn 1 | awk '{ print $9  }' | tail -n+8 | awk '{s+=$1 } END {print s}' ")
        data = pipe.read()
        pipe.close()
        cpu_usage={"cpu_usage":data}
    except Exception as err:
        pass

    return cpu_usage



def get_netstat(interface):
    """
    Get ports and applications
    """


    net_usage={}
    try:
        pipe = os.popen("cat /proc/net/dev |" + "grep " + interface + "| awk '{print $2, $10}'")
        data = pipe.read().split()
        print data

        pipe.close()

        traffic_in = int(data[0])
        traffic_out = int(data[1])
        net_usage={"traffic_in":traffic_in,"traffic_out":traffic_out}

    except Exception as err:
        pass
        
    return net_usage
# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

# Make coding more python3-ish
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

from ansible.playbook.attribute import FieldAttribute
from ansible.playbook.base import FieldAttributeBase


class LoopControl(FieldAttributeBase):

    _loop_var = FieldAttribute(isa='str', default='item')
    _index_var = FieldAttribute(isa='str')
    _label = FieldAttribute(isa='str')
    _pause = FieldAttribute(isa='int', default=0)

    def __init__(self):
        super(LoopControl, self).__init__()

    @staticmethod
    def load(data, variable_manager=None, loader=None):
        t = LoopControl()
        return t.load_data(data, variable_manager=variable_manager, loader=loader)

#!/usr/bin/env python
"""Code coverage wrapper."""

from __future__ import absolute_import, print_function

import errno
import os
import sys
import pipes
import logging
import getpass

logger = logging.getLogger('injector')  # pylint: disable=locally-disabled, invalid-name


def main():
    """Main entry point."""
    formatter = logging.Formatter('%(asctime)s %(process)d %(levelname)s %(message)s')
    log_name = 'ansible-test-coverage.%s.log' % getpass.getuser()
    self_dir = os.path.dirname(os.path.abspath(__file__))

    handler = logging.FileHandler(os.path.join('/tmp', log_name))
    handler.setFormatter(formatter)
    logger.addHandler(handler)

    handler = logging.FileHandler(os.path.abspath(os.path.join(self_dir, '..', 'logs', log_name)))
    handler.setFormatter(formatter)
    logger.addHandler(handler)

    logger.setLevel(logging.DEBUG)

    try:
        logger.debug('Self: %s', __file__)
        logger.debug('Arguments: %s', ' '.join(pipes.quote(c) for c in sys.argv))

        if os.path.basename(__file__).startswith('runner'):
            args, env = runner()
        elif os.path.basename(__file__).startswith('cover'):
            args, env = cover()
        else:
            args, env = injector()

        logger.debug('Run command: %s', ' '.join(pipes.quote(c) for c in args))

        try:
            cwd = os.getcwd()
        except OSError as ex:
            if ex.errno != errno.EACCES:
                raise
            cwd = None

        logger.debug('Working directory: %s', cwd or '?')

        for key in sorted(env.keys()):
            logger.debug('%s=%s', key, env[key])

        os.execvpe(args[0], args, env)
    except Exception as ex:
        logger.fatal(ex)
        raise


def injector():
    """
    :rtype: list[str], dict[str, str]
    """
    self_dir = os.path.dirname(os.path.abspath(__file__))
    command = os.path.basename(__file__)
    mode = os.environ.get('ANSIBLE_TEST_COVERAGE')
    version = os.environ.get('ANSIBLE_TEST_PYTHON_VERSION', '')
    executable = find_executable(command)

    if mode in ('coverage', 'version'):
        if mode == 'coverage':
            args, env = coverage_command(self_dir, version)
            args += [executable]
            tool = 'cover'
        else:
            interpreter = find_executable('python' + version)
            args, env = [interpreter, executable], os.environ.copy()
            tool = 'runner'

        if command in ('ansible', 'ansible-playbook', 'ansible-pull'):
            interpreter = find_executable(tool + version)
            args += ['--extra-vars', 'ansible_python_interpreter=' + interpreter]
    else:
        args, env = [executable], os.environ.copy()

    args += sys.argv[1:]

    return args, env


def runner():
    """
    :rtype: list[str], dict[str, str]
    """
    command = os.path.basename(__file__)
    version = command.replace('runner', '')

    interpreter = find_executable('python' + version)
    args, env = [interpreter], os.environ.copy()

    args += sys.argv[1:]

    return args, env


def cover():
    """
    :rtype: list[str], dict[str, str]
    """
    self_dir = os.path.dirname(os.path.abspath(__file__))
    command = os.path.basename(__file__)
    version = command.replace('cover', '')

    if len(sys.argv) > 1:
        executable = sys.argv[1]
    else:
        executable = ''

    if os.path.basename(executable).startswith('ansible_module_'):
        args, env = coverage_command(self_dir, version)
    else:
        interpreter = find_executable('python' + version)
        args, env = [interpreter], os.environ.copy()

    args += sys.argv[1:]

    return args, env


def coverage_command(self_dir, version):
    """
    :type self_dir: str
    :type version: str
    :rtype: list[str], dict[str, str]
    """
    executable = 'coverage'

    if version:
        executable += '-%s' % version

    args = [
        find_executable(executable),
        'run',
        '--rcfile',
        os.path.join(self_dir, '.coveragerc'),
    ]

    env = os.environ.copy()
    env['COVERAGE_FILE'] = os.path.abspath(os.path.join(self_dir, '..', 'output', 'coverage'))

    return args, env


def find_executable(executable):
    """
    :type executable: str
    :rtype: str
    """
    self = os.path.abspath(__file__)
    path = os.environ.get('PATH', os.defpath)
    seen_dirs = set()

    for path_dir in path.split(os.pathsep):
        if path_dir in seen_dirs:
            continue

        seen_dirs.add(path_dir)
        candidate = os.path.abspath(os.path.join(path_dir, executable))

        if candidate == self:
            continue

        if os.path.exists(candidate) and os.access(candidate, os.F_OK | os.X_OK):
            return candidate

    raise Exception('Executable "%s" not found in path: %s' % (executable, path))


if __name__ == '__main__':
    main()

from urllib.parse import urlencode

from django.apps import apps
from django.conf import settings
from django.contrib.admin.utils import quote, unquote
from django.core.exceptions import PermissionDenied
from django.core.paginator import Paginator
from django.http import Http404
from django.shortcuts import get_object_or_404, redirect
from django.template.response import TemplateResponse
from django.urls import reverse
from django.utils.text import capfirst
from django.utils.translation import gettext as _
from django.utils.translation import ngettext
from django.views.generic import TemplateView

from wagtail.admin import messages
from wagtail.admin.edit_handlers import ObjectList, extract_panel_definitions_from_model_class
from wagtail.admin.forms.search import SearchForm
from wagtail.core import hooks
from wagtail.core.models import Locale, TranslatableMixin
from wagtail.search.backends import get_search_backend
from wagtail.search.index import class_is_indexed
from wagtail.snippets.action_menu import SnippetActionMenu
from wagtail.snippets.models import get_snippet_models
from wagtail.snippets.permissions import get_permission_name, user_can_edit_snippet_type


# == Helper functions ==
def get_snippet_model_from_url_params(app_name, model_name):
    """
    Retrieve a model from an app_label / model_name combo.
    Raise Http404 if the model is not a valid snippet type.
    """
    try:
        model = apps.get_model(app_name, model_name)
    except LookupError:
        raise Http404
    if model not in get_snippet_models():
        # don't allow people to hack the URL to edit content types that aren't registered as snippets
        raise Http404

    return model


SNIPPET_EDIT_HANDLERS = {}


def get_snippet_edit_handler(model):
    if model not in SNIPPET_EDIT_HANDLERS:
        if hasattr(model, 'edit_handler'):
            # use the edit handler specified on the page class
            edit_handler = model.edit_handler
        else:
            panels = extract_panel_definitions_from_model_class(model)
            edit_handler = ObjectList(panels)

        SNIPPET_EDIT_HANDLERS[model] = edit_handler.bind_to(model=model)

    return SNIPPET_EDIT_HANDLERS[model]


# == Views ==


def index(request):
    snippet_model_opts = [
        model._meta for model in get_snippet_models()
        if user_can_edit_snippet_type(request.user, model)]
    if snippet_model_opts:
        return TemplateResponse(request, 'wagtailsnippets/snippets/index.html', {
            'snippet_model_opts': sorted(
                snippet_model_opts, key=lambda x: x.verbose_name.lower())})
    else:
        raise PermissionDenied


class ListView(TemplateView):

    # If true, returns just the 'results' include, for use in AJAX responses from search
    results_only = False

    def get(self, request, app_label, model_name):
        self.app_label = app_label
        self.model_name = model_name
        self.model = get_snippet_model_from_url_params(app_label, model_name)

        permissions = [
            get_permission_name(action, self.model)
            for action in ['add', 'change', 'delete']
        ]
        if not any([request.user.has_perm(perm) for perm in permissions]):
            raise PermissionDenied

        return super().get(request)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)

        items = self.model.objects.all()
        enable_locale_filter = getattr(settings, 'WAGTAIL_I18N_ENABLED', False) and issubclass(self.model, TranslatableMixin)

        if enable_locale_filter:
            if 'locale' in self.request.GET:
                try:
                    locale = Locale.objects.get(language_code=self.request.GET['locale'])
                except Locale.DoesNotExist:
                    # Redirect to snippet without locale
                    return redirect('wagtailsnippets:list', self.app_label, self.model_name)
            else:
                # Default to active locale (this will take into account the user's chosen admin language)
                locale = Locale.get_active()

            items = items.filter(locale=locale)

        else:
            locale = None

        # Preserve the snippet's model-level ordering if specified, but fall back on PK if not
        # (to ensure pagination is consistent)
        if not items.ordered:
            items = items.order_by('pk')

        # Search
        is_searchable = class_is_indexed(self.model)
        is_searching = False
        search_query = None
        if is_searchable and 'q' in self.request.GET:
            search_form = SearchForm(self.request.GET, placeholder=_("Search %(snippet_type_name)s") % {
                'snippet_type_name': self.model._meta.verbose_name_plural
            })

            if search_form.is_valid():
                search_query = search_form.cleaned_data['q']

                search_backend = get_search_backend()
                items = search_backend.search(search_query, items)
                is_searching = True

        else:
            search_form = SearchForm(placeholder=_("Search %(snippet_type_name)s") % {
                'snippet_type_name': self.model._meta.verbose_name_plural
            })

        paginator = Paginator(items, per_page=20)
        paginated_items = paginator.get_page(self.request.GET.get('p'))

        context.update({
            'model_opts': self.model._meta,
            'items': paginated_items,
            'can_add_snippet': self.request.user.has_perm(get_permission_name('add', self.model)),
            'can_delete_snippets': self.request.user.has_perm(get_permission_name('delete', self.model)),
            'is_searchable': is_searchable,
            'search_form': search_form,
            'is_searching': is_searching,
            'query_string': search_query,
            'locale': None,
            'translations': [],
        })

        if enable_locale_filter:
            context.update({
                'locale': locale,
                'translations': [
                    {
                        'locale': locale,
                        'url': reverse('wagtailsnippets:list', args=[self.app_label, self.model_name]) + '?locale=' + locale.language_code
                    }
                    for locale in Locale.objects.all().exclude(id=locale.id)
                ],
            })

        return context

    def get_template_names(self):
        if self.results_only:
            return ['wagtailsnippets/snippets/results.html']
        else:
            return ['wagtailsnippets/snippets/type_index.html']


def create(request, app_label, model_name):
    model = get_snippet_model_from_url_params(app_label, model_name)

    permission = get_permission_name('add', model)
    if not request.user.has_perm(permission):
        raise PermissionDenied

    for fn in hooks.get_hooks('before_create_snippet'):
        result = fn(request, model)
        if hasattr(result, 'status_code'):
            return result

    instance = model()

    # Set locale of the new instance
    if issubclass(model, TranslatableMixin):
        selected_locale = request.GET.get('locale')
        if selected_locale:
            instance.locale = get_object_or_404(Locale, language_code=selected_locale)
        else:
            instance.locale = Locale.get_default()

    # Make edit handler
    edit_handler = get_snippet_edit_handler(model)
    edit_handler = edit_handler.bind_to(request=request)
    form_class = edit_handler.get_form_class()

    if request.method == 'POST':
        form = form_class(request.POST, request.FILES, instance=instance)

        if form.is_valid():
            form.save()

            messages.success(
                request,
                _("%(snippet_type)s '%(instance)s' created.") % {
                    'snippet_type': capfirst(model._meta.verbose_name),
                    'instance': instance
                },
                buttons=[
                    messages.button(reverse(
                        'wagtailsnippets:edit', args=(app_label, model_name, quote(instance.pk))
                    ), _('Edit'))
                ]
            )

            for fn in hooks.get_hooks('after_create_snippet'):
                result = fn(request, instance)
                if hasattr(result, 'status_code'):
                    return result

            urlquery = ''
            if isinstance(instance, TranslatableMixin) and instance.locale is not Locale.get_default():
                urlquery = '?locale=' + instance.locale.language_code

            return redirect(reverse('wagtailsnippets:list', args=[app_label, model_name]) + urlquery)
        else:
            messages.validation_error(
                request, _("The snippet could not be created due to errors."), form
            )
    else:
        form = form_class(instance=instance)

    edit_handler = edit_handler.bind_to(instance=instance, form=form)

    context = {
        'model_opts': model._meta,
        'edit_handler': edit_handler,
        'form': form,
        'action_menu': SnippetActionMenu(request, view='create', model=model),
        'locale': None,
        'translations': [],
    }

    if getattr(settings, 'WAGTAIL_I18N_ENABLED', False) and issubclass(model, TranslatableMixin):
        context.update({
            'locale': instance.locale,
            'translations': [
                {
                    'locale': locale,
                    'url': reverse('wagtailsnippets:add', args=[app_label, model_name]) + '?locale=' + locale.language_code
                }
                for locale in Locale.objects.all().exclude(id=instance.locale.id)
            ],
        })

    return TemplateResponse(request, 'wagtailsnippets/snippets/create.html', context)


def edit(request, app_label, model_name, pk):
    model = get_snippet_model_from_url_params(app_label, model_name)

    permission = get_permission_name('change', model)
    if not request.user.has_perm(permission):
        raise PermissionDenied

    instance = get_object_or_404(model, pk=unquote(pk))

    for fn in hooks.get_hooks('before_edit_snippet'):
        result = fn(request, instance)
        if hasattr(result, 'status_code'):
            return result

    edit_handler = get_snippet_edit_handler(model)
    edit_handler = edit_handler.bind_to(instance=instance, request=request)
    form_class = edit_handler.get_form_class()

    if request.method == 'POST':
        form = form_class(request.POST, request.FILES, instance=instance)

        if form.is_valid():
            form.save()

            messages.success(
                request,
                _("%(snippet_type)s '%(instance)s' updated.") % {
                    'snippet_type': capfirst(model._meta.verbose_name),
                    'instance': instance
                },
                buttons=[
                    messages.button(reverse(
                        'wagtailsnippets:edit', args=(app_label, model_name, quote(instance.pk))
                    ), _('Edit'))
                ]
            )

            for fn in hooks.get_hooks('after_edit_snippet'):
                result = fn(request, instance)
                if hasattr(result, 'status_code'):
                    return result

            return redirect('wagtailsnippets:list', app_label, model_name)
        else:
            messages.validation_error(
                request, _("The snippet could not be saved due to errors."), form
            )
    else:
        form = form_class(instance=instance)

    edit_handler = edit_handler.bind_to(form=form)

    context = {
        'model_opts': model._meta,
        'instance': instance,
        'edit_handler': edit_handler,
        'form': form,
        'action_menu': SnippetActionMenu(request, view='edit', instance=instance),
        'locale': None,
        'translations': [],
    }

    if getattr(settings, 'WAGTAIL_I18N_ENABLED', False) and issubclass(model, TranslatableMixin):
        context.update({
            'locale': instance.locale,
            'translations': [
                {
                    'locale': translation.locale,
                    'url': reverse('wagtailsnippets:edit', args=[app_label, model_name, quote(translation.pk)])
                }
                for translation in instance.get_translations().select_related('locale')
            ],
        })

    return TemplateResponse(request, 'wagtailsnippets/snippets/edit.html', context)


def delete(request, app_label, model_name, pk=None):
    model = get_snippet_model_from_url_params(app_label, model_name)

    permission = get_permission_name('delete', model)
    if not request.user.has_perm(permission):
        raise PermissionDenied

    if pk:
        instances = [get_object_or_404(model, pk=unquote(pk))]
    else:
        ids = request.GET.getlist('id')
        instances = model.objects.filter(pk__in=ids)

    for fn in hooks.get_hooks('before_delete_snippet'):
        result = fn(request, instances)
        if hasattr(result, 'status_code'):
            return result

    count = len(instances)

    if request.method == 'POST':
        for instance in instances:
            instance.delete()

        if count == 1:
            message_content = _("%(snippet_type)s '%(instance)s' deleted.") % {
                'snippet_type': capfirst(model._meta.verbose_name),
                'instance': instance
            }
        else:
            # This message is only used in plural form, but we'll define it with ngettext so that
            # languages with multiple plural forms can be handled correctly (or, at least, as
            # correctly as possible within the limitations of verbose_name_plural...)
            message_content = ngettext(
                "%(count)d %(snippet_type)s deleted.",
                "%(count)d %(snippet_type)s deleted.",
                count
            ) % {
                'snippet_type': capfirst(model._meta.verbose_name_plural),
                'count': count
            }

        messages.success(request, message_content)

        for fn in hooks.get_hooks('after_delete_snippet'):
            result = fn(request, instances)
            if hasattr(result, 'status_code'):
                return result

        return redirect('wagtailsnippets:list', app_label, model_name)

    return TemplateResponse(request, 'wagtailsnippets/snippets/confirm_delete.html', {
        'model_opts': model._meta,
        'count': count,
        'instances': instances,
        'submit_url': (
            reverse('wagtailsnippets:delete-multiple', args=(app_label, model_name))
            + '?' + urlencode([('id', instance.pk) for instance in instances])
        ),
    })


def usage(request, app_label, model_name, pk):
    model = get_snippet_model_from_url_params(app_label, model_name)
    instance = get_object_or_404(model, pk=unquote(pk))

    paginator = Paginator(instance.get_usage(), per_page=20)
    used_by = paginator.get_page(request.GET.get('p'))

    return TemplateResponse(request, "wagtailsnippets/snippets/usage.html", {
        'instance': instance,
        'used_by': used_by
    })


def redirect_to_edit(request, app_label, model_name, pk):
    return redirect('wagtailsnippets:edit', app_label, model_name, pk, permanent=True)


def redirect_to_delete(request, app_label, model_name, pk):
    return redirect('wagtailsnippets:delete', app_label, model_name, pk, permanent=True)


def redirect_to_usage(request, app_label, model_name, pk):
    return redirect('wagtailsnippets:usage', app_label, model_name, pk, permanent=True)

# Ansible module to manage CheckPoint Firewall (c) 2019
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
#

from __future__ import absolute_import, division, print_function
__metaclass__ = type

import pytest
from units.modules.utils import set_module_args, exit_json, fail_json, AnsibleExitJson

from ansible.module_utils import basic
from ansible.modules.network.check_point import cp_mgmt_multicast_address_range

OBJECT = {
    "name": "New Multicast Address Range",
    "ip_address_first": "224.0.0.1",
    "ip_address_last": "224.0.0.4"
}

CREATE_PAYLOAD = {
    "name": "New Multicast Address Range",
    "ip_address_first": "224.0.0.1",
    "ip_address_last": "224.0.0.4"
}

UPDATE_PAYLOAD = {
    "name": "New Multicast Address Range",
    "ip_address_first": "224.0.0.7",
    "ip_address_last": "224.0.0.10"
}

OBJECT_AFTER_UPDATE = UPDATE_PAYLOAD

DELETE_PAYLOAD = {
    "name": "New Multicast Address Range",
    "state": "absent"
}

function_path = 'ansible.modules.network.check_point.cp_mgmt_multicast_address_range.api_call'
api_call_object = 'multicast-address-range'


class TestCheckpointMulticastAddressRange(object):
    module = cp_mgmt_multicast_address_range

    @pytest.fixture(autouse=True)
    def module_mock(self, mocker):
        return mocker.patch.multiple(basic.AnsibleModule, exit_json=exit_json, fail_json=fail_json)

    @pytest.fixture
    def connection_mock(self, mocker):
        connection_class_mock = mocker.patch('ansible.module_utils.network.checkpoint.checkpoint.Connection')
        return connection_class_mock.return_value

    def test_create(self, mocker, connection_mock):
        mock_function = mocker.patch(function_path)
        mock_function.return_value = {'changed': True, api_call_object: OBJECT}
        result = self._run_module(CREATE_PAYLOAD)

        assert result['changed']
        assert OBJECT.items() == result[api_call_object].items()

    def test_create_idempotent(self, mocker, connection_mock):
        mock_function = mocker.patch(function_path)
        mock_function.return_value = {'changed': False, api_call_object: OBJECT}
        result = self._run_module(CREATE_PAYLOAD)

        assert not result['changed']

    def test_update(self, mocker, connection_mock):
        mock_function = mocker.patch(function_path)
        mock_function.return_value = {'changed': True, api_call_object: OBJECT_AFTER_UPDATE}
        result = self._run_module(UPDATE_PAYLOAD)

        assert result['changed']
        assert OBJECT_AFTER_UPDATE.items() == result[api_call_object].items()

    def test_update_idempotent(self, mocker, connection_mock):
        mock_function = mocker.patch(function_path)
        mock_function.return_value = {'changed': False, api_call_object: OBJECT_AFTER_UPDATE}
        result = self._run_module(UPDATE_PAYLOAD)

        assert not result['changed']

    def test_delete(self, mocker, connection_mock):
        mock_function = mocker.patch(function_path)
        mock_function.return_value = {'changed': True}
        result = self._run_module(DELETE_PAYLOAD)

        assert result['changed']

    def test_delete_idempotent(self, mocker, connection_mock):
        mock_function = mocker.patch(function_path)
        mock_function.return_value = {'changed': False}
        result = self._run_module(DELETE_PAYLOAD)

        assert not result['changed']

    def _run_module(self, module_args):
        set_module_args(module_args)
        with pytest.raises(AnsibleExitJson) as ex:
            self.module.main()
        return ex.value.args[0]

import numbers
import math

import ply.lex as lex

variables = {}
usr_funcs = {}
usr_basecases = {}

debug = False

argcounts = {
    "+": 2,
    "/": 2,
    "-": 2,
    "*": 2,
    "**": 2,
    ">>": 2,
    "<<": 2,
    "=": 2,
    "==": 2,
    ">=": 2,
    "<=": 2,
    ">": 2,
    "<": 2,
    "!=": 2,
    "if": 2,

    "sin": 1,
    "cos": 1,
    "asin": 1,
    "acos": 1,
    "debug": 1,
}


def varr(x, lvars):
    if x is None:
        return None
    if isinstance(x, numbers.Real):
        return x
    elif x.type == "VAR" and x.value in lvars:
        return lvars[x.value]
    elif x.type == "NUMBER":
        return x.value
    else:
        return x


def eval_rpn(intoks, lvars=None):
    if lvars is None:
        lvars = variables

    values = [x for x in intoks]

    stack = []
    while len(values) > 0:
        t = values.pop(0)
        if (isinstance(t, lex.LexToken) and t.type in ("VAR", "NUMBER")) or \
           (isinstance(t, numbers.Real)):
            stack.append(t)
        else:
            if t.type == "FUNC" and t.value not in usr_funcs:
                argcount = len(stack)
            elif t.type == "THEN":
                argcount = 1
            else:
                if t.value in argcounts:
                    argcount = argcounts[t.value]
                else:
                    raise NameError("function {} not defined".format(t.value))
            args = []

            while len(args) < argcount:
                try:
                    args.append(stack.pop())
                except IndexError:
                    raise IndexError("Not enough arguments")

            args = args[::-1]

            # Need to reverse it.
            if t.type == "PLUS":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)
                res = x1 + x2
                stack.append(res)

            elif t.type == "MINUS":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)
                res = x1 - x2
                stack.append(res)

            elif t.type == "TIMES":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)
                res = x1 * x2
                stack.append(res)

            elif t.type == "DIVIDE":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)
                res = x1 / x2
                stack.append(res)

            elif t.type == "LSHIFT":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)
                res = x1 << x2
                stack.append(res)

            elif t.type == "RSHIFT":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)
                res = x1 >> x2
                stack.append(res)

            elif t.type == "EXP":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)
                res = x1 ** x2
                stack.append(res)

            elif t.type == "COMPARE":
                x1 = varr(args[0], lvars)
                x2 = varr(args[1], lvars)

                if t.value == "==":
                    res = int(x1 == x2)
                if t.value == ">=":
                    res = int(x1 >= x2)
                if t.value == "<=":
                    res = int(x1 <= x2)
                if t.value == ">":
                    res = int(x1 > x2)
                if t.value == "<":
                    res = int(x1 < x2)
                if t.value == "!=":
                    res = int(x1 != x2)

                stack.append(res)

            elif t.type == "ASSIGN":
                lvars[args[0].value] = varr(args[1], {})

            elif t.type == "THEN":
                x1 = varr(args[0], lvars)
                if x1 > 0:
                    stack.append(eval_rpn(values, lvars))
                else:
                    return

            elif t.type == "FUNC":
                if t.value == "sin":
                    res = math.sin(varr(args[0], lvars))
                    stack.append(res)
                elif t.value == "cos":
                    res = math.cos(varr(args[0], lvars))
                    stack.append(res)
                elif t.value == "asin":
                    res = math.asin(varr(args[0], lvars))
                    stack.append(res)
                elif t.value == "acos":
                    res = math.acos(varr(args[0], lvars))
                    stack.append(res)
                elif t.value == "debug":
                    global debug
                    debug = not(debug)
                elif t.value in usr_funcs:
                    func = usr_funcs[t.value]
                    fargs = {}
                    for index, item in enumerate(func[0]):
                        fargs[item.value] = varr(args[index], lvars)
                    if (t.value in usr_basecases) and \
                            (tuple(varr(x, {}) for x in args) in usr_basecases[t.value]):
                        r = usr_basecases[t.value][tuple(varr(x, {}) for x in args)]
                        stack.append(r[0])
                    else:
                        stack.append(eval_rpn(func[1], fargs))

                else:
                    newfunc = t
                    funccode = []
                    while len(values) > 0:
                        t = values.pop(0)
                        funccode.append(varr(t, {}))
                    if len(funccode) == 0:
                        raise ValueError("No function body given")
                    if funccode[-1].type == "ASSIGN":
                        funccode.pop()

                    usr_funcs[newfunc.value] = (args, funccode)
                    argcounts[newfunc.value] = len(args)

                    return
            elif t.type == "FUNC_BASE":
                funcname = t.value.replace("@", "")
                funccode = []

                while len(values) > 0:
                    t = values.pop(0)
                    funccode.append(varr(t, {}))

                if len(funccode) == 0:
                    raise ValueError("No function body given")

                if funccode[-1].type == "ASSIGN":
                    funccode.pop()

                if funcname in usr_basecases:
                    usr_basecases[funcname][tuple([varr(x, {}) for x in args])] = funccode
                else:
                    usr_basecases[funcname] = {}
                    usr_basecases[funcname][tuple([varr(x, {}) for x in args])] = funccode

            else:
                raise TypeError("Unknown token")

    if len(stack) == 1:
        return varr(stack[0], lvars)

    elif len(stack) > 1:
        raise IndexError("Too many values!")

# Copyright (c) 2016-2017 Hewlett Packard Enterprise Development LP
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from units.compat import unittest, mock
from oneview_module_loader import SanManagerModule
from hpe_test_utils import OneViewBaseTestCase
from copy import deepcopy

FAKE_MSG_ERROR = 'Fake message error'

DEFAULT_SAN_MANAGER_TEMPLATE = dict(
    name='172.18.15.1',
    providerDisplayName='Brocade Network Advisor',
    uri='/rest/fc-sans/device-managers/UUU-AAA-BBB',
    refreshState='OK',
    connectionInfo=[
        {
            'valueFormat': 'IPAddressOrHostname',
            'displayName': 'Host',
            'name': 'Host',
            'valueType': 'String',
            'required': False,
            'value': '172.18.15.1'
        }]
)


class SanManagerModuleSpec(unittest.TestCase,
                           OneViewBaseTestCase):
    PARAMS_FOR_PRESENT = dict(
        config='config.json',
        state='present',
        data=DEFAULT_SAN_MANAGER_TEMPLATE
    )

    PARAMS_FOR_CONNECTION_INFORMATION_SET = dict(
        config='config.json',
        state='connection_information_set',
        data=DEFAULT_SAN_MANAGER_TEMPLATE.copy()
    )

    PARAMS_WITH_CHANGES = dict(
        config='config.json',
        state='present',
        data=dict(name=DEFAULT_SAN_MANAGER_TEMPLATE['name'],
                  refreshState='RefreshPending')
    )

    PARAMS_FOR_ABSENT = dict(
        config='config.json',
        state='absent',
        data=dict(name=DEFAULT_SAN_MANAGER_TEMPLATE['name'])
    )

    def setUp(self):
        self.configure_mocks(self, SanManagerModule)
        self.resource = self.mock_ov_client.san_managers

    def test_should_add_new_san_manager(self):
        self.resource.get_by_name.return_value = []
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'
        self.resource.add.return_value = DEFAULT_SAN_MANAGER_TEMPLATE

        self.mock_ansible_module.params = self.PARAMS_FOR_PRESENT

        SanManagerModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=True,
            msg=SanManagerModule.MSG_CREATED,
            ansible_facts=dict(san_manager=DEFAULT_SAN_MANAGER_TEMPLATE)
        )

    def test_should_find_provider_uri_to_add(self):
        self.resource.get_by_name.return_value = []
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'
        self.resource.add.return_value = DEFAULT_SAN_MANAGER_TEMPLATE

        self.mock_ansible_module.params = self.PARAMS_FOR_PRESENT

        SanManagerModule().run()

        provider_display_name = DEFAULT_SAN_MANAGER_TEMPLATE['providerDisplayName']
        self.resource.get_provider_uri.assert_called_once_with(provider_display_name)

    def test_should_not_update_when_data_is_equals(self):
        output_data = deepcopy(DEFAULT_SAN_MANAGER_TEMPLATE)
        output_data.pop('connectionInfo')
        self.resource.get_by_name.return_value = deepcopy(DEFAULT_SAN_MANAGER_TEMPLATE)
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'

        self.mock_ansible_module.params = self.PARAMS_FOR_PRESENT

        SanManagerModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            msg=SanManagerModule.MSG_ALREADY_PRESENT,
            ansible_facts=dict(san_manager=output_data)
        )

    def test_update_when_data_has_modified_attributes(self):
        data_merged = deepcopy(DEFAULT_SAN_MANAGER_TEMPLATE)
        data_merged['fabricType'] = 'DirectAttach'

        self.resource.get_by_name.return_value = DEFAULT_SAN_MANAGER_TEMPLATE
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'

        self.resource.update.return_value = data_merged
        self.mock_ansible_module.params = self.PARAMS_WITH_CHANGES

        SanManagerModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=True,
            msg=SanManagerModule.MSG_UPDATED,
            ansible_facts=dict(san_manager=data_merged)
        )

    def test_update_should_not_send_connection_info_when_not_informed_on_data(self):
        merged_data = deepcopy(DEFAULT_SAN_MANAGER_TEMPLATE)
        merged_data['refreshState'] = 'RefreshPending'
        output_data = deepcopy(merged_data)
        output_data.pop('connectionInfo')

        self.resource.get_by_name.return_value = DEFAULT_SAN_MANAGER_TEMPLATE
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'

        self.resource.update.return_value = merged_data
        self.mock_ansible_module.params = self.PARAMS_WITH_CHANGES

        SanManagerModule().run()

        self.resource.update.assert_called_once_with(resource=output_data, id_or_uri=output_data['uri'])

    def test_should_remove_san_manager(self):
        self.resource.get_by_name.return_value = deepcopy(DEFAULT_SAN_MANAGER_TEMPLATE)
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'

        self.mock_ansible_module.params = self.PARAMS_FOR_ABSENT.copy()

        SanManagerModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=True,
            msg=SanManagerModule.MSG_DELETED
        )

    def test_should_do_nothing_when_san_manager_not_exist(self):
        self.resource.get_by_name.return_value = []

        self.mock_ansible_module.params = self.PARAMS_FOR_ABSENT.copy()

        SanManagerModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=False,
            msg=SanManagerModule.MSG_ALREADY_ABSENT
        )

    def test_should_fail_when_name_not_found(self):
        self.resource.get_by_name.return_value = []
        self.resource.get_provider_uri.return_value = None

        self.mock_ansible_module.params = self.PARAMS_FOR_PRESENT

        SanManagerModule().run()

        self.mock_ansible_module.fail_json.assert_called_once_with(
            exception=mock.ANY,
            msg="The provider 'Brocade Network Advisor' was not found."
        )

    def test_should_fail_when_name_and_hosts_in_connectionInfo_missing(self):
        bad_params = deepcopy(self.PARAMS_FOR_PRESENT)
        bad_params['data'].pop('name')
        bad_params['data'].pop('connectionInfo')

        self.mock_ansible_module.params = bad_params

        SanManagerModule().run()

        msg = 'A "name" or "connectionInfo" must be provided inside the "data" field for this operation. '
        msg += 'If a "connectionInfo" is provided, the "Host" name is considered as the "name" for the resource.'

        self.mock_ansible_module.fail_json.assert_called_once_with(exception=mock.ANY, msg=msg)

    def test_connection_information_set_should_set_the_connection_information(self):
        data_merged = deepcopy(DEFAULT_SAN_MANAGER_TEMPLATE)
        data_merged['fabricType'] = 'DirectAttach'

        self.resource.get_by_name.return_value = DEFAULT_SAN_MANAGER_TEMPLATE
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'

        self.resource.update.return_value = data_merged
        self.mock_ansible_module.params = self.PARAMS_FOR_CONNECTION_INFORMATION_SET

        SanManagerModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=True,
            msg=SanManagerModule.MSG_UPDATED,
            ansible_facts=dict(san_manager=data_merged)
        )

    def test_should_add_new_san_manager_when_connection_information_set_called_without_resource(self):
        self.resource.get_by_name.return_value = []
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'
        self.resource.add.return_value = DEFAULT_SAN_MANAGER_TEMPLATE

        self.mock_ansible_module.params = self.PARAMS_FOR_CONNECTION_INFORMATION_SET

        SanManagerModule().run()

        self.mock_ansible_module.exit_json.assert_called_once_with(
            changed=True,
            msg=SanManagerModule.MSG_CREATED,
            ansible_facts=dict(san_manager=DEFAULT_SAN_MANAGER_TEMPLATE)
        )

    def test_should_fail_when_required_attribute_missing(self):
        bad_params = deepcopy(self.PARAMS_FOR_CONNECTION_INFORMATION_SET)
        bad_params['data'] = self.PARAMS_FOR_CONNECTION_INFORMATION_SET['data'].copy()
        bad_params['data'].pop('connectionInfo')

        self.resource.get_by_name.return_value = DEFAULT_SAN_MANAGER_TEMPLATE
        self.resource.get_provider_uri.return_value = '/rest/fc-sans/providers/123/device-managers'

        self.mock_ansible_module.params = bad_params

        SanManagerModule().run()

        msg = 'A connectionInfo field is required for this operation.'

        self.mock_ansible_module.fail_json.assert_called_once_with(exception=mock.ANY, msg=msg)


if __name__ == '__main__':
    unittest.main()

# Import modules
import numpy as np, sys, os, time, gzip, cPickle as pickle, scipy
sys.path.append('/tera_raid/gudni/gitCodes/simpeg')
sys.path.append('/tera_raid/gudni')
from pymatsolver import MumpsSolver
import SimPEG as simpeg
from SimPEG import MT
from numpy.lib import recfunctions as rFunc

# Function to get data and data info
def getDataInfo(MTdata):

    dL, freqL, rxTL = [], [], []

    for src in MTdata.survey.srcList:
        for rx in src.rxList:
            dL.append(MTdata[src,rx])
            freqL.append(np.ones(rx.nD)*src.freq)
            rxTL.extend( ((rx.rxType+' ')*rx.nD).split())
    return np.concatenate(dL), np.concatenate(freqL), np.array(rxTL)

# Script to read MT data and run an inversion.

# Load the data
drecAll = np.load('../../MTdataStArr_nsmesh_HKPK1.npy')
# Select larger frequency band for the MT data
indMTFreq = np.sum([drecAll['freq'] == val for val in  np.unique(drecAll['freq'])[::2] ],axis=0,dtype=bool)
mtRecArr = drecAll[indMTFreq][['freq','x','y','z','zxy','zyx']]
dUse = MT.Data.fromRecArray(mtRecArr)

# Extract to survey
survey = dUse.survey

# # Add noise to the data
dobs, freqArr, rxT = getDataInfo(dUse)
# Set the data

survey.dobs = dobs
# Assign std based on- and off-diagonal parts of the impedance tensor
std = np.ones_like(dobs)*.025 # 5% on all off-diagonals
# std[np.array([ ('xx' in l or 'yy' in l) for l in rxT])] = 0.15 # 15% on the on-diagonal
survey.std = np.abs(survey.dobs*std) #+ 0.01*np.linalg.norm(survey.dobs) #survey.dobs*0 + std
# Estimate a floor for the data.
# Use the 10% of the mean of the off-diagonals for each frequency
floor = np.zeros_like(dobs)
offind = np.array([('zxy' in l or 'zyx' in l) for l in rxT],bool)
onind = np.array([('zxx' in l or 'zyy' in l) for l in rxT],bool)

for f in np.unique(freqArr):
    freqInd = freqArr == f
    floorFreq = floor[freqInd]
    offD = np.sort(np.abs(dobs[freqInd*offind]))
    floor[freqInd] = 0.0001*np.mean(offD)
    # onD = np.sort(np.abs(dobs[freqInd*onind]))
    # floor[freqInd*onind] = 0.1*np.mean(onD)

# Assign the data weight
Wd = 1./(survey.std + floor)

# Make the mesh

mesh, modDict = simpeg.Mesh.TensorMesh.readVTK('../../nsmesh_HPVK1_inv.vtr')
sigma = modDict['S/m']

# Make the mapping
active = sigma > 9.999e-7
actMap = simpeg.Maps.ActiveCells(mesh, active, np.log(1e-8), nC=mesh.nC)
mappingExpAct = simpeg.Maps.ExpMap(mesh) * actMap

# sigma1d = 1e-8 * mesh.vectorCCz
# sigma1d[mesh.vectorCCz < 750] = 1e-2
sigmaBG = np.ones_like(sigma)*1e-8
sigmaBG[active] = 1e-4
sigma1d = mesh.r(sigmaBG,'CC','CC','M')[0,0,:]

# Make teh starting model
m_0 = np.log(sigmaBG[active])
## Setup the problem object
problem = MT.Problem3D.eForm_ps(mesh,mapping=mappingExpAct,sigmaPrimary = sigma1d)
problem.verbose = True
# Change the solver
problem.Solver = MumpsSolver
problem.pair(survey)

## Setup the inversion proceedure
C =  simpeg.Utils.Counter()

# Set the optimization
# opt = simpeg.Optimization.ProjectedGNCG(maxIter = 50)
# opt.lower = np.log(1e-5) # Set bounds to
# opt.upper = np.log(10)
opt = simpeg.Optimization.InexactGaussNewton(maxIter = 36)
opt.counter = C
opt.LSshorten = 0.5
opt.remember('xc')
# Need to add to the number of iter per beta.
# Data misfit
dmis = simpeg.DataMisfit.l2_DataMisfit(survey)
dmis.Wd = Wd
# Regularization
regMap = simpeg.Maps.InjectActiveCellsTopo(mesh,active) # valInactive=
reg = simpeg.Regularization.Tikhonov(mesh,mapping=regMap)#,indActive=np.where(active))
reg.mref = m_0
reg.alpha_s = 1e-14
reg.alpha_x = 1.
reg.alpha_y = 1.
reg.alpha_z = 1.
reg.alpha_xx = 0.
reg.alpha_yy = 0.
reg.alpha_zz = 0.
reg.smoothModel = False # Use reference in the smoothness regularization
# Inversion problem
invProb = simpeg.InvProblem.BaseInvProblem(dmis, reg, opt)
invProb.counter = C
# Beta cooling
beta = simpeg.Directives.BetaSchedule()
beta.coolingRate = 3 # Number of beta iterations
beta.coolingFactor = 8.
betaest = simpeg.Directives.BetaEstimate_ByEig(beta0_ratio=1.)
targmis = simpeg.Directives.TargetMisfit()
targmis.target = 0.5 * survey.nD
# saveModel = simpeg.Directives.SaveModelEveryIteration()
saveDict = simpeg.Directives.SaveOutputDictEveryIteration()
# Create an inversion object
inv = simpeg.Inversion.BaseInversion(invProb, directiveList=[beta,betaest,targmis,saveDict])

# Print
print 'Target Misfit is: {:.1f}'.format(targmis.target)

# Run the inversion
mopt = inv.run(m_0)
# 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.

import sqlalchemy

from solum.objects import sensor as abstract
from solum.objects.sqlalchemy import models as sql


class Sensor(sql.Base, abstract.Sensor):
    """Represent an sensor in sqlalchemy."""

    __resource__ = 'sensors'
    __tablename__ = 'sensor'
    __table_args__ = sql.table_args()

    id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True,
                           autoincrement=True)
    uuid = sqlalchemy.Column(sqlalchemy.String(36))
    project_id = sqlalchemy.Column(sqlalchemy.String(36))
    user_id = sqlalchemy.Column(sqlalchemy.String(36))
    name = sqlalchemy.Column(sqlalchemy.String(255))
    sensor_type = sqlalchemy.Column(sqlalchemy.String(255))
    value = sqlalchemy.Column(sqlalchemy.String(255))
    timestamp = sqlalchemy.Column(sqlalchemy.DateTime)
    description = sqlalchemy.Column(sqlalchemy.String(255))
    documentation = sqlalchemy.Column(sqlalchemy.String(255))
    target_resource = sqlalchemy.Column(sqlalchemy.String(255))


class SensorList(abstract.SensorList):
    """Represent a list of sensors in sqlalchemy."""

    @classmethod
    def get_all(cls, context):
        return SensorList(sql.model_query(context, Sensor))

"""
These modules exist to translate old format XML into newer, semantic forms
"""
from .x_module import XModuleDescriptor
from lxml import etree
from functools import wraps
import logging
import traceback

log = logging.getLogger(__name__)


def process_includes(fn):
    """
    Wraps a XModuleDescriptor.from_xml method, and modifies xml_data to replace
    any immediate child <include> items with the contents of the file that they
    are supposed to include
    """
    @wraps(fn)
    def from_xml(cls, xml_data, system, id_generator):
        xml_object = etree.fromstring(xml_data)
        next_include = xml_object.find('include')
        while next_include is not None:
            system.error_tracker("WARNING: the <include> tag is deprecated, and will go away.")
            file = next_include.get('file')
            parent = next_include.getparent()

            if file is None:
                continue

            try:
                ifp = system.resources_fs.open(file)
                # read in and convert to XML
                incxml = etree.XML(ifp.read())

                # insert  new XML into tree in place of include
                parent.insert(parent.index(next_include), incxml)
            except Exception:
                # Log error
                msg = "Error in problem xml include: %s" % (
                    etree.tostring(next_include, pretty_print=True))
                # tell the tracker
                system.error_tracker(msg)

                # work around
                parent = next_include.getparent()
                errorxml = etree.Element('error')
                messagexml = etree.SubElement(errorxml, 'message')
                messagexml.text = msg
                stackxml = etree.SubElement(errorxml, 'stacktrace')
                stackxml.text = traceback.format_exc()
                # insert error XML in place of include
                parent.insert(parent.index(next_include), errorxml)

            parent.remove(next_include)

            next_include = xml_object.find('include')
        return fn(cls, etree.tostring(xml_object), system, id_generator)
    return from_xml


class SemanticSectionDescriptor(XModuleDescriptor):
    @classmethod
    @process_includes
    def from_xml(cls, xml_data, system, id_generator):
        """
        Removes sections with single child elements in favor of just embedding
        the child element
        """
        xml_object = etree.fromstring(xml_data)
        system.error_tracker("WARNING: the <{0}> tag is deprecated.  Please do not use in new content."
                             .format(xml_object.tag))

        if len(xml_object) == 1:
            for (key, val) in xml_object.items():
                xml_object[0].set(key, val)

            return system.process_xml(etree.tostring(xml_object[0]))
        else:
            xml_object.tag = 'sequential'
            return system.process_xml(etree.tostring(xml_object))


class TranslateCustomTagDescriptor(XModuleDescriptor):
    @classmethod
    def from_xml(cls, xml_data, system, id_generator):
        """
        Transforms the xml_data from <$custom_tag attr="" attr=""/> to
        <customtag attr="" attr="" impl="$custom_tag"/>
        """

        xml_object = etree.fromstring(xml_data)
        system.error_tracker('WARNING: the <{tag}> tag is deprecated.  '
                             'Instead, use <customtag impl="{tag}" attr1="..." attr2="..."/>. '
                             .format(tag=xml_object.tag))

        tag = xml_object.tag
        xml_object.tag = 'customtag'
        xml_object.attrib['impl'] = tag

        return system.process_xml(etree.tostring(xml_object))

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'sql_example_ui.ui'
#
# Created by: PyQt5 UI code generator 5.6
#
# WARNING! All changes made in this file will be lost!

from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName("MainWindow")
        MainWindow.resize(847, 761)
        self.centralwidget = QtWidgets.QWidget(MainWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.centralwidget)
        self.verticalLayout_2.setObjectName("verticalLayout_2")
        self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
        self.horizontalLayout_2.setObjectName("horizontalLayout_2")
        self.label_5 = QtWidgets.QLabel(self.centralwidget)
        self.label_5.setObjectName("label_5")
        self.horizontalLayout_2.addWidget(self.label_5)
        self.selectLine = QtWidgets.QComboBox(self.centralwidget)
        self.selectLine.setMinimumSize(QtCore.QSize(400, 0))
        self.selectLine.setEditable(True)
        self.selectLine.setInsertPolicy(QtWidgets.QComboBox.NoInsert)
        self.selectLine.setObjectName("selectLine")
        self.horizontalLayout_2.addWidget(self.selectLine)
        spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
        self.horizontalLayout_2.addItem(spacerItem)
        self.verticalLayout_2.addLayout(self.horizontalLayout_2)
        self.groupBox = QtWidgets.QGroupBox(self.centralwidget)
        self.groupBox.setObjectName("groupBox")
        self.horizontalLayout_4 = QtWidgets.QHBoxLayout(self.groupBox)
        self.horizontalLayout_4.setObjectName("horizontalLayout_4")
        self.formLayout = QtWidgets.QFormLayout()
        self.formLayout.setObjectName("formLayout")
        self.label = QtWidgets.QLabel(self.groupBox)
        self.label.setObjectName("label")
        self.formLayout.setWidget(2, QtWidgets.QFormLayout.LabelRole, self.label)
        self.label_3 = QtWidgets.QLabel(self.groupBox)
        self.label_3.setObjectName("label_3")
        self.formLayout.setWidget(1, QtWidgets.QFormLayout.LabelRole, self.label_3)
        self.label_2 = QtWidgets.QLabel(self.groupBox)
        self.label_2.setObjectName("label_2")
        self.formLayout.setWidget(0, QtWidgets.QFormLayout.LabelRole, self.label_2)
        self.filterBranch = QtWidgets.QComboBox(self.groupBox)
        self.filterBranch.setEnabled(True)
        self.filterBranch.setEditable(True)
        self.filterBranch.setObjectName("filterBranch")
        self.formLayout.setWidget(0, QtWidgets.QFormLayout.FieldRole, self.filterBranch)
        self.filterBus = QtWidgets.QComboBox(self.groupBox)
        self.filterBus.setEditable(True)
        self.filterBus.setInsertPolicy(QtWidgets.QComboBox.NoInsert)
        self.filterBus.setObjectName("filterBus")
        self.formLayout.setWidget(1, QtWidgets.QFormLayout.FieldRole, self.filterBus)
        self.horizontalLayout_3 = QtWidgets.QHBoxLayout()
        self.horizontalLayout_3.setObjectName("horizontalLayout_3")
        self.filterEquipment = QtWidgets.QLineEdit(self.groupBox)
        self.filterEquipment.setMaximumSize(QtCore.QSize(50, 16777215))
        self.filterEquipment.setMaxLength(8)
        self.filterEquipment.setObjectName("filterEquipment")
        self.horizontalLayout_3.addWidget(self.filterEquipment)
        spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
        self.horizontalLayout_3.addItem(spacerItem1)
        self.formLayout.setLayout(2, QtWidgets.QFormLayout.FieldRole, self.horizontalLayout_3)
        self.horizontalLayout_4.addLayout(self.formLayout)
        spacerItem2 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
        self.horizontalLayout_4.addItem(spacerItem2)
        self.verticalLayout_2.addWidget(self.groupBox)
        self.groupBox_2 = QtWidgets.QGroupBox(self.centralwidget)
        self.groupBox_2.setObjectName("groupBox_2")
        self.verticalLayout = QtWidgets.QVBoxLayout(self.groupBox_2)
        self.verticalLayout.setObjectName("verticalLayout")
        self.horizontalLayout = QtWidgets.QHBoxLayout()
        self.horizontalLayout.setObjectName("horizontalLayout")
        self.copyButton = QtWidgets.QToolButton(self.groupBox_2)
        self.copyButton.setObjectName("copyButton")
        self.horizontalLayout.addWidget(self.copyButton)
        self.deleteButton = QtWidgets.QToolButton(self.groupBox_2)
        self.deleteButton.setObjectName("deleteButton")
        self.horizontalLayout.addWidget(self.deleteButton)
        self.clearSelection = QtWidgets.QToolButton(self.groupBox_2)
        self.clearSelection.setObjectName("clearSelection")
        self.horizontalLayout.addWidget(self.clearSelection)
        spacerItem3 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
        self.horizontalLayout.addItem(spacerItem3)
        self.verticalLayout.addLayout(self.horizontalLayout)
        self.tableView = CustomTableView(self.groupBox_2)
        self.tableView.setSelectionMode(QtWidgets.QAbstractItemView.SingleSelection)
        self.tableView.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
        self.tableView.setSortingEnabled(True)
        self.tableView.setObjectName("tableView")
        self.verticalLayout.addWidget(self.tableView)
        self.verticalLayout_2.addWidget(self.groupBox_2)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtWidgets.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 847, 21))
        self.menubar.setObjectName("menubar")
        self.menuFile = QtWidgets.QMenu(self.menubar)
        self.menuFile.setObjectName("menuFile")
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtWidgets.QStatusBar(MainWindow)
        self.statusbar.setObjectName("statusbar")
        MainWindow.setStatusBar(self.statusbar)
        self.actionExit = QtWidgets.QAction(MainWindow)
        self.actionExit.setObjectName("actionExit")
        self.menuFile.addAction(self.actionExit)
        self.menubar.addAction(self.menuFile.menuAction())

        self.retranslateUi(MainWindow)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)

    def retranslateUi(self, MainWindow):
        _translate = QtCore.QCoreApplication.translate
        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow"))
        self.label_5.setText(_translate("MainWindow", "Line"))
        self.selectLine.setCurrentText(_translate("MainWindow", "Select Line"))
        self.groupBox.setTitle(_translate("MainWindow", "Filters"))
        self.label.setText(_translate("MainWindow", "Equipment Letter"))
        self.label_3.setText(_translate("MainWindow", "Bus"))
        self.label_2.setText(_translate("MainWindow", "Branch"))
        self.groupBox_2.setTitle(_translate("MainWindow", "Equipment"))
        self.copyButton.setText(_translate("MainWindow", "Copy"))
        self.deleteButton.setText(_translate("MainWindow", "Delete"))
        self.clearSelection.setText(_translate("MainWindow", "Clear Selection"))
        self.menuFile.setTitle(_translate("MainWindow", "File"))
        self.actionExit.setText(_translate("MainWindow", "Exit"))

from customtableview import CustomTableView

#!/usr/bin/python2
from __future__ import division
import scipy, sys, time, os, argparse, numpy.random
from pylab import *

import read, arguments
import mayavi.mlab as mlab
from tvtk.api import tvtk

# ------------------------------------------------------------------------------
# Define functions
# ------------------------------------------------------------------------------
# returns the distance from the point p to the plane defined by 3 points
def dist_to_plane(point, plane):
  p = point-plane[2]
  e1 = plane[0]-plane[2]
  e2 = plane[1]-plane[2]
  n = cross(e1, e2)
  nhat = n/norm(n)
  return dot(nhat, p)

# takes a 2d array and treats it as a list of vertices
# returns a 2d array, that is a list of indices of vertices per face.
# It will pad each list of vertices so that they are a minimum of length pad
# which is useful for mixtures

# new method, look at all possible triplets of vertices, then reject those that have
# other vertices on both sides of the plane that they span
def get_faces(verts, pad = 0, acc = 0.1):
  # find the distance between neighbors. Assumes all neighbors are equidistant
  faces = []
  for i in range(len(verts)):
    u = verts[i]
    for j in range(i+1, len(verts)):
      v = verts[j]
      for k in range(j+1, len(verts)):
        w = verts[k]
        # now make sure we don't have a duplicate
        keep = True
        for face in faces:
          if (i in face) and (j in face) and (k in face):
            keep = False
            break
        if keep:
          plane = vstack((u, v, w))
          has_neg = False
          has_pos = False
          for l in range(len(verts)):
            if l != i and l != j and l != k:
              dist = dist_to_plane(verts[l], plane)
              if (dist > acc): has_pos = True
              elif (dist < -acc): has_neg = True
          if (not has_neg) or (not has_pos):
            # this plane is good!
            face = empty(0)
            for l in range(len(verts)):
              if abs(dist_to_plane(verts[l], plane)) < acc:
                face = append(face, l)
            faces.append(face)
  # okay we have our faces, but we need to sort them so they'll connect properly
  sfaces = []
  for face in faces:
    sface = array([face[0]])
    for i in range(len(face)-1):
      last = sface[-1]
      dmin = 10000
      for j in face:
        if not j in sface:
          dist = norm(verts[last] - verts[j])
          if dist < dmin:
            dmin = dist
            next_neighbor = j
      sface = append(sface, next_neighbor)
    sfaces.append(sface)
  faces = sfaces
  #print("we have %i vertices, %i faces, and the first face has %i vertices." %(len(verts), len(faces), len(faces[0])))
  # enforce that all faces have the same number of points so it can be a
  # 2d array:
  n = max([len(face) for face in faces])
  n = max(n, pad)
  for i in range(len(faces)):
    if len(face) < n:
      faces[i] = hstack((faces[i], ones(n-len(faces[i]))*faces[i][-1]))
  return array(faces)


# Get all the data into one Polydata, that is defined by two large arrays
# The first is an N x 3 array of vertex coordines
# The second is an fN x v array where v is the number of vertices per face
# and f is the number of faces per object.
# If the shapes are all the same, then the face array is just repeated copies
# of the face array for one shape, with each copy incremented by the number of
# vertices added.
def create_plot_data(shape_array, ncolors, mixture=False):
  nvertices = sum([len(shape_array[i]) for i in range(len(shape_array))])
  shapes = vstack(shape_array)
  N = len(shape_array)
  shapedim = shape_array[0].shape

  cvals = tile(linspace(0, 1, ncolors), ceil(N/ncolors))[:N]
  numpy.random.shuffle(cvals)

  most_vertices = 0
  if mixture:
    for shape in shape_array:
      if len(shape) > most_vertices:
        most_vertices = len(shape)

  face0 = get_faces(shape_array[0], most_vertices)
  faces = empty((0, len(face0[0])))
  colors = empty((0, 3))
  vertices_so_far = 0

  for i in range(N):
    if mixture:
      newface = get_faces(shape_array[i], most_vertices) + vertices_so_far
    else:
      newface = face0 + vertices_so_far
    vertices_so_far += len(shape_array[i])

    faces = vstack((faces, newface))
    newcolor = ones(shapedim)*cvals[i] + (2*numpy.random.random_sample(shapedim)-1)*0.1
    colors = vstack((colors, newcolor))

  mesh = tvtk.PolyData(points=shapes, polys=faces)
  mesh.point_data.scalars = colors
  mesh.point_data.scalars.name = 'colors'
  src = mlab.pipeline.add_dataset(mesh)
  return src, shapes

# ------------------------------------------------------------------------------
# Argument parsing
# ------------------------------------------------------------------------------
if __name__ == '__main__':
  parser = argparse.ArgumentParser(
    description='Plot density of polyhedra.', parents = [arguments.parser])
  parser.add_argument(
    '-d', '--delay', metavar='N', type=int, default=10,
    help='time in ms to pause between frames. Minimum 10')

  parser.add_argument(
    '-f', '--frames', metavar='N', type=int, default=10000,
    help='number of frames to animate')

  parser.add_argument(
    '-o', '--one_frame', metavar='N', type=int, default=-100,
    help='Instead of animating, view the specific frame')

  parser.add_argument(
    '-b', '--begin', metavar='N', type=int, default=0,
    help='start at this frame instead of frame 0')

  parser.add_argument(
    '-n', '--show_only', metavar='F', type=double, default=0,
    help='will only render a fraction of the polyhedra')

  parser.add_argument(
    '-k', '--skip', metavar='N', type=int, default=1,
    help='only play every N frames')

  parser.add_argument(
    '-a', '--alpha', metavar='F', type=double,
    help='sets the alpha of the polyhedra', default=1)

  parser.add_argument(
    '-v', '--save', action='store_true',
    help='will save animation frames as pdfs')

  parser.add_argument(
    '-m', '--mixture', action='store_true',
    help="""signals that the system may have multiple different shapes.
    The default assumption is that it does not, which allows faster runtime""")

  parser.add_argument(
    '-t', '--talk', action='store_true',
    help='instead of performing normal function, generate figures for talk')

  parser.add_argument('-w', '--hide_walls', action='store_true', help='won\'t draw walls')
  parser.add_argument('--xmin', type=double, default=0, help='minimum x-value')
  parser.add_argument('--xmax', type=double, default=1000, help='maximum x-value')
  parser.add_argument('--ymin', type=double, default=0, help='minimum y-value')
  parser.add_argument('--ymax', type=double, default=1000, help='maximum y-value')
  parser.add_argument('--zmin', type=double, default=0, help='minimum z-value')
  parser.add_argument('--zmax', type=double, default=1000, help='maximum z-value')
  parser.add_argument(
    '--shiftx', type=double, default=0, help='shift everything over by this many x')
  parser.add_argument(
    '--shifty', type=double, default=0, help='shift everything over by this many y')
  parser.add_argument(
    '--shiftz', type=double, default=0, help='shift everything over by this many z')
  parser.add_argument(
    '--notext', action='store_true', help='won\'t write any text on plot')

  args = parser.parse_args()

  if args.hide:
    mlab.options.offscreen = True

  ff = args.ff
  if args.ratio != 0:
    polyhedron = args.shape + "_%05.2f" %args.ratio
  else:
    polyhedron = args.shape
  frames = args.frames

  if args.periodic:
    celltype = 'periodic'
  else:
    celltype = 'walls'
  print(("Using %s with %s" %(polyhedron, celltype)))

  if args.N == 0:
    N = read.get_N("figs/mc/vertices/%s-%4.2f-vertices-%s" %(celltype, ff, polyhedron))
    if N == 0:
      exit(1)
  else: N = args.N

  if (args.xmin == 0 and args.xmax == 1000 and args.ymin == 0 and args.ymax == 1000 and
      args.zmin == 0 and args.zmax == 1000):
    partial_cell = False
  else: partial_cell = True


  # ------------------------------------------------------------------------------
  # Inital plot setup
  # ------------------------------------------------------------------------------
  figure = mlab.figure(bgcolor=(1, 1, 1), fgcolor=(0, 0, 0), size=(1024, 768))

  if args.one_frame > -100:
    f = args.one_frame
  else:
    f = args.begin
  dim, centers, shape_array, iteration = read.read_vertices(ff, polyhedron, N, celltype, f)
  if partial_cell:
    for i in range(N):
      if (centers[i, 0] < args.xmin or centers[i, 0] > args.xmax or
          centers[i, 1] < args.ymin or centers[i, 1] > args.ymax or
          centers[i, 2] < args.zmin or centers[i, 2] > args.zmax):
        shape_array[i] = zeros_like(shape_array[i])
  if args.shiftx > 0:
    for i in range(len(centers)):
      val = args.shiftx
      centers[i, 0] += val
      if centers[i, 0] > dim[0]:
        centers[i, 0] -= dim[0]
        val -= dim[0]
      shape_array[i,:, 0] += val

  if args.shifty > 0:
    for i in range(len(centers)):
      val = args.shifty
      centers[i, 1] += val
      if centers[i, 1] > dim[1]:
        centers[i, 1] -= dim[1]
        val -= dim[1]
      shape_array[i,:, 1] += val

  if args.shiftz > 0:
    for i in range(len(centers)):
      val = args.shiftz
      centers[i, 2] += val
      if centers[i, 2] > dim[2]:
        centers[i, 2] -= dim[2]
        val -= dim[2]
      shape_array[i,:, 2] += val

  if partial_cell:
    dim[0] = min(dim[0], args.xmax)
    dim[1] = min(dim[1], args.ymax)
    dim[2] = min(dim[2], args.zmax)
  if args.show_only > 0:
    shape_array = shape_array[:N*args.show_only]

  src, shapes = create_plot_data(shape_array, 5, args.mixture)
  nvertices = len(shapes)
  s =  mlab.pipeline.surface(src, colormap='jet', vmin=0, vmax=1, opacity=args.alpha)

  mlab.view(azimuth=30, elevation=65, distance=28, focalpoint=(dim[0]/2, dim[1]/2, dim[2]/2))

  words = [polyhedron,
          celltype,
          'ff = %g' %ff,
          'N = %i' %N,
          '                                       ']
  text = "\n".join(words)
  if not args.notext:
    mlab.text(.8, .9, text, figure=figure, width=.2)
    if iteration == -1:
      iterword = 'initial grid'
    elif iteration == -2:
      iterword = 'post initialization'
    elif iteration == -3:
      iterword = 'latest save'
    else:
      iterword = '%08i' %iteration
    itertext = mlab.text(.02, .95, iterword, figure=figure, width=.2)

  if not args.notext:
    mlab.orientation_axes(figure=figure, name='bob')

  # Draw the cell
  cell = mlab.outline(extent=[0, dim[0], 0, dim[1], 0, dim[2]], color=(0, 0, 0), line_width=3)

  if(celltype == 'walls' and not args.hide_walls):
    sheet_points = array([[0, 0, 0], [dim[0], 0, 0], [dim[0], dim[1], 0], [0, dim[1], 0],
                   [0, 0, dim[2]], [dim[0], 0, dim[2]], [dim[0], dim[1], dim[2]],
                   [0, dim[1], dim[2]]])
    sheet_connections = array([[0, 1, 2, 3], [4, 5, 6, 7]])
    sheetmesh = tvtk.PolyData(points=sheet_points, polys=sheet_connections)
    mlab.pipeline.surface(sheetmesh, opacity=.6, color=(1, 1, 1))

  # if(celltype == 'walls'and not args.hide_walls):
  #   nbars = 11
  #   x = tile(repeat(linspace(0, dim[0], nbars), 2), 2)
  #   y = tile(array([0, dim[1]]), 2*nbars)
  #   z = hstack((zeros(nbars*2), ones(nbars*2)*dim[2]))
  #   s = ones(nbars*4)
  #   bar_points = zeros((nbars*4, 3))
  #   bar_points[:,0] = x
  #   bar_points[:,1] = y
  #   bar_points[:,2] = z

  #   bar_connections = empty((2*nbars, 2))
  #   for i in xrange(2*nbars):
  #     bar_connections[i,:] = array([2*i, 2*i+1])

  #   bar_src = mlab.pipeline.scalar_scatter(x, y, z, s)
  #   bar_src.mlab_source.dataset.lines = bar_connections
  #   bars = mlab.pipeline.stripper(bar_src)
  #   mlab.pipeline.surface(bars, color=(0,0,0), line_width=3, opacity=.7)


  # ------------------------------------------------------------------------------
  # Animate
  # ------------------------------------------------------------------------------

  @mlab.animate(delay=args.delay, ui=False)
  def anim():
    global f, dim
    while f <= frames:
      if (not read.check_vertices(ff, polyhedron, N, celltype, f)) or f == frames:
        if args.save:
          print("All done.")
          exit(0)
        f = args.begin
        print("Looping!")
      newdim, newcenters, newshapes, iteration = read.read_vertices(ff, polyhedron, N, celltype, f)
      if not args.notext:
        itertext.set(text="%08i" %iteration)
      if args.show_only>0:
        newshapes = newshapes[:N*args.show_only]
      if partial_cell:
        for i in range(N):
          if (newcenters[i, 0] < args.xmin or newcenters[i, 0] > args.xmax or
              newcenters[i, 1] < args.ymin or newcenters[i, 1] > args.ymax or
              newcenters[i, 2] < args.zmin or newcenters[i, 2] > args.zmax):
            newshapes[i] = zeros_like(newshapes[i])

      shapes[:] = newshapes.reshape((nvertices, 3))
      src.update()
      if partial_cell:
        newdim[0] = min(dim[0], args.xmax)
        newdim[1] = min(dim[1], args.ymax)
        newdim[2] = min(dim[2], args.zmax)
      if newdim[0] != dim[0]:
        dim = newdim
        cell = mlab.outline(extent=[0, dim[0], 0, dim[1], 0, dim[2]], color=(0, 0, 0), line_width=3)
      # fixme : yield screws things up even when args.hide == True
      # if not args.hide:
        # yield
      if args.save:
        print(("saving figs/anim/%s-%4.2f-%s-%i-%i.png" %(celltype, ff, polyhedron, N, f)))
        figure.scene.save("figs/anim/%s-%4.2f-%s-%i-%i.png" %(celltype, ff, polyhedron, N, f))
      f += args.skip

  if args.one_frame == -100:
    a = anim()

  # if args.notext:
  #   mlab.view(azimuth=175, elevation=54, distance=27, focalpoint=(3, 2.6, 11), roll=1.33)
  #   figure.scene.save("../../talks/polyhedra/figs/cube-img-%04.2f.png" %ff)

  # @mlab.animate(delay=1000, ui=False)
  # def anim2():
  #   global bondcolors
  #   while True:
  #     print mlab.view(), mlab.roll()
  #     yield
  # a = anim2()

  mlab.show()

# -*- coding: utf-8 -*-
import re
import urlparse

import mock
import pytest

from pyquery import PyQuery as pq

from olympia import amo
from olympia.addons.models import Addon
from olympia.addons.tests.test_views import TestPersonas
from olympia.amo.tests import TestCase
from olympia.users.models import UserProfile
from olympia.users.templatetags.jinja_helpers import (
    addon_users_list, emaillink, manage_fxa_link, user_link, users_list)


pytestmark = pytest.mark.django_db


def test_emaillink():
    email = 'me@example.com'
    obfuscated = unicode(emaillink(email))

    # remove junk
    m = re.match(r'<a href="#"><span class="emaillink">(.*?)'
                 r'<span class="i">null</span>(.*)</span></a>'
                 r'<span class="emaillink js-hidden">(.*?)'
                 r'<span class="i">null</span>(.*)</span>', obfuscated)
    obfuscated = (''.join((m.group(1), m.group(2)))
                  .replace('&#x0040;', '@').replace('&#x002E;', '.'))[::-1]
    assert email == obfuscated

    title = 'E-mail your question'
    obfuscated = unicode(emaillink(email, title))
    m = re.match(r'<a href="#">(.*)</a>'
                 r'<span class="emaillink js-hidden">(.*?)'
                 r'<span class="i">null</span>(.*)</span>', obfuscated)
    assert title == m.group(1)
    obfuscated = (''.join((m.group(2), m.group(3)))
                  .replace('&#x0040;', '@').replace('&#x002E;', '.'))[::-1]
    assert email == obfuscated


def test_user_link():
    u = UserProfile(username='jconnor', display_name='John Connor', pk=1)
    assert user_link(u) == (
        '<a href="%s" title="%s">John Connor</a>' % (u.get_url_path(),
                                                     u.name))

    # handle None gracefully
    assert user_link(None) == ''


def test_user_link_xss():
    u = UserProfile(username='jconnor',
                    display_name='<script>alert(1)</script>', pk=1)
    html = "&lt;script&gt;alert(1)&lt;/script&gt;"
    assert user_link(u) == '<a href="%s" title="%s">%s</a>' % (
        u.get_url_path(), html, html)

    u = UserProfile(username='jconnor',
                    display_name="""xss"'><iframe onload=alert(3)>""", pk=1)
    html = """xss&#34;&#39;&gt;&lt;iframe onload=alert(3)&gt;"""
    assert user_link(u) == '<a href="%s" title="%s">%s</a>' % (
        u.get_url_path(), html, html)


def test_users_list():
    u1 = UserProfile(username='jconnor', display_name='John Connor', pk=1)
    u2 = UserProfile(username='sconnor', display_name='Sarah Connor', pk=2)
    assert users_list([u1, u2]) == ', '.join((user_link(u1), user_link(u2)))

    # handle None gracefully
    assert user_link(None) == ''


def test_short_users_list():
    """Test the option to shortened the users list to a certain size."""
    # short list with 'others'
    u1 = UserProfile(username='oscar', display_name='Oscar the Grouch', pk=1)
    u2 = UserProfile(username='grover', display_name='Grover', pk=2)
    u3 = UserProfile(username='cookies!', display_name='Cookie Monster', pk=3)
    shortlist = users_list([u1, u2, u3], size=2)
    assert shortlist == ', '.join((user_link(u1), user_link(u2))) + ', others'


def test_users_list_truncate_display_name():
    u = UserProfile(username='oscar',
                    display_name='Some Very Long Display Name', pk=1)
    truncated_list = users_list([u], None, 10)
    assert truncated_list == (
        u'<a href="%s" title="%s">Some Very...</a>' % (u.get_url_path(),
                                                       u.name))


def test_user_link_unicode():
    """make sure helper won't choke on unicode input"""
    u = UserProfile(username=u'jmüller', display_name=u'Jürgen Müller', pk=1)
    assert user_link(u) == (
        u'<a href="%s" title="%s">Jürgen Müller</a>' % (
            u.get_url_path(), u.name))

    u = UserProfile(username='\xe5\xaf\x92\xe6\x98\x9f', pk=1)
    assert user_link(u) == (
        u'<a href="%s" title="%s">%s</a>' % (u.get_url_path(), u.name,
                                             u.username))


class TestAddonUsersList(TestPersonas, TestCase):

    def setUp(self):
        super(TestAddonUsersList, self).setUp()
        self.addon = Addon.objects.get(id=15663)
        self.persona = self.addon.persona
        self.create_addon_user(self.addon)

    def test_by(self):
        """Test that the by... bit works."""
        content = addon_users_list({'amo': amo}, self.addon)
        assert pq(content).text() == 'by %s' % self.addon.authors.all()[0].name


def test_manage_fxa_link():
    user = mock.MagicMock(email='me@someplace.ca', fxa_id='abcd1234')
    link = urlparse.urlparse(manage_fxa_link({'user': user}))
    url = '{scheme}://{netloc}{path}'.format(
        scheme=link.scheme, netloc=link.netloc, path=link.path)
    assert url == 'https://stable.dev.lcip.org/settings'
    query = urlparse.parse_qs(link.query)
    assert query == {
        'uid': ['abcd1234'],
        'email': ['me@someplace.ca'],
        'entrypoint': ['addons'],
    }

#
# Copyright (C) 2013 UNINETT
#
# This file is part of Network Administration Visualized (NAV).
#
# NAV is free software: you can redistribute it and/or modify it under
# the terms of the GNU General Public License version 2 as published by
# the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.  You should have received a copy of the GNU General Public License
# along with NAV. If not, see <http://www.gnu.org/licenses/>.
#
"""pynetsnmp specific trap agent functions."""

import select
import logging
from socket import AF_INET, AF_INET6, inet_ntop, EINTR
from ctypes import (c_ushort, c_char, POINTER, cast, c_long)

from IPy import IP
from pynetsnmp import netsnmp

from nav.errors import GeneralException
from nav.oids import OID
from nav.util import address_to_string

from .trap import SNMPTrap

__all__ = ['TrapListener', 'UnsupportedSnmpVersionError']

_logger = logging.getLogger(__name__)


class TrapListener(object):
    """A pynetsnmp based implementation of a TrapListener"""
    def __init__(self, *addresses):
        """Initializes a TrapListener.

        iface -- A (srcadr, port) tuple.

        """
        self.addresses = addresses
        self._client_callback = None
        self._sessions = [TrapSession(addr, self.callback)
                          for addr in addresses]

    def open(self):
        """Opens the server socket at port 162."""
        for session in self._sessions:
            session.await_traps()

    def close(self):
        """Closes the server socket."""
        for session in self._sessions:
            session.close()

    def listen(self, _community, callback):
        """Listens for and dispatches incoming traps to callback.

        Any exceptions that occur, except SystemExit, are logged and
        subsequently ignored to avoid taking down the entire snmptrapd
        process by accident.

        """
        self._client_callback = callback
        while 1:
            fdlist, timeout = netsnmp.snmp_select_info()
            try:
                rlist, _wlist, _xlist = select.select(fdlist, [], [], timeout)
            except select.error as error:
                if error.args[0] == EINTR:
                    continue
                else:
                    raise
            if rlist:
                for fdescr in rlist:
                    netsnmp.snmp_read(fdescr)
            else:
                netsnmp.lib.snmp_timeout()

    def callback(self, src, pdu):
        """Handles trap callbacks from a TrapSession"""
        if not self._client_callback:
            return

        agent_addr = None
        generic_type = None
        community = pdu.community[:pdu.community_len]

        varbinds = netsnmp.getResult(pdu)

        if pdu.version == netsnmp.SNMP_VERSION_1:
            version = 1
            agent_addr = ".".join(str(d) for d in pdu.agent_addr)
            snmp_trap_oid, generic_type = transform_trap_type(pdu)
            uptime = pdu.time
        elif pdu.version == netsnmp.SNMP_VERSION_2c:
            version = 2
            _time_oid, time_val = varbinds.pop(0)
            _trap_oid_oid, trap_oid = varbinds.pop(0)

            uptime = time_val
            snmp_trap_oid = OID(trap_oid)
        else:
            raise UnsupportedSnmpVersionError(pdu.version)

        # Dump varbinds to debug log
        _logger.debug("varbinds: %r", varbinds)
        # Add remaining varbinds to dict
        varbind_dict = dict((str(OID(oid)), value_to_str(value))
                            for oid, value in varbinds)

        trap = SNMPTrap(str(src), agent_addr or str(src), None, generic_type,
                        str(snmp_trap_oid), uptime, community, version,
                        varbind_dict)
        self._client_callback(trap)

def value_to_str(value):
    """Converts a value from a varbind to a string, as that is what the
    SNMPTrap API expects :-P
    """
    if isinstance(value, tuple):
        return str(OID(value))
    else:
        return str(value)

SNMP_TRAPS = OID('.1.3.6.1.6.3.1.1.5')
TRAP_MAP = {
    netsnmp.SNMP_TRAP_COLDSTART: 'coldStart',
    netsnmp.SNMP_TRAP_WARMSTART: 'warmStart',
    netsnmp.SNMP_TRAP_LINKDOWN: 'linkDown',
    netsnmp.SNMP_TRAP_LINKUP: 'linkUp',
    netsnmp.SNMP_TRAP_AUTHFAIL: 'authenticationFailure',
    netsnmp.SNMP_TRAP_EGPNEIGHBORLOSS: 'egpNeighborLoss',
    netsnmp.SNMP_TRAP_ENTERPRISESPECIFIC: 'enterpriseSpecific',
    }


def transform_trap_type(pdu):
    """Transforms trap information from an SNMP-v1 pdu to something that
    is consistent with SNMP-v2c, as documented in RFC2576.

    :returns: A tuple of (snmpTrapOID, genericType)

    """
    enterprise_type = POINTER(c_long * pdu.enterprise_length)
    enterprise_p = cast(pdu.enterprise, enterprise_type)
    enterprise = OID(enterprise_p.contents)

    generic = pdu.trap_type

    # According to RFC2576 "Coexistence between Version 1, Version 2,
    # and Version 3 of the Internet-standard Network Management
    # Framework", we build snmpTrapOID from the snmp-v1 trap by
    # combining enterprise + 0 + specific trap parameter IF the
    # generic trap parameter is 6. If not, the traps are defined as
    # 1.3.6.1.6.3.1.1.5 + (generic trap parameter + 1)
    if generic == netsnmp.SNMP_TRAP_ENTERPRISESPECIFIC:
        snmp_trap_oid = enterprise + [0, pdu.specific_type]
    else:
        snmp_trap_oid = SNMP_TRAPS + [generic + 1]

    generic_type = TRAP_MAP.get(generic, str(generic)).upper()
    return snmp_trap_oid, generic_type


class TrapSession(netsnmp.Session):
    """A shim to adapt netsnmp.Session to our trap-receiving needs"""
    def __init__(self, iface, callback):
        super(TrapSession, self).__init__()
        self.addr, self.port = iface
        self._callback = callback

    def await_traps(self):
        """Starts dispatch of incoming traps to the registered callback"""
        addr = address_to_string(self.addr, self.port)
        if IP(self.addr).version() == 6:
            addr = "udp6:" + addr
            self._initv6()
        return self.awaitTraps(addr)

    def _initv6(self):
        lib = netsnmp.lib
        sentinel = object()
        if getattr(lib, "netsnmp_udpipv6_ctor", sentinel) is not sentinel:
            lib.netsnmp_udpipv6_ctor()
        elif getattr(lib, "netsnmp_udp6_ctor", sentinel) is not sentinel:
            lib.netsnmp_udp6_ctor()
        else:
            _logger.warning("Cannot find constructor function for UDP/IPv6 "
                            "transport domain object.")

    def callback(self, pdu):
        addr = get_transport_addr(pdu)
        self._callback(addr, pdu)

IPADDR_SIZE = 4
IP6ADDR_SIZE = 16
IPADDR_OFFSET = 4
IP6ADDR_OFFSET = 8

def get_transport_addr(pdu):
    """Retrieves the IP source address from the PDU's reference to an opaque
    transport data struct.

    Only works when assuming the opaque structure is sockaddr_in and
    sockaddr_in6. It should be as long as we are only using an IPv4 or
    IPv6-based netsnmp transport.

    """
    if pdu.transport_data_length <= 1:
        return

    # peek the first two bytes of the pdu's transport data to determine socket
    # address family (we are assuming the transport_data is a sockaddr_in or
    # sockaddr_in6 structure and accessing it naughtily here)
    family_p = cast(pdu.transport_data, POINTER(c_ushort))
    family = family_p.contents.value
    if family not in (AF_INET, AF_INET6):
        return

    addr_size, offset = ((IPADDR_SIZE, IPADDR_OFFSET) if family == AF_INET
                         else (IP6ADDR_SIZE, IP6ADDR_OFFSET))

    buffer_type = c_char * pdu.transport_data_length
    data_p = cast(pdu.transport_data, POINTER(buffer_type))
    data = data_p.contents
    addr = data[offset:offset + addr_size]
    return inet_ntop(family, addr)


class UnsupportedSnmpVersionError(GeneralException):
    """Received a trap with an unsupported SNMP version"""
    pass

# Copyright 2015 Red Hat, Inc.
# All Rights Reserved.
#
# 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.

import argparse
import logging
import textwrap

from os_cloud_management.cmd.utils import _clients as clients
from os_cloud_management.cmd.utils import environment
from os_cloud_management import updates


def parse_args():
    description = textwrap.dedent("""
    Run stack update.
    """)

    parser = argparse.ArgumentParser(
        description=description,
        formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument('-s', '--stack', dest='orig_stack',
                        help='Name or ID of a stack to update')
    parser.add_argument('-c', '--continue', dest='update_stack',
                        help='Name or ID of a stack representing an '
                        'existing update')
    parser.add_argument('-t', '--template', dest='template',
                        help='A template containing UpdateConfig to be '
                        'used for update')
    parser.add_argument('-n', '--name', dest='update_name',
                        help='Name for the update stack')
    parser.add_argument('-i', '--interactive', dest='interactive',
                        action='store_true',
                        help='Run update process in interactive mode')
    environment._add_logging_arguments(parser)
    return parser.parse_args()


def main():
    args = parse_args()
    environment._configure_logging(args)
    try:
        environment._ensure()
        client = clients.get_heat_client()
        if args.orig_stack:
            update = updates.UpdateManager(client=client)
            update.start(args.orig_stack, args.template, args.update_name)
        elif args.update_stack:
            update = updates.UpdateManager(client=client,
                                           stack_id=args.update_stack)
        if args.interactive:
            update.do_interactive_update()
        else:
            print("status: {0} ({1})".format(update.get_status()))
    except Exception:
        logging.exception("Unexpected error during command execution")
        return 1
    return 0

import argparse as ap
import os
import shutil

parser = ap.ArgumentParser(description='Auto grader script.')
parser.add_argument('-n', '--name', required=True, dest='problem_name', default=[],
                    help="the name of question")
parser.add_argument('-i', '--id', dest='problem_id',
                    help="the id number of question on leetcode")
parser.add_argument('-t', '--tag', dest='problem_tags', nargs='+',
                    help="the tags for the problem")
parser.add_argument('-c', '--company', dest='problem_company', nargs='+',
                    help="the company names who use this question")
parser.add_argument('-l', '--link', dest='problem_link',
                    help="the question link(on leetcode)")

args = parser.parse_args()

if __name__ == '__main__':
    problem_name = args.problem_name
    problem_id = args.problem_id
    problem_tags = args.problem_tags
    problem_companies = args.problem_company
    problem_link = args.problem_link
    os.makedirs(problem_name)
    readme_file_path = os.path.join(problem_name, 'README.md')
    shutil.copy('q_template.md', readme_file_path)

    # edit content
    with open(readme_file_path, 'r') as file:
        data = file.readlines()

    line_num = 0
    for line in list(data):  # create new list in case delete on iterating
        if line.lower().startswith('tags:'):  # this line contains all tags
            if problem_tags is not None: # add all tags
                line = 'Tags:'
                for tag in problem_tags:
                    line += ' __' + tag + '__,'
            if problem_companies is not None: # add company tags
                for company in problem_companies:
                    line += ' __' + company + '__,'

            data[line_num] = line[:-1]

        if line.lower().startswith('# brief intro'):
            if problem_id is not None:
                # edit File Title to problem name
                data[line_num] = '# ' + problem_id + '. ' + problem_name + '\n'
            else:
                data[2] = '# ' + problem_name + '\n'

        if 'leetcode qxxx' in line:
            if problem_link is not None:
                line = line.replace('https://www.google.com', problem_link)
            if problem_id is not None:
                line = line.replace('qxxx', ('' + problem_id).zfill(3))

            data[line_num] = line
            del data[line_num - 1] # delete the 'from CCI page xxx' line, all following lines will reduce number by 1

        line_num += 1

    # and write everything back
    with open(readme_file_path, 'w') as file:
        file.writelines(data)

# Copyright 2013 Rackspace Hosting
#
# Author: Tim Simmons <tim.simmons@rackspace.com>
#
# 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.
from designate.openstack.common import log as logging
from sqlalchemy import MetaData, Table, Column, Unicode

LOG = logging.getLogger(__name__)
meta = MetaData()


def upgrade(migrate_engine):
    meta.bind = migrate_engine

    domains_table = Table('domains', meta, autoload=True)
    records_table = Table('records', meta, autoload=True)

    #Add in description columns in domain/record databases
    domain_description = Column('description', Unicode(160),
                                nullable=True)
    domain_description.create(domains_table, populate_default=True)

    record_description = Column('description', Unicode(160),
                                nullable=True)
    record_description.create(records_table, populate_default=True)


def downgrade(migrate_engine):
    meta.bind = migrate_engine

    domains_table = Table('domains', meta, autoload=True)
    domains_table.c.description.drop()

    record_table = Table('records', meta, autoload=True)
    record_table.c.description.drop()

# -*- coding: utf-8 -*-
"""
@author: MiWi,HR,S1@KIT/2017,2018
"""
import qkit
import logging
from pkgutil import find_loader


def _load_visa():
    try:
        try:
            import pyvisa as visa
        except:
            import visa
    except Exception as e:
        qkit.cfg['load_visa'] = False
        raise type(e)('Failed loading visa. Check if you have NI VISA or pyvisa-py installed. Original error: ' + str(e))
    else:
        from pkg_resources import get_distribution
        from distutils.version import LooseVersion
        if LooseVersion(get_distribution('pyvisa').version) < LooseVersion("1.5.0"):
            logging.warning("Old pyvisa version loaded. Please update to a version > 1.5.x")
            # compatibility with old visa lib
            qkit.visa = visa
            qkit.visa.__version__ = get_distribution('pyvisa').version
            qkit.visa.qkit_visa_version = 1 #This makes it just much easier to distinguish between the main versions
        else:
            # active py visa version
            logging.info("Modern pyvisa version loaded. Version %s" % visa.__version__)
            try:
                rm = visa.ResourceManager(qkit.cfg.get('visa_backend',""))
                qkit.visa = rm
                qkit.visa.__version__ = visa.__version__
                qkit.visa.qkit_visa_version = 2
                qkit.visa.VisaIOError = visa.VisaIOError
                
                def instrument(resource_name, **kwargs):
                    return rm.open_resource(resource_name, **kwargs)
                qkit.visa.instrument = instrument
                # define data types:
                qkit.visa.double = "d"
                qkit.visa.single = "f"
                qkit.visa.dtypes = {1:qkit.visa.single,
                                    3:qkit.visa.double,
                                    "d":"d","f":"f"}
            except OSError:
                raise OSError('Failed creating ResourceManager. Check if you have NI VISA or pyvisa-py installed.')

class DummyVisa(object):
    def __getattr__(self,name):
        raise qkit.QkitCfgError("Please set qkit.cfg['load_visa'] = True if you need visa.")

if qkit.cfg.get('load_visa',False):
    _load_visa()
else:
    qkit.visa = DummyVisa()

"""
doc snipplet from 
https://pyvisa.readthedocs.io/en/stable/migrating.html
"""
# -*- coding: utf-8 -*-

# ########################## Copyrights and license ############################
#                                                                              #
# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
#                                                                              #
# This file is part of PyGithub. http://jacquev6.github.com/PyGithub/          #
#                                                                              #
# PyGithub is free software: you can redistribute it and/or modify it under    #
# the terms of the GNU Lesser General Public License as published by the Free  #
# Software Foundation, either version 3 of the License, or (at your option)    #
# any later version.                                                           #
#                                                                              #
# PyGithub is distributed in the hope that it will be useful, but WITHOUT ANY  #
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS    #
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more #
# details.                                                                     #
#                                                                              #
# You should have received a copy of the GNU Lesser General Public License     #
# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
#                                                                              #
# ##############################################################################

import github.GithubObject


class Status(github.GithubObject.NonCompletableGithubObject):
    """
    This class represents status as defined in https://status.github.com/api
    """

    @property
    def status(self):
        """
        :type: string
        """
        return self._status.value

    @property
    def last_updated(self):
        """
        :type: datetime.datetime
        """
        return self._last_updated.value

    def _initAttributes(self):
        self._status = github.GithubObject.NotSet
        self._last_updated = github.GithubObject.NotSet

    def _useAttributes(self, attributes):
        if "status" in attributes:  # pragma no branch
            self._status = self._makeStringAttribute(attributes["status"])
        if "last_updated" in attributes:  # pragma no branch
            self._last_updated = self._makeDatetimeAttribute(attributes["last_updated"])

# Copyright 2013-2014 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#
# Refer to the README and COPYING files for full details of the license
#
from __future__ import absolute_import
import logging
import os
import threading

import pyinotify

from vdsm.constants import P_VDSM_RUN
from vdsm import utils

from .configurators.iproute2 import Iproute2
from .sourceroute import DynamicSourceRoute


SOURCE_ROUTES_FOLDER = P_VDSM_RUN + 'sourceRoutes'
configurator = Iproute2()


class DHClientEventHandler(pyinotify.ProcessEvent):
    def process_IN_CLOSE_WRITE_filePath(self, sourceRouteFilePath):
        logging.debug("Responding to DHCP response in %s", sourceRouteFilePath)
        with open(sourceRouteFilePath, 'r') as sourceRouteFile:
            sourceRouteContents = sourceRouteFile.read().split()
            action = sourceRouteContents[0]
            device = sourceRouteContents[-1]

            if DynamicSourceRoute.isVDSMInterface(device):
                if action == 'configure':
                    ip = sourceRouteContents[1]
                    mask = sourceRouteContents[2]
                    gateway = sourceRouteContents[3]
                    if gateway in (None, '0.0.0.0') or not ip or not mask:
                        logging.error('invalid DHCP response %s',
                                      sourceRouteContents)
                    else:
                        DynamicSourceRoute(device, configurator,
                                           ip, mask, gateway).configure()
                else:
                    DynamicSourceRoute(device, configurator,
                                       None, None, None).remove()
            else:
                logging.info("interface %s is not a libvirt interface", device)

            DynamicSourceRoute.removeInterfaceTracking(device)

        os.remove(sourceRouteFilePath)

    def process_IN_CLOSE_WRITE(self, event):
        self.process_IN_CLOSE_WRITE_filePath(event.pathname)


def start():
    thread = threading.Thread(target=_subscribeToInotifyLoop,
                              name='sourceRoute')
    thread.daemon = True
    thread.start()


@utils.traceback()
def _subscribeToInotifyLoop():
    logging.debug("sourceRouteThread.subscribeToInotifyLoop started")

    # Subscribe to pyinotify event
    watchManager = pyinotify.WatchManager()
    handler = DHClientEventHandler()
    notifier = pyinotify.Notifier(watchManager, handler)
    watchManager.add_watch(SOURCE_ROUTES_FOLDER, pyinotify.IN_CLOSE_WRITE)

    # Run once manually in case dhclient operated while supervdsm was down
    # Run sorted so that if multiple files exist for an interface, we'll
    # execute them alphabetically and thus according to their time stamp
    for filePath in sorted(os.listdir(SOURCE_ROUTES_FOLDER)):
        handler.process_IN_CLOSE_WRITE_filePath(
            SOURCE_ROUTES_FOLDER + '/' + filePath)

    notifier.loop()

"""
This is used to test the ElasticSearchDB module. It is used to discover all possible changes of Elasticsearch api.
If you modify the test data, you have to update the test cases...
"""

import unittest
import datetime
import time

from DIRAC                                import gLogger
from DIRAC.Core.Utilities.ElasticSearchDB import ElasticSearchDB
from DIRAC.Core.Utilities.ElasticSearchDB import generateFullIndexName

elHost = 'localhost'
elPort = 9200

class ElasticTestCase( unittest.TestCase ):

  def setUp( self ):
    gLogger.setLevel( 'DEBUG' )
    self.el = ElasticSearchDB( host = elHost, 
                               port = elPort, 
                               useSSL = False )
    
    self.data = [{"Color": "red", "quantity": 1, "Product": "a", "timestamp": "2015-02-09 09:00:00.0"},
                 {"Color": "red", "quantity": 1, "Product": "b", "timestamp": "2015-02-09 16:15:00.0"},
                 {"Color": "red", "quantity": 1, "Product": "b", "timestamp": "2015-02-09 16:30:00.0"},
                 {"Color": "red", "quantity": 1, "Product": "a", "timestamp":"2015-02-09 09:00:00.0"},
                 {"Color": "red", "quantity": 1, "Product": "a", "timestamp": "2015-02-09 09:15:00.0"},
                 {"Color": "red", "quantity": 2, "Product": "b", "timestamp": "2015-02-09 16:15:00.0"},
                 {"Color": "red", "quantity": 1, "Product": "a", "timestamp":"2015-02-09 09:15:00.0"},
                 {"Color": "red", "quantity": 2, "Product": "b", "timestamp": "2015-02-09 16:15:00.0"},
                 {"Color": "red", "quantity": 1, "Product": "a", "timestamp": "2015-02-09 09:15:00.0"},
                 {"Color": "red", "quantity": 2, "Product": "b", "timestamp": "2015-02-09 16:15:00.0"}]
    self.index_name = ''

  def tearDown( self ):
    pass

class ElasticBulkCreateChain( ElasticTestCase ):

  def test_bulkindex( self ):
    result = self.el.bulk_index( 'integrationtest', 'test', self.data )
    self.assertTrue(result['OK'])
    self.assertEqual( result['Value'], 10 )
    time.sleep( 10 )
  
  def test_bulkindexMonthly(self):
        
    result = self.el.bulk_index( indexprefix = 'integrationtestmontly',
                                 doc_type = 'test',
                                 data = self.data,
                                 period = 'month' )
    self.assertTrue(result['OK'])
    self.assertEqual( result['Value'], 10 )
    time.sleep( 10 )

class ElasticCreateChain( ElasticTestCase ):


  def tearDown( self ):
    self.el.deleteIndex( self.index_name )

  def test_wrongdataindex( self ):
    result = self.el.createIndex( 'dsh63tsdgad', {} )
    self.assertTrue(result['OK'])
    index_name = result['Value']
    result = self.el.index( index_name, 'test', {"Color": "red", "quantity": 1, "Product": "a", "timestamp": 1458226213})
    self.assertTrue(result['OK'])
    result = self.el.index( index_name, 'test', {"Color": "red", "quantity": 1, "Product": "a", "timestamp": "2015-02-09T16:15:00Z"})
    self.assertTrue( result['Message'] )
    result = self.el.deleteIndex( index_name )
    self.assertTrue(result['OK'])


  def test_index( self ):
    result = self.el.createIndex( 'integrationtest', {} )
    self.assertTrue(result['OK'])
    self.index_name = result['Value']
    for i in self.data:
      result = self.el.index( self.index_name, 'test', i )
      self.assertTrue(result['OK'])



class ElasticDeleteChain( ElasticTestCase ):

  def test_deleteNonExistingIndex(self):
    result = self.el.deleteIndex( 'dsdssuu' )
    self.assertTrue( result['Message'] )

  def test_deleteIndex( self ):
    result = generateFullIndexName( 'integrationtest' )
    res = self.el.deleteIndex( result )
    self.assertTrue(res['OK'])
    self.assertEqual( res['Value'], result )

  def test_deleteMonthlyIndex( self ):
    result = generateFullIndexName( 'integrationtestmontly', 'month' )
    res = self.el.deleteIndex( result )
    self.assertTrue(res['OK'])
    self.assertEqual( res['Value'], result )

class ElasticTestChain( ElasticTestCase ):

  def setUp( self ):
    self.el = ElasticSearchDB( host = elHost, 
                               port = elPort, 
                               useSSL = False )
    result = generateFullIndexName( 'integrationtest' )
    self.assertTrue( len( result ) > len( 'integrationtest' ) )
    self.index_name = result

  def test_getIndexes( self ):
    result = self.el.getIndexes()
    self.assertTrue( len( result ) > 0 )


  def test_getDocTypes( self ):
    result = self.el.getDocTypes( self.index_name )
    self.assertTrue( result )
    self.assertDictEqual( result['Value'], {u'test': {u'properties': {u'Color': {u'type': u'string'}, u'timestamp': {u'type': u'long'}, u'Product': {u'type': u'string'}, u'quantity': {u'type': u'long'}}}} )

  def test_exists( self ):
    result = self.el.exists( self.index_name )
    self.assertTrue( result )

  def test_generateFullIndexName( self ):
    indexName = 'test'
    today = datetime.datetime.today().strftime( "%Y-%m-%d" )
    expected = "%s-%s" % ( indexName, today )
    result = generateFullIndexName( indexName )
    self.assertEqual( result, expected )
  
  def test_generateFullIndexName2( self ):
    indexName = 'test'
    month = datetime.datetime.today().strftime( "%Y-%m" )
    expected = "%s-%s" % ( indexName, month )
    result = generateFullIndexName( indexName, 'month' )
    self.assertEqual( result, expected )
  
  def test_getUniqueValue( self ):
    result = self.el.getUniqueValue( self.index_name, 'Color', )
    self.assertTrue( result )
    self.assertEqual( result['Value'], [] )
    result = self.el.getUniqueValue( self.index_name, 'Product' )
    self.assertTrue( result )
    self.assertEqual( result['Value'], [] )
    result = self.el.getUniqueValue( self.index_name, 'quantity' )
    self.assertTrue( result )
    self.assertEqual( result['Value'], [] )

  def test_query( self ):
    body = { "size": 0,
             "query": { "filtered": { "query": { "query_string": { "query": "*" } },
                                      "filter": { "bool": { "must": [{ "range": {
                            "timestamp": {
                                "gte": 1423399451544,
                                "lte": 1423631917911
                            }
                        }
                    }],
                    "must_not": []
                }
            }
        }
    },
    "aggs": {
        "3": {
            "date_histogram": {
                "field": "timestamp",
                "interval": "3600000ms",
                "min_doc_count": 1,
                "extended_bounds": {
                    "min": 1423399451544,
                    "max": 1423631917911
                }
            },
            "aggs": {
                "4": {
                    "terms": {
                        "field": "Product",
                        "size": 0,
                        "order": {
                            "1": "desc"
                        }
                    },
                    "aggs": {
                        "1": {
                            "sum": {
                                "field": "quantity"
                            }
                        }
                    }
                }
            }
        }
      }
    }
    result = self.el.query( self.index_name, body )
    self.assertEqual( result['aggregations'], {u'3': {u'buckets': [{u'4': {u'buckets': [{u'1': {u'value': 5.0}, u'key': u'a', u'doc_count': 5}], u'sum_other_doc_count': 0, u'doc_count_error_upper_bound': 0}, u'key': 1423468800000, u'doc_count': 5}, {u'4': {u'buckets': [{u'1': {u'value': 8.0}, u'key': u'b', u'doc_count': 5}], u'sum_other_doc_count': 0, u'doc_count_error_upper_bound': 0}, u'key': 1423494000000, u'doc_count': 5}]}} )
  
  def test_queryMontly( self ):
    body = { "size": 0,
             "query": { "filtered": { "query": { "query_string": { "query": "*" } },
                                      "filter": { "bool": { "must": [{ "range": {
                            "timestamp": {
                                "gte": 1423399451544,
                                "lte": 1423631917911
                            }
                        }
                    }],
                    "must_not": []
                }
            }
        }
    },
    "aggs": {
        "3": {
            "date_histogram": {
                "field": "timestamp",
                "interval": "3600000ms",
                "min_doc_count": 1,
                "extended_bounds": {
                    "min": 1423399451544,
                    "max": 1423631917911
                }
            },
            "aggs": {
                "4": {
                    "terms": {
                        "field": "Product",
                        "size": 0,
                        "order": {
                            "1": "desc"
                        }
                    },
                    "aggs": {
                        "1": {
                            "sum": {
                                "field": "quantity"
                            }
                        }
                    }
                }
            }
        }
      }
    }
    result = self.el.query( 'integrationtestmontly*', body )
    self.assertEqual( result['aggregations'], {u'3': {u'buckets': [{u'4': {u'buckets': [{u'1': {u'value': 5.0}, u'key': u'a', u'doc_count': 5}], u'sum_other_doc_count': 0, u'doc_count_error_upper_bound': 0}, u'key': 1423468800000, u'doc_count': 5}, {u'4': {u'buckets': [{u'1': {u'value': 8.0}, u'key': u'b', u'doc_count': 5}], u'sum_other_doc_count': 0, u'doc_count_error_upper_bound': 0}, u'key': 1423494000000, u'doc_count': 5}]}} )

  def test_Search( self ):
    s = self.el._Search( self.index_name )
    result = s.execute()
    self.assertEqual( len( result.hits ), 10 )
    self.assertEqual( dir( result.hits[0] ), [u'Color', u'Product', 'meta', u'quantity', u'timestamp'] )

  def test_Q1( self ):
    q = self.el._Q( 'range', timestamp = {'lte':1423501337292, 'gte': 1423497057518} )
    s = self.el._Search( self.index_name )
    s = s.filter( 'bool', must = q )
    query = s.to_dict()
    self.assertEqual( query, {'query': {'bool': {'filter': [{'bool': {'must': [{'range': {'timestamp': {'gte': 1423497057518, 'lte': 1423501337292}}}]}}]}}} )
    result = s.execute()
    self.assertEqual( len( result.hits ), 0 )
    
    q = self.el._Q( 'range', timestamp = {'lte':1423631917911, 'gte': 1423399451544} )
    s = self.el._Search( self.index_name )
    s = s.filter( 'bool', must = q )
    query = s.to_dict()
    self.assertEqual( query, {'query': {'bool': {'filter': [{'bool': {'must': [{'range': {'timestamp': {'gte': 1423399451544, 'lte': 1423631917911}}}]}}]}}} )
    result = s.execute()
    self.assertEqual( len( result.hits ), 10 )
    self.assertEqual( dir( result.hits[0] ), [u'Color', u'Product', 'meta', u'quantity', u'timestamp'] )

  def test_Q2( self ):
    q = [self.el._Q( 'range', timestamp = {'lte':1423631917911, 'gte': 1423399451544} ), self.el._Q( 'match', Product = 'a' )]
    s = self.el._Search( self.index_name )
    s = s.filter( 'bool', must = q )
    query = s.to_dict()
    self.assertEqual( query, {'query': {'bool': {'filter': [{'bool': {'must': [{'range': {'timestamp': {'gte': 1423399451544, 'lte': 1423631917911}}}, {'match': {'Product': 'a'}}]}}]}}} )
    result = s.execute()
    self.assertEqual( len( result.hits ), 5 )
    self.assertEqual( result.hits[0].Product, 'a' )
    self.assertEqual( result.hits[4].Product, 'a' )

  def test_A1( self ):
    q = [self.el._Q( 'range', timestamp = {'lte':1423631917911, 'gte': 1423399451544} )]
    s = self.el._Search( self.index_name )
    s = s.filter( 'bool', must = q )
    a1 = self.el._A( 'terms', field = 'Product', size = 0 )
    s.aggs.bucket( '2', a1 )
    query = s.to_dict()
    self.assertEqual( query, {'query': {'bool': {'filter': [{'bool': {'must': [{'range': {'timestamp': {'gte': 1423399451544, 'lte': 1423631917911}}}]}}]}}, 'aggs': {'2': {'terms': {'field': 'Product', 'size': 0}}}} )
    result = s.execute()
    self.assertEqual( result.aggregations['2'].buckets, [{u'key': u'a', u'doc_count': 5}, {u'key': u'b', u'doc_count': 5}] )

  def test_A2( self ):
    q = [self.el._Q( 'range', timestamp = {'lte':1423631917911, 'gte': 1423399451544} )]
    s = self.el._Search( self.index_name )
    s = s.filter( 'bool', must = q )
    a1 = self.el._A( 'terms', field = 'Product', size = 0 )
    a1.metric( 'total_quantity', 'sum', field = 'quantity' )
    s.aggs.bucket( '2', a1 )
    query = s.to_dict()
    self.assertEqual( query, {'query': {'bool': {'filter': [{'bool': {'must': [{'range': {'timestamp': {'gte': 1423399451544, 'lte': 1423631917911}}}]}}]}}, 'aggs': {'2': {'terms': {'field': 'Product', 'size': 0}, 'aggs': {'total_quantity': {'sum': {'field': 'quantity'}}}}}} )
    result = s.execute()
    self.assertEqual( result.aggregations['2'].buckets, [{u'total_quantity': {u'value': 5.0}, u'key': u'a', u'doc_count': 5}, {u'total_quantity': {u'value': 8.0}, u'key': u'b', u'doc_count': 5}] )

  def test_piplineaggregation( self ):
    q = [self.el._Q( 'range', timestamp = {'lte':1423631917911, 'gte': 1423399451544} )]
    s = self.el._Search( self.index_name )
    s = s.filter( 'bool', must = q )
    a1 = self.el._A( 'terms', field = 'Product', size = 0 )
    a2 = self.el._A( 'terms', field = 'timestamp' )
    a2.metric( 'total_quantity', 'sum', field = 'quantity' )
    a1.bucket( 'end_data', 'date_histogram', field = 'timestamp', interval = '3600000ms' ).metric( 'tt', a2 ).pipeline( 'avg_buckets', 'avg_bucket', buckets_path = 'tt>total_quantity', gap_policy = 'insert_zeros' )
    s.aggs.bucket( '2', a1 )
    query = s.to_dict()
    self.assertEqual( query, {'query': {'bool': {'filter': [{'bool': {'must': [{'range': {'timestamp': {'gte': 1423399451544, 'lte': 1423631917911}}}]}}]}}, 'aggs': {'2': {'terms': {'field': 'Product', 'size': 0}, 'aggs': {'end_data': {'date_histogram': {'field': 'timestamp', 'interval': '3600000ms'}, 'aggs': {'tt': {'terms': {'field': 'timestamp'}, 'aggs': {'total_quantity': {'sum': {'field': 'quantity'}}}}, 'avg_buckets': {'avg_bucket': {'buckets_path': 'tt>total_quantity', 'gap_policy': 'insert_zeros'}}}}}}}} )
    result = s.execute()
    self.assertEqual( len( result.aggregations['2'].buckets ), 2 )
    self.assertEqual( result.aggregations['2'].buckets[0].key, u'a' )
    self.assertEqual( result.aggregations['2'].buckets[1].key, u'b' )
    self.assertEqual( result.aggregations['2'].buckets[0]['end_data'].buckets[0].avg_buckets, {u'value': 2.5} )
    self.assertEqual( result.aggregations['2'].buckets[1]['end_data'].buckets[0].avg_buckets, {u'value': 4} )

if __name__ == '__main__':
  testSuite = unittest.defaultTestLoader.loadTestsFromTestCase( ElasticTestCase )
  testSuite.addTest( unittest.defaultTestLoader.loadTestsFromTestCase( ElasticCreateChain ) )
  testSuite.addTest( unittest.defaultTestLoader.loadTestsFromTestCase( ElasticBulkCreateChain ) )
  testSuite.addTest( unittest.defaultTestLoader.loadTestsFromTestCase( ElasticTestChain ) )
  testSuite.addTest( unittest.defaultTestLoader.loadTestsFromTestCase( ElasticDeleteChain ) )
  unittest.TextTestRunner( verbosity = 2 ).run( testSuite )

# -*- coding: utf-8 -*-
# Generated by Django 1.11.2 on 2017-07-25 17:16
from __future__ import unicode_literals

from django.conf import settings
from django.db import migrations, models
from osf.utils.migrations import disable_auto_now_fields


def migrate_user_guid_array_to_m2m(state, schema):
    from osf.models import OSFUser as FindableOSFUser
    AddableOSFUser = state.get_model('osf', 'osfuser')
    Comment = state.get_model('osf', 'comment')
    for comment in Comment.objects.exclude(_ever_mentioned=[]).all():
        for user in AddableOSFUser.objects.filter(id__in=[FindableOSFUser.objects.get(guids___id=_id).id for _id in comment._ever_mentioned]):
            comment.ever_mentioned.add(user)

def unmigrate_user_guid_array_from_m2m(state, schema):
    Comment = state.get_model('osf', 'comment')
    with disable_auto_now_fields(models=[Comment]):
        for comment in Comment.objects.exclude(ever_mentioned__isnull=False).all():
            comment._ever_mentioned = list(comment.ever_mentioned.values_list('guids___id', flat=True))
            comment.save()

class Migration(migrations.Migration):

    dependencies = [
        ('osf', '0043_merge_20170725_1328'),
    ]

    operations = [
        migrations.RenameField(
            model_name='comment',
            old_name='ever_mentioned',
            new_name='_ever_mentioned'
        ),
        migrations.AddField(
            model_name='comment',
            name='ever_mentioned',
            field=models.ManyToManyField(blank=True, related_name='mentioned_in', to=settings.AUTH_USER_MODEL),
        ),
        migrations.RunPython(
            migrate_user_guid_array_to_m2m, unmigrate_user_guid_array_from_m2m
        ),
        migrations.RemoveField(
            model_name='comment',
            name='_ever_mentioned'
        ),
    ]

from __future__ import absolute_import, unicode_literals

import json
from threading import local
from time import time

from django.utils.encoding import force_text
from django.utils import six

from debug_toolbar.utils import tidy_stacktrace, get_template_info, get_stack
from debug_toolbar import settings as dt_settings


class SQLQueryTriggered(Exception):
    """Thrown when template panel triggers a query"""
    pass


class ThreadLocalState(local):
    def __init__(self):
        self.enabled = True

    @property
    def Wrapper(self):
        if self.enabled:
            return NormalCursorWrapper
        return ExceptionCursorWrapper

    def recording(self, v):
        self.enabled = v


state = ThreadLocalState()
recording = state.recording  # export function


def wrap_cursor(connection, panel):
    if not hasattr(connection, '_djdt_cursor'):
        connection._djdt_cursor = connection.cursor

        def cursor():
            return state.Wrapper(connection._djdt_cursor(), connection, panel)

        connection.cursor = cursor
        return cursor


def unwrap_cursor(connection):
    if hasattr(connection, '_djdt_cursor'):
        del connection._djdt_cursor
        del connection.cursor


class ExceptionCursorWrapper(object):
    """
    Wraps a cursor and raises an exception on any operation.
    Used in Templates panel.
    """
    def __init__(self, cursor, db, logger):
        pass

    def __getattr__(self, attr):
        raise SQLQueryTriggered()


class NormalCursorWrapper(object):
    """
    Wraps a cursor and logs queries.
    """

    def __init__(self, cursor, db, logger):
        self.cursor = cursor
        # Instance of a BaseDatabaseWrapper subclass
        self.db = db
        # logger must implement a ``record`` method
        self.logger = logger

    def _quote_expr(self, element):
        if isinstance(element, six.string_types):
            return "'%s'" % force_text(element).replace("'", "''")
        else:
            return repr(element)

    def _quote_params(self, params):
        if not params:
            return params
        if isinstance(params, dict):
            return dict((key, self._quote_expr(value))
                        for key, value in params.items())
        return list(map(self._quote_expr, params))

    def _decode(self, param):
        try:
            return force_text(param, strings_only=True)
        except UnicodeDecodeError:
            return '(encoded string)'

    def _record(self, method, sql, params):
        start_time = time()
        try:
            return method(sql, params)
        finally:
            stop_time = time()
            duration = (stop_time - start_time) * 1000
            if dt_settings.CONFIG['ENABLE_STACKTRACES']:
                stacktrace = tidy_stacktrace(reversed(get_stack()))
            else:
                stacktrace = []
            _params = ''
            try:
                _params = json.dumps(list(map(self._decode, params)))
            except Exception:
                pass  # object not JSON serializable

            template_info = get_template_info()

            alias = getattr(self.db, 'alias', 'default')
            conn = self.db.connection
            vendor = getattr(conn, 'vendor', 'unknown')

            params = {
                'vendor': vendor,
                'alias': alias,
                'sql': self.db.ops.last_executed_query(
                    self.cursor, sql, self._quote_params(params)),
                'duration': duration,
                'raw_sql': sql,
                'params': _params,
                'stacktrace': stacktrace,
                'start_time': start_time,
                'stop_time': stop_time,
                'is_slow': duration > dt_settings.CONFIG['SQL_WARNING_THRESHOLD'],
                'is_select': sql.lower().strip().startswith('select'),
                'template_info': template_info,
            }

            if vendor == 'postgresql':
                # If an erroneous query was ran on the connection, it might
                # be in a state where checking isolation_level raises an
                # exception.
                try:
                    iso_level = conn.isolation_level
                except conn.InternalError:
                    iso_level = 'unknown'
                params.update({
                    'trans_id': self.logger.get_transaction_id(alias),
                    'trans_status': conn.get_transaction_status(),
                    'iso_level': iso_level,
                    'encoding': conn.encoding,
                })

            # We keep `sql` to maintain backwards compatibility
            self.logger.record(**params)

    def callproc(self, procname, params=()):
        return self._record(self.cursor.callproc, procname, params)

    def execute(self, sql, params=()):
        return self._record(self.cursor.execute, sql, params)

    def executemany(self, sql, param_list):
        return self._record(self.cursor.executemany, sql, param_list)

    def __getattr__(self, attr):
        return getattr(self.cursor, attr)

    def __iter__(self):
        return iter(self.cursor)

    def __enter__(self):
        return self

    def __exit__(self, type, value, traceback):
        self.close()

# Copyright 2013 OpenStack Foundation.
# All Rights Reserved.
#
#    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.

from neutron.api import extensions
from neutron.api.v2 import attributes
from neutron.api.v2 import base
from neutron.db import servicetype_db
from neutron.openstack.common import log as logging

LOG = logging.getLogger(__name__)

RESOURCE_NAME = "service_provider"
COLLECTION_NAME = "%ss" % RESOURCE_NAME
SERVICE_ATTR = 'service_type'
PLUGIN_ATTR = 'plugin'
DRIVER_ATTR = 'driver'
EXT_ALIAS = 'service-type'

# Attribute Map for Service Provider Resource
# Allow read-only access
RESOURCE_ATTRIBUTE_MAP = {
    COLLECTION_NAME: {
        'service_type': {'allow_post': False, 'allow_put': False,
                         'is_visible': True},
        'name': {'allow_post': False, 'allow_put': False,
                 'is_visible': True},
        'default': {'allow_post': False, 'allow_put': False,
                    'is_visible': True},
    }
}


class Servicetype(extensions.ExtensionDescriptor):

    @classmethod
    def get_name(cls):
        return _("Neutron Service Type Management")

    @classmethod
    def get_alias(cls):
        return EXT_ALIAS

    @classmethod
    def get_description(cls):
        return _("API for retrieving service providers for "
                 "Neutron advanced services")

    @classmethod
    def get_namespace(cls):
        return "http://docs.openstack.org/ext/neutron/service-type/api/v1.0"

    @classmethod
    def get_updated(cls):
        return "2013-01-20T00:00:00-00:00"

    @classmethod
    def get_resources(cls):
        """Returns Extended Resource for service type management."""
        my_plurals = [(key, key[:-1]) for key in RESOURCE_ATTRIBUTE_MAP.keys()]
        attributes.PLURALS.update(dict(my_plurals))
        attr_map = RESOURCE_ATTRIBUTE_MAP[COLLECTION_NAME]
        collection_name = COLLECTION_NAME.replace('_', '-')
        controller = base.create_resource(
            collection_name,
            RESOURCE_NAME,
            servicetype_db.ServiceTypeManager.get_instance(),
            attr_map)
        return [extensions.ResourceExtension(collection_name,
                                             controller,
                                             attr_map=attr_map)]

    def get_extended_resources(self, version):
        if version == "2.0":
            return RESOURCE_ATTRIBUTE_MAP
        else:
            return {}

"""
Support for IKEA Tradfri.

For more details about this component, please refer to the documentation at
https://home-assistant.io/components/ikea_tradfri/
"""
import logging

import voluptuous as vol

from homeassistant import config_entries
from homeassistant.const import EVENT_HOMEASSISTANT_STOP
import homeassistant.helpers.config_validation as cv
from homeassistant.util.json import load_json

from .const import (
    CONF_IMPORT_GROUPS, CONF_IDENTITY, CONF_HOST, CONF_KEY, CONF_GATEWAY_ID)

from . import config_flow  # noqa  pylint_disable=unused-import

REQUIREMENTS = ['pytradfri[async]==6.0.1']

DOMAIN = 'tradfri'
CONFIG_FILE = '.tradfri_psk.conf'
KEY_GATEWAY = 'tradfri_gateway'
KEY_API = 'tradfri_api'
CONF_ALLOW_TRADFRI_GROUPS = 'allow_tradfri_groups'
DEFAULT_ALLOW_TRADFRI_GROUPS = False

CONFIG_SCHEMA = vol.Schema({
    DOMAIN: vol.Schema({
        vol.Optional(CONF_HOST): cv.string,
        vol.Optional(CONF_ALLOW_TRADFRI_GROUPS,
                     default=DEFAULT_ALLOW_TRADFRI_GROUPS): cv.boolean,
    })
}, extra=vol.ALLOW_EXTRA)

_LOGGER = logging.getLogger(__name__)


async def async_setup(hass, config):
    """Set up the Tradfri component."""
    conf = config.get(DOMAIN)

    if conf is None:
        return True

    configured_hosts = [entry.data['host'] for entry in
                        hass.config_entries.async_entries(DOMAIN)]

    legacy_hosts = await hass.async_add_executor_job(
        load_json, hass.config.path(CONFIG_FILE))

    for host, info in legacy_hosts.items():
        if host in configured_hosts:
            continue

        info[CONF_HOST] = host
        info[CONF_IMPORT_GROUPS] = conf[CONF_ALLOW_TRADFRI_GROUPS]

        hass.async_create_task(hass.config_entries.flow.async_init(
            DOMAIN, context={'source': config_entries.SOURCE_IMPORT},
            data=info
        ))

    host = conf.get(CONF_HOST)
    import_groups = conf[CONF_ALLOW_TRADFRI_GROUPS]

    if host is None or host in configured_hosts or host in legacy_hosts:
        return True

    hass.async_create_task(hass.config_entries.flow.async_init(
        DOMAIN, context={'source': config_entries.SOURCE_IMPORT},
        data={CONF_HOST: host, CONF_IMPORT_GROUPS: import_groups}
    ))

    return True


async def async_setup_entry(hass, entry):
    """Create a gateway."""
    # host, identity, key, allow_tradfri_groups
    from pytradfri import Gateway, RequestError  # pylint: disable=import-error
    from pytradfri.api.aiocoap_api import APIFactory

    factory = APIFactory(
        entry.data[CONF_HOST],
        psk_id=entry.data[CONF_IDENTITY],
        psk=entry.data[CONF_KEY],
        loop=hass.loop
    )

    async def on_hass_stop(event):
        """Close connection when hass stops."""
        await factory.shutdown()

    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, on_hass_stop)

    api = factory.request
    gateway = Gateway()

    try:
        gateway_info = await api(gateway.get_gateway_info())
    except RequestError:
        _LOGGER.error("Tradfri setup failed.")
        return False

    hass.data.setdefault(KEY_API, {})[entry.entry_id] = api
    hass.data.setdefault(KEY_GATEWAY, {})[entry.entry_id] = gateway

    dev_reg = await hass.helpers.device_registry.async_get_registry()
    dev_reg.async_get_or_create(
        config_entry_id=entry.entry_id,
        connections=set(),
        identifiers={
            (DOMAIN, entry.data[CONF_GATEWAY_ID])
        },
        manufacturer='IKEA',
        name='Gateway',
        # They just have 1 gateway model. Type is not exposed yet.
        model='E1526',
        sw_version=gateway_info.firmware_version,
    )

    hass.async_create_task(hass.config_entries.async_forward_entry_setup(
        entry, 'light'
    ))
    hass.async_create_task(hass.config_entries.async_forward_entry_setup(
        entry, 'sensor'
    ))
    hass.async_create_task(hass.config_entries.async_forward_entry_setup(
        entry, 'switch'
    ))

    return True

# -*- coding: utf-8 -*-
from __future__ import absolute_import

import os
import re
import sys
import types
import warnings
from gettext import gettext as _

import argparse

from flask import Flask
from flask._compat import text_type

from ._compat import iteritems
from .commands import Group, Option, Command, Server, Shell
from .cli import prompt, prompt_pass, prompt_bool, prompt_choices

__all__ = ["Command", "Shell", "Server", "Manager", "Group", "Option",
           "prompt", "prompt_pass", "prompt_bool", "prompt_choices"]

safe_actions = (argparse._StoreAction,
                argparse._StoreConstAction,
                argparse._StoreTrueAction,
                argparse._StoreFalseAction,
                argparse._AppendAction,
                argparse._AppendConstAction,
                argparse._CountAction)


try:
    import argcomplete
    ARGCOMPLETE_IMPORTED = True
except ImportError:
    ARGCOMPLETE_IMPORTED = False

def add_help(parser, help_args): 
    if not help_args:
        return
    parser.add_argument(*help_args,
                        action='help', default=argparse.SUPPRESS, help=_('show this help message and exit'))

class Manager(object):
    """
    Controller class for handling a set of commands.

    Typical usage::

        class Print(Command):

            def run(self):
                print "hello"

        app = Flask(__name__)

        manager = Manager(app)
        manager.add_command("print", Print())

        if __name__ == "__main__":
            manager.run()

    On command line::

        python manage.py print
        > hello

    :param app: Flask instance, or callable returning a Flask instance.
    :param with_default_commands: load commands **runserver** and **shell**
                                  by default.
    :param disable_argcomplete: disable automatic loading of argcomplete.

    """
    help_args = ('-?','--help')

    def __init__(self, app=None, with_default_commands=None, usage=None,
                 help=None, description=None, disable_argcomplete=False):

        self.app = app

        self._commands = dict()
        self._options = list()

        self.usage = usage
        self.help = help if help is not None else usage
        self.description = description if description is not None else usage
        self.disable_argcomplete = disable_argcomplete
        self.with_default_commands = with_default_commands

        self.parent = None

    def add_default_commands(self):
        """
        Adds the shell and runserver default commands. To override these,
        simply add your own equivalents using add_command or decorators.
        """

        if "shell" not in self._commands:
            self.add_command("shell", Shell())
        if "runserver" not in self._commands:
            self.add_command("runserver", Server())

    def add_option(self, *args, **kwargs):
        """
        Adds a global option. This is useful if you want to set variables
        applying to the application setup, rather than individual commands.

        For this to work, the manager must be initialized with a factory
        function rather than a Flask instance. Otherwise any options you set
        will be ignored.

        The arguments are then passed to your function, e.g.::

            def create_my_app(config=None):
                app = Flask(__name__)
                if config:
                    app.config.from_pyfile(config)

                return app

            manager = Manager(create_my_app)
            manager.add_option("-c", "--config", dest="config", required=False)
            @manager.command
            def mycommand(app):
                app.do_something()

        and are invoked like this::

            > python manage.py -c dev.cfg mycommand

        Any manager options passed on the command line will not be passed to
        the command.

        Arguments for this function are the same as for the Option class.
        """

        self._options.append(Option(*args, **kwargs))

    def __call__(self, app=None, **kwargs):
        """
        This procedure is called with the App instance (if this is a
        sub-Manager) and any options. 

        If your sub-Manager does not override this, any values for options will get lost.
        """
        if app is None:
            app = self.app
            if app is None:
                raise Exception("There is no app here. This is unlikely to work.")

        if isinstance(app, Flask):
            if kwargs:
                import warnings
                warnings.warn("Options will be ignored.")
            return app

        app = app(**kwargs)
        self.app = app
        return app

    def create_app(self, *args, **kwargs):
        warnings.warn("create_app() is deprecated; use __call__().", warnings.DeprecationWarning)
        return self(*args,**kwargs)

    def create_parser(self, prog, func_stack=(), parent=None):
        """
        Creates an ArgumentParser instance from options returned
        by get_options(), and subparser for the given commands.
        """
        prog = os.path.basename(prog)
        func_stack=func_stack+(self,)

        options_parser = argparse.ArgumentParser(add_help=False)
        for option in self.get_options():
            options_parser.add_argument(*option.args, **option.kwargs)

        parser = argparse.ArgumentParser(prog=prog, usage=self.usage,
                                         description=self.description,
                                         parents=[options_parser],
                                         add_help=False)
        add_help(parser, self.help_args)

        self._patch_argparser(parser)

        subparsers = parser.add_subparsers()

        for name, command in self._commands.items():
            usage = getattr(command, 'usage', None)
            help = getattr(command, 'help', None)
            if help is None: help = command.__doc__
            description = getattr(command, 'description', None)
            if description is None: description = command.__doc__

            command_parser = command.create_parser(name, func_stack=func_stack, parent=self)

            subparser = subparsers.add_parser(name, usage=usage, help=help,
                                              description=description,
                                              parents=[command_parser],
                                              add_help=False)

            if isinstance(command, Manager):
                self._patch_argparser(subparser)

        ## enable autocomplete only for parent parser when argcomplete is
        ## imported and it is NOT disabled in constructor
        if parent is None and ARGCOMPLETE_IMPORTED \
                and not self.disable_argcomplete:
            argcomplete.autocomplete(parser, always_complete_options=True)

        self.parser = parser
        return parser

    # def foo(self, app, *args, **kwargs):
    #     print(args)

    def _patch_argparser(self, parser):
        """
        Patches the parser to print the full help if no arguments are supplied
        """

        def _parse_known_args(self, arg_strings, *args, **kw):
            if not arg_strings:
                self.print_help()
                self.exit(2)

            return self._parse_known_args2(arg_strings, *args, **kw)

        parser._parse_known_args2 = parser._parse_known_args
        parser._parse_known_args = types.MethodType(_parse_known_args, parser)

    def get_options(self):
        return self._options

    def add_command(self, *args, **kwargs):
        """
        Adds command to registry.

        :param command: Command instance
        :param name: Name of the command (optional)
        :param namespace: Namespace of the command (optional; pass as kwarg)
        """

        if len(args) == 1:
            command = args[0]
            name = None

        else:
            name, command = args

        if name is None:
            if hasattr(command, 'name'):
                name = command.name

            else:
                name = type(command).__name__.lower()
                name = re.sub(r'command$', '', name)

        if isinstance(command, Manager):
            command.parent = self

        if isinstance(command, type):
            command = command()

        namespace = kwargs.get('namespace')
        if not namespace:
            namespace = getattr(command, 'namespace', None)

        if namespace:
            if namespace not in self._commands:
                self.add_command(namespace, Manager())

            self._commands[namespace]._commands[name] = command

        else:
            self._commands[name] = command

    def command(self, func):
        """
        Decorator to add a command function to the registry.

        :param func: command function.Arguments depend on the
                     options.

        """

        command = Command(func)
        self.add_command(func.__name__, command)

        return func

    def option(self, *args, **kwargs):
        """
        Decorator to add an option to a function. Automatically registers the
        function - do not use together with ``@command``. You can add as many
        ``@option`` calls as you like, for example::

            @option('-n', '--name', dest='name')
            @option('-u', '--url', dest='url')
            def hello(name, url):
                print "hello", name, url

        Takes the same arguments as the ``Option`` constructor.
        """

        option = Option(*args, **kwargs)

        def decorate(func):
            name = func.__name__

            if name not in self._commands:

                command = Command()
                command.run = func
                command.__doc__ = func.__doc__
                command.option_list = []

                self.add_command(name, command)

            self._commands[name].option_list.append(option)
            return func
        return decorate

    def shell(self, func):
        """
        Decorator that wraps function in shell command. This is equivalent to::

            def _make_context(app):
                return dict(app=app)

            manager.add_command("shell", Shell(make_context=_make_context))

        The decorated function should take a single "app" argument, and return
        a dict.

        For more sophisticated usage use the Shell class.
        """

        self.add_command('shell', Shell(make_context=func))

        return func

    def set_defaults(self):
        if self.with_default_commands is None:
            self.with_default_commands = self.parent is None
        if self.with_default_commands:
            self.add_default_commands()
        self.with_default_commands = False

    def handle(self, prog, args=None):
        self.set_defaults()
        app_parser = self.create_parser(prog)
        
        args = list(args or [])
        app_namespace, remaining_args = app_parser.parse_known_args(args)

        # get the handle function and remove it from parsed options
        kwargs = app_namespace.__dict__
        func_stack = kwargs.pop('func_stack', None)
        if not func_stack:
            app_parser.error('too few arguments')

        last_func = func_stack[-1]
        if remaining_args and not getattr(last_func, 'capture_all_args', False):
            app_parser.error('too many arguments')

        args = []
        for handle in func_stack:

            # get only safe config options
            config_keys = [action.dest for action in handle.parser._actions
                               if handle is last_func or action.__class__ in safe_actions]

            # pass only safe app config keys
            config = dict((k, v) for k, v in iteritems(kwargs)
                          if k in config_keys)

            # remove application config keys from handle kwargs
            kwargs = dict((k, v) for k, v in iteritems(kwargs)
                          if k not in config_keys)

            if handle is last_func and getattr(last_func, 'capture_all_args', False):
                args.append(remaining_args)
            try:
                res = handle(*args, **config)
            except TypeError as err:
                err.args = ("{0}: {1}".format(handle,str(err)),)
                raise

            args = [res]

        assert not kwargs
        return res

    def run(self, commands=None, default_command=None):
        """
        Prepares manager to receive command line input. Usually run
        inside "if __name__ == "__main__" block in a Python script.

        :param commands: optional dict of commands. Appended to any commands
                         added using add_command().

        :param default_command: name of default command to run if no
                                arguments passed.
        """

        if commands:
            self._commands.update(commands)

        # Make sure all of this is Unicode
        argv = list(text_type(arg) for arg in sys.argv)
        if default_command is not None and len(argv) == 1:
            argv.append(default_command)

        try:
            result = self.handle(argv[0], argv[1:])
        except SystemExit as e:
            result = e.code

        sys.exit(result or 0)

# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from config.template_middleware import TemplateResponse
from tekton import router
from gaecookie.decorator import no_csrf
from question_app import question_facade
from routes.questions import new, edit
from tekton.gae.middleware.redirect import RedirectResponse
from gaepermission.model import MainUser
from datetime import datetime
from routes.comments.rest import new as comment_new, index as comment_list, delete as comment_delete
from comment_app import comment_facade
from comment_app.comment_model import Comment
from permission_app.permission_facade import main_user_form
from json import dumps
from gaepermission.decorator import login_required


@login_required
@no_csrf
def index(question_id=""):
    main_uform = main_user_form()
    if question_id:
        cmd = question_facade.get_question_cmd(question_id)
        question = cmd()
        form = question_facade.question_form()
        if not question:
            return RedirectResponse(index)
        question_dct = form.fill_with_model(question)
        question_dct['user'] = main_uform.fill_with_model(MainUser.get_by_id(question_dct['user']))

        context = {
            "question": question_dct,
            "questions": dumps([question_dct]),
            "comment_url": router.to_path(comment_new),
            "comment_list": router.to_path(comment_list)}
        return TemplateResponse(context=context, template_path='questions/question.html')
    return TemplateResponse(template_path='questions/home.html')


@login_required
def delete(question_id):
    question_facade.delete_question_cmd(question_id)()
    return RedirectResponse(router.to_path(index))


# -*- coding: utf-8 -*-

"""
***************************************************************************
    test_qgsserver_services.py
    ---------------------
    Date                 : December 2016
    Copyright            : (C) 2016 by David Marteau
    Email                : david at innophi dot com
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""

__author__ = 'David Marteau'
__date__ = 'December 2016'
__copyright__ = '(C) 2016, David Marteau'

""" QGIS test for server services
"""
from qgis.PyQt.QtCore import QBuffer, QIODevice, QTextStream
from qgis.testing import unittest
from qgis.server import (QgsServiceRegistry,
                         QgsService,
                         QgsServerRequest,
                         QgsServerResponse)

from qgis.core import QgsApplication


class Response(QgsServerResponse):

    def __init__(self):
        QgsServerResponse.__init__(self)
        self._buffer = QBuffer()
        self._buffer.open(QIODevice.ReadWrite)

    def setStatusCode(self, code):
        self.code = code

    def statusCode(self):
        return self.code

    def setHeader(self, key, val):
        pass

    def clearHeader(self, key):
        pass

    def sendError(self, code, message):
        pass

    def io(self):
        return self._buffer

    def finish(self):
        pass

    def flush(self):
        pass

    def clear(self):
        pass


class MyService(QgsService):

    def __init__(self, name, version, response):
        QgsService.__init__(self)
        self._response = response
        self._name = name
        self._version = version

    def name(self):
        return self._name

    def version(self):
        return self._version

    def executeRequest(self, request, response):
        response.setStatusCode(201)
        response.write(self._response)


class TestServices(unittest.TestCase):
    """
    """

    @classmethod
    def setUpClass(cls):
        cls.app = QgsApplication([], False)

    @classmethod
    def tearDownClass(cls):
        cls.app.exitQgis()

    def test_register(self):

        reg = QgsServiceRegistry()

        myserv = MyService("TEST", "1.0", "Hello world")

        reg.registerService(myserv)

        # Retrieve service
        request = QgsServerRequest("http://DoStufff", QgsServerRequest.GetMethod)
        response = Response()

        service = reg.getService("TEST")
        if service:
            service.executeRequest(request, response)

        io = response.io()
        io.seek(0)

        self.assertEqual(QTextStream(io).readLine(), "Hello world")
        self.assertEqual(response.statusCode(), 201)

    def test_0_version_registration(self):

        reg = QgsServiceRegistry()
        myserv11 = MyService("TEST", "1.1", "Hello")
        myserv10 = MyService("TEST", "1.0", "Hello")

        reg.registerService(myserv11)
        reg.registerService(myserv10)

        service = reg.getService("TEST")
        self.assertIsNotNone(service)
        self.assertEqual(service.version(), "1.1")

        service = reg.getService("TEST", "2.0")
        self.assertIsNotNone(service)
        self.assertEqual(service.version(), "1.1")

        service = reg.getService("TEST", "1.0")
        self.assertIsNotNone(service)
        self.assertEqual(service.version(), "1.0")

    def test_1_unregister_services(self):

        reg = QgsServiceRegistry()
        serv1 = MyService("TEST", "1.0a", "Hello")
        serv2 = MyService("TEST", "1.0b", "Hello")
        serv3 = MyService("TEST", "1.0c", "Hello")

        reg.registerService(serv1)
        reg.registerService(serv2)
        reg.registerService(serv3)

        # Check we get the default version
        service = reg.getService("TEST")
        self.assertEqual(service.version(), "1.0a")

        # Remove one service
        removed = reg.unregisterService("TEST", "1.0a")
        self.assertEqual(removed, 1)

        # Check that we get the highest version
        service = reg.getService("TEST")
        self.assertEqual(service.version(), "1.0c")

        # Remove all services
        removed = reg.unregisterService("TEST")
        self.assertEqual(removed, 2)

        # Check that there is no more services available
        service = reg.getService("TEST")
        self.assertIsNone(service)


if __name__ == '__main__':
    unittest.main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys

import json
import yaml


def merge_dicts(a, b):
    if not (isinstance(a, dict) and isinstance(b, dict)):
        raise ValueError("Error merging variables: '{}' and '{}'".format(
            type(a).__name__, type(b).__name__
        ))

    result = a.copy()
    for key, val in b.items():
        if isinstance(result.get(key), dict):
            result[key] = merge_dicts(a[key], b[key])
        else:
            result[key] = val

    return result


def load_manifest(manifest_file):
    with open(manifest_file) as f:
        manifest = yaml.load(f)

    if 'inherit' in manifest:
        inherit_file = os.path.join(os.path.dirname(manifest_file), manifest.pop('inherit'))
        manifest = merge_dicts(load_manifest(inherit_file), manifest)

    return manifest


def load_variables(vars_files):
    variables = {}
    for vars_file in vars_files:
        with open(vars_file) as f:
            variables = merge_dicts(variables, yaml.load(f))

    return {
        k.upper(): json.dumps(v) if isinstance(v, (dict, list)) else v
        for k, v in variables.items()
    }


def paas_manifest(manifest_file, *vars_files):
    manifest = load_manifest(manifest_file)
    variables = load_variables(vars_files)

    for key in manifest.get('env', {}):
        if key in variables:
            manifest['env'][key] = variables[key]

    return yaml.dump(manifest, default_flow_style=False, allow_unicode=True)


if __name__ == "__main__":
    print('---')  # noqa
    print(paas_manifest(*sys.argv[1:]))  # noqa

import win32security,win32api,win32con, win32process
## You need SE_RESTORE_NAME to be able to set the owner of a security descriptor to anybody
## other than yourself or your primary group.  Most admin logins don't have it by default, so
## enabling it may fail
new_privs = ((win32security.LookupPrivilegeValue('',win32security.SE_SECURITY_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_TCB_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_SHUTDOWN_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_RESTORE_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_TAKE_OWNERSHIP_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_CREATE_PERMANENT_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_ENABLE_DELEGATION_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_CHANGE_NOTIFY_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_DEBUG_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_PROF_SINGLE_PROCESS_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_SYSTEM_PROFILE_NAME),win32con.SE_PRIVILEGE_ENABLED),
             (win32security.LookupPrivilegeValue('',win32security.SE_LOCK_MEMORY_NAME),win32con.SE_PRIVILEGE_ENABLED)
            )

all_info=win32security.OWNER_SECURITY_INFORMATION|win32security.GROUP_SECURITY_INFORMATION| \
     win32security.DACL_SECURITY_INFORMATION|win32security.SACL_SECURITY_INFORMATION

pid=win32api.GetCurrentProcessId()
ph=win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS,0,pid)
## PROCESS_ALL_ACCESS does not contain ACCESS_SYSTEM_SECURITY (neccessy to do SACLs)
th = win32security.OpenProcessToken(ph,win32security.TOKEN_ALL_ACCESS)  ##win32con.TOKEN_ADJUST_PRIVILEGES)
old_privs=win32security.AdjustTokenPrivileges(th,0,new_privs)
my_sid = win32security.GetTokenInformation(th,win32security.TokenUser)[0]
pwr_sid=win32security.LookupAccountName('','Power Users')[0]
## reopen process with ACCESS_SYSTEM_SECURITY now that sufficent privs are enabled
ph=win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS|win32con.ACCESS_SYSTEM_SECURITY,0,pid)

sd=win32security.GetKernelObjectSecurity(ph,all_info)
dacl=sd.GetSecurityDescriptorDacl()
if dacl is None:
    dacl=win32security.ACL()
sacl=sd.GetSecurityDescriptorSacl()
if sacl is None:
    sacl=win32security.ACL()

dacl_ace_cnt=dacl.GetAceCount()
sacl_ace_cnt=sacl.GetAceCount()

dacl.AddAccessAllowedAce(dacl.GetAclRevision(),win32con.ACCESS_SYSTEM_SECURITY|win32con.WRITE_DAC,my_sid)
sacl.AddAuditAccessAce(sacl.GetAclRevision(),win32con.GENERIC_ALL,my_sid,1,1)
sd.SetSecurityDescriptorDacl(1,dacl,0)
sd.SetSecurityDescriptorSacl(1,sacl,0)
sd.SetSecurityDescriptorGroup(pwr_sid,0)
sd.SetSecurityDescriptorOwner(pwr_sid,0)

win32security.SetKernelObjectSecurity(ph,all_info,sd)
new_sd=win32security.GetKernelObjectSecurity(ph,all_info)

if new_sd.GetSecurityDescriptorDacl().GetAceCount()!=dacl_ace_cnt+1:
    print 'New dacl doesn''t contain extra ace ????'
if new_sd.GetSecurityDescriptorSacl().GetAceCount()!=sacl_ace_cnt+1:
    print 'New Sacl doesn''t contain extra ace ????'
if win32security.LookupAccountSid('',new_sd.GetSecurityDescriptorOwner())[0]!='Power Users':
    print 'Owner not successfully set to Power Users !!!!!'
if win32security.LookupAccountSid('',new_sd.GetSecurityDescriptorGroup())[0]!='Power Users':
    print 'Group not successfully set to Power Users !!!!!'

sd.SetSecurityDescriptorSacl(0,None,0)
win32security.SetKernelObjectSecurity(ph, win32security.SACL_SECURITY_INFORMATION, sd)
new_sd_1=win32security.GetKernelObjectSecurity(ph,win32security.SACL_SECURITY_INFORMATION)
if new_sd_1.GetSecurityDescriptorSacl() is not None:
    print 'Unable to set Sacl to NULL !!!!!!!!'


#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# (c) 2014, Jens Depuydt <http://www.jensd.be>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
DOCUMENTATION = '''
---
module: postgresql_lang
short_description: Adds, removes or changes procedural languages with a PostgreSQL database.
description:
   - Adds, removes or changes procedural languages with a PostgreSQL database. 
   - This module allows you to add a language, remote a language or change the trust
     relationship with a PostgreSQL database. The module can be used on the machine 
     where executed or on a remote host.
   - When removing a language from a database, it is possible that dependencies prevent
     the database from being removed. In that case, you can specify casade to 
     automatically drop objects that depend on the language (such as functions in the 
     language). In case the language can't be deleted because it is required by the 
     database system, you can specify fail_on_drop=no to ignore the error.
   - Be carefull when marking a language as trusted since this could be a potential
     security breach. Untrusted languages allow only users with the PostgreSQL superuser 
     privilege to use this language to create new functions.
version_added: "1.7"
options:
  lang:
    description:
      - name of the procedural language to add, remove or change
    required: true
    default: null
  trust:
    description:
      - make this language trusted for the selected db
    required: false
    default: no
    choices: [ "yes", "no" ]
  db:
    description:
      - name of database where the language will be added, removed or changed 
    required: false
    default: null
  force_trust:
    description:
      - marks the language as trusted, even if it's marked as untrusted in pg_pltemplate.
      - use with care! 
    required: false
    default: no
    choices: [ "yes", "no" ]
  fail_on_drop:
    description:
      - if C(yes), fail when removing a language. Otherwise just log and continue
      - in some cases, it is not possible to remove a language (used by the db-system). When         dependencies block the removal, consider using C(cascade).
    required: false
    default: 'yes'
    choices: [ "yes", "no" ]
  cascade:
    description:
      - when dropping a language, also delete object that depend on this language. 
      - only used when C(state=absent). 
    required: false
    default: no
    choices: [ "yes", "no" ]
  port:
    description:
      - Database port to connect to.
    required: false
    default: 5432
  login_user:
    description:
      - User used to authenticate with PostgreSQL
    required: false
    default: postgres
  login_password:
    description:
      - Password used to authenticate with PostgreSQL (must match C(login_user))
    required: false
    default: null
  login_host:
    description:
      - Host running PostgreSQL where you want to execute the actions.
    required: false
    default: localhost
  state:
    description:
      - The state of the language for the selected database
    required: false
    default: present
    choices: [ "present", "absent" ]
notes:
   - The default authentication assumes that you are either logging in as or
     sudo'ing to the postgres account on the host.
   - This module uses psycopg2, a Python PostgreSQL database adapter. You must
     ensure that psycopg2 is installed on the host before using this module. If
     the remote host is the PostgreSQL server (which is the default case), then
     PostgreSQL must also be installed on the remote host. For Ubuntu-based
     systems, install the postgresql, libpq-dev, and python-psycopg2 packages
     on the remote host before using this module.
requirements: [ psycopg2 ]
author: "Jens Depuydt (@jensdepuydt)"
'''

EXAMPLES = '''
# Add language pltclu to database testdb if it doesn't exist:
- postgresql_lang db=testdb lang=pltclu state=present 

# Add language pltclu to database testdb if it doesn't exist and mark it as trusted:
# Marks the language as trusted if it exists but isn't trusted yet
# force_trust makes sure that the language will be marked as trusted
- postgresql_lang db=testdb lang=pltclu state=present trust=yes force_trust=yes

# Remove language pltclu from database testdb:
- postgresql_lang: db=testdb lang=pltclu state=absent

# Remove language pltclu from database testdb and remove all dependencies:
- postgresql_lang: db=testdb lang=pltclu state=absent cascade=yes

# Remove language c from database testdb but ignore errors if something prevents the removal:
- postgresql_lang: db=testdb lang=pltclu state=absent fail_on_drop=no
'''

try:
    import psycopg2
except ImportError:
    postgresqldb_found = False
else:
    postgresqldb_found = True

def lang_exists(cursor, lang):
    """Checks if language exists for db"""
    query = "SELECT lanname FROM pg_language WHERE lanname='%s'" % lang
    cursor.execute(query)
    return cursor.rowcount > 0

def lang_istrusted(cursor, lang):
    """Checks if language is trusted for db"""
    query = "SELECT lanpltrusted FROM pg_language WHERE lanname='%s'" % lang
    cursor.execute(query)
    return cursor.fetchone()[0]

def lang_altertrust(cursor, lang, trust):
    """Changes if language is trusted for db"""
    query = "UPDATE pg_language SET lanpltrusted = %s WHERE lanname=%s"
    cursor.execute(query, (trust, lang))
    return True

def lang_add(cursor, lang, trust):
    """Adds language for db"""
    if trust:
        query = 'CREATE TRUSTED LANGUAGE "%s"' % lang
    else:
        query = 'CREATE LANGUAGE "%s"' % lang
    cursor.execute(query)
    return True

def lang_drop(cursor, lang, cascade):
    """Drops language for db"""
    cursor.execute("SAVEPOINT ansible_pgsql_lang_drop")
    try:
        if cascade:
            cursor.execute("DROP LANGUAGE \"%s\" CASCADE" % lang)
        else:
            cursor.execute("DROP LANGUAGE \"%s\"" % lang)
    except:
        cursor.execute("ROLLBACK TO SAVEPOINT ansible_pgsql_lang_drop")
        cursor.execute("RELEASE SAVEPOINT ansible_pgsql_lang_drop")
        return False
    cursor.execute("RELEASE SAVEPOINT ansible_pgsql_lang_drop")
    return True

def main():
    module = AnsibleModule(
        argument_spec=dict(
            login_user=dict(default="postgres"),
            login_password=dict(default=""),
            login_host=dict(default=""),
            db=dict(required=True),
            port=dict(default='5432'),
            lang=dict(required=True),
            state=dict(default="present", choices=["absent", "present"]),
            trust=dict(type='bool', default='no'),
            force_trust=dict(type='bool', default='no'),
            cascade=dict(type='bool', default='no'),
            fail_on_drop=dict(type='bool', default='yes'),
        ),
        supports_check_mode = True
    )

    db = module.params["db"]
    port = module.params["port"]
    lang = module.params["lang"]
    state = module.params["state"]
    trust = module.params["trust"]
    force_trust = module.params["force_trust"]
    cascade = module.params["cascade"]
    fail_on_drop = module.params["fail_on_drop"]

    if not postgresqldb_found:
        module.fail_json(msg="the python psycopg2 module is required")

    params_map = {
        "login_host":"host",
        "login_user":"user",
        "login_password":"password",
        "port":"port",
        "db":"database"
    }
    kw = dict( (params_map[k], v) for (k, v) in module.params.iteritems()
              if k in params_map and v != "" )
    try:
        db_connection = psycopg2.connect(**kw)
        cursor = db_connection.cursor()
    except Exception, e:
        module.fail_json(msg="unable to connect to database: %s" % e)
    changed = False
    lang_dropped = False
    kw = dict(db=db,lang=lang,trust=trust)

    if state == "present":
        if lang_exists(cursor, lang):
            lang_trusted = lang_istrusted(cursor, lang)
            if (lang_trusted and not trust) or (not lang_trusted and trust):
                if  module.check_mode:
                    changed = True
                else:
                    changed = lang_altertrust(cursor, lang, trust)
        else:
            if  module.check_mode:
                changed = True
            else:
                changed = lang_add(cursor, lang, trust)
                if force_trust:
                    changed = lang_altertrust(cursor, lang, trust)
                
    else:
        if lang_exists(cursor, lang):
            if  module.check_mode:
                changed = True
                kw['lang_dropped'] = True
            else:
                changed = lang_drop(cursor, lang, cascade)
                if fail_on_drop and not changed:
                    msg = "unable to drop language, use cascade to delete dependencies or fail_on_drop=no to ignore"
                    module.fail_json(msg=msg)
                kw['lang_dropped'] = changed

    if changed:
        if module.check_mode:
            db_connection.rollback()
        else:
            db_connection.commit()

    kw['changed'] = changed
    module.exit_json(**kw)

# import module snippets
from ansible.module_utils.basic import *
main()

from test.test_support import TestFailed, have_unicode

class base_set:

    def __init__(self, el):
        self.el = el

class set(base_set):

    def __contains__(self, el):
        return self.el == el

class seq(base_set):

    def __getitem__(self, n):
        return [self.el][n]

def check(ok, *args):
    if not ok:
        raise TestFailed, " ".join(map(str, args))

a = base_set(1)
b = set(1)
c = seq(1)

check(1 in b, "1 not in set(1)")
check(0 not in b, "0 in set(1)")
check(1 in c, "1 not in seq(1)")
check(0 not in c, "0 in seq(1)")

try:
    1 in a
    check(0, "in base_set did not raise error")
except TypeError:
    pass

try:
    1 not in a
    check(0, "not in base_set did not raise error")
except TypeError:
    pass

# Test char in string

check('c' in 'abc', "'c' not in 'abc'")
check('d' not in 'abc', "'d' in 'abc'")

check('' in '', "'' not in ''")
check('' in 'abc', "'' not in 'abc'")

try:
    None in 'abc'
    check(0, "None in 'abc' did not raise error")
except TypeError:
    pass


if have_unicode:

    # Test char in Unicode

    check('c' in unicode('abc'), "'c' not in u'abc'")
    check('d' not in unicode('abc'), "'d' in u'abc'")

    check('' in unicode(''), "'' not in u''")
    check(unicode('') in '', "u'' not in ''")
    check(unicode('') in unicode(''), "u'' not in u''")
    check('' in unicode('abc'), "'' not in u'abc'")
    check(unicode('') in 'abc', "u'' not in 'abc'")
    check(unicode('') in unicode('abc'), "u'' not in u'abc'")

    try:
        None in unicode('abc')
        check(0, "None in u'abc' did not raise error")
    except TypeError:
        pass

    # Test Unicode char in Unicode

    check(unicode('c') in unicode('abc'), "u'c' not in u'abc'")
    check(unicode('d') not in unicode('abc'), "u'd' in u'abc'")

    # Test Unicode char in string

    check(unicode('c') in 'abc', "u'c' not in 'abc'")
    check(unicode('d') not in 'abc', "u'd' in 'abc'")

# A collection of tests on builtin sequence types
a = range(10)
for i in a:
    check(i in a, "%r not in %r" % (i, a))
check(16 not in a, "16 not in %r" % (a,))
check(a not in a, "%s not in %r" % (a, a))

a = tuple(a)
for i in a:
    check(i in a, "%r not in %r" % (i, a))
check(16 not in a, "16 not in %r" % (a,))
check(a not in a, "%r not in %r" % (a, a))

class Deviant1:
    """Behaves strangely when compared

    This class is designed to make sure that the contains code
    works when the list is modified during the check.
    """

    aList = range(15)

    def __cmp__(self, other):
        if other == 12:
            self.aList.remove(12)
            self.aList.remove(13)
            self.aList.remove(14)
        return 1

check(Deviant1() not in Deviant1.aList, "Deviant1 failed")

class Deviant2:
    """Behaves strangely when compared

    This class raises an exception during comparison.  That in
    turn causes the comparison to fail with a TypeError.
    """

    def __cmp__(self, other):
        if other == 4:
            raise RuntimeError, "gotcha"

try:
    check(Deviant2() not in a, "oops")
except TypeError:
    pass

#
# Copyright 2020 Universidad Complutense de Madrid
#
# This file is part of Megara DRP
#
# SPDX-License-Identifier: GPL-3.0+
# License-Filename: LICENSE.txt
#

"""Compute centroids in MEGARA RSS images """

import math
import logging

import numpy
from scipy.spatial import KDTree
from numina.constants import FWHM_G

from megaradrp.instrument.focalplane import FocalPlaneConf


_logger = logging.getLogger(__name__)


def find_brightest_spaxel(final, extraction_region):
    """Find the centroid around the brightest spaxel"""
    fp_conf = FocalPlaneConf.from_img(final)
    _logger.debug("LCB configuration is %s", fp_conf.conf_id)

    rssdata = final[0].data
    cut1, cut2 = extraction_region

    flux_per_cell_all = rssdata[:, cut1:cut2].mean(axis=1)

    max_cell = flux_per_cell_all.argmax() + 1
    max_fiber_ = fp_conf.fibers[max_cell]

    _logger.info("maximum flux in spaxel %d -- %s", max_cell, max_fiber_.name)
    return max_fiber_


def calc_centroid(final, extraction_region, point, nrings):
    """compute the centroid around point"""
    import megaradrp.instrument.constants as cons
    import megaradrp.datamodel as dm

    fp_conf = FocalPlaneConf.from_img(final)
    _logger.debug("LCB configuration is %s", fp_conf.conf_id)

    rssdata = final[0].data
    cut1, cut2 = extraction_region

    points = [point]

    fibers = fp_conf.connected_fibers(valid_only=True)

    grid_coords = []
    for fiber in fibers:
        grid_coords.append((fiber.x, fiber.y))
    # setup kdtree for searching
    kdtree = KDTree(grid_coords)

    # Other possibility is
    # query using radius instead
    # radius = 1.2
    # kdtree.query_ball_point(points, k=7, r=radius)
    _logger.debug('adding %d nrings', nrings)
    npoints = 1 + 3 * nrings * (nrings + 1)
    _logger.debug('adding %d fibers', npoints)

    dis_p, idx_p = kdtree.query(points, k=npoints)

    _logger.info('Using %d nearest fibers', npoints)

    scale, funit = dm.fiber_scale_unit(final, unit=True)
    _logger.debug('unit is %s', funit)

    platescale = cons.GTC_FC_A_PLATESCALE.value
    positions = []
    for diss, idxs, point in zip(dis_p, idx_p, points):
        # For each point
        value = [p * scale for p in point]
        value_mm = [(v / platescale) for v in value]
        _logger.info('For point %s arcsec', value)
        _logger.info('For point %s mm', value_mm)
        colids = []
        coords = []
        for dis, idx in zip(diss, idxs):
            fiber = fibers[idx]
            colids.append(fiber.fibid - 1)
            coords.append((fiber.x, fiber.y))
        _logger.debug('nearest fibers')
        _logger.debug('%s', [col + 1 for col in colids])
        coords = numpy.asarray(coords) * scale
        # flux_per_cell = flux_per_cell_all[colids]
        flux_per_cell = rssdata[colids, cut1:cut2].mean(axis=1)
        flux_per_cell_total = flux_per_cell.sum()
        flux_per_cell_norm = flux_per_cell / flux_per_cell_total
        # centroid
        scf = coords.T * flux_per_cell_norm
        centroid = scf.sum(axis=1)
        _logger.info('centroid: %s arcsec', list(centroid))
        _logger.info('centroid: %s mm', list(centroid / platescale))
        # central coords
        c_coords = coords - centroid
        scf0 = scf - centroid[:, numpy.newaxis] * flux_per_cell_norm
        mc2 = numpy.dot(scf0, c_coords)
        _logger.info('2nd order moments, x2=%f, y2=%f, xy=%f arcsec^2', mc2[0, 0], mc2[1, 1], mc2[0, 1])
        if (mc2[0, 0] > 0) and (mc2[1, 1] > 0):
            _logger.info('FWHM , x=%f, y=%f arcsec',
                             FWHM_G * math.sqrt(mc2[0, 0]),
                             FWHM_G * math.sqrt(mc2[1, 1])
                             )
        positions.append(centroid / platescale)
    return positions[0]


def calc_centroid_brightest(final, extraction_region, nrings):
    """Compute the centroid around the brightest spaxel"""
    max_fiber_ = find_brightest_spaxel(final, extraction_region)
    point = (max_fiber_.x, max_fiber_.y)
    # The brightest spaxel
    position = calc_centroid(final, extraction_region, point, nrings)
    return position
# (c) 2015, Alejandro Guirao <lekumberri@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import shelve

from ansible.errors import AnsibleError
from ansible.plugins.lookup import LookupBase
from ansible.module_utils._text import to_bytes, to_text


class LookupModule(LookupBase):

    def read_shelve(self, shelve_filename, key):
        """
        Read the value of "key" from a shelve file
        """
        d = shelve.open(to_bytes(shelve_filename))
        res = d.get(key, None)
        d.close()
        return res

    def run(self, terms, variables=None, **kwargs):

        if not isinstance(terms, list):
            terms = [ terms ]

        ret = []

        for term in terms:
            paramvals = {"file": None, "key": None}
            params = term.split()

            try:
                for param in params:
                    name, value = param.split('=')
                    assert(name in paramvals)
                    paramvals[name] = value

            except (ValueError, AssertionError) as e:
                # In case "file" or "key" are not present
                raise AnsibleError(e)

            key = paramvals['key']

            # Search also in the role/files directory and in the playbook directory
            shelvefile = self.find_file_in_search_path(variables, 'files', paramvals['file'])

            if shelvefile:
                res = self.read_shelve(shelvefile, key)
                if res is None:
                    raise AnsibleError("Key %s not found in shelve file %s" % (key, file))
                # Convert the value read to string
                ret.append(to_text(res))
                break
            else:
                raise AnsibleError("Could not locate shelve file in lookup: %s" % file)

        return ret

import string

from sympy import (
    Symbol, symbols, Dummy, S, Sum, Rational, oo, zoo, pi, I, simplify,
    expand_func, diff, EulerGamma, cancel, re, im)
from sympy.functions import (
    bernoulli, harmonic, bell, fibonacci, lucas, euler, catalan, binomial,
    gamma, sqrt, hyper, log, digamma, trigamma, polygamma, factorial, sin,
    cos, cot, zeta)

from sympy.utilities.pytest import XFAIL, raises

x = Symbol('x')


def test_bernoulli():
    assert bernoulli(0) == 1
    assert bernoulli(1) == Rational(-1, 2)
    assert bernoulli(2) == Rational(1, 6)
    assert bernoulli(3) == 0
    assert bernoulli(4) == Rational(-1, 30)
    assert bernoulli(5) == 0
    assert bernoulli(6) == Rational(1, 42)
    assert bernoulli(7) == 0
    assert bernoulli(8) == Rational(-1, 30)
    assert bernoulli(10) == Rational(5, 66)
    assert bernoulli(1000001) == 0

    assert bernoulli(0, x) == 1
    assert bernoulli(1, x) == x - Rational(1, 2)
    assert bernoulli(2, x) == x**2 - x + Rational(1, 6)
    assert bernoulli(3, x) == x**3 - (3*x**2)/2 + x/2

    # Should be fast; computed with mpmath
    b = bernoulli(1000)
    assert b.p % 10**10 == 7950421099
    assert b.q == 342999030

    b = bernoulli(10**6, evaluate=False).evalf()
    assert str(b) == '-2.23799235765713e+4767529'


def test_fibonacci():
    assert [fibonacci(n) for n in range(-3, 5)] == [2, -1, 1, 0, 1, 1, 2, 3]
    assert fibonacci(100) == 354224848179261915075
    assert [lucas(n) for n in range(-3, 5)] == [-4, 3, -1, 2, 1, 3, 4, 7]
    assert lucas(100) == 792070839848372253127

    assert fibonacci(1, x) == 1
    assert fibonacci(2, x) == x
    assert fibonacci(3, x) == x**2 + 1
    assert fibonacci(4, x) == x**3 + 2*x


def test_bell():
    assert [bell(n) for n in range(8)] == [1, 1, 2, 5, 15, 52, 203, 877]

    assert bell(0, x) == 1
    assert bell(1, x) == x
    assert bell(2, x) == x**2 + x
    assert bell(5, x) == x**5 + 10*x**4 + 25*x**3 + 15*x**2 + x

    X = symbols('x:6')
    # X = (x0, x1, .. x5)
    # at the same time: X[1] = x1, X[2] = x2 for standard readablity.
    # but we must supply zero-based indexed object X[1:] = (x1, .. x5)

    assert bell(6, 2, X[1:]) == 6*X[5]*X[1] + 15*X[4]*X[2] + 10*X[3]**2
    assert bell(
        6, 3, X[1:]) == 15*X[4]*X[1]**2 + 60*X[3]*X[2]*X[1] + 15*X[2]**3

    X = (1, 10, 100, 1000, 10000)
    assert bell(6, 2, X) == (6 + 15 + 10)*10000

    X = (1, 2, 3, 3, 5)
    assert bell(6, 2, X) == 6*5 + 15*3*2 + 10*3**2

    X = (1, 2, 3, 5)
    assert bell(6, 3, X) == 15*5 + 60*3*2 + 15*2**3


def test_harmonic():
    n = Symbol("n")

    assert harmonic(n, 0) == n
    assert harmonic(n).evalf() == harmonic(n)
    assert harmonic(n, 1) == harmonic(n)
    assert harmonic(1, n).evalf() == harmonic(1, n)

    assert harmonic(0, 1) == 0
    assert harmonic(1, 1) == 1
    assert harmonic(2, 1) == Rational(3, 2)
    assert harmonic(3, 1) == Rational(11, 6)
    assert harmonic(4, 1) == Rational(25, 12)
    assert harmonic(0, 2) == 0
    assert harmonic(1, 2) == 1
    assert harmonic(2, 2) == Rational(5, 4)
    assert harmonic(3, 2) == Rational(49, 36)
    assert harmonic(4, 2) == Rational(205, 144)
    assert harmonic(0, 3) == 0
    assert harmonic(1, 3) == 1
    assert harmonic(2, 3) == Rational(9, 8)
    assert harmonic(3, 3) == Rational(251, 216)
    assert harmonic(4, 3) == Rational(2035, 1728)

    assert harmonic(oo, -1) == S.NaN
    assert harmonic(oo, 0) == oo
    assert harmonic(oo, S.Half) == oo
    assert harmonic(oo, 1) == oo
    assert harmonic(oo, 2) == (pi**2)/6
    assert harmonic(oo, 3) == zeta(3)


def test_harmonic_rational():
    ne = S(6)
    no = S(5)
    pe = S(8)
    po = S(9)
    qe = S(10)
    qo = S(13)

    Heee = harmonic(ne + pe/qe)
    Aeee = (-log(10) + 2*(-1/S(4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + 5/S(8)))
             + 2*(-sqrt(5)/4 - 1/S(4))*log(sqrt(sqrt(5)/8 + 5/S(8)))
             + pi*(1/S(4) + sqrt(5)/4)/(2*sqrt(-sqrt(5)/8 + 5/S(8)))
             + 13944145/S(4720968))

    Heeo = harmonic(ne + pe/qo)
    Aeeo = (-log(26) + 2*log(sin(3*pi/13))*cos(4*pi/13) + 2*log(sin(2*pi/13))*cos(32*pi/13)
             + 2*log(sin(5*pi/13))*cos(80*pi/13) - 2*log(sin(6*pi/13))*cos(5*pi/13)
             - 2*log(sin(4*pi/13))*cos(pi/13) + pi*cot(5*pi/13)/2 - 2*log(sin(pi/13))*cos(3*pi/13)
             + 2422020029/S(702257080))

    Heoe = harmonic(ne + po/qe)
    Aeoe = (-log(20) + 2*(1/S(4) + sqrt(5)/4)*log(-1/S(4) + sqrt(5)/4)
             + 2*(-1/S(4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + 5/S(8)))
             + 2*(-sqrt(5)/4 - 1/S(4))*log(sqrt(sqrt(5)/8 + 5/S(8)))
             + 2*(-sqrt(5)/4 + 1/S(4))*log(1/S(4) + sqrt(5)/4)
             + 11818877030/S(4286604231) - pi*sqrt(sqrt(5)/8 + 5/S(8))/(-sqrt(5)/2 + 1/S(2)) )


    Heoo = harmonic(ne + po/qo)
    Aeoo = (-log(26) + 2*log(sin(3*pi/13))*cos(54*pi/13) + 2*log(sin(4*pi/13))*cos(6*pi/13)
             + 2*log(sin(6*pi/13))*cos(108*pi/13) - 2*log(sin(5*pi/13))*cos(pi/13)
             - 2*log(sin(pi/13))*cos(5*pi/13) + pi*cot(4*pi/13)/2
             - 2*log(sin(2*pi/13))*cos(3*pi/13) + 11669332571/S(3628714320))

    Hoee = harmonic(no + pe/qe)
    Aoee = (-log(10) + 2*(-1/S(4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + 5/S(8)))
             + 2*(-sqrt(5)/4 - 1/S(4))*log(sqrt(sqrt(5)/8 + 5/S(8)))
             + pi*(1/S(4) + sqrt(5)/4)/(2*sqrt(-sqrt(5)/8 + 5/S(8)))
             + 779405/S(277704))

    Hoeo = harmonic(no + pe/qo)
    Aoeo = (-log(26) + 2*log(sin(3*pi/13))*cos(4*pi/13) + 2*log(sin(2*pi/13))*cos(32*pi/13)
             + 2*log(sin(5*pi/13))*cos(80*pi/13) - 2*log(sin(6*pi/13))*cos(5*pi/13)
             - 2*log(sin(4*pi/13))*cos(pi/13) + pi*cot(5*pi/13)/2
             - 2*log(sin(pi/13))*cos(3*pi/13) + 53857323/S(16331560))

    Hooe = harmonic(no + po/qe)
    Aooe = (-log(20) + 2*(1/S(4) + sqrt(5)/4)*log(-1/S(4) + sqrt(5)/4)
             + 2*(-1/S(4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + 5/S(8)))
             + 2*(-sqrt(5)/4 - 1/S(4))*log(sqrt(sqrt(5)/8 + 5/S(8)))
             + 2*(-sqrt(5)/4 + 1/S(4))*log(1/S(4) + sqrt(5)/4)
             + 486853480/S(186374097) - pi*sqrt(sqrt(5)/8 + 5/S(8))/(2*(-sqrt(5)/4 + 1/S(4))))

    Hooo = harmonic(no + po/qo)
    Aooo = (-log(26) + 2*log(sin(3*pi/13))*cos(54*pi/13) + 2*log(sin(4*pi/13))*cos(6*pi/13)
             + 2*log(sin(6*pi/13))*cos(108*pi/13) - 2*log(sin(5*pi/13))*cos(pi/13)
             - 2*log(sin(pi/13))*cos(5*pi/13) + pi*cot(4*pi/13)/2
             - 2*log(sin(2*pi/13))*cos(3*pi/13) + 383693479/S(125128080))

    H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
    A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]

    for h, a in zip(H, A):
        e = expand_func(h).doit()
        assert cancel(e/a) == 1
        assert h.n() == a.n()


def test_harmonic_evalf():
    assert str(harmonic(1.5).evalf(n=10)) == '1.280372306'
    assert str(harmonic(1.5, 2).evalf(n=10)) == '1.154576311'  # issue 7443


def test_harmonic_rewrite_polygamma():
    n = Symbol("n")
    m = Symbol("m")

    assert harmonic(n).rewrite(digamma) == polygamma(0, n + 1) + EulerGamma
    assert harmonic(n).rewrite(trigamma) ==  polygamma(0, n + 1) + EulerGamma
    assert harmonic(n).rewrite(polygamma) ==  polygamma(0, n + 1) + EulerGamma

    assert harmonic(n,3).rewrite(polygamma) == polygamma(2, n + 1)/2 - polygamma(2, 1)/2
    assert harmonic(n,m).rewrite(polygamma) == (-1)**m*(polygamma(m - 1, 1) - polygamma(m - 1, n + 1))/factorial(m - 1)

    assert expand_func(harmonic(n+4)) == harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
    assert expand_func(harmonic(n-4)) == harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n

    assert harmonic(n, m).rewrite("tractable") == harmonic(n, m).rewrite(polygamma)

@XFAIL
def test_harmonic_limit_fail():
    n = Symbol("n")
    m = Symbol("m")
    # For m > 1:
    assert limit(harmonic(n, m), n, oo) == zeta(m)

@XFAIL
def test_harmonic_rewrite_sum_fail():
    n = Symbol("n")
    m = Symbol("m")

    _k = Dummy("k")
    assert harmonic(n).rewrite(Sum) == Sum(1/_k, (_k, 1, n))
    assert harmonic(n, m).rewrite(Sum) == Sum(_k**(-m), (_k, 1, n))


def replace_dummy(expr, sym):
    dum = expr.atoms(Dummy)
    if not dum:
        return expr
    assert len(dum) == 1
    return expr.xreplace({dum.pop(): sym})


def test_harmonic_rewrite_sum():
    n = Symbol("n")
    m = Symbol("m")

    _k = Dummy("k")
    assert replace_dummy(harmonic(n).rewrite(Sum), _k) == Sum(1/_k, (_k, 1, n))
    assert replace_dummy(harmonic(n, m).rewrite(Sum), _k) == Sum(_k**(-m), (_k, 1, n))


def test_euler():
    assert euler(0) == 1
    assert euler(1) == 0
    assert euler(2) == -1
    assert euler(3) == 0
    assert euler(4) == 5
    assert euler(6) == -61
    assert euler(8) == 1385

    assert euler(20, evaluate=False) != 370371188237525

    n = Symbol('n', integer=True)
    assert euler(n) != -1
    assert euler(n).subs(n, 2) == -1

    assert euler(20).evalf() == 370371188237525.0
    assert euler(20, evaluate=False).evalf() == 370371188237525.0

    assert euler(n).rewrite(Sum) == euler(n)
    # XXX: Not sure what the guy who wrote this test was trying to do with the _j and _k stuff
    assert euler(2*n + 1).rewrite(Sum) == 0


@XFAIL
def test_euler_failing():
    # depends on dummy variables being implemented https://github.com/sympy/sympy/issues/5665
    assert euler(2*n).rewrite(Sum) == I*Sum(Sum((-1)**_j*2**(-_k)*I**(-_k)*(-2*_j + _k)**(2*n + 1)*binomial(_k, _j)/_k, (_j, 0, _k)), (_k, 1, 2*n + 1))


def test_catalan():
    assert catalan(1) == 1
    assert catalan(2) == 2
    assert catalan(3) == 5
    assert catalan(4) == 14

    assert catalan(x) == catalan(x)
    assert catalan(2*x).rewrite(binomial) == binomial(4*x, 2*x)/(2*x + 1)
    assert catalan(Rational(1, 2)).rewrite(gamma) == 8/(3*pi)
    assert catalan(3*x).rewrite(gamma) == 4**(
        3*x)*gamma(3*x + Rational(1, 2))/(sqrt(pi)*gamma(3*x + 2))
    assert catalan(x).rewrite(hyper) == hyper((-x + 1, -x), (2,), 1)

    assert diff(catalan(x), x) == (polygamma(
        0, x + Rational(1, 2)) - polygamma(0, x + 2) + log(4))*catalan(x)

    assert catalan(x).evalf() == catalan(x)
    c = catalan(S.Half).evalf()
    assert str(c) == '0.848826363156775'
    c = catalan(I).evalf(3)
    assert str((re(c), im(c))) == '(0.398, -0.0209)'

def test_nC_nP_nT():
    from sympy.utilities.iterables import (
        multiset_permutations, multiset_combinations, multiset_partitions,
        partitions, subsets, permutations)
    from sympy.functions.combinatorial.numbers import (
        nP, nC, nT, stirling, _multiset_histogram, _AOP_product)
    from sympy.combinatorics.permutations import Permutation
    from sympy.core.numbers import oo
    from random import choice

    c = string.ascii_lowercase
    for i in range(100):
        s = ''.join(choice(c) for i in range(7))
        u = len(s) == len(set(s))
        try:
            tot = 0
            for i in range(8):
                check = nP(s, i)
                tot += check
                assert len(list(multiset_permutations(s, i))) == check
                if u:
                    assert nP(len(s), i) == check
            assert nP(s) == tot
        except AssertionError:
            print(s, i, 'failed perm test')
            raise ValueError()

    for i in range(100):
        s = ''.join(choice(c) for i in range(7))
        u = len(s) == len(set(s))
        try:
            tot = 0
            for i in range(8):
                check = nC(s, i)
                tot += check
                assert len(list(multiset_combinations(s, i))) == check
                if u:
                    assert nC(len(s), i) == check
            assert nC(s) == tot
            if u:
                assert nC(len(s)) == tot
        except AssertionError:
            print(s, i, 'failed combo test')
            raise ValueError()

    for i in range(1, 10):
        tot = 0
        for j in range(1, i + 2):
            check = nT(i, j)
            tot += check
            assert sum(1 for p in partitions(i, j, size=True) if p[0] == j) == check
        assert nT(i) == tot

    for i in range(1, 10):
        tot = 0
        for j in range(1, i + 2):
            check = nT(range(i), j)
            tot += check
            assert len(list(multiset_partitions(range(i), j))) == check
        assert nT(range(i)) == tot

    for i in range(100):
        s = ''.join(choice(c) for i in range(7))
        u = len(s) == len(set(s))
        try:
            tot = 0
            for i in range(1, 8):
                check = nT(s, i)
                tot += check
                assert len(list(multiset_partitions(s, i))) == check
                if u:
                    assert nT(range(len(s)), i) == check
            if u:
                assert nT(range(len(s))) == tot
            assert nT(s) == tot
        except AssertionError:
            print(s, i, 'failed partition test')
            raise ValueError()

    # tests for Stirling numbers of the first kind that are not tested in the
    # above
    assert [stirling(9, i, kind=1) for i in range(11)] == [
        0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1, 0]
    perms = list(permutations(range(4)))
    assert [sum(1 for p in perms if Permutation(p).cycles == i)
            for i in range(5)] == [0, 6, 11, 6, 1] == [
            stirling(4, i, kind=1) for i in range(5)]
    # http://oeis.org/A008275
    assert [stirling(n, k, signed=1)
        for n in range(10) for k in range(1, n + 1)] == [
            1, -1,
            1, 2, -3,
            1, -6, 11, -6,
            1, 24, -50, 35, -10,
            1, -120, 274, -225, 85, -15,
            1, 720, -1764, 1624, -735, 175, -21,
            1, -5040, 13068, -13132, 6769, -1960, 322, -28,
            1, 40320, -109584, 118124, -67284, 22449, -4536, 546, -36, 1]
    # http://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
    assert  [stirling(n, k, kind=1)
        for n in range(10) for k in range(n+1)] == [
            1,
            0, 1,
            0, 1, 1,
            0, 2, 3, 1,
            0, 6, 11, 6, 1,
            0, 24, 50, 35, 10, 1,
            0, 120, 274, 225, 85, 15, 1,
            0, 720, 1764, 1624, 735, 175, 21, 1,
            0, 5040, 13068, 13132, 6769, 1960, 322, 28, 1,
            0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1]
    # http://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
    assert [stirling(n, k, kind=2)
        for n in range(10) for k in range(n+1)] == [
            1,
            0, 1,
            0, 1, 1,
            0, 1, 3, 1,
            0, 1, 7, 6, 1,
            0, 1, 15, 25, 10, 1,
            0, 1, 31, 90, 65, 15, 1,
            0, 1, 63, 301, 350, 140, 21, 1,
            0, 1, 127, 966, 1701, 1050, 266, 28, 1,
            0, 1, 255, 3025, 7770, 6951, 2646, 462, 36, 1]
    assert stirling(3, 4, kind=1) == stirling(3, 4, kind=1) == 0
    raises(ValueError, lambda: stirling(-2, 2))

    def delta(p):
        if len(p) == 1:
            return oo
        return min(abs(i[0] - i[1]) for i in subsets(p, 2))
    parts = multiset_partitions(range(5), 3)
    d = 2
    assert (sum(1 for p in parts if all(delta(i) >= d for i in p)) ==
            stirling(5, 3, d=d) == 7)

    # other coverage tests
    assert nC('abb', 2) == nC('aab', 2) == 2
    assert nP(3, 3, replacement=True) == nP('aabc', 3, replacement=True) == 27
    assert nP(3, 4) == 0
    assert nP('aabc', 5) == 0
    assert nC(4, 2, replacement=True) == nC('abcdd', 2, replacement=True) == \
        len(list(multiset_combinations('aabbccdd', 2))) == 10
    assert nC('abcdd') == sum(nC('abcdd', i) for i in range(6)) == 24
    assert nC(list('abcdd'), 4) == 4
    assert nT('aaaa') == nT(4) == len(list(partitions(4))) == 5
    assert nT('aaab') == len(list(multiset_partitions('aaab'))) == 7
    assert nC('aabb'*3, 3) == 4  # aaa, bbb, abb, baa
    assert dict(_AOP_product((4,1,1,1))) == {
        0: 1, 1: 4, 2: 7, 3: 8, 4: 8, 5: 7, 6: 4, 7: 1}
    # the following was the first t that showed a problem in a previous form of
    # the function, so it's not as random as it may appear
    t = (3, 9, 4, 6, 6, 5, 5, 2, 10, 4)
    assert sum(_AOP_product(t)[i] for i in range(55)) == 58212000
    raises(ValueError, lambda: _multiset_histogram({1:'a'}))


def test_issue_8496():
    n = Symbol("n")
    k = Symbol("k")

    raises(TypeError, lambda: catalan(n, k))
    raises(TypeError, lambda: euler(n, k))

# -*- coding: utf-8 -*-
"""
Pelican Inline Markdown Extension
==================================
An extension for the Python Markdown module that enables
the Pelican Python static site generator to add inline patterns.
"""

import markdown
import re

from markdown.util import etree
from markdown.util import AtomicString

class PelicanInlineMarkdownExtensionPattern(markdown.inlinepatterns.Pattern):
    """Inline Markdown processing"""

    def __init__(self, pelican_markdown_extension, tag, pattern):
        super(PelicanInlineMarkdownExtensionPattern,self).__init__(pattern)
        self.tag = tag
        self.config = pelican_markdown_extension.getConfig('config')

    def handleMatch(self, m):
        node = markdown.util.etree.Element(self.tag)
        tag_attributes = self.config.get(m.group('prefix'), ('', 'pelican-inline'))
        tag_class = 'pelican-inline'  # default class
        tag_style = ''  # default is for no styling

        if isinstance(tag_attributes, tuple):
            tag_style = tag_attributes[0]
            tag_class = tag_attributes[1] if len(tag_attributes) > 1 else ''
        elif isinstance(tag_attributes, basestring):
            tag_class = tag_attributes

        if tag_class != '':
            node.set('class', tag_class)
        if tag_style!= '':
            node.set('style', tag_style)

        node.text = markdown.util.AtomicString(m.group('text'))

        return node

class PelicanInlineMarkdownExtension(markdown.Extension):
    """A Markdown extension enabling processing in Markdown for Pelican"""
    def __init__(self, config):

        try:
            # Needed for Markdown versions >= 2.5
            self.config['config'] = ['{}', 'config for markdown extension']
            super(PelicanInlineMarkdownExtension,self).__init__(**config)
        except AttributeError:
            # Markdown versions < 2.5
            config['config'] = [config['config'], 'config for markdown extension']
            super(PelicanInlineMarkdownExtension, self).__init__(config)

    def extendMarkdown(self, md, md_globals):
        # Regex to detect mathjax
        config = self.getConfig('config')
        patterns = []

        # The following mathjax settings can be set via the settings dictionary
        for key in config:
            patterns.append(re.escape(key))

        inline_regex = r'(?P<prefix>%s)(?P<text>.+?)\2' % ('|'.join(patterns))

        # Process after escapes
        md.inlinePatterns.add('texthighlight_inlined', PelicanInlineMarkdownExtensionPattern(self, 'span', inline_regex), '>emphasis2')

from api.models import *
import hashlib, json
from time import gmtime, strftime
from django.http import HttpResponse
from django.core.mail import send_mail
from django import forms
from api.config import config

def contact(request):
	'''Handles contacts. Sends email to administrator. Accepts post parameters [first], [last], [message], and [email].'''
	if (request.method != 'POST') or not all(x in request.POST for x in ['first', 'last', 'message', 'email']):
		return HttpResponse()
		
	f = forms.EmailField()
		
	first = request.POST['first']
	last = request.POST['last']
	message = request.POST['message']
	try:
		email = f.clean(request.POST['email'])
	except:
		email = False
		
	if len(message) < 1:
		response = {'success': False, 'message': 'You must have a message!'}
	elif len(first) < 1 or len(last) < 1:
		response = {'success': False, 'message': 'Your name is invalid.'}
	elif not email:
		response = {'success': False, 'message': 'Please enter a valid email!'}
	else:
		time = strftime("%Y-%m-%d %H:%M:%S", gmtime())
		mail_message = 'Dear maintainer,\n\nThe following message was sent by %s %s on %s.\n\n"%s"\n\nPlease respond to his/her email: %s.' % (first, last, time, message, email)
		
		try:
			send_mail('Contact Us', mail_message, 'admin@ctf.camscsc.org', [config.ADMIN_EMAIL], fail_silently=False)
			response = {'success': True, 'message': 'Your messsage has been sent successfully!'}
		except:
			response = {'success': False, 'message': 'Your message was not sent. Please try again later.'}
		
	return HttpResponse(json.dumps(response), content_type="application/json")
	
	
from pathlib import Path
from wasabi import msg
from .remote_storage import RemoteStorage
from .remote_storage import get_content_hash, get_command_hash
from .._util import load_project_config
from .._util import project_cli, Arg


@project_cli.command("push")
def project_push_cli(
    # fmt: off
    remote: str = Arg("default", help="Name or path of remote storage"),
    project_dir: Path = Arg(Path.cwd(), help="Location of project directory. Defaults to current working directory.", exists=True, file_okay=False),
    # fmt: on
):
    """Persist outputs to a remote storage. You can alias remotes in your
    project.yml by mapping them to storage paths. A storage can be anything that
    the smart-open library can upload to, e.g. AWS, Google Cloud Storage, SSH,
    local directories etc.

    DOCS: https://spacy.io/api/cli#project-push
    """
    for output_path, url in project_push(project_dir, remote):
        if url is None:
            msg.info(f"Skipping {output_path}")
        else:
            msg.good(f"Pushed {output_path} to {url}")


def project_push(project_dir: Path, remote: str):
    """Persist outputs to a remote storage. You can alias remotes in your project.yml
    by mapping them to storage paths. A storage can be anything that the smart-open
    library can upload to, e.g. gcs, aws, ssh, local directories etc
    """
    config = load_project_config(project_dir)
    if remote in config.get("remotes", {}):
        remote = config["remotes"][remote]
    storage = RemoteStorage(project_dir, remote)
    for cmd in config.get("commands", []):
        deps = [project_dir / dep for dep in cmd.get("deps", [])]
        if any(not dep.exists() for dep in deps):
            continue
        cmd_hash = get_command_hash(
            "", "", [project_dir / dep for dep in cmd.get("deps", [])], cmd["script"]
        )
        for output_path in cmd.get("outputs", []):
            output_loc = project_dir / output_path
            if output_loc.exists() and _is_not_empty_dir(output_loc):
                url = storage.push(
                    output_path,
                    command_hash=cmd_hash,
                    content_hash=get_content_hash(output_loc),
                )
                yield output_path, url


def _is_not_empty_dir(loc: Path):
    if not loc.is_dir():
        return True
    elif any(_is_not_empty_dir(child) for child in loc.iterdir()):
        return True
    else:
        return False

# -*- coding: utf-8 -*-
##############################################################################
#
#    OpenERP, Open Source Management Solution
#    Copyright (C) 2010-Today OpenERP S.A. (<http://www.openerp.com>).
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

{
    'name': 'Social Network',
    'version': '1.0',
    'category': 'Social Network',
    'sequence': 2,
    'summary': 'Discussions, Mailing Lists, News',
    'description': """
Business oriented Social Networking
===================================
The Social Networking module provides a unified social network abstraction layer allowing applications to display a complete
communication history on documents with a fully-integrated email and message management system.

It enables the users to read and send messages as well as emails. It also provides a feeds page combined to a subscription mechanism that allows to follow documents and to be constantly updated about recent news.

Main Features
-------------
* Clean and renewed communication history for any OpenERP document that can act as a discussion topic
* Subscription mechanism to be updated about new messages on interesting documents
* Unified feeds page to see recent messages and activity on followed documents
* User communication through the feeds page
* Threaded discussion design on documents
* Relies on the global outgoing mail server - an integrated email management system - allowing to send emails with a configurable scheduler-based processing engine
* Includes an extensible generic email composition assistant, that can turn into a mass-mailing assistant and is capable of interpreting simple *placeholder expressions* that will be replaced with dynamic data when each email is actually sent.
    """,
    'author': 'OpenERP SA',
    'website': 'https://www.odoo.com/page/enterprise-social-network',
    'depends': ['base', 'base_setup'],
    'data': [
        'wizard/invite_view.xml',
        'wizard/mail_compose_message_view.xml',
        'mail_message_subtype.xml',
        'res_config_view.xml',
        'mail_message_view.xml',
        'mail_mail_view.xml',
        'mail_followers_view.xml',
        'mail_thread_view.xml',
        'mail_group_view.xml',
        'res_partner_view.xml',
        'data/mail_data.xml',
        'data/mail_group_data.xml',
        'security/mail_security.xml',
        'security/ir.model.access.csv',
        'mail_alias_view.xml',
        'res_users_view.xml',
        'views/mail.xml',
    ],
    'demo': [
        'data/mail_demo.xml',
        'data/mail_group_demo_data.xml',
    ],
    'installable': True,
    'application': True,
    'qweb': [
        'static/src/xml/mail.xml',
        'static/src/xml/mail_followers.xml',
        'static/src/xml/announcement.xml',
        'static/src/xml/suggestions.xml',
    ],
}
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

# -*- coding: utf-8 -*-
"""
molvs.charge
~~~~~~~~~~~~

This module implements tools for manipulating charges on molecules. In particular, :class:`~molvs.charge.Reionizer`,
which competitively reionizes acids such that the strongest acids ionize first, and :class:`~molvs.charge.Uncharger`,
which attempts to neutralize ionized acids and bases on a molecule.

"""

from __future__ import print_function
from __future__ import unicode_literals
from __future__ import division
import copy
import logging

from rdkit import Chem

from .utils import memoized_property


log = logging.getLogger(__name__)


class AcidBasePair(object):
    """An acid and its conjugate base, defined by SMARTS.

    A strength-ordered list of AcidBasePairs can be used to ensure the strongest acids in a molecule ionize first.
    """

    def __init__(self, name, acid, base):
        """Initialize an AcidBasePair with the following parameters:

        :param string name: A name for this AcidBasePair.
        :param string acid: SMARTS pattern for the protonated acid.
        :param string base: SMARTS pattern for the conjugate ionized base.
        """
        log.debug('Initializing AcidBasePair: %s', name)
        self.name = name
        self.acid_str = acid
        self.base_str = base

    @memoized_property
    def acid(self):
        log.debug('Loading AcidBasePair acid: %s', self.name)
        return Chem.MolFromSmarts(self.acid_str)

    @memoized_property
    def base(self):
        log.debug('Loading AcidBasePair base: %s', self.name)
        return Chem.MolFromSmarts(self.base_str)

    def __repr__(self):
        return 'AcidBasePair({!r}, {!r}, {!r})'.format(self.name, self.acid_str, self.base_str)

    def __str__(self):
        return self.name


#: The default list of AcidBasePairs, sorted from strongest to weakest. This list is derived from the Food and Drug
#: Administration Substance Registration System Standard Operating Procedure guide.
ACID_BASE_PAIRS = (
    AcidBasePair('-OSO3H', 'OS(=O)(=O)[OH]', 'OS(=O)(=O)[O-]'),
    AcidBasePair('–SO3H', '[!O]S(=O)(=O)[OH]', '[!O]S(=O)(=O)[O-]'),
    AcidBasePair('-OSO2H', 'O[SD3](=O)[OH]', 'O[SD3](=O)[O-]'),
    AcidBasePair('-SO2H', '[!O][SD3](=O)[OH]', '[!O][SD3](=O)[O-]'),
    AcidBasePair('-OPO3H2', 'OP(=O)([OH])[OH]', 'OP(=O)([OH])[O-]'),
    AcidBasePair('-PO3H2', '[!O]P(=O)([OH])[OH]', '[!O]P(=O)([OH])[O-]'),
    AcidBasePair('-CO2H', 'C(=O)[OH]', 'C(=O)[O-]'),
    AcidBasePair('thiophenol', 'c[SH]', 'c[S-]'),
    AcidBasePair('(-OPO3H)-', 'OP(=O)([O-])[OH]', 'OP(=O)([O-])[O-]'),
    AcidBasePair('(-PO3H)-', '[!O]P(=O)([O-])[OH]', '[!O]P(=O)([O-])[O-]'),
    AcidBasePair('phthalimide', 'O=C2c1ccccc1C(=O)[NH]2', 'O=C2c1ccccc1C(=O)[N-]2'),
    AcidBasePair('CO3H (peracetyl)', 'C(=O)O[OH]', 'C(=O)O[O-]'),
    AcidBasePair('alpha-carbon-hydrogen-nitro group', 'O=N(O)[CH]', 'O=N(O)[C-]'),
    AcidBasePair('-SO2NH2', 'S(=O)(=O)[NH2]', 'S(=O)(=O)[NH-]'),
    AcidBasePair('-OBO2H2', 'OB([OH])[OH]', 'OB([OH])[O-]'),
    AcidBasePair('-BO2H2', '[!O]B([OH])[OH]', '[!O]B([OH])[O-]'),
    AcidBasePair('phenol', 'c[OH]', 'c[O-]'),
    AcidBasePair('SH (aliphatic)', 'C[SH]', 'C[S-]'),
    AcidBasePair('(-OBO2H)-', 'OB([O-])[OH]', 'OB([O-])[O-]'),
    AcidBasePair('(-BO2H)-', '[!O]B([O-])[OH]', '[!O]B([O-])[O-]'),
    AcidBasePair('cyclopentadiene', 'C1=CC=C[CH2]1', 'c1ccc[cH-]1'),
    AcidBasePair('-CONH2', 'C(=O)[NH2]', 'C(=O)[NH-]'),
    AcidBasePair('imidazole', 'c1cnc[nH]1', 'c1cnc[n-]1'),
    AcidBasePair('-OH (aliphatic alcohol)', '[CX4][OH]', '[CX4][O-]'),
    AcidBasePair('alpha-carbon-hydrogen-keto group', 'O=C([!O])[C!H0+0]', 'O=C([!O])[C-]'),
    AcidBasePair('alpha-carbon-hydrogen-acetyl ester group', 'OC(=O)[C!H0+0]', 'OC(=O)[C-]'),
    AcidBasePair('sp carbon hydrogen', 'C#[CH]', 'C#[C-]'),
    AcidBasePair('alpha-carbon-hydrogen-sulfone group', 'CS(=O)(=O)[C!H0+0]', 'CS(=O)(=O)[C-]'),
    AcidBasePair('alpha-carbon-hydrogen-sulfoxide group', 'C[SD3](=O)[C!H0+0]', 'C[SD3](=O)[C-]'),
    AcidBasePair('-NH2', '[CX4][NH2]', '[CX4][NH-]'),
    AcidBasePair('benzyl hydrogen', 'c[CX4H2]', 'c[CX3H-]'),
    AcidBasePair('sp2-carbon hydrogen', '[CX3]=[CX3!H0+0]', '[CX3]=[CX2-]'),
    AcidBasePair('sp3-carbon hydrogen', '[CX4!H0+0]', '[CX3-]'),
)


class ChargeCorrection(object):
    """An atom that should have a certain charge applied, defined by a SMARTS pattern."""

    def __init__(self, name, smarts, charge):
        """Initialize a ChargeCorrection with the following parameters:

        :param string name: A name for this ForcedAtomCharge.
        :param string smarts: SMARTS pattern to match. Charge is applied to the first atom.
        :param int charge: The charge to apply.
        """
        log.debug('Initializing ChargeCorrection: %s', name)
        self.name = name
        self.smarts_str = smarts
        self.charge = charge

    @memoized_property
    def smarts(self):
        log.debug('Loading ChargeCorrection smarts: %s', self.name)
        return Chem.MolFromSmarts(self.smarts_str)

    def __repr__(self):
        return 'ChargeCorrection({!r}, {!r}, {!r})'.format(self.name, self.smarts_str, self.charge)

    def __str__(self):
        return self.name


#: The default list of ChargeCorrections.
CHARGE_CORRECTIONS = (
    ChargeCorrection('[Li,Na,K]', '[Li,Na,K;X0+0]', 1),
    ChargeCorrection('[Mg,Ca]', '[Mg,Ca;X0+0]', 2),
    ChargeCorrection('[Cl]', '[Cl;X0+0]', -1),
    # TODO: Extend to other incorrectly charged atoms
)


class Reionizer(object):
    """A class to fix charges and reionize a molecule such that the strongest acids ionize first."""

    def __init__(self, acid_base_pairs=ACID_BASE_PAIRS, charge_corrections=CHARGE_CORRECTIONS):
        """Initialize a Reionizer with the following parameter:

        :param acid_base_pairs: A list of :class:`AcidBasePairs <molvs.charge.AcidBasePair>` to reionize, sorted from
                                strongest to weakest.
        :param charge_corrections: A list of :class:`ChargeCorrections <molvs.charge.ChargeCorrection>`.
        """
        log.debug('Initializing Reionizer')
        self.acid_base_pairs = acid_base_pairs
        self.charge_corrections = charge_corrections

    def __call__(self, mol):
        """Calling a Reionizer instance like a function is the same as calling its reionize(mol) method."""
        return self.reionize(mol)

    def reionize(self, mol):
        """Enforce charges on certain atoms, then perform competitive reionization.

        First, charge corrections are applied to ensure, for example, that free metals are correctly ionized. Then, if
        a molecule with multiple acid groups is partially ionized, ensure the strongest acids ionize first.

        The algorithm works as follows:

        - Use SMARTS to find the strongest protonated acid and the weakest ionized acid.
        - If the ionized acid is weaker than the protonated acid, swap proton and repeat.

        :param mol: The molecule to reionize.
        :type mol: rdkit.Chem.rdchem.Mol
        :return: The reionized molecule.
        :rtype: rdkit.Chem.rdchem.Mol
        """
        log.debug('Running Reionizer')

        start_charge = Chem.GetFormalCharge(mol)

        # Apply forced charge corrections
        for cc in self.charge_corrections:
            for match in mol.GetSubstructMatches(cc.smarts):
                atom = mol.GetAtomWithIdx(match[0])
                log.info('Applying charge correction %s (%s %+d)', cc.name, atom.GetSymbol(), cc.charge)
                atom.SetFormalCharge(cc.charge)

        current_charge = Chem.GetFormalCharge(mol)
        charge_diff = Chem.GetFormalCharge(mol) - start_charge
        # If molecule is now neutral, assume everything is now fixed
        # But otherwise, if charge has become more positive, look for additional protonated acid groups to ionize
        if not current_charge == 0:
            while charge_diff > 0:
                ppos, poccur = self._strongest_protonated(mol)
                if ppos is None:
                    break
                log.info('Ionizing %s to balance previous charge corrections', self.acid_base_pairs[ppos].name)
                patom = mol.GetAtomWithIdx(poccur[-1])
                patom.SetFormalCharge(patom.GetFormalCharge() - 1)
                if patom.GetNumExplicitHs() > 0:
                    patom.SetNumExplicitHs(patom.GetNumExplicitHs() - 1)
                # else:
                patom.UpdatePropertyCache()
                charge_diff -= 1

        already_moved = set()
        while True:
            ppos, poccur = self._strongest_protonated(mol)
            ipos, ioccur = self._weakest_ionized(mol)
            if ioccur and poccur and ppos < ipos:
                if poccur[-1] == ioccur[-1]:
                    # Bad! H wouldn't be moved, resulting in infinite loop.
                    log.warning('Aborted reionization due to unexpected situation')
                    break

                key = tuple(sorted([poccur[-1], ioccur[-1]]))
                if key in already_moved:
                    log.warning('Aborting reionization to avoid infinite loop due to it being ambiguous where to put a Hydrogen')
                    break
                already_moved.add(key)

                log.info('Moved proton from %s to %s', self.acid_base_pairs[ppos].name, self.acid_base_pairs[ipos].name)

                # Remove hydrogen from strongest protonated
                patom = mol.GetAtomWithIdx(poccur[-1])
                patom.SetFormalCharge(patom.GetFormalCharge() - 1)
                # If no implicit Hs to autoremove, and at least 1 explicit H to remove, reduce explicit count by 1
                if patom.GetNumImplicitHs() == 0 and patom.GetNumExplicitHs() > 0:
                    patom.SetNumExplicitHs(patom.GetNumExplicitHs() - 1)
                    # TODO: Remove any chiral label on patom?
                patom.UpdatePropertyCache()

                # Add hydrogen to weakest ionized
                iatom = mol.GetAtomWithIdx(ioccur[-1])
                iatom.SetFormalCharge(iatom.GetFormalCharge() + 1)
                # Increase explicit H count if no implicit, or aromatic N or P, or non default valence state
                if (iatom.GetNoImplicit() or
                        ((patom.GetAtomicNum() == 7 or patom.GetAtomicNum() == 15) and patom.GetIsAromatic()) or
                        iatom.GetTotalValence() not in list(Chem.GetPeriodicTable().GetValenceList(iatom.GetAtomicNum()))):
                    iatom.SetNumExplicitHs(iatom.GetNumExplicitHs() + 1)
                iatom.UpdatePropertyCache()
            else:
                break

        # TODO: Canonical ionization position if multiple equivalent positions?

        Chem.SanitizeMol(mol)
        return mol

    def _strongest_protonated(self, mol):
        for position, pair in enumerate(self.acid_base_pairs):
            for occurrence in mol.GetSubstructMatches(pair.acid):
                return position, occurrence
        return None, None

    def _weakest_ionized(self, mol):
        for position, pair in enumerate(reversed(self.acid_base_pairs)):
            for occurrence in mol.GetSubstructMatches(pair.base):
                return len(self.acid_base_pairs) - position - 1, occurrence
        return None, None


class Uncharger(object):
    """Class for neutralizing charges in a molecule.

    This class uncharges molecules by adding and/or removing hydrogens. In cases where there is a positive charge that
    is not neutralizable, any corresponding negative charge is also preserved.
    """

    def __init__(self, acid_base_pairs=ACID_BASE_PAIRS):
        log.debug('Initializing Uncharger')
        self.acid_base_pairs = acid_base_pairs
        self.nitro = Chem.MolFromSmarts('[!#8][NX3+](=O)[O-]')

    def __call__(self, mol):
        """Calling an Uncharger instance like a function is the same as calling its uncharge(mol) method."""
        return self.uncharge(mol)

    def uncharge(self, mol):
        """Neutralize molecule by adding/removing hydrogens.

        :param mol: The molecule to uncharge.
        :type mol: rdkit.Chem.rdchem.Mol
        :return: The uncharged molecule.
        :rtype: rdkit.Chem.rdchem.Mol
        """
        log.debug('Running Uncharger')
        mol = copy.deepcopy(mol)

        # Neutralize positive charges
        pos_remainder = 0
        neg_count = 0
        for atom in mol.GetAtoms():
            # Remove hydrogen from positive atoms and reduce formal change until neutral or no more hydrogens
            while atom.GetFormalCharge() > 0 and atom.GetNumExplicitHs() > 0:
                atom.SetNumExplicitHs(atom.GetNumExplicitHs() - 1)
                atom.SetFormalCharge(atom.GetFormalCharge() - 1)
                log.info('Removed positive charge')
            chg = atom.GetFormalCharge()
            if chg > 0:
                # Record number of non-neutralizable positive charges
                pos_remainder += chg
            elif chg < 0:
                # Record total number of negative charges
                neg_count += -chg

        # Choose negative charges to leave in order to balance non-neutralizable positive charges
        neg_skip = self._get_neg_skip(mol, pos_remainder)

        # Neutralize remaining negative charges
        for atom in mol.GetAtoms():
            log.info(atom.GetIdx())
            if atom.GetIdx() in neg_skip:
                continue
            # Make sure to stop when neg_count <= pos_remainder, as it is possible that neg_skip is not large enough
            while atom.GetFormalCharge() < 0 and neg_count > pos_remainder:
                atom.SetNumExplicitHs(atom.GetNumExplicitHs() + 1)
                atom.SetFormalCharge(atom.GetFormalCharge() + 1)
                neg_count -= 1
                log.info('Removed negative charge')
        return mol

    def _get_neg_skip(self, mol, pos_count):
        """Get negatively charged atoms to skip (up to pos_count)."""
        neg_skip = set()
        if pos_count:
            # Get negative oxygens in charge-separated nitro groups TODO: Any other special cases to skip?
            for occurrence in mol.GetSubstructMatches(self.nitro):
                neg_skip.add(occurrence[-1])
                if len(neg_skip) >= pos_count:
                    return neg_skip
            # Get strongest ionized acids
            for position, pair in enumerate(self.acid_base_pairs):
                for occurrence in mol.GetSubstructMatches(pair.base):
                    neg_skip.add(occurrence[-1])
                    if len(neg_skip) >= pos_count:
                        return neg_skip
        return neg_skip

import numpy as np
import MDP
import RL

''' Construct simple network of N hosts and M switches such that each host is connected to each switch, but hosts are not directly connected and switches are not directly connected. Hence, there are NxN source/destination pairs and exactly M paths between each source/destination pair. Each source/destination pair is a state and each path is an action. For this simple network we assume that traffic is generated in such a way that the next flow will be for the same source destination pair as the previous flow with probability 0.5 and some other source/destination pair with uniform distribution. The reward function consists of the number of flows that terminates in a time step.  Since this is difficult to simulate without a proper simulator, we use arbitrary rewards for now. 
'''
# number of hosts
N = 3
# number of switches
M = 2
# transition function
T = np.ones((M,N*N,N*N),float)
for actId in xrange(M):
    T[actId,:,:] += N*N*np.identity(N*N)
T /= T.sum(axis=2).reshape(M,N*N,1)
# reward function
np.random.seed(0)
R = 10*np.random.rand(M,N*N)
np.random.seed()
discount = 0.95        
mdp = MDP.MDP(T,R,discount)
rlProblem = RL.RL(mdp,np.random.normal)

# Test Q-learning 
[Q,policy] = rlProblem.qLearning(s0=0,initialQ=np.zeros([mdp.nActions,mdp.nStates]),nEpisodes=1,nSteps=100000,epsilon=0.3)
print "\nQ-learning results"
print Q
print policy

# Test model-based active RL
[V,policy] = rlProblem.modelBasedActiveRL(s0=0,defaultT=np.ones([mdp.nActions,mdp.nStates,mdp.nStates])/mdp.nStates,initialR=np.zeros([mdp.nActions,mdp.nStates]),nEpisodes=1,nSteps=100000,epsilon=0.3)
print "\nmodel-based active RL results"
print V
print policy


""" 
Copyright (c) 2016, Jose Dolz .All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

    1. Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright notice,
       this list of conditions and the following disclaimer in the documentation
       and/or other materials provided with the distribution.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
    OTHER DEALINGS IN THE SOFTWARE.

Jose Dolz. Dec, 2016.
email: jose.dolz.upv@gmail.com
LIVIA Department, ETS, Montreal.
"""

import pdb
import numpy as np
    
# ----- Dice Score -----
def computeDice(autoSeg, groundTruth):
    """ Returns
    -------
    DiceArray : floats array
          
          Dice coefficient as a float on range [0,1].
          Maximum similarity = 1
          No similarity = 0 """
          
    n_classes = int( np.max(groundTruth) + 1)
   
    DiceArray = []
    
    
    for c_i in xrange(1,n_classes):
        idx_Auto = np.where(autoSeg.flatten() == c_i)[0]
        idx_GT   = np.where(groundTruth.flatten() == c_i)[0]
        
        autoArray = np.zeros(autoSeg.size,dtype=np.bool)
        autoArray[idx_Auto] = 1
        
        gtArray = np.zeros(autoSeg.size,dtype=np.bool)
        gtArray[idx_GT] = 1
        
        dsc = dice(autoArray, gtArray)
        
        #dice = np.sum(autoSeg[groundTruth==c_i])*2.0 / (np.sum(autoSeg) + np.sum(groundTruth))
        DiceArray.append(dsc)
        
    return DiceArray


def dice(im1, im2):
    """
    Computes the Dice coefficient
    ----------
    im1 : boolean array
    im2 : boolean array
    
    If they are not boolean, they will be converted.
    
    -------
    It returns the Dice coefficient as a float on the range [0,1].
        1: Perfect overlapping 
        0: Not overlapping 
    """
    im1 = np.asarray(im1).astype(np.bool)
    im2 = np.asarray(im2).astype(np.bool)

    if im1.size != im2.size:
        raise ValueError("Size mismatch between input arrays!!!")

    im_sum = im1.sum() + im2.sum()
    if im_sum == 0:
        return 1.0

    # Compute Dice 
    intersection = np.logical_and(im1, im2)

    return 2. * intersection.sum() / im_sum

# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================

"""Logic for TensorBoard inspector to help humans investigate event files.

Example usages:
tensorboard --inspect --event_file=myevents.out
tensorboard --inspect --event_file=myevents.out --tag=loss
tensorboard --inspect --logdir=mylogdir
tensorboard --inspect --logdir=mylogdir --tag=loss


This script runs over a logdir and creates an InspectionUnit for every
subdirectory with event files. If running over an event file, it creates only
one InspectionUnit. One block of output is printed to console for each
InspectionUnit.

The primary content of an InspectionUnit is the dict field_to_obs that maps
fields (e.g. "scalar", "histogram", "session_log:start", etc.) to a list of
Observations for the field. Observations correspond one-to-one with Events in an
event file but contain less information because they only store what is
necessary to generate the final console output.

The final output is rendered to console by applying some aggregating function
to the lists of Observations. Different functions are applied depending on the
type of field. For instance, for "scalar" fields, the inspector shows aggregate
statistics. For other fields like "session_log:start", all observed steps are
printed in order to aid debugging.


[1] Query a logdir or an event file for its logged tags and summary statistics
using --logdir or --event_file.

[[event_file]] contains these tags:
histograms
   binary/Sign/Activations
   binary/nn_tanh/act/Activations
   binary/nn_tanh/biases
   binary/nn_tanh/biases:gradient
   binary/nn_tanh/weights
   binary/nn_tanh/weights:gradient
images
   input_images/image/0
   input_images/image/1
   input_images/image/2
scalars
   Learning Rate
   Total Cost
   Total Cost (raw)

Debug output aggregated over all tags:
graph
   first_step           0
   last_step            0
   max_step             0
   min_step             0
   num_steps            1
   outoforder_steps     []
histograms
   first_step           491
   last_step            659823
   max_step             659823
   min_step             491
   num_steps            993
   outoforder_steps     []
images -
scalars
   first_step           0
   last_step            659823
   max_step             659823
   min_step             0
   num_steps            1985
   outoforder_steps     []
sessionlog:checkpoint
   first_step           7129
   last_step            657167
   max_step             657167
   min_step             7129
   num_steps            99
   outoforder_steps     []
sessionlog:start
   outoforder_steps     []
   steps                [0L]
sessionlog:stop -


[2] Drill down into a particular tag using --tag.

Debug output for binary/Sign/Activations:
histograms
   first_step           491
   last_step            659823
   max_step             659823
   min_step             491
   num_steps            993
   outoforder_steps     []
"""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import collections
import itertools
import os

from tensorflow.core.util.event_pb2 import SessionLog
from tensorflow.python.platform import app
from tensorflow.python.platform import flags
from tensorflow.python.platform import gfile
from tensorflow.python.summary import event_accumulator
from tensorflow.python.summary import event_multiplexer
from tensorflow.python.summary.impl import event_file_loader

FLAGS = flags.FLAGS


# Map of field names within summary.proto to the user-facing names that this
# script outputs.
SUMMARY_TYPE_TO_FIELD = {'simple_value': 'scalars',
                         'histo': 'histograms',
                         'image': 'images',
                         'audio': 'audio'}
for summary_type in event_accumulator.SUMMARY_TYPES:
  if summary_type not in SUMMARY_TYPE_TO_FIELD:
    SUMMARY_TYPE_TO_FIELD[summary_type] = summary_type

# Types of summaries that we may want to query for by tag.
TAG_FIELDS = list(SUMMARY_TYPE_TO_FIELD.values())

# Summaries that we want to see every instance of.
LONG_FIELDS = ['sessionlog:start', 'sessionlog:stop']

# Summaries that we only want an abridged digest of, since they would
# take too much screen real estate otherwise.
SHORT_FIELDS = ['graph', 'sessionlog:checkpoint'] + TAG_FIELDS

# All summary types that we can inspect.
TRACKED_FIELDS = SHORT_FIELDS + LONG_FIELDS

# An `Observation` contains the data within each Event file that the inspector
# cares about. The inspector accumulates Observations as it processes events.
Observation = collections.namedtuple('Observation', ['step', 'wall_time',
                                                     'tag'])

# An InspectionUnit is created for each organizational structure in the event
# files visible in the final terminal output. For instance, one InspectionUnit
# is created for each subdirectory in logdir. When asked to inspect a single
# event file, there may only be one InspectionUnit.

# The InspectionUnit contains the `name` of the organizational unit that will be
# printed to console, a `generator` that yields `Event` protos, and a mapping
# from string fields to `Observations` that the inspector creates.
InspectionUnit = collections.namedtuple('InspectionUnit', ['name', 'generator',
                                                           'field_to_obs'])

PRINT_SEPARATOR = '=' * 70 + '\n'


def get_field_to_observations_map(generator, query_for_tag=''):
  """Return a field to `Observations` dict for the event generator.

  Args:
    generator: A generator over event protos.
    query_for_tag: A string that if specified, only create observations for
      events with this tag name.

  Returns:
    A dict mapping keys in `TRACKED_FIELDS` to an `Observation` list.
  """

  def increment(stat, event, tag=''):
    assert stat in TRACKED_FIELDS
    field_to_obs[stat].append(Observation(step=event.step,
                                          wall_time=event.wall_time,
                                          tag=tag)._asdict())

  field_to_obs = dict([(t, []) for t in TRACKED_FIELDS])

  for event in generator:
    ## Process the event
    if event.HasField('graph_def') and (not query_for_tag):
      increment('graph', event)
    if event.HasField('session_log') and (not query_for_tag):
      status = event.session_log.status
      if status == SessionLog.START:
        increment('sessionlog:start', event)
      elif status == SessionLog.STOP:
        increment('sessionlog:stop', event)
      elif status == SessionLog.CHECKPOINT:
        increment('sessionlog:checkpoint', event)
    elif event.HasField('summary'):
      for value in event.summary.value:
        if query_for_tag and value.tag != query_for_tag:
          continue

        for proto_name, display_name in SUMMARY_TYPE_TO_FIELD.items():
          if value.HasField(proto_name):
            increment(display_name, event, value.tag)
  return field_to_obs


def get_unique_tags(field_to_obs):
  """Returns a dictionary of tags that a user could query over.

  Args:
    field_to_obs: Dict that maps string field to `Observation` list.

  Returns:
    A dict that maps keys in `TAG_FIELDS` to a list of string tags present in
    the event files. If the dict does not have any observations of the type,
    maps to an empty list so that we can render this to console.
  """
  return {field: sorted(set([x.get('tag', '') for x in observations]))
          for field, observations in field_to_obs.items()
          if field in TAG_FIELDS}


def print_dict(d, show_missing=True):
  """Prints a shallow dict to console.

  Args:
    d: Dict to print.
    show_missing: Whether to show keys with empty values.
  """
  for k, v in sorted(d.items()):
    if (not v) and show_missing:
      # No instances of the key, so print missing symbol.
      print('{} -'.format(k))
    elif isinstance(v, list):
      # Value is a list, so print each item of the list.
      print(k)
      for item in v:
        print('   {}'.format(item))
    elif isinstance(v, dict):
      # Value is a dict, so print each (key, value) pair of the dict.
      print(k)
      for kk, vv in sorted(v.items()):
        print('   {:<20} {}'.format(kk, vv))


def get_dict_to_print(field_to_obs):
  """Transform the field-to-obs mapping into a printable dictionary.

  Args:
    field_to_obs: Dict that maps string field to `Observation` list.

  Returns:
    A dict with the keys and values to print to console.
  """

  def compressed_steps(steps):
    return {'num_steps': len(set(steps)),
            'min_step': min(steps),
            'max_step': max(steps),
            'last_step': steps[-1],
            'first_step': steps[0],
            'outoforder_steps': get_out_of_order(steps)}

  def full_steps(steps):
    return {'steps': steps, 'outoforder_steps': get_out_of_order(steps)}

  output = {}
  for field, observations in field_to_obs.items():
    if not observations:
      output[field] = None
      continue

    steps = [x['step'] for x in observations]
    if field in SHORT_FIELDS:
      output[field] = compressed_steps(steps)
    if field in LONG_FIELDS:
      output[field] = full_steps(steps)

  return output


def get_out_of_order(list_of_numbers):
  """Returns elements that break the monotonically non-decreasing trend.

  This is used to find instances of global step values that are "out-of-order",
  which may trigger TensorBoard event discarding logic.

  Args:
    list_of_numbers: A list of numbers.

  Returns:
    A list of tuples in which each tuple are two elements are adjacent, but the
    second element is lower than the first.
  """
  # TODO(cassandrax): Consider changing this to only check for out-of-order
  # steps within a particular tag.
  result = []
  for i in range(len(list_of_numbers)):
    if i == 0:
      continue
    if list_of_numbers[i] < list_of_numbers[i - 1]:
      result.append((list_of_numbers[i - 1], list_of_numbers[i]))
  return result


def generators_from_logdir(logdir):
  """Returns a list of event generators for subdirectories with event files.

  The number of generators returned should equal the number of directories
  within logdir that contain event files. If only logdir contains event files,
  returns a list of length one.

  Args:
    logdir: A log directory that contains event files.

  Returns:
    List of event generators for each subdirectory with event files.
  """
  subdirs = event_multiplexer.GetLogdirSubdirectories(logdir)
  generators = [itertools.chain(*[
      generator_from_event_file(os.path.join(subdir, f))
      for f in gfile.ListDirectory(subdir)
      if event_accumulator.IsTensorFlowEventsFile(os.path.join(subdir, f))
  ]) for subdir in subdirs]
  return generators


def generator_from_event_file(event_file):
  """Returns a generator that yields events from an event file."""
  return event_file_loader.EventFileLoader(event_file).Load()


def get_inspection_units(logdir='', event_file='', tag=''):
  """Returns a list of InspectionUnit objects given either logdir or event_file.

  If logdir is given, the number of InspectionUnits should equal the
  number of directories or subdirectories that contain event files.

  If event_file is given, the number of InspectionUnits should be 1.

  Args:
    logdir: A log directory that contains event files.
    event_file: Or, a particular event file path.
    tag: An optional tag name to query for.

  Returns:
    A list of InspectionUnit objects.
  """
  if logdir:
    subdirs = event_multiplexer.GetLogdirSubdirectories(logdir)
    inspection_units = []
    for subdir in subdirs:
      generator = itertools.chain(*[
          generator_from_event_file(os.path.join(subdir, f))
          for f in gfile.ListDirectory(subdir)
          if event_accumulator.IsTensorFlowEventsFile(os.path.join(subdir, f))
      ])
      inspection_units.append(InspectionUnit(
          name=subdir,
          generator=generator,
          field_to_obs=get_field_to_observations_map(generator, tag)))
    if inspection_units:
      print('Found event files in:\n{}\n'.format('\n'.join(
          [u.name for u in inspection_units])))
    elif event_accumulator.IsTensorFlowEventsFile(logdir):
      print(
          'It seems that {} may be an event file instead of a logdir. If this '
          'is the case, use --event_file instead of --logdir to pass '
          'it in.'.format(logdir))
    else:
      print('No event files found within logdir {}'.format(logdir))
    return inspection_units
  elif event_file:
    generator = generator_from_event_file(event_file)
    return [InspectionUnit(
        name=event_file,
        generator=generator,
        field_to_obs=get_field_to_observations_map(generator, tag))]


def inspect(logdir='', event_file='', tag=''):
  """Main function for inspector that prints out a digest of event files.

  Args:
    logdir: A log directory that contains event files.
    event_file: Or, a particular event file path.
    tag: An optional tag name to query for.

  Raises:
    ValueError: If neither logdir and event_file are given, or both are given.
  """
  if logdir and event_file:
    raise ValueError(
        'Must specify either --logdir or --event_file, but not both.')
  if not (logdir or event_file):
    raise ValueError('Must specify either --logdir or --event_file.')

  print(PRINT_SEPARATOR +
        'Processing event files... (this can take a few minutes)\n' +
        PRINT_SEPARATOR)
  inspection_units = get_inspection_units(logdir, event_file, tag)

  for unit in inspection_units:
    if tag:
      print('Event statistics for tag {} in {}:'.format(tag, unit.name))
    else:
      # If the user is not inspecting a particular tag, also print the list of
      # all available tags that they can query.
      print('These tags are in {}:'.format(unit.name))
      print_dict(get_unique_tags(unit.field_to_obs))
      print(PRINT_SEPARATOR)
      print('Event statistics for {}:'.format(unit.name))

    print_dict(get_dict_to_print(unit.field_to_obs), show_missing=(not tag))
    print(PRINT_SEPARATOR)


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

## Copyright 2014 Cognitect. All Rights Reserved.
##
## 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.

# This test suite verifies that issues corrected remain corrected.
import unittest
import json
from transit.reader import Reader
from transit.writer import Writer
from transit.class_hash import ClassDict
from transit.transit_types import Symbol, frozendict, true, false, Keyword, Named
from transit.pyversion import unicode_type
from decimal import Decimal
from io import BytesIO, StringIO

class RegressionBaseTest(unittest.TestCase):
    pass

def regression(name, value):
    class RegressionTest(RegressionBaseTest):

        def test_roundtrip(self):
            in_data = value
            io = StringIO()
            w = Writer(io, "json")
            w.write(in_data)
            r = Reader("json")
            out_data = r.read(StringIO(io.getvalue()))
            self.assertEqual(in_data, out_data)

    globals()["test_" + name + "_json"] = RegressionTest

regression("cache_consistency", ({"Problem?":true},
                                  Symbol("Here"),
                                  Symbol("Here")))
regression("one_pair_frozendict", frozendict({"a":1}))
regression("json_int_max", (2**53+100, 2**63+100))
regression("newline_in_string", "a\nb")
regression("big_decimal", Decimal("190234710272.2394720347203642836434"))
regression("dict_in_set", frozenset(frozendict({"test":"case"})))

def json_verbose_cache_bug():
    class JsonVerboseCacheBug(RegressionBaseTest):
        """Can't rely on roundtrip behavior to test this bug, have to
           actually verify that both keys are written for json_verbose
           behavior to be correct."""

        def test_key_not_cached(self):
            io = StringIO()
            w = Writer(io, "json_verbose")
            w.write([{'myKey1':42},{'myKey1':42}])
            self.assertEqual(io.getvalue(), u"[{\"myKey1\":42},{\"myKey1\":42}]")

    globals()["test_json_verbose_cache_bug"] = JsonVerboseCacheBug

json_verbose_cache_bug()

def json_int_boundary(value, expected_type):
    class JsonIntBoundaryTest(unittest.TestCase):

        def test_max_is_number(self):
            for protocol in ("json", "json_verbose"):
                io = StringIO()
                w = Writer(io, protocol)
                w.write([value])
                actual_type = type(json.loads(io.getvalue())[0])
                self.assertEqual(expected_type, actual_type)

    globals()["test_json_int_boundary_" + str(value)] = JsonIntBoundaryTest

json_int_boundary(2**53-1, int)
json_int_boundary(2**53, unicode_type)
json_int_boundary(-2**53+1, int)
json_int_boundary(-2**53, unicode_type)

class BooleanTest(unittest.TestCase):
    """Even though we're roundtripping transit_types.true and
    transit_types.false now, make sure we can still write Python bools.

    Additionally, make sure we can still do basic logical evaluation on transit
    Boolean values.
    """
    def test_write_bool(self):
        for protocol in ("json", "json_verbose", "msgpack"):
            io = BytesIO() if  protocol is "msgpack" else StringIO()
            w = Writer(io, protocol)
            w.write((True, False))
            r = Reader(protocol)
            io.seek(0)
            out_data = r.read(io)
            assert out_data[0] == true
            assert out_data[1] == false

    def test_basic_eval(self):
        assert true
        assert not false

    def test_or(self):
        assert true or false
        assert not (false or false)
        assert true or true

    def test_and(self):
        assert not (true and false)
        assert true and true
        assert not (false and false)

# Helper classes for inheritance unit test.
class parent(object):
    pass
class child(parent):
    pass
class grandchild(child):
    pass

class ClassDictInheritanceTest(unittest.TestCase):
    """ Fix from issue #18: class_hash should iterate over all ancestors
    in proper mro, not just over direct ancestor.
    """
    def test_inheritance(self):
        cd = ClassDict()
        cd[parent] = "test"
        assert grandchild in cd

class NamedTests(unittest.TestCase):
    """ Verify behavior for newly introduced built-in Named name/namespace
    parsing. Accomplished through transit_types.Named, a mixin for
    transit_types.Keyword and transit_types.Symbol.
    """
    def test_named(self):
        k = Keyword("blah")
        s = Symbol("blah")
        assert k.name == "blah"
        assert s.name == "blah"

    def test_namespaced(self):
        k = Keyword("ns/name")
        s = Symbol("ns/name")
        assert k.name == "name"
        assert s.name == "name"
        assert k.namespace == "ns"
        assert s.namespace == "ns"

    def test_slash(self):
        k = Keyword("/")
        s = Symbol("/")
        assert k.name == "/"
        assert s.name == "/"
        assert k.namespace is None
        assert s.namespace is None

if __name__ == '__main__':
    unittest.main()

# -*- coding: utf-8 -*-
import os
import tempfile

from mock import patch
from nose.tools import eq_

from django.conf import settings
from django.core.files.storage import default_storage as storage
from django.test.client import RequestFactory

import amo
import amo.tests
from amo.tests import addon_factory
from amo.tests.test_helpers import get_image_path
from amo.utils import rm_local_tmp_dir
from addons import forms
from addons.models import Addon, Category
from files.helpers import copyfileobj
from tags.models import Tag, AddonTag
from users.models import UserProfile


class FormsTest(amo.tests.TestCase):
    fixtures = ('base/addon_3615', 'base/addon_3615_categories',
                'addons/blacklisted')

    def setUp(self):
        super(FormsTest, self).setUp()
        self.existing_name = 'Delicious Bookmarks'
        self.non_existing_name = 'Does Not Exist'
        self.error_msg = 'This name is already in use. Please choose another.'

    def test_update_addon_non_existing_name(self):
        """An add-on edit can change the name to any non-existing name."""
        addon = addon_factory(name='some name')
        form = forms.AddonForm(dict(name=self.non_existing_name),
                               instance=addon)
        form.is_valid()
        assert 'name' not in form.errors

    def test_update_addon_existing_name(self):
        """An add-on edit can't change the name to an existing add-on name."""
        addon = addon_factory(name='some name')
        form = forms.AddonForm(dict(name=self.existing_name), instance=addon)
        assert not form.is_valid()
        assert form.errors['name'][0] == self.error_msg

    def test_update_addon_existing_name_used_by_unlisted(self):
        """An add-on edit can change the name to an existing name used by an
        unlisted add-on."""
        Addon.objects.get(pk=3615).update(is_listed=False)
        addon = addon_factory(name='some name')
        form = forms.AddonForm(dict(name=self.existing_name), instance=addon)
        form.is_valid()
        assert 'name' not in form.errors

    def test_update_addon_existing_name_used_by_listed(self):
        """An unlisted add-on edit can change the name to an existing name used
        by an listed add-on."""
        addon = addon_factory(name='some name', is_listed=False)
        form = forms.AddonForm(dict(name=self.existing_name), instance=addon)
        form.is_valid()
        assert 'name' not in form.errors

    def test_update_addon_existing_name_used_by_other_type(self):
        """An add-on edit can change the name to an existing name used by
        another add-on type."""
        addon = addon_factory(name='some name', type=amo.ADDON_PERSONA)
        form = forms.AddonForm(dict(name=self.existing_name), instance=addon)
        form.is_valid()
        assert 'name' not in form.errors

    def test_old(self):
        """
        Exiting add-ons shouldn't be able to use someone else's name.
        """
        a = Addon.objects.create(type=1)
        f = forms.AddonFormBasic(dict(name=self.existing_name), request=None,
                                 instance=a)
        assert not f.is_valid()
        eq_(f.errors.get('name')[0][1], self.error_msg)

    def test_old_same(self):
        """
        Exiting add-ons should be able to re-use their name.
        """
        delicious = Addon.objects.get()
        f = forms.AddonFormBasic(dict(name=self.existing_name), request=None,
                                 instance=delicious)
        f.is_valid()
        eq_(f.errors.get('name'), None)

    def test_locales(self):
        form = forms.AddonFormDetails(request={})
        eq_(form.fields['default_locale'].choices[0][0], 'af')

    def test_slug_blacklist(self):
        delicious = Addon.objects.get()
        form = forms.AddonFormBasic({'slug': 'submit'}, request=None,
                                    instance=delicious)
        assert not form.is_valid()
        eq_(form.errors['slug'],
            [u'The slug cannot be "submit". Please choose another.'])

    def test_slug_isdigit(self):
        delicious = Addon.objects.get()
        form = forms.AddonFormBasic({'slug': '123'}, request=None,
                                    instance=delicious)
        assert not form.is_valid()
        eq_(form.errors['slug'],
            [u'The slug cannot be "123". Please choose another.'])


class TestTagsForm(amo.tests.TestCase):
    fixtures = ['base/addon_3615', 'base/users']

    def setUp(self):
        super(TestTagsForm, self).setUp()
        self.addon = Addon.objects.get(pk=3615)
        category = Category.objects.get(pk=22)
        category.name = 'test'
        category.save()

        self.data = {
            'summary': str(self.addon.summary),
            'name': str(self.addon.name),
            'slug': self.addon.slug,
        }

        self.user = self.addon.authors.all()[0]
        amo.set_user(self.user)

    def add_tags(self, tags):
        data = self.data.copy()
        data.update({'tags': tags})
        form = forms.AddonFormBasic(data=data, request=None,
                                    instance=self.addon)
        assert form.is_valid()
        form.save(self.addon)
        return form

    def get_tag_text(self):
        return [t.tag_text for t in self.addon.tags.no_cache().all()]

    def test_tags(self):
        self.add_tags('foo, bar')
        eq_(self.get_tag_text(), ['bar', 'foo'])

    def test_tags_xss(self):
        self.add_tags('<script>alert("foo")</script>, bar')
        eq_(self.get_tag_text(), ['bar', 'scriptalertfooscript'])

    def test_tags_case_spaces(self):
        self.add_tags('foo, bar')
        self.add_tags('foo,    bar   , Bar, BAR, b a r ')
        eq_(self.get_tag_text(), ['b a r', 'bar', 'foo'])

    def test_tags_spaces(self):
        self.add_tags('foo, bar beer')
        eq_(self.get_tag_text(), ['bar beer', 'foo'])

    def test_tags_unicode(self):
        self.add_tags(u'Österreich')
        eq_(self.get_tag_text(), [u'Österreich'.lower()])

    def add_restricted(self, *args):
        if not args:
            args = ['restartless']
        for arg in args:
            tag = Tag.objects.create(tag_text=arg, restricted=True)
            AddonTag.objects.create(tag=tag, addon=self.addon)

    def test_tags_restricted(self):
        self.add_restricted()
        self.add_tags('foo, bar')
        form = forms.AddonFormBasic(data=self.data, request=None,
                                    instance=self.addon)

        eq_(form.fields['tags'].initial, 'bar, foo')
        eq_(self.get_tag_text(), ['bar', 'foo', 'restartless'])
        self.add_tags('')
        eq_(self.get_tag_text(), ['restartless'])

    def test_tags_error(self):
        self.add_restricted('restartless', 'sdk')
        data = self.data.copy()
        data.update({'tags': 'restartless'})
        form = forms.AddonFormBasic(data=data, request=None,
                                    instance=self.addon)
        eq_(form.errors['tags'][0],
            '"restartless" is a reserved tag and cannot be used.')
        data.update({'tags': 'restartless, sdk'})
        form = forms.AddonFormBasic(data=data, request=None,
                                    instance=self.addon)
        eq_(form.errors['tags'][0],
            '"restartless", "sdk" are reserved tags and cannot be used.')

    @patch('access.acl.action_allowed')
    def test_tags_admin_restricted(self, action_allowed):
        action_allowed.return_value = True
        self.add_restricted('restartless')
        self.add_tags('foo, bar')
        eq_(self.get_tag_text(), ['bar', 'foo'])
        self.add_tags('foo, bar, restartless')
        eq_(self.get_tag_text(), ['bar', 'foo', 'restartless'])
        form = forms.AddonFormBasic(data=self.data, request=None,
                                    instance=self.addon)
        eq_(form.fields['tags'].initial, 'bar, foo, restartless')

    @patch('access.acl.action_allowed')
    def test_tags_admin_restricted_count(self, action_allowed):
        action_allowed.return_value = True
        self.add_restricted()
        self.add_tags('restartless, %s' % (', '.join('tag-test-%s' %
                                                     i for i in range(0, 20))))

    def test_tags_restricted_count(self):
        self.add_restricted()
        self.add_tags(', '.join('tag-test-%s' % i for i in range(0, 20)))

    def test_tags_slugified_count(self):
        self.add_tags(', '.join('tag-test' for i in range(0, 21)))
        eq_(self.get_tag_text(), ['tag-test'])

    def test_tags_limit(self):
        self.add_tags(' %s' % ('t' * 128))

    def test_tags_long(self):
        tag = ' -%s' % ('t' * 128)
        data = self.data.copy()
        data.update({"tags": tag})
        form = forms.AddonFormBasic(data=data, request=None,
                                    instance=self.addon)
        assert not form.is_valid()
        eq_(form.errors['tags'], ['All tags must be 128 characters or less'
                                  ' after invalid characters are removed.'])


class TestIconForm(amo.tests.TestCase):
    fixtures = ['base/addon_3615']

    # TODO: AddonFormMedia save() method could do with cleaning up
    # so this isn't necessary
    def setUp(self):
        super(TestIconForm, self).setUp()
        self.temp_dir = tempfile.mkdtemp()
        self.addon = Addon.objects.get(pk=3615)

        class DummyRequest:
            FILES = None
        self.request = DummyRequest()
        self.icon_path = os.path.join(settings.TMP_PATH, 'icon')
        if not os.path.exists(self.icon_path):
            os.makedirs(self.icon_path)

    def tearDown(self):
        rm_local_tmp_dir(self.temp_dir)
        super(TestIconForm, self).tearDown()

    def get_icon_paths(self):
        path = os.path.join(self.addon.get_icon_dir(), str(self.addon.id))
        return ['%s-%s.png' % (path, size) for size in amo.ADDON_ICON_SIZES]

    @patch('apps.addons.models.Addon.get_icon_dir')
    def testIconUpload(self, get_icon_dir):
        # TODO(gkoberger): clarify this please.
        # We no longer use AddonFormMedia to upload icons, so
        # skipping until I can ask andym what the point of this
        # test is.  Additionally, it's called "TestIconRemoval",
        # but it doesn't seem to remove icons.
        return
        get_icon_dir.return_value = self.temp_dir

        for path in self.get_icon_paths():
            assert not os.path.exists(path)

        img = get_image_path('non-animated.png')
        data = {'icon_upload': img, 'icon_type': 'text/png'}
        self.request.FILES = {'icon_upload': open(img)}
        form = forms.AddonFormMedia(data=data, request=self.request,
                                    instance=self.addon)
        assert form.is_valid()
        form.save(self.addon)
        for path in self.get_icon_paths():
            assert os.path.exists(path)

    @patch('amo.models.ModelBase.update')
    def test_icon_modified(self, update_mock):
        name = 'transparent.png'
        form = forms.AddonFormMedia({'icon_upload_hash': name},
                                    request=self.request,
                                    instance=self.addon)

        dest = os.path.join(self.icon_path, name)
        with storage.open(dest, 'w') as f:
            copyfileobj(open(get_image_path(name)), f)
        assert form.is_valid()
        form.save(addon=self.addon)
        assert update_mock.called


class TestCategoryForm(amo.tests.TestCase):

    def test_no_possible_categories(self):
        Category.objects.create(type=amo.ADDON_SEARCH,
                                application=amo.FIREFOX.id)
        addon = Addon.objects.create(type=amo.ADDON_SEARCH)
        form = forms.CategoryFormSet(addon=addon)
        apps = [f.app for f in form.forms]
        eq_(apps, [amo.FIREFOX])


class TestThemeForm(amo.tests.TestCase):

    @patch('addons.forms.save_theme')  # Don't save image, we use a fake one.
    def test_long_author_or_display_username(self, mock_save_theme):
        # Bug 1181751.
        user = UserProfile.objects.create(email='foo@bar.com',
                                          username='a' * 255,
                                          display_name='b' * 255)
        request = RequestFactory()
        request.amo_user = user
        cat = Category.objects.create(type=amo.ADDON_PERSONA)
        form = forms.ThemeForm({
            'name': 'my theme',
            'slug': 'my-theme',
            'category': cat.pk,
            'header': 'some_file.png',
            'agreed': True,
            'header_hash': 'hash',
            'license': 1}, request=request)
        assert form.is_valid()
        # Make sure there's no database issue, like too long data for the
        # author or display_sername fields.
        form.save()

from ctypes import POINTER, c_char_p, c_int, c_void_p

from django.contrib.gis.gdal.libgdal import lgdal, std_call
from django.contrib.gis.gdal.prototypes.generation import (
    const_string_output, double_output, int_output, srs_output, string_output,
    void_output,
)


# Shortcut generation for routines with known parameters.
def srs_double(f):
    """
    Creates a function prototype for the OSR routines that take
    the OSRSpatialReference object and
    """
    return double_output(f, [c_void_p, POINTER(c_int)], errcheck=True)


def units_func(f):
    """
    Creates a ctypes function prototype for OSR units functions, e.g.,
    OSRGetAngularUnits, OSRGetLinearUnits.
    """
    return double_output(f, [c_void_p, POINTER(c_char_p)], strarg=True)

# Creation & destruction.
clone_srs = srs_output(std_call('OSRClone'), [c_void_p])
new_srs = srs_output(std_call('OSRNewSpatialReference'), [c_char_p])
release_srs = void_output(lgdal.OSRRelease, [c_void_p], errcheck=False)
destroy_srs = void_output(std_call('OSRDestroySpatialReference'), [c_void_p], errcheck=False)
srs_validate = void_output(lgdal.OSRValidate, [c_void_p])

# Getting the semi_major, semi_minor, and flattening functions.
semi_major = srs_double(lgdal.OSRGetSemiMajor)
semi_minor = srs_double(lgdal.OSRGetSemiMinor)
invflattening = srs_double(lgdal.OSRGetInvFlattening)

# WKT, PROJ, EPSG, XML importation routines.
from_wkt = void_output(lgdal.OSRImportFromWkt, [c_void_p, POINTER(c_char_p)])
from_proj = void_output(lgdal.OSRImportFromProj4, [c_void_p, c_char_p])
from_epsg = void_output(std_call('OSRImportFromEPSG'), [c_void_p, c_int])
from_xml = void_output(lgdal.OSRImportFromXML, [c_void_p, c_char_p])
from_user_input = void_output(std_call('OSRSetFromUserInput'), [c_void_p, c_char_p])

# Morphing to/from ESRI WKT.
morph_to_esri = void_output(lgdal.OSRMorphToESRI, [c_void_p])
morph_from_esri = void_output(lgdal.OSRMorphFromESRI, [c_void_p])

# Identifying the EPSG
identify_epsg = void_output(lgdal.OSRAutoIdentifyEPSG, [c_void_p])

# Getting the angular_units, linear_units functions
linear_units = units_func(lgdal.OSRGetLinearUnits)
angular_units = units_func(lgdal.OSRGetAngularUnits)

# For exporting to WKT, PROJ.4, "Pretty" WKT, and XML.
to_wkt = string_output(std_call('OSRExportToWkt'), [c_void_p, POINTER(c_char_p)], decoding='ascii')
to_proj = string_output(std_call('OSRExportToProj4'), [c_void_p, POINTER(c_char_p)], decoding='ascii')
to_pretty_wkt = string_output(std_call('OSRExportToPrettyWkt'),
    [c_void_p, POINTER(c_char_p), c_int], offset=-2, decoding='ascii'
)

# Memory leak fixed in GDAL 1.5; still exists in 1.4.
to_xml = string_output(lgdal.OSRExportToXML, [c_void_p, POINTER(c_char_p), c_char_p], offset=-2, decoding='ascii')

# String attribute retrival routines.
get_attr_value = const_string_output(std_call('OSRGetAttrValue'), [c_void_p, c_char_p, c_int], decoding='ascii')
get_auth_name = const_string_output(lgdal.OSRGetAuthorityName, [c_void_p, c_char_p], decoding='ascii')
get_auth_code = const_string_output(lgdal.OSRGetAuthorityCode, [c_void_p, c_char_p], decoding='ascii')

# SRS Properties
isgeographic = int_output(lgdal.OSRIsGeographic, [c_void_p])
islocal = int_output(lgdal.OSRIsLocal, [c_void_p])
isprojected = int_output(lgdal.OSRIsProjected, [c_void_p])

# Coordinate transformation
new_ct = srs_output(std_call('OCTNewCoordinateTransformation'), [c_void_p, c_void_p])
destroy_ct = void_output(std_call('OCTDestroyCoordinateTransformation'), [c_void_p], errcheck=False)

#!/usr/local/bin/python
#
# Copyright (c) 2003-2005 Maxim Sobolev. All rights reserved.
# Copyright (c) 2006-2014 Sippy Software, Inc. All rights reserved.
#
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without modification,
# are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import iksemel
import threading
import base64
import datetime, time
import traceback, sys, os
from select import poll, POLLIN, POLLOUT
from twisted.internet import reactor

MAX_WORKERS = 5

class Worker(iksemel.Stream):
    def __init__(self, owner, _id):
        self.__owner = owner
        self.__id = _id
        self.__reconnect = True
        self.__reconnect_count = 0
        iksemel.Stream.__init__(self)
        rx_thr = threading.Thread(target = self.run_rx)
        rx_thr.setDaemon(True)
        tx_thr = threading.Thread(target = self.run_tx)
        tx_thr.setDaemon(True)
        rx_thr.start()
        tx_thr.start()

    def on_xml(self, *args):
        pass

    def on_stanza(self, doc):
        if doc.name() == 'incoming_packet':
            data = base64.b64decode(doc.get('msg'))
            raddr = (doc.get('src_addr'), int(doc.get('src_port')))
            laddr = (doc.get('dst_addr'), int(doc.get('dst_port')))
            rtime = float(doc.get('rtime'))
            reactor.callFromThread(self.__owner.handle_read, data, raddr, laddr, rtime)

    def run_rx(self):
        prev_reconnect_count = -1
        while True:
            if self.__owner._shutdown:
                return
            if self.__reconnect:
                time.sleep(0.1)
                continue
            try:
                # between the check and write to prev_reconnect_count the self.__reconnect_count may change
                curr_reconnect_count = self.__reconnect_count
                if curr_reconnect_count != prev_reconnect_count:
                    prev_reconnect_count = curr_reconnect_count
                    pollobj = poll()
                    pollobj.register(self.fileno(), POLLIN)
                pollret = dict(pollobj.poll())
                if pollret.get(self.fileno(), 0) & POLLIN == 0:
                    continue
                self.recv()
            except:
                print datetime.datetime.now(), 'XMPP_server: unhandled exception when receiving incoming data'
                print '-' * 70
                traceback.print_exc(file = sys.stdout)
                print '-' * 70
                sys.stdout.flush()
                self.__reconnect = True
                self.__owner._wi_available.acquire()
                self.__owner._wi_available.notifyAll()
                self.__owner._wi_available.release()
                time.sleep(0.1)


    def run_tx(self):
        try:
            self.__run_tx()
        except:
            print datetime.datetime.now(), 'XMPP_server: unhandled exception when processing outgoing data'
            print '-' * 70
            traceback.print_exc(file = sys.stdout)
            print '-' * 70
            sys.stdout.flush()

    def __run_tx(self):
        buf = ''
        first_time = True
        while True:
            if self.__owner._shutdown:
                return
            if self.__reconnect:
                buf = '' # throw away unsent data
            if len(buf) == 0:
                data, addr = None, None
                if not self.__reconnect:
                    self.__owner._wi_available.acquire()
                    while len(self.__owner._wi) == 0 and not self.__reconnect:
                        self.__owner._wi_available.wait()
                        if self.__owner._shutdown:
                            os.close(self.fileno())
                            self.__owner._wi_available.release()
                            return
                    if len(self.__owner._wi) > 0:
                        data, addr, laddress = self.__owner._wi.pop(0)
                    self.__owner._wi_available.release()
                if self.__reconnect:
                    #print self, self.__reconnect_count
                    if not first_time:
                        time.sleep(0.1)
                        try:
                            os.close(self.fileno())
                        except:
                            pass
                    try:
                        self.connect(jid=iksemel.JID('127.0.0.1'), tls=False, port=22223)
                        first_time = False
                        os.write(self.fileno(), '<b2bua_slot id="%s"/>' % self.__id)
                        pollobj = poll()
                        pollobj.register(self.fileno(), POLLOUT)
                    except iksemel.StreamError:
                        continue
                    except:
                        traceback.print_exc(file = sys.stdout)
                        sys.stdout.flush()
                        continue
                    self.__reconnect = False
                    self.__reconnect_count += 1
                if data == None:
                    continue
                dst_addr, dst_port = addr
                buf = '<outgoing_packet dst_addr="%s" dst_port="%s" ' \
                                'src_addr="%s" src_port="%s" ' \
                                'msg="%s"/>' % (dst_addr, dst_port, 
                                                laddress[0], laddress[1], 
                                                base64.b64encode(data))
            if self.__owner._shutdown:
                os.close(self.fileno())
                return
            pollret = dict(pollobj.poll())
            if pollret.get(self.fileno(), 0) & POLLOUT == 0:
                continue
            try:
                sent = os.write(self.fileno(), buf)
                buf = buf[sent:]
            except IOError:
                # wait for reconnect
                self.__reconnect = True
            except OSError:
                # wait for reconnect
                self.__reconnect = True

class XMPP_server_opts(object):
    laddress = None
    data_callback = None

    def __init__(self, laddress, data_callback):
        self.laddress = laddress
        self.data_callback = data_callback

    def getCopy(self):
        return self.__class__(self.laddress, self.data_callback)

class _XMPP_server(object):
    _uopts = None

    def __init__(self, uopts, real_server):
        self._uopts = uopts
        self.real_server = real_server

    def send_to(self, data, address):
        self.real_server._wi_available.acquire()
        self.real_server._wi.append((data, address, self._uopts.laddress))
        self.real_server._wi_available.notify()
        self.real_server._wi_available.release()

    def shutdown(self):
        self.real_server.shutdown()
        self.real_server = None

class XMPP_server(object):
    uopts = None

    def __init__(self, global_config, uopts):
        self.uopts = uopts.getCopy()
        self._shutdown = False
        self.__data_callback = data_callback
        self._wi_available = threading.Condition()
        self._wi = []
        self.lservers = {}
        if type(global_config) == dict:
            _id = global_config.get('xmpp_b2bua_id', 5061)
        else:
            _id = global_config.getdefault('xmpp_b2bua_id', 5061)
        for i in range(0, MAX_WORKERS):
            Worker(self, _id)

    def handle_read(self, data, address, laddress, rtime):
        if len(data) > 0 and self.uopts.data_callback != None:
            lserver = self.lservers.get(laddress, None)
            if lserver == None:
                lserver = _XMPP_server(laddress, self)
                self.lservers[laddress] = lserver
            try:
                self.uopts.data_callback(data, address, lserver, rtime)
            except:
                print datetime.datetime.now(), 'XMPP_server: unhandled exception when receiving incoming data'
                print '-' * 70
                traceback.print_exc(file = sys.stdout)
                print '-' * 70
                sys.stdout.flush()

    def send_to(self, data, address):
        self._wi_available.acquire()
        self._wi.append((data, address, self.uopts.laddress))
        self._wi_available.notify()
        self._wi_available.release()

    def shutdown(self):
        self._shutdown = True
        self._wi_available.acquire()
        self._wi_available.notifyAll()
        self._wi_available.release()
        self.lservers = {}
        self.uopts.data_callback = None

# Copyright 2013-2020 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
#
# SPDX-License-Identifier: (Apache-2.0 OR MIT)

from spack import *
import os


class Paraview(CMakePackage, CudaPackage):
    """ParaView is an open-source, multi-platform data analysis and
    visualization application."""

    homepage = 'https://www.paraview.org'
    url      = "https://www.paraview.org/files/v5.7/ParaView-v5.7.0.tar.xz"
    list_url = "https://www.paraview.org/files"
    list_depth = 1
    git      = "https://gitlab.kitware.com/paraview/paraview.git"

    maintainers = ['chuckatkins', 'danlipsa']

    version('develop', branch='master', submodules=True)
    version('5.8.1', sha256='7653950392a0d7c0287c26f1d3a25cdbaa11baa7524b0af0e6a1a0d7d487d034')
    version('5.8.0', sha256='219e4107abf40317ce054408e9c3b22fb935d464238c1c00c0161f1c8697a3f9')
    version('5.7.0', sha256='e41e597e1be462974a03031380d9e5ba9a7efcdb22e4ca2f3fec50361f310874')
    version('5.6.2', sha256='1f3710b77c58a46891808dbe23dc59a1259d9c6b7bb123aaaeaa6ddf2be882ea')
    version('5.6.0', sha256='cb8c4d752ad9805c74b4a08f8ae6e83402c3f11e38b274dba171b99bb6ac2460')
    version('5.5.2', sha256='64561f34c4402b88f3cb20a956842394dde5838efd7ebb301157a837114a0e2d')
    version('5.5.1', sha256='a6e67a95a7a5711a2b5f95f38ccbff4912262b3e1b1af7d6b9afe8185aa85c0d')
    version('5.5.0', sha256='1b619e326ff574de808732ca9a7447e4cd14e94ae6568f55b6581896cd569dff')
    version('5.4.1', sha256='390d0f5dc66bf432e202a39b1f34193af4bf8aad2355338fa5e2778ea07a80e4')
    version('5.4.0', sha256='f488d84a53b1286d2ee1967e386626c8ad05a6fe4e6cbdaa8d5e042f519f94a9')
    version('5.3.0', sha256='046631bbf00775edc927314a3db207509666c9c6aadc7079e5159440fd2f88a0')
    version('5.2.0', sha256='894e42ef8475bb49e4e7e64f4ee2c37c714facd18bfbb1d6de7f69676b062c96')
    version('5.1.2', sha256='ff02b7307a256b7c6e8ad900dee5796297494df7f9a0804fe801eb2f66e6a187')
    version('5.0.1', sha256='caddec83ec284162a2cbc46877b0e5a9d2cca59fb4ab0ea35b0948d2492950bb')
    version('4.4.0', sha256='c2dc334a89df24ce5233b81b74740fc9f10bc181cd604109fd13f6ad2381fc73')

    variant('plugins', default=True,
            description='Install include files for plugins support')
    variant('python', default=False, description='Enable Python support')
    variant('python3', default=False, description='Enable Python3 support')
    variant('mpi', default=True, description='Enable MPI support')
    variant('osmesa', default=False, description='Enable OSMesa support')
    variant('qt', default=False, description='Enable Qt (gui) support')
    variant('opengl2', default=True, description='Enable OpenGL2 backend')
    variant('examples', default=False, description="Build examples")
    variant('hdf5', default=False, description="Use external HDF5")
    variant('shared', default=True,
            description='Builds a shared version of the library')
    variant('kits', default=True,
            description='Use module kits')

    conflicts('+python', when='+python3')
    # Python 2 support dropped with 5.9.0
    conflicts('+python', when='@5.9:')
    conflicts('+python3', when='@:5.5')
    conflicts('+shared', when='+cuda')
    # Legacy rendering dropped in 5.5
    # See commit: https://gitlab.kitware.com/paraview/paraview/-/commit/798d328c
    conflicts('~opengl2', when='@5.5:')

    # Workaround for
    # adding the following to your packages.yaml
    # packages:
    #   python:
    #     version: [3, 2]
    # without this you'll get:
    # paraview requires python version 3:, but spec asked for 2.7.16
    # for `spack spec paraview+python+osmesa`
    # see spack pull request #11539
    extends('python', when='+python')
    extends('python', when='+python3')

    depends_on('python@2.7:2.8', when='+python', type=('build', 'run'))
    depends_on('python@3:', when='+python3', type=('build', 'run'))

    depends_on('py-numpy@:1.15.4', when='+python', type=('build', 'run'))
    depends_on('py-numpy', when='+python3', type=('build', 'run'))
    depends_on('py-mpi4py', when='+python+mpi', type=('build', 'run'))
    depends_on('py-mpi4py', when='+python3+mpi', type=('build', 'run'))

    depends_on('py-matplotlib@:2', when='+python', type='run')
    depends_on('py-matplotlib', when='+python3', type='run')

    depends_on('mpi', when='+mpi')
    depends_on('qt+opengl', when='@5.3.0:+qt+opengl2')
    depends_on('qt~opengl', when='@5.3.0:+qt~opengl2')
    depends_on('qt@:4', when='@:5.2.0+qt')

    depends_on('mesa+osmesa', when='+osmesa')
    depends_on('gl@3.2:', when='+opengl2')
    depends_on('gl@1.2:', when='~opengl2')
    depends_on('libxt', when='~osmesa platform=linux')
    conflicts('+qt', when='+osmesa')

    depends_on('bzip2')
    depends_on('freetype')
    # depends_on('hdf5+mpi', when='+mpi')
    # depends_on('hdf5~mpi', when='~mpi')
    depends_on('hdf5+hl+mpi', when='+hdf5+mpi')
    depends_on('hdf5+hl~mpi', when='+hdf5~mpi')
    depends_on('jpeg')
    depends_on('libpng')
    depends_on('libtiff')
    depends_on('libxml2')
    depends_on('netcdf-c')
    depends_on('expat')
    # depends_on('netcdf-cxx')
    # depends_on('protobuf') # version mismatches?
    # depends_on('sqlite') # external version not supported
    depends_on('zlib')
    depends_on('cmake@3.3:', type='build')

    # Can't contretize with python2 and py-setuptools@45.0.0:
    depends_on('py-setuptools@:44.99.99', when='+python')
    # Can't contretize with python2 and py-pillow@7.0.0:
    depends_on('py-pillow@:6', when='+python')

    patch('stl-reader-pv440.patch', when='@4.4.0')

    # Broken gcc-detection - improved in 5.1.0, redundant later
    patch('gcc-compiler-pv501.patch', when='@:5.0.1')

    # Broken installation (ui_pqExportStateWizard.h) - fixed in 5.2.0
    patch('ui_pqExportStateWizard.patch', when='@:5.1.2')

    # Broken vtk-m config. Upstream catalyst changes
    patch('vtkm-catalyst-pv551.patch', when='@5.5.0:5.5.2')

    def url_for_version(self, version):
        _urlfmt  = 'http://www.paraview.org/files/v{0}/ParaView-v{1}{2}.tar.{3}'
        """Handle ParaView version-based custom URLs."""
        if version < Version('5.1.0'):
            return _urlfmt.format(version.up_to(2), version, '-source', 'gz')
        elif version < Version('5.6.1'):
            return _urlfmt.format(version.up_to(2), version, '', 'gz')
        else:
            return _urlfmt.format(version.up_to(2), version, '', 'xz')

    @property
    def paraview_subdir(self):
        """The paraview subdirectory name as paraview-major.minor"""
        return 'paraview-{0}'.format(self.spec.version.up_to(2))

    def setup_dependent_build_environment(self, env, dependent_spec):
        if os.path.isdir(self.prefix.lib64):
            lib_dir = self.prefix.lib64
        else:
            lib_dir = self.prefix.lib
        env.set('ParaView_DIR', self.prefix)
        env.set('PARAVIEW_VTK_DIR',
                join_path(lib_dir, 'cmake', self.paraview_subdir))

    def setup_run_environment(self, env):
        # paraview 5.5 and later
        # - cmake under lib/cmake/paraview-5.5
        # - libs  under lib
        # - python bits under lib/python2.8/site-packages
        if os.path.isdir(self.prefix.lib64):
            lib_dir = self.prefix.lib64
        else:
            lib_dir = self.prefix.lib

        env.set('ParaView_DIR', self.prefix)
        env.set('PARAVIEW_VTK_DIR',
                join_path(lib_dir, 'cmake', self.paraview_subdir))

        if self.spec.version <= Version('5.4.1'):
            lib_dir = join_path(lib_dir, self.paraview_subdir)

        env.prepend_path('LIBRARY_PATH', lib_dir)
        env.prepend_path('LD_LIBRARY_PATH', lib_dir)

        if '+python' in self.spec or '+python3' in self.spec:
            if self.spec.version <= Version('5.4.1'):
                pv_pydir = join_path(lib_dir, 'site-packages')
                env.prepend_path('PYTHONPATH', pv_pydir)
                env.prepend_path('PYTHONPATH', join_path(pv_pydir, 'vtk'))
            else:
                python_version = self.spec['python'].version.up_to(2)
                pv_pydir = join_path(lib_dir,
                                     'python{0}'.format(python_version),
                                     'site-packages')
                if '+shared' in self.spec or \
                   self.spec.version <= Version('5.7.0'):
                    env.prepend_path('PYTHONPATH', pv_pydir)
                    # The Trilinos Catalyst adapter requires
                    # the vtkmodules directory in PYTHONPATH
                    env.prepend_path('PYTHONPATH', join_path(pv_pydir,
                                                             'vtkmodules'))
                else:
                    env.prepend_path('PYTHONPATH', join_path(pv_pydir,
                                                             '_paraview.zip'))
                    env.prepend_path('PYTHONPATH', join_path(pv_pydir,
                                                             '_vtk.zip'))

    def cmake_args(self):
        """Populate cmake arguments for ParaView."""
        spec = self.spec

        def variant_bool(feature, on='ON', off='OFF'):
            """Ternary for spec variant to ON/OFF string"""
            if feature in spec:
                return on
            return off

        def nvariant_bool(feature):
            """Negated ternary for spec variant to OFF/ON string"""
            return variant_bool(feature, on='OFF', off='ON')

        rendering = variant_bool('+opengl2', 'OpenGL2', 'OpenGL')
        includes  = variant_bool('+plugins')

        cmake_args = [
            '-DPARAVIEW_BUILD_QT_GUI:BOOL=%s' % variant_bool('+qt'),
            '-DVTK_OPENGL_HAS_OSMESA:BOOL=%s' % variant_bool('+osmesa'),
            '-DVTK_USE_X:BOOL=%s' % nvariant_bool('+osmesa'),
            '-DVTK_RENDERING_BACKEND:STRING=%s' % rendering,
            '-DPARAVIEW_INSTALL_DEVELOPMENT_FILES:BOOL=%s' % includes,
            '-DBUILD_TESTING:BOOL=OFF',
            '-DBUILD_EXAMPLES:BOOL=%s' % variant_bool('+examples'),
            '-DVTK_USE_SYSTEM_FREETYPE:BOOL=ON',
            '-DVTK_USE_SYSTEM_HDF5:BOOL=%s' % variant_bool('+hdf5'),
            '-DVTK_USE_SYSTEM_JPEG:BOOL=ON',
            '-DVTK_USE_SYSTEM_LIBXML2:BOOL=ON',
            '-DVTK_USE_SYSTEM_NETCDF:BOOL=ON',
            '-DVTK_USE_SYSTEM_EXPAT:BOOL=ON',
            '-DVTK_USE_SYSTEM_TIFF:BOOL=ON',
            '-DVTK_USE_SYSTEM_ZLIB:BOOL=ON',
            '-DVTK_USE_SYSTEM_PNG:BOOL=ON',
            '-DOpenGL_GL_PREFERENCE:STRING=LEGACY'
        ]

        # The assumed qt version changed to QT5 (as of paraview 5.2.1),
        # so explicitly specify which QT major version is actually being used
        if '+qt' in spec:
            cmake_args.extend([
                '-DPARAVIEW_QT_VERSION=%s' % spec['qt'].version[0],
            ])

        # CMake flags for python have changed with newer ParaView versions
        # Make sure Spack uses the right cmake flags
        if '+python' in spec or '+python3' in spec:
            py_use_opt = 'USE' if spec.satisfies('@5.8:') else 'ENABLE'
            py_ver_opt = 'PARAVIEW' if spec.satisfies('@5.7:') else 'VTK'
            py_ver_val = 3 if '+python3' in spec else 2
            cmake_args.extend([
                '-DPARAVIEW_%s_PYTHON:BOOL=ON' % py_use_opt,
                '-DPYTHON_EXECUTABLE:FILEPATH=%s' %
                spec['python'].command.path,
                '-DVTK_USE_SYSTEM_MPI4PY:BOOL=%s' % variant_bool('+mpi'),
                '-D%s_PYTHON_VERSION:STRING=%d' % (py_ver_opt, py_ver_val)
            ])

        else:
            cmake_args.append('-DPARAVIEW_ENABLE_PYTHON:BOOL=OFF')

        if '+mpi' in spec:
            cmake_args.extend([
                '-DPARAVIEW_USE_MPI:BOOL=ON',
                '-DMPIEXEC:FILEPATH=%s/bin/mpiexec' % spec['mpi'].prefix,
                '-DMPI_CXX_COMPILER:PATH=%s' % spec['mpi'].mpicxx,
                '-DMPI_C_COMPILER:PATH=%s' % spec['mpi'].mpicc,
                '-DMPI_Fortran_COMPILER:PATH=%s' % spec['mpi'].mpifc
            ])

        if '+shared' in spec:
            cmake_args.append(
                '-DPARAVIEW_BUILD_SHARED_LIBS:BOOL=ON'
            )
        else:
            cmake_args.append(
                '-DPARAVIEW_BUILD_SHARED_LIBS:BOOL=OFF'
            )

        if '+cuda' in spec:
            cmake_args.extend([
                '-DPARAVIEW_USE_CUDA:BOOL=ON',
                '-DPARAVIEW_BUILD_SHARED_LIBS:BOOL=OFF'
            ])
        else:
            cmake_args.extend([
                '-DPARAVIEW_USE_CUDA:BOOL=OFF',
            ])

        if 'darwin' in spec.architecture:
            cmake_args.extend([
                '-DVTK_USE_X:BOOL=OFF',
                '-DPARAVIEW_DO_UNIX_STYLE_INSTALLS:BOOL=ON',
            ])

        if '+kits' in spec:
            if spec.satisfies('@5.0:5.6'):
                cmake_args.append(
                    '-DVTK_ENABLE_KITS:BOOL=ON')
            elif spec.satisfies('@5.7'):
                cmake_args.append(
                    '-DPARAVIEW_ENABLE_KITS:BOOL=ON')
            else:
                cmake_args.append(
                    '-DPARAVIEW_BUILD_WITH_KITS:BOOL=ON')

        # Hide git from Paraview so it will not use `git describe`
        # to find its own version number
        if spec.satisfies('@5.4.0:5.4.1'):
            cmake_args.extend([
                '-DGIT_EXECUTABLE=FALSE'
            ])

        # A bug that has been found in vtk causes an error for
        # intel builds for version 5.6.  This should be revisited
        # with later versions of Paraview to see if the issues still
        # arises.
        if '%intel' in spec and spec.version >= Version('5.6'):
            cmake_args.append('-DPARAVIEW_ENABLE_MOTIONFX:BOOL=OFF')

        return cmake_args

# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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.
# ==============================================================================
"""Tests for the IgnoreErrors input pipeline ops."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from absl.testing import parameterized

from tensorflow.python.data.experimental.kernel_tests.serialization import dataset_serialization_test_base
from tensorflow.python.data.experimental.ops import error_ops
from tensorflow.python.data.kernel_tests import test_base
from tensorflow.python.data.ops import dataset_ops
from tensorflow.python.framework import combinations
from tensorflow.python.ops import array_ops
from tensorflow.python.platform import test


class IgnoreErrorsSerializationTest(
    dataset_serialization_test_base.DatasetSerializationTestBase,
    parameterized.TestCase):

  def _build_ds(self):
    return dataset_ops.Dataset.range(5).map(
        array_ops.ones).map(lambda x: array_ops.gather(x, [0])).apply(
            error_ops.ignore_errors())

  @combinations.generate(test_base.default_test_combinations())
  def testIgnoreErrorsCore(self):
    num_outputs = 4
    self.run_core_tests(self._build_ds, num_outputs)


if __name__ == "__main__":
  test.main()

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Copyright (c) 2016 Jérémie DECOCK (http://www.jdhp.org)

# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:

# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.

# See: http://effbot.org/tkinterbook/variable.htm

import tkinter as tk

root = tk.Tk()        # Useless but mandatory...

# Integer variable ####################

int_var = tk.IntVar()

int_var.set(3)
print(int_var.get())

# Float variable ######################

double_var = tk.DoubleVar()

double_var.set(3.14)
print(double_var.get())

# String variable #####################

str_var = tk.StringVar()

str_var.set("Hello")
print(str_var.get())

# Boolean variable ####################

bool_var = tk.BooleanVar()

bool_var.set(True)
print(bool_var.get())


## (Largely internal) module for access to asynchoronously dispatched
## module job ID's.  The Func Overlord() module wraps most of this usage
## so it's not entirely relevant to folks using the CLI or Func API
## directly.
##
## Copyright 2008, Red Hat, Inc
## Michael DeHaan <mdehaan@redhat.com>
##
## This software may be freely redistributed under the terms of the GNU
## general public license.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
##

from func import jobthing
import func_module
NUM_OF_LINES = 50
# =================================

# copyright 2004 Michael D. Stenner <mstenner@ece.arizona.edu>
# license: LGPL

class xreverse:
    def __init__(self, file_object, buf_size=1024*8):
        self.fo = fo = file_object
        fo.seek(0, 2)        # go to the end of the file
        self.pos = fo.tell() # where we are
        self.buffer = ''     # data buffer
        self.lbuf = []       # buffer for parsed lines
        self.done = 0        # we've read the last line
        self.jump = -1 * buf_size

        while 1:
            try:            fo.seek(self.jump, 1)
            except IOError: fo.seek(0)
            new_position = fo.tell()
            new = fo.read(self.pos - new_position)
            fo.seek(new_position)
            self.pos = new_position

            self.buffer = new + self.buffer
            if '\n' in new: break
            if self.pos == 0: return self.buffer

        nl = self.buffer.split('\n')
        nlb = [ i + '\n' for i in nl[1:-1] ]
        if not self.buffer[-1] == '\n': nlb.append(nl[-1])
        self.buffer = nl[0]
        self.lbuf = nlb

    def __iter__(self): return self

    def next(self):
        try:
            return self.lbuf.pop()
        except IndexError:
            fo = self.fo
            while 1:
                #get the next chunk of data
                try:            fo.seek(self.jump, 1)
                except IOError: fo.seek(0)
                new_position = fo.tell()
                new = fo.read(self.pos - new_position)
                fo.seek(new_position)
                self.pos = new_position

                nl = (new + self.buffer).split('\n')
                self.buffer = nl.pop(0)
                self.lbuf = [ i + '\n' for i in nl ]

                if self.lbuf: return self.lbuf.pop()
                elif self.pos == 0:
                    if self.done:
                        raise StopIteration
                    else:
                        self.done = 1
                        return self.buffer + '\n'



class JobsModule(func_module.FuncModule):

    version = "0.0.1"
    api_version = "0.0.1"
    description = "Internal module for tracking background minion tasks."

    def job_status(self, job_id):
        """
        Returns job status in the form of (status, datastruct).
        Datastruct is undefined for unfinished jobs.  See jobthing.py and
        Wiki details on async invocation for more information.
        """
        return jobthing.job_status(job_id)

    def tail_output(self,minion_job_id):
        """
        A tail method which will tail the log files
        that will track their output ....
        """

        from func.minion import sub_process
        from certmaster.config import read_config
        from func.commonconfig import FuncdConfig
        from func.logger import config_file
        import os
        import subprocess



        config = read_config(config_file, FuncdConfig)
        method_log_dir = config.method_log_dir
        method_log_file = os.path.join(method_log_dir,minion_job_id)
        cmd= subprocess.Popen(
                args=["tail","-n",str(NUM_OF_LINES),method_log_file],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                shell = False,
                )

        return cmd.communicate()


    def get_progress(self,minion_job_id):
        """
        Get the log file and parse the progress part
        to be polled on overlord
        """
        from certmaster.config import read_config
        from func.commonconfig import FuncdConfig
        from func.logger import config_file
        import os
        import re

        config = read_config(config_file, FuncdConfig)
        method_log_dir = config.method_log_dir
        method_log_file = os.path.join(method_log_dir,minion_job_id)

        reco=re.compile("Progress report (\d+)/(\d+) completed")
        fo = file(method_log_file)
        for line in xreverse(fo):
            tmp = re.search(reco,line)
            if tmp:
                current = tmp.group(1)
                all = tmp.group(2)
                return (int(current),int(all))

        #that tells that we couldnt found any report there
        return(0,0)

# -*- test-case-name: twisted.internet.test.test_endpoints -*-
# Copyright (c) 2010 Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Fake client and server endpoint string parser plugins for testing purposes.
"""

from zope.interface.declarations import implements
from twisted.plugin import IPlugin
from twisted.internet.interfaces import (IStreamClientEndpoint,
                                         IStreamServerEndpoint,
                                         IStreamClientEndpointStringParser,
                                         IStreamServerEndpointStringParser)

class PluginBase(object):
    implements(IPlugin)

    def __init__(self, pfx):
        self.prefix = pfx



class FakeClientParser(PluginBase):

    implements(IStreamClientEndpointStringParser)

    def parseStreamClient(self, *a, **kw):
        return StreamClient(self, a, kw)



class FakeParser(PluginBase):

    implements(IStreamServerEndpointStringParser)

    def parseStreamServer(self, *a, **kw):
        return StreamServer(self, a, kw)



class EndpointBase(object):

    def __init__(self, parser, args, kwargs):
        self.parser = parser
        self.args = args
        self.kwargs = kwargs



class StreamClient(EndpointBase):

    implements(IStreamClientEndpoint)



class StreamServer(EndpointBase):

    implements(IStreamServerEndpoint)



# Instantiate plugin interface providers to register them.
fake = FakeParser('fake')
fakeClient = FakeClientParser('cfake')


# Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Provides an interface for installing Chrome.

At present the only platform it supports is Windows.
"""

import _winreg
import ctypes
from ctypes import wintypes, windll
import httplib
import logging
import os
import shutil
import socket
import subprocess
import tempfile
import urllib


class InstallationType(object):
  """Defines the Chrome installation types."""
  SYSTEM = 1
  USER = 2


def IsVersionNewer(cur_version, new_version):
  """Determines if new Chrome version is higher than the installed one.

  Args:
    cur_version: Current version of Chrome.
    new_version: New version that will be installed.

  Returns:
    True, if new version is higher, otherwise False.
  """
  if cur_version == new_version:
    return False
  cur = cur_version.split('.')
  new = new_version.split('.')
  if len(cur) != 4 or len(new) != 4:
    raise RuntimeError('One or both of the versions are invalid.')
  for x in range(len(cur)):
    if int(cur[x]) > int(new[x]):
      return False
  return True


def Install(installer_path, install_type, build, options):
  """Installs the specified Chrome version.

  Args:
    installer_path: Path to the Chrome installer.
    install_type: Type of installation (i.e., system or user).
    build: Chrome build number.
    options: Additional installation options.

  Returns:
    An instance of ChromeInstallation.
  """
  current = ChromeInstallation.GetCurrent()
  if current:
    # Make sure new build can be installed over existing Chrome build.
    if (current.GetType() == InstallationType.SYSTEM and
        install_type == InstallationType.USER):
      raise RuntimeError('System level Chrome exists, aborting user level '
                         'installation.')
    # Confirm the new Chrome build is higher than the installed build.
    if not IsVersionNewer(current.GetVersion(), build):
      raise RuntimeError('Installation failed because a newer version is '
                         'already installed.')
  options.append('--install')
  options.append('--do-not-launch-chrome')
  logging.info('Installing Chrome build %s...' % build)
  args = [installer_path]
  args.extend(options)
  if subprocess.Popen(args).wait() != 0:
    raise RuntimeError('Chrome installation for build %s failed.' % build)
  logging.info('Installation complete.')
  return ChromeInstallation.GetCurrent()


class ChromeRegistryValues(object):
  """Defines the Chrome registry key values."""
  PRODUCT_VERSION = 'pv'
  UNINSTALL_STRING = 'UninstallString'
  UNINSTALL_ARGUMENTS = 'UninstallArguments'


class ChromeRegistryKeys(object):
  """An interface for accessing and manipulating Chrome registry keys."""

  _HKEY_LOCAL = r'SOFTWARE\Wow6432Node\Google\Update'
  _HKEY_USER = _HKEY_LOCAL.replace(r'\Wow6432Node', '')
  _chrome_version = r'Clients\{8A69D345-D564-463C-AFF1-A69D9E530F96}'
  _chrome_args = r'ClientState\{8A69D345-D564-463C-AFF1-A69D9E530F96}'

  def _GetKeyName(self, install_type, value):
    """Gets the registry key name for the specified value.

    Args:
      install_type: Type of installation, must be InstallationType type.
      value: ChromeRegistryValues type for which the key name is required.

    Returns:
      A string representing the full key name of the specified key value.
    """
    key_name = None
    if install_type == InstallationType.USER:
      key_name = self._HKEY_USER
    elif install_type == InstallationType.SYSTEM:
      key_name = self._HKEY_LOCAL
    if value == ChromeRegistryValues.PRODUCT_VERSION:
      return r'%s\%s' % (key_name, self._chrome_version)
    elif value == ChromeRegistryValues.UNINSTALL_ARGUMENTS:
      return r'%s\%s' % (key_name, self._chrome_args)
    elif value == ChromeRegistryValues.UNINSTALL_STRING:
      return r'%s\%s' % (key_name, self._chrome_args)
    raise RuntimeError('Invalid registry value.')

  def _GetRegistryType(self, install_type):
    """Determines the registry key to use based on installation type.

    Args:
      install_type: Type of installation, must be InstallationType type.

    Returns:
      A long representing HKLM or HKCU, depending on installation type.
    """
    if install_type == InstallationType.SYSTEM:
      return _winreg.HKEY_LOCAL_MACHINE
    elif install_type == InstallationType.USER:
      return _winreg.HKEY_CURRENT_USER
    raise RuntimeError('Invalid installation type.')

  def DoesKeyExist(self, install_type, subkey):
    """Determines if a particular key exists in the registry.

    Args:
      install_type: Type of installation, must be InstallationType type.
      subkey: Subkey to look up. It must be a ChromeRegistryValues type.

    Returns:
      True if the key exists, otherwise False.
    """
    key = self._GetRegistryType(install_type)
    key_name = self._GetKeyName(install_type, subkey)
    try:
      hkey = _winreg.OpenKey(key, key_name)
    except _winreg.error:
      return False
    if not hkey.handle:
      return False
    hkey.Close()
    return True

  def GetKeyValue(self, install_type, subkey):
    """Gets value of the specified subkey from the registry.

    Args:
      install_type: Type of installation, must be InstallationType type.
      subkey: ChromeRegistryValue type representing the value to be returned.

    Returns:
      A string representing the subkey value.
    """
    key = self._GetRegistryType(install_type)
    key_name = self._GetKeyName(install_type, subkey)
    hkey = _winreg.OpenKey(key, key_name)
    reg_value = str(_winreg.QueryValueEx(hkey, subkey)[0])
    hkey.Close()
    return reg_value

  def DeleteRegistryEntries(self, install_type):
    """Deletes chrome registry settings.

    Args:
      install_type: Type of installation, must be InstallationType type.
    """
    reg_type = self._GetRegistryType(install_type)
    key_name = self._GetKeyName(install_type,
                                ChromeRegistryValues.UNINSTALL_ARGUMENTS)
    root = key_name[:key_name.rfind('\\')]
    child = key_name[key_name.rfind('\\') + 1:]
    key = _winreg.OpenKey(reg_type, root, 0, _winreg.KEY_ALL_ACCESS)
    _winreg.DeleteKey(key, child)
    key.Close()


class ChromeInstallation(object):
  """Provides pertinent information about the installed Chrome version.

  The type of Chrome version must be passed as an argument to the constructor,
  (i.e. - user or system level).
  """

  _CSIDL_COMMON_APPDATA = 0x1C
  _CSIDL_PROGRAM_FILESX86 = 0x2A

  def __init__(self, install_type):
    assert(install_type == InstallationType.SYSTEM or
           install_type == InstallationType.USER)
    self._type = install_type
    self._regedit = ChromeRegistryKeys()

  def GetType(self):
    """Returns the current installation type."""
    return self._type

  def GetVersion(self):
    """Returns the installed version of Chrome."""
    return self._regedit.GetKeyValue(self._type,
                                     ChromeRegistryValues.PRODUCT_VERSION)

  def _GetWinLocalFolder(self, ftype=_CSIDL_COMMON_APPDATA):
    """Returns full path of the 'Local' folder on Windows.

    Args:
      ftype: Location to look up, which could vary based on installation type.

    Returns:
      A String representing the folder path if successful, otherwise an empty
      string.
    """
    SHGetFolderPathW = windll.shell32.SHGetFolderPathW
    SHGetFolderPathW.argtypes = [wintypes.HWND,
                                 ctypes.c_int,
                                 wintypes.HANDLE,
                                 wintypes.DWORD,
                                 wintypes.LPCWSTR]
    path_buf = wintypes.create_unicode_buffer(wintypes.MAX_PATH)
    result = SHGetFolderPathW(0, ftype, 0, 0, path_buf)
    return str(path_buf.value)

  def _GetUninstallString(self):
    """Returns the Chrome uninstall string from the registry."""
    return self._regedit.GetKeyValue(self._type,
                                     ChromeRegistryValues.UNINSTALL_STRING)

  def _GetUninstallArguments(self):
    """Returns the Chrome uninstall arguments from the registry."""
    return self._regedit.GetKeyValue(self._type,
                                     ChromeRegistryValues.UNINSTALL_ARGUMENTS)

  def GetExePath(self):
    """Returns Chrome binary location based on installation type.

    Currently this method only returns the location of the Chrome binary.
    It does not support Chromium.
    """
    if self._type == InstallationType.USER:
      folder_id = self._CSIDL_COMMON_APPDATA
    elif self._type == InstallationType.SYSTEM:
      folder_id = self._CSIDL_PROGRAM_FILESX86
    chrome_path = os.path.join(self._GetWinLocalFolder(folder_id), 'Google',
                               'Chrome', 'Application', 'chrome.exe')
    return (chrome_path if os.path.exists(chrome_path) else '')

  @staticmethod
  def GetCurrent():
    """Determines Chrome installation type.

    Returns:
      ChromeInstallation object if Chrome is present, otherwise None.
    """
    registry = ChromeRegistryKeys()
    if registry.DoesKeyExist(InstallationType.SYSTEM,
                             ChromeRegistryValues.PRODUCT_VERSION):
      return ChromeInstallation(InstallationType.SYSTEM)
    elif registry.DoesKeyExist(InstallationType.USER,
                               ChromeRegistryValues.PRODUCT_VERSION):
      return ChromeInstallation(InstallationType.USER)
    return None

  def Uninstall(self):
    """Uninstalls Chrome."""
    chrome_path = self.GetExePath()
    reg_opts = self._GetUninstallArguments()
    uninstall_str = self._GetUninstallString()
    options = '%s --force-uninstall' % (reg_opts)
    if self._type == InstallationType.SYSTEM:
      options += ' --system-level'
    if not os.path.exists(chrome_path):
      raise RuntimeError('Could not find chrome, aborting uninstall.')
    logging.info('Launching Chrome installer...')
    cmd = '"%s" %s' % (uninstall_str, options)
    subprocess.call(cmd)
    if not os.path.exists(chrome_path):
      logging.info('Chrome was uninstalled successfully...')
      logging.info('Deleting registry entries...')
      self._regedit.DeleteRegistryEntries(self._type)
      logging.info('Uninstall complete.')
    else:
      raise RuntimeError('Uninstall failed.')

from    PyQt4       import QtGui, QtCore
from    dionysus    import Simplex

class ComplexViewer2D(QtGui.QGraphicsView):
    def __init__(self, points, complex = None, values = None, subcomplex = None):
        super(QtGui.QGraphicsView, self).__init__()
        self._pan = False

        self.points = points
        if complex:
            complex = [s for s in complex]
        else:
            # Create vertex simplices if no complex provided
            complex = [Simplex([i]) for i in xrange(len(self.points))]

        if not subcomplex:
            subcomplex = []

        if not values:
            values = [0]*len(self.points)
        self.values = values
        self.maxval, self.minval = max(values), min(values)

        self.setRenderHint(QtGui.QPainter.Antialiasing)
        self.scene = QtGui.QGraphicsScene(self)
        self.setScene(self.scene)

        minx = min(p[0] for p in points)
        miny = min(p[1] for p in points)
        maxx = max(p[0] for p in points)
        maxy = max(p[1] for p in points)

        radius = min(maxx - minx, maxy - miny)/100
        self.scene.setSceneRect(minx - 10*radius, miny - 10*radius, (maxx - minx) + 20*radius, (maxy - miny) + 20*radius)

        self.draw_complex(complex, radius, colormap = self.colormap)
        self.draw_complex(subcomplex, 3*radius, colormap = lambda v: QtCore.Qt.green, line_color = QtCore.Qt.green)

        # Flip y-axis
        self.scale(1,-1)

        # Set the correct view
        rect = self.scene.itemsBoundingRect()
        self.fitInView(rect, QtCore.Qt.KeepAspectRatio)

    def draw_complex(self, complex, radius, colormap, line_color = QtCore.Qt.black):
        complex.sort(lambda s1, s2: -cmp(s1.dimension(), s2.dimension()))
        for s in complex:
            vertices = [v for v in s.vertices]
            if s.dimension() == 0:              # point
                p = self.points[vertices[0]]
                v = self.values[vertices[0]]
                item = QtGui.QGraphicsEllipseItem(p[0] - radius/2,p[1] - radius/2,radius,radius)
                color = colormap(v)
                item.setBrush(QtGui.QBrush(color))
                item.setPen(QtGui.QPen(color))
            elif s.dimension() == 1:            # edge
                p0 = self.points[vertices[0]]
                p1 = self.points[vertices[1]]
                item = QtGui.QGraphicsLineItem(p0[0], p0[1], p1[0], p1[1])
                item.setPen(QtGui.QPen(line_color))
            else:                               # higher-d simplex
                pts = [QtCore.QPointF(self.points[v][0], self.points[v][1]) for v in vertices]
                item = QtGui.QGraphicsPolygonItem(QtGui.QPolygonF(pts))
                item.setBrush(QtCore.Qt.blue)

            self.scene.addItem(item)

    def colormap(self, v):
        if self.maxval <= self.minval:
            t = 0
        else:
            t = (v - self.minval)/(self.maxval - self.minval)
        c = QtGui.QColor()
        c.setHsv(int(t*255), 255, 255)
        return c

    def wheelEvent(self, event):
        delta = 1 + float(event.delta())/100
        if delta < 0:
            event.ignore()
            return
        self.scale(delta, delta)
        event.accept()

    def mousePressEvent(self, event):
        if event.button() == QtCore.Qt.RightButton:
            self._pan = True
            self._panStartX = event.x()
            self._panStartY = event.y()
            self.setCursor(QtCore.Qt.ClosedHandCursor)
            event.accept()

    def mouseReleaseEvent(self, event):
        if event.button() == QtCore.Qt.RightButton:
            self._pan = False
            self.setCursor(QtCore.Qt.ArrowCursor)
            event.accept()
            return
        event.ignore()

    def mouseMoveEvent(self, event):
        if self._pan:
            self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - (event.x() - self._panStartX))
            self.verticalScrollBar().setValue(self.verticalScrollBar().value() - (event.y() - self._panStartY))
            self._panStartX = event.x()
            self._panStartY = event.y()
            event.accept()
            return
        event.ignore()

def show_complex_2D(points, complex = None, values = None, subcomplex = None, app = None):
    #app = QtGui.QApplication([])
    view = ComplexViewer2D(points, complex, values, subcomplex)
    view.show()
    view.raise_()
    app.exec_()

#
# This file is part of the LibreOffice project.
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This file incorporates work covered by the following license notice:
#
#   Licensed to the Apache Software Foundation (ASF) under one or more
#   contributor license agreements. See the NOTICE file distributed
#   with this work for additional information regarding copyright
#   ownership. The ASF licenses this file to you 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 .
#
import uno
import traceback
from .PeerConfig import PeerConfig
from .UIConsts import UIConsts
from ..common.PropertyNames import PropertyNames

from com.sun.star.awt import Rectangle
from com.sun.star.awt.PosSize import POS

class UnoDialog(object):

    createDict = False
    dictProperties = None

    def __init__(self, xMSF, PropertyNames, PropertyValues):
        try:
            self.xMSF = xMSF
            self.ControlList = {}
            self.xDialogModel = xMSF.createInstance(
                "com.sun.star.awt.UnoControlDialogModel")
            self.xDialogModel.setPropertyValues(PropertyNames, PropertyValues)
            self.xUnoDialog = xMSF.createInstance(
                "com.sun.star.awt.UnoControlDialog")
            self.xUnoDialog.setModel(self.xDialogModel)
            self.m_oPeerConfig = None
            self.xWindowPeer = None
        except Exception:
            traceback.print_exc()

    def getPeerConfiguration(self):
        if self.m_oPeerConfig is None:
            self.m_oPeerConfig = PeerConfig(self)
        return self.m_oPeerConfig

    def getMAPConversionFactor(self, ControlName):
        xControl2 = self.xUnoDialog.getControl(ControlName)
        aSize = xControl2.Size
        dblMAPWidth = xControl2.Model.Width
        return (aSize.Width / dblMAPWidth)

    def getpreferredLabelSize(self, LabelName, sLabel):
        xControl2 = self.xUnoDialog.getControl(LabelName)
        OldText = xControl2.Text
        xControl2.setText(sLabel)
        aSize = xControl2.PreferredSize
        xControl2.setText(OldText)
        return aSize

    def removeSelectedItems(self, xListBox):
        SelList = xListBox.SelectedItemsPos
        Sellen = SelList.length
        i = Sellen - 1
        while i >= 0:
            xListBox.removeItems(SelList[i], 1)
            i -= 1

    def getListBoxItemCount(self, _xListBox):
        # This function may look ugly, but this is the only way to check
        # the count of values in the model,which is always right.
        # the control is only a view and could be right or not.
        fieldnames = getModel(_xListBox).StringItemList
        return fieldnames.length

    def getSelectedItemPos(self, _xListBox):
        ipos = getModel(_xListBox).SelectedItems
        return ipos[0]

    def isListBoxSelected(self, _xListBox):
        ipos = getModel(_xListBox).SelectedItems
        return ipos.length > 0

    '''
    The problem with setting the visibility of controls is that
    changing the current step of a dialog will automatically make
    all controls visible. The PropertyNames.PROPERTY_STEP property
    always wins against the property "visible".
    Therfor a control meant to be invisible is placed on a step far far away.
    Afterwards the step property of the dialog has to be set with
    "repaintDialogStep". As the performance of that method is very bad it
    should be used only once for all controls
    @param controlname the name of the control
    @param bIsVisible sets the control visible or invisible
    '''

    def setControlVisible(self, controlname, bIsVisible):
        try:
            iCurControlStep = int(getControlProperty(
                controlname, PropertyNames.PROPERTY_STEP))
            iCurDialogStep = int(self.xDialogModel.Step)
            if bIsVisible:
                setControlProperty(
                    controlname, PropertyNames.PROPERTY_STEP, iCurDialogStep)
            else:
                setControlProperty(
                    controlname, PropertyNames.PROPERTY_STEP,
                    UIConsts.INVISIBLESTEP)

        except Exception:
            traceback.print_exc()

    # repaints the currentDialogStep

    def repaintDialogStep(self):
        try:
            ncurstep = int(self.xDialogModel.Step)
            self.xDialogModel.Step = 99
            self.xDialogModel.Step = ncurstep
        except Exception:
            traceback.print_exc()

    def insertControlModel(
        self, serviceName, componentName, sPropNames, oPropValues):
        try:
            xControlModel = self.xDialogModel.createInstance(serviceName)
            uno.invoke(xControlModel, "setPropertyValues",
                    (sPropNames, oPropValues))
            self.xDialogModel.insertByName(componentName, xControlModel)
            xControlModel.Name = componentName
        except Exception:
            traceback.print_exc()

        aObj = self.xUnoDialog.getControl(componentName)
        return aObj

    def setFocus(self, ControlName):
        oFocusControl = self.xUnoDialog.getControl(ControlName)
        oFocusControl.setFocus()

    def selectListBoxItem(self, xListBox, iFieldsSelIndex):
        if iFieldsSelIndex > -1:
            FieldCount = xListBox.getItemCount()
            if FieldCount > 0:
                if iFieldsSelIndex < FieldCount:
                    xListBox.selectItemPos(iFieldsSelIndex, True)
                else:
                    xListBox.selectItemPos((short)(iFieldsSelIndex - 1), True)

    # deselects a Listbox. MultipleMode is not supported
    def deselectListBox(self, _xBasisListBox):
        oListBoxModel = getModel(_xBasisListBox)
        sList = oListBoxModel.StringItemList
        oListBoxModel.StringItemList = [[],[]]
        oListBoxModel.StringItemList = sList

    def calculateDialogPosition(self, FramePosSize):
        # Todo:check if it would be useful or possible to create a dialog peer
        # that can be used for the messageboxes to
        # maintain modality when they pop up.
        CurPosSize = self.xUnoDialog.getPosSize()
        WindowHeight = FramePosSize.Height
        WindowWidth = FramePosSize.Width
        DialogWidth = CurPosSize.Width
        DialogHeight = CurPosSize.Height
        iXPos = ((WindowWidth / 2) - (DialogWidth / 2))
        iYPos = ((WindowHeight / 2) - (DialogHeight / 2))
        self.xUnoDialog.setPosSize(
            iXPos, iYPos, DialogWidth, DialogHeight, POS)

    '''
     @param FramePosSize
    @return 0 for cancel, 1 for ok
    @throws com.sun.star.uno.Exception
    '''

    def executeDialog(self, FramePosSize):
        if self.xUnoDialog.getPeer() == None:
            raise AttributeError(
                "Please create a peer, using your own frame")

        self.calculateDialogPosition(FramePosSize)

        if self.xWindowPeer == None:
            self.createWindowPeer()
        return self.xUnoDialog.execute()

    def setVisible(self, parent):
        self.calculateDialogPosition(parent.xWindow.getPosSize())
        if self.xWindowPeer == None:
            self.createWindowPeer()

        self.xUnoDialog.setVisible(True)

    '''
    @param parent
    @return 0 for cancel, 1 for ok
    @throws com.sun.star.uno.Exception
    '''

    def executeDialogFromParent(self, parent):
        return self.executeDialog(parent.xUnoDialog.PosSize)

    '''
    @param XComponent
    @return 0 for cancel, 1 for ok
    @throws com.sun.star.uno.Exception
    '''

    def executeDialogFromComponent(self, xComponent):
        if xComponent is not None:
            w = xComponent.ComponentWindow
            if w is not None:
                return self.executeDialog(w.PosSize)

        return self.executeDialog( Rectangle (0, 0, 640, 400))

    def modifyFontWeight(self, ControlName, FontWeight):
        oFontDesc = FontDescriptor.FontDescriptor()
        oFontDesc.Weight = FontWeight
        setControlProperty(ControlName, "FontDescriptor", oFontDesc)

    '''
    create a peer for this
    dialog, using the given
    peer as a parent.
    @param parentPeer
    @return
    @throws java.lang.Exception
    '''

    def createWindowPeer(self, parentPeer=None):
        self.xUnoDialog.setVisible(False)
        xToolkit = self.xMSF.createInstance("com.sun.star.awt.Toolkit")
        if parentPeer == None:
            parentPeer = xToolkit.getDesktopWindow()

        self.xUnoDialog.createPeer(xToolkit, parentPeer)
        self.xWindowPeer = self.xUnoDialog.getPeer()
        return self.xUnoDialog.getPeer()

    # deletes the first entry when this is equal to "DelEntryName"
    # returns true when a new item is selected

    def deletefirstListboxEntry(self, ListBoxName, DelEntryName):
        xListBox = self.xUnoDialog.getControl(ListBoxName)
        FirstItem = xListBox.getItem(0)
        if FirstItem.equals(DelEntryName):
            SelPos = xListBox.getSelectedItemPos()
            xListBox.removeItems(0, 1)
            if SelPos > 0:
                setControlProperty(ListBoxName, "SelectedItems", [SelPos])
                xListBox.selectItemPos((short)(SelPos - 1), True)

    @classmethod
    def setEnabled(self, control, enabled):
        control.Model.Enabled = enabled

    @classmethod
    def getControlModelType(self, xServiceInfo):
        if xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlFixedTextModel"):
            return UIConsts.CONTROLTYPE.FIXEDTEXT
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlButtonModel"):
            return UIConsts.CONTROLTYPE.BUTTON
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlCurrencyFieldModel"):
            return UIConsts.CONTROLTYPE.CURRENCYFIELD
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlDateFieldModel"):
            return UIConsts.CONTROLTYPE.DATEFIELD
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlFixedLineModel"):
            return UIConsts.CONTROLTYPE.FIXEDLINE
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlFormattedFieldModel"):
            return UIConsts.CONTROLTYPE.FORMATTEDFIELD
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlRoadmapModel"):
            return UIConsts.CONTROLTYPE.ROADMAP
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlNumericFieldModel"):
            return UIConsts.CONTROLTYPE.NUMERICFIELD
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlPatternFieldModel"):
            return UIConsts.CONTROLTYPE.PATTERNFIELD
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlHyperTextModel"):
            return UIConsts.CONTROLTYPE.HYPERTEXT
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlProgressBarModel"):
            return UIConsts.CONTROLTYPE.PROGRESSBAR
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlTimeFieldModel"):
            return UIConsts.CONTROLTYPE.TIMEFIELD
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlImageControlModel"):
            return UIConsts.CONTROLTYPE.IMAGECONTROL
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlRadioButtonModel"):
            return UIConsts.CONTROLTYPE.RADIOBUTTON
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlCheckBoxModel"):
            return UIConsts.CONTROLTYPE.CHECKBOX
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlEditModel"):
            return UIConsts.CONTROLTYPE.EDITCONTROL
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlComboBoxModel"):
            return UIConsts.CONTROLTYPE.COMBOBOX
        elif xServiceInfo.supportsService(
                "com.sun.star.awt.UnoControlListBoxModel"):
            return UIConsts.CONTROLTYPE.LISTBOX
        else:
            return UIConsts.CONTROLTYPE.UNKNOWN

    @classmethod
    def getDisplayProperty(self, oControlModel):
        itype = self.getControlModelType(oControlModel)
        if not UnoDialog.createDict:
            UnoDialog.createDict = True
            UnoDialog.dictProperties = {
                UIConsts.CONTROLTYPE.FIXEDTEXT:PropertyNames.PROPERTY_LABEL,
                UIConsts.CONTROLTYPE.BUTTON:PropertyNames.PROPERTY_LABEL,
                UIConsts.CONTROLTYPE.FIXEDLINE:PropertyNames.PROPERTY_LABEL,
                UIConsts.CONTROLTYPE.NUMERICFIELD:"Value",
                UIConsts.CONTROLTYPE.CURRENCYFIELD:"Value",
                UIConsts.CONTROLTYPE.FORMATTEDFIELD:"EffectiveValue",
                UIConsts.CONTROLTYPE.DATEFIELD:"Date",
                UIConsts.CONTROLTYPE.TIMEFIELD:"Time",
                UIConsts.CONTROLTYPE.SCROLLBAR:"ScrollValue",
                UIConsts.CONTROLTYPE.PROGRESSBAR:"ProgressValue",
                UIConsts.CONTROLTYPE.IMAGECONTROL:PropertyNames.PROPERTY_IMAGEURL,
                UIConsts.CONTROLTYPE.RADIOBUTTON:PropertyNames.PROPERTY_STATE,
                UIConsts.CONTROLTYPE.CHECKBOX:PropertyNames.PROPERTY_STATE,
                UIConsts.CONTROLTYPE.EDITCONTROL:"Text",
                UIConsts.CONTROLTYPE.COMBOBOX:"Text",
                UIConsts.CONTROLTYPE.PATTERNFIELD:"Text",
                UIConsts.CONTROLTYPE.LISTBOX:"SelectedItems"
            }
        try:
            return UnoDialog.dictProperties[itype]
        except KeyError:
            return ""

    def addResourceHandler(self, _Unit, _Module):
        self.m_oResource = Resource(self.xMSF, _Unit, _Module)

import logging
import jsonpickle
from Dependency import Dependency
from tests.CairisTests import CairisTests
from tools.ModelDefinitions import DependencyModel

__author__ = 'Robin Quetin'


class DependencyTests(CairisTests):
    logger = logging.getLogger(__name__)
    working_name_1 = ('Stroke', 'all', 'all', 'all')
    working_name_2 = ('Stroke', 'Data%20Consumer', 'Certificate%20Authority', 'Personal%20certificate')
    existing_environment_1 = 'Stroke'
    existing_environment_2 = 'Psychosis'
    existing_role_1 = 'Data Consumer'
    existing_role_2 = 'Certificate Authority'
    existing_type = 'goal'
    existing_dependency = 'Upload authorisation'

    def test_all_get(self):
        method = 'test_all_get'
        url = '/api/dependencies?session_id=test'

        rv = self.app.get(url)
        self.assertIsNotNone(rv.data, 'No response')
        json_dict = jsonpickle.decode(rv.data)
        self.assertIsInstance(json_dict, dict, 'The response is not a valid JSON dictionary')
        self.assertGreater(len(json_dict), 0, 'No dependencies found')
        assert isinstance(json_dict, dict)
        item = json_dict.items()[0]
        self.logger.info('[%s] First dependency: %s [%d]\n', method, item[0], item[1]['theId'])

    def test_dependencies_name_get(self):
        method = 'test_dependencies_name_get'
        url = '/api/dependencies/environment/%s/depender/%s/dependee/%s/dependency/%s?session_id=test' % self.working_name_1

        rv = self.app.get(url)
        self.assertIsNotNone(rv.data, 'No response')
        json_dict = jsonpickle.decode(rv.data)
        self.assertIsInstance(json_dict, list, 'The response is not a valid JSON dictionary')
        self.assertGreater(len(json_dict), 0, 'No dependencies found')
        assert isinstance(json_dict, list)
        ids = []
        for dep in json_dict:
            ids.append(str(dep['theId']))
        self.logger.info('[%s] Dependency IDs: %s\n', method, ', '.join(ids))

    def test_dependency_name_get(self):
        method = 'test_dependency_name_get'
        url = '/api/dependencies/environment/%s/depender/%s/dependee/%s/dependency/%s?session_id=test' % self.working_name_2

        rv = self.app.get(url)
        self.assertIsNotNone(rv.data, 'No response')
        json_dict = jsonpickle.decode(rv.data)
        self.assertIsInstance(json_dict, list, 'The response is not a valid JSON dictionary')
        self.assertEqual(len(json_dict), 1, 'Result is not unique')
        assert isinstance(json_dict, list)
        item = json_dict[0]
        has_keys = all (k in item for k in DependencyModel.required)
        self.assertTrue(has_keys, 'Result is not a dependency')
        dep_name = '/'.join([item['theEnvironmentName'], item['theDepender'], item['theDependee'], item['theDependency']])
        self.logger.info('[%s] Dependency: %s [%d]\n', method, dep_name, item['theId'])

    def test_dependency_post(self):
        method = 'test_dependency_post'
        url = '/api/dependencies'
        new_dep = self.prepare_new_dependency()
        json_dict = {
            'session_id': 'test',
            'object': new_dep
        }
        json_body = jsonpickle.encode(json_dict)

        new_name = (new_dep.theEnvironmentName, new_dep.theDepender, new_dep.theDependee, new_dep.theDependency)
        delete_url = '/api/dependencies/environment/%s/depender/%s/dependee/%s/dependency/%s?session_id=test' % new_name
        self.app.delete(delete_url)

        rv = self.app.post(url, data=json_body, content_type='application/json')
        self.assertIsNotNone(rv.data, 'No response')
        json_dict = jsonpickle.decode(rv.data)
        self.assertIsInstance(json_dict, dict, 'Response is not a valid JSON dictionary')
        message = json_dict.get('message', None)
        self.assertIsNotNone(message, 'No message in response')
        self.assertNotIsInstance(message, dict, 'Message is an object')
        self.logger.info('[%s] Message: %s', method, message)
        dep_id = json_dict.get('dependency_id', None)
        self.assertIsNotNone(dep_id, 'No dependency ID returned')
        self.logger.info('[%s] New dependency ID: %d\n', method, dep_id)

        new_name = (new_dep.theEnvironmentName, new_dep.theDepender, new_dep.theDependee, new_dep.theDependency)
        delete_url = '/api/dependencies/environment/%s/depender/%s/dependee/%s/dependency/%s?session_id=test' % new_name
        self.app.delete(delete_url)

    def test_dependency_name_delete(self):
        method = 'test_dependency_name_delete'
        url = '/api/dependencies'
        new_dep = self.prepare_new_dependency()
        json_dict = {
            'session_id': 'test',
            'object': new_dep
        }
        json_body = jsonpickle.encode(json_dict)
        self.app.post(url, data=json_body, content_type='application/json')

        new_name = (new_dep.theEnvironmentName, new_dep.theDepender, new_dep.theDependee, new_dep.theDependency)
        delete_url = '/api/dependencies/environment/%s/depender/%s/dependee/%s/dependency/%s?session_id=test' % new_name
        rv = self.app.delete(delete_url)
        self.assertIsNotNone(rv.data, 'No response')
        json_dict = jsonpickle.decode(rv.data)
        self.assertIsInstance(json_dict, dict, 'Response is not a valid JSON dictionary')
        message = json_dict.get('message', None)
        self.assertIsNotNone(message, 'No message in response')
        self.assertNotIsInstance(message, dict, 'Message is an object')
        self.logger.info('[%s] Message: %s\n', method, message)

    def test_dependency_name_put(self):
        method = 'test_dependency_name_put'
        url = '/api/dependencies'
        new_dep = self.prepare_new_dependency()
        json_dict = {
            'session_id': 'test',
            'object': new_dep
        }
        json_body = jsonpickle.encode(json_dict)
        self.app.post(url, data=json_body, content_type='application/json')
        new_name = (new_dep.theEnvironmentName, new_dep.theDepender, new_dep.theDependee, new_dep.theDependency)

        upd_dep = new_dep
        upd_dep.theEnvironmentName = self.existing_environment_2
        json_dict = {
            'session_id': 'test',
            'object': upd_dep
        }
        json_body = jsonpickle.encode(json_dict)
        upd_url = '/api/dependencies/environment/%s/depender/%s/dependee/%s/dependency/%s?session_id=test' % new_name
        rv = self.app.put(upd_url, data=json_body, content_type='application/json')
        self.assertIsNotNone(rv.data, 'No response')
        json_dict = jsonpickle.decode(rv.data)
        self.assertIsInstance(json_dict, dict, 'Response is not a valid JSON dictionary')
        message = json_dict.get('message', None)
        self.assertIsNotNone(message, 'No message in response')
        self.assertNotIsInstance(message, dict, 'Message is an object')
        self.logger.info('[%s] Message: %s\n', method, message)

        delete_name = (upd_dep.theEnvironmentName, upd_dep.theDepender, upd_dep.theDependee, upd_dep.theDependency)
        del_get_url = '/api/dependencies/environment/%s/depender/%s/dependee/%s/dependency/%s?session_id=test' % delete_name
        rv = self.app.get(del_get_url)
        self.logger.debug('[%s] Updated dependency:\n%s\n', method, rv.data)
        self.app.delete(del_get_url)

    def prepare_new_dependency(self):
        d = Dependency(
            -1,
            self.existing_environment_1,
            self.existing_role_1,
            self.existing_role_2,
            self.existing_type,
            self.existing_dependency,
            'This is a test dependency'
        )
        return d
# -*- coding: utf-8 -*-
from django.db import models
from django.utils.encoding import python_2_unicode_compatible


@python_2_unicode_compatible
class Author(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()
    friends = models.ManyToManyField('self', blank=True)

    def __str__(self):
        return self.name


@python_2_unicode_compatible
class Publisher(models.Model):
    name = models.CharField(max_length=255)
    num_awards = models.IntegerField()

    def __str__(self):
        return self.name


@python_2_unicode_compatible
class Book(models.Model):
    isbn = models.CharField(max_length=9)
    name = models.CharField(max_length=255)
    pages = models.IntegerField()
    rating = models.FloatField()
    price = models.DecimalField(decimal_places=2, max_digits=6)
    authors = models.ManyToManyField(Author)
    contact = models.ForeignKey(Author, related_name='book_contact_set')
    publisher = models.ForeignKey(Publisher)
    pubdate = models.DateField()

    def __str__(self):
        return self.name


@python_2_unicode_compatible
class Store(models.Model):
    name = models.CharField(max_length=255)
    books = models.ManyToManyField(Book)
    original_opening = models.DateTimeField()
    friday_night_closing = models.TimeField()

    def __str__(self):
        return self.name

# -*- coding: utf-8 -*-
##############################################################################
#
#   Author Vincent Renaville/Joel Grand-Guillaume.Copyright 2012 Camptocamp SA
#
#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU Affero General Public License as
#   published by the Free Software Foundation, either version 3 of the
#   License, or (at your option) any later version.
#
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU Affero General Public License for more details.
#
#   You should have received a copy of the GNU Affero General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
##############################################################################

from openerp import models, api, exceptions, _


class AccountInvoice(models.Model):
    _inherit = 'account.invoice'

    @api.multi
    def action_move_create(self):
        """Set move line in draft state after creating them."""
        res = super(AccountInvoice, self).action_move_create()
        for inv in self:
            if inv.move_id:
                inv.move_id.state = 'draft'
        return res


class AccountMove(models.Model):
    _inherit = 'account.move'

    @api.multi
    def button_cancel(self):
        """ We rewrite function button_cancel, to allow invoice or bank
        statement with linked draft moved
        to be canceled """
        for line in self:
            if line.state == 'draft':
                continue
            else:
                if not line.journal_id.update_posted:
                    raise exceptions.Warning(
                        _('You cannot modify a posted entry of this journal.'
                          'First you should set the journal to allow'
                          ' cancelling entries.'))
        if self:
            self._cr.execute('UPDATE account_move '
                             'SET state=%s '
                             'WHERE id IN %s', ('draft', tuple(self.ids)))
        return True

# coding: utf-8
#
# Copyright 2014 The Oppia Authors. All Rights Reserved.
#
# 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.

"""Registry for calculations."""

import inspect

from extensions.answer_summarizers import models


class Registry(object):
    """Registry of all calculations for summarizing answers."""

    # Dict mapping calculation class names to their classes.
    calculations_dict = {}

    @classmethod
    def _refresh_registry(cls):
        cls.calculations_dict.clear()

        # Add new visualization instances to the registry.
        for name, clazz in inspect.getmembers(models, inspect.isclass):
            if name.endswith('_test') or name == 'BaseCalculation':
                continue

            ancestor_names = [
                base_class.__name__ for base_class in inspect.getmro(clazz)]
            if 'BaseCalculation' not in ancestor_names:
                continue

            cls.calculations_dict[clazz.__name__] = clazz

    @classmethod
    def get_calculation_by_id(cls, calculation_id):
        """Gets a calculation instance by its id (which is also its class name).

        Refreshes once if the class is not found; subsequently, throws an
        error.
        """
        if calculation_id not in cls.calculations_dict:
            cls._refresh_registry()
        if calculation_id not in cls.calculations_dict:
            raise TypeError(
                '\'%s\' is not a valid calculation id.' % calculation_id)
        return cls.calculations_dict[calculation_id]()

# A list of properties a data source may have.

# All properties are unique strings using only characters [a-z0-9_],
# so that they can easily be used anywhere, from URLs to JSON to
# whatever.

# This datasource has layers made out of discrete points
LAYER_POINTS = "layer_points"

# The data in this datasource are integers between 0 and 255
DATA_UINT8 = "data_uint8"

# The data in this datasource are timeseries of doubles
DATA_TIMESERIES_DOUBLE = "data_timeseries_double"

# The datasource can return values for each point on the map (in case of
# timeseries, this would be the last value in the timeseries)
DATA_CAN_HAVE_VALUE_LAYER = "data_can_have_value_layer"

# If lizard-datasource were to run a script trying to received the last
# value of every possible timeseries and storing it in its own tables,
# then that would work to make a layer of the last values.
# If the datasource has DATA_CAN_HAVE_VALUE_LAYER, this won't be used.
DATA_CAN_HAVE_VALUE_LAYER_SCRIPT = "data_can_have_value_layer_script"

# Datasource can return values for all locations in it for arbitrary
# moments in time, not just the most recent.
# If the datasource has this, it is assumed it also has
# DATA_CAN_HAVE_VALUE_LAYER.
DATA_CAN_HAVE_VALUE_LAYER_ARBITRARY_MOMENT = (
    "data_can_have_value_layer_arbitrary_moment")


# This file is part of the Printrun suite.
#
# Printrun is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Printrun is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Printrun.  If not, see <http://www.gnu.org/licenses/>.

from xmlrpc.server import SimpleXMLRPCServer
from threading import Thread
import socket
import logging

from .utils import install_locale, parse_temperature_report
install_locale('pronterface')

RPC_PORT = 7978

class ProntRPC:

    server = None

    def __init__(self, pronsole, port = RPC_PORT):
        self.pronsole = pronsole
        used_port = port
        while True:
            try:
                self.server = SimpleXMLRPCServer(("localhost", used_port),
                                                 allow_none = True,
                                                 logRequests = False)
                if used_port != port:
                    logging.warning(_("RPC server bound on non-default port %d") % used_port)
                break
            except socket.error as e:
                if e.errno == 98:
                    used_port += 1
                    continue
                else:
                    raise
        self.server.register_function(self.get_status, 'status')
        self.server.register_function(self.set_extruder_temperature,'settemp')
        self.server.register_function(self.set_bed_temperature,'setbedtemp')
        self.server.register_function(self.load_file,'load_file')
        self.server.register_function(self.startprint,'startprint')
        self.server.register_function(self.pauseprint,'pauseprint')
        self.server.register_function(self.resumeprint,'resumeprint')
        self.server.register_function(self.sendhome,'sendhome')
        self.server.register_function(self.connect,'connect')
        self.server.register_function(self.disconnect, 'disconnect')
        self.server.register_function(self.send, 'send')
        self.thread = Thread(target = self.run_server)
        self.thread.start()

    def run_server(self):
        self.server.serve_forever()

    def shutdown(self):
        self.server.shutdown()
        self.thread.join()

    def get_status(self):
        if self.pronsole.p.printing:
            progress = 100 * float(self.pronsole.p.queueindex) / len(self.pronsole.p.mainqueue)
        elif self.pronsole.sdprinting:
            progress = self.pronsole.percentdone
        else: progress = None
        if self.pronsole.p.printing or self.pronsole.sdprinting:
            eta = self.pronsole.get_eta()
        else:
            eta = None
        if self.pronsole.tempreadings:
            temps = parse_temperature_report(self.pronsole.tempreadings)
        else:
            temps = None
        z = self.pronsole.curlayer
        return {"filename": self.pronsole.filename,
                "progress": progress,
                "eta": eta,
                "temps": temps,
                "z": z,
                }
    def set_extruder_temperature(self, targettemp):
        if self.pronsole.p.online:
           self.pronsole.p.send_now("M104 S" + targettemp)

    def set_bed_temperature(self,targettemp):
        if self.pronsole.p.online:
           self.pronsole.p.send_now("M140 S" + targettemp)

    def load_file(self,filename):
        self.pronsole.do_load(filename)

    def startprint(self):
        self.pronsole.do_print("")

    def pauseprint(self):
        self.pronsole.do_pause("")

    def resumeprint(self):
        self.pronsole.do_resume("")
    def sendhome(self):
        self.pronsole.do_home("")
    def connect(self):
        self.pronsole.do_connect("")
    def disconnect(self):
        self.pronsole.do_disconnect("")
    def send(self, command):
        self.pronsole.p.send_now(command)

#!/usr/bin/env python
"""
BenchExec is a framework for reliable benchmarking.
This file is part of BenchExec.

Copyright (C) 2007-2015  Dirk Beyer
All rights reserved.

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.
"""

# prepare for Python 3
from __future__ import absolute_import, division, print_function, unicode_literals

import subprocess

import benchexec.util as util
import benchexec.tools.smtlib2

class Tool(benchexec.tools.smtlib2.Smtlib2Tool):
    """
    Tool wrapper for SMTInterpol.
    """

    def executable(self):
        return util.find_executable('java')

    def version(self, executable):
        stderr = subprocess.Popen(self.cmdline(executable, ['-version'], []),
                                  stderr=subprocess.PIPE).communicate()[1]
        stderr = util.decode_to_string(stderr)
        line = next(l for l in stderr.splitlines() if l.startswith('SMTInterpol'))
        line = line.replace('SMTInterpol' , '')
        return line.strip()

    def name(self):
        return 'SMTInterpol'

    def cmdline(self, executable, options, tasks, propertyfile=None, rlimits={}):
        assert len(tasks) <= 1, "only one inputfile supported"
        return [executable, '-jar', 'smtinterpol.jar'] + options + tasks

"""
This plugin installs a SKIP error class for the SkipTest exception.
When SkipTest is raised, the exception will be logged in the skipped
attribute of the result, 'S' or 'SKIP' (verbose) will be output, and
the exception will not be counted as an error or failure. This plugin
is enabled by default but may be disabled with the ``--no-skip`` option.
"""

from nose.plugins.errorclass import ErrorClass, ErrorClassPlugin


# on SkipTest:
#  - unittest SkipTest is first preference, but it's only available
#    for >= 2.7
#  - unittest2 SkipTest is second preference for older pythons.  This
#    mirrors logic for choosing SkipTest exception in testtools
#  - if none of the above, provide custom class
try:
    from unittest.case import SkipTest
except ImportError:
    try:
        from unittest2.case import SkipTest
    except ImportError:
        class SkipTest(Exception):
            """Raise this exception to mark a test as skipped.
            """
            pass


class Skip(ErrorClassPlugin):
    """
    Plugin that installs a SKIP error class for the SkipTest
    exception.  When SkipTest is raised, the exception will be logged
    in the skipped attribute of the result, 'S' or 'SKIP' (verbose)
    will be output, and the exception will not be counted as an error
    or failure.
    """
    enabled = True
    skipped = ErrorClass(SkipTest,
                         label='SKIP',
                         isfailure=False)

    def options(self, parser, env):
        """
        Add my options to command line.
        """
        env_opt = 'NOSE_WITHOUT_SKIP'
        parser.add_option('--no-skip', action='store_true',
                          dest='noSkip', default=env.get(env_opt, False),
                          help="Disable special handling of SkipTest "
                          "exceptions.")

    def configure(self, options, conf):
        """
        Configure plugin. Skip plugin is enabled by default.
        """
        if not self.can_configure:
            return
        self.conf = conf
        disable = getattr(options, 'noSkip', False)
        if disable:
            self.enabled = False


#!/usr/bin/env python
from nose.tools import *
import networkx as nx


class TestBFS:

    def setUp(self):
        # simple graph
        G = nx.Graph()
        G.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4)])
        self.G = G

    def test_successor(self):
        assert_equal(nx.bfs_successors(self.G, source=0),
                     {0: [1], 1: [2, 3], 2: [4]})

    def test_predecessor(self):
        assert_equal(nx.bfs_predecessors(self.G, source=0),
                     {1: 0, 2: 1, 3: 1, 4: 2})

    def test_bfs_tree(self):
        T = nx.bfs_tree(self.G, source=0)
        assert_equal(sorted(T.nodes()), sorted(self.G.nodes()))
        assert_equal(sorted(T.edges()), [(0, 1), (1, 2), (1, 3), (2, 4)])

    def test_bfs_edges(self):
        edges = nx.bfs_edges(self.G, source=0)
        assert_equal(list(edges), [(0, 1), (1, 2), (1, 3), (2, 4)])

    def test_bfs_edges_reverse(self):
        D = nx.DiGraph()
        D.add_edges_from([(0, 1), (1, 2), (1, 3), (2, 4), (3, 4)])
        edges = nx.bfs_edges(D, source=4, reverse=True)
        assert_equal(list(edges), [(4, 2), (4, 3), (2, 1), (1, 0)])

    def test_bfs_tree_isolates(self):
        G = nx.Graph()
        G.add_node(1)
        G.add_node(2)
        T = nx.bfs_tree(G, source=1)
        assert_equal(sorted(T.nodes()), [1])
        assert_equal(sorted(T.edges()), [])

"""
Serializer for video outline
"""
from rest_framework.reverse import reverse

from xmodule.modulestore.mongo.base import BLOCK_TYPES_WITH_CHILDREN
from xmodule.modulestore.django import modulestore
from courseware.access import has_access
from courseware.courses import get_course_by_id
from courseware.model_data import FieldDataCache
from courseware.module_render import get_module_for_descriptor
from util.module_utils import get_dynamic_descriptor_children

from edxval.api import (
    get_video_info_for_course_and_profiles, ValInternalError
)


class BlockOutline(object):
    """
    Serializes course videos, pulling data from VAL and the video modules.
    """
    def __init__(self, course_id, start_block, block_types, request, video_profiles):
        """Create a BlockOutline using `start_block` as a starting point."""
        self.start_block = start_block
        self.block_types = block_types
        self.course_id = course_id
        self.request = request  # needed for making full URLS
        self.local_cache = {}
        try:
            self.local_cache['course_videos'] = get_video_info_for_course_and_profiles(
                unicode(course_id), video_profiles
            )
        except ValInternalError:  # pragma: nocover
            self.local_cache['course_videos'] = {}

    def __iter__(self):
        def parent_or_requested_block_type(usage_key):
            """
            Returns whether the usage_key's block_type is one of self.block_types or a parent type.
            """
            return (
                usage_key.block_type in self.block_types or
                usage_key.block_type in BLOCK_TYPES_WITH_CHILDREN
            )

        def create_module(descriptor):
            """
            Factory method for creating and binding a module for the given descriptor.
            """
            field_data_cache = FieldDataCache.cache_for_descriptor_descendents(
                self.course_id, self.request.user, descriptor, depth=0,
            )
            course = get_course_by_id(self.course_id)
            return get_module_for_descriptor(
                self.request.user, self.request, descriptor, field_data_cache, self.course_id, course=course
            )

        with modulestore().bulk_operations(self.course_id):
            child_to_parent = {}
            stack = [self.start_block]
            while stack:
                curr_block = stack.pop()

                if curr_block.hide_from_toc:
                    # For now, if the 'hide_from_toc' setting is set on the block, do not traverse down
                    # the hierarchy.  The reason being is that these blocks may not have human-readable names
                    # to display on the mobile clients.
                    # Eventually, we'll need to figure out how we want these blocks to be displayed on the
                    # mobile clients.  As they are still accessible in the browser, just not navigatable
                    # from the table-of-contents.
                    continue

                if curr_block.location.block_type in self.block_types:
                    if not has_access(self.request.user, 'load', curr_block, course_key=self.course_id):
                        continue

                    summary_fn = self.block_types[curr_block.category]
                    block_path = list(path(curr_block, child_to_parent, self.start_block))
                    unit_url, section_url = find_urls(self.course_id, curr_block, child_to_parent, self.request)

                    yield {
                        "path": block_path,
                        "named_path": [b["name"] for b in block_path],
                        "unit_url": unit_url,
                        "section_url": section_url,
                        "summary": summary_fn(self.course_id, curr_block, self.request, self.local_cache)
                    }

                if curr_block.has_children:
                    children = get_dynamic_descriptor_children(
                        curr_block,
                        self.request.user.id,
                        create_module,
                        usage_key_filter=parent_or_requested_block_type
                    )
                    for block in reversed(children):
                        stack.append(block)
                        child_to_parent[block] = curr_block


def path(block, child_to_parent, start_block):
    """path for block"""
    block_path = []
    while block in child_to_parent:
        block = child_to_parent[block]
        if block is not start_block:
            block_path.append({
                # to be consistent with other edx-platform clients, return the defaulted display name
                'name': block.display_name_with_default,
                'category': block.category,
                'id': unicode(block.location)
            })
    return reversed(block_path)


def find_urls(course_id, block, child_to_parent, request):
    """
    Find the section and unit urls for a block.

    Returns:
        unit_url, section_url:
            unit_url (str): The url of a unit
            section_url (str): The url of a section

    """
    block_path = []
    while block in child_to_parent:
        block = child_to_parent[block]
        block_path.append(block)

    block_list = list(reversed(block_path))
    block_count = len(block_list)

    chapter_id = block_list[1].location.block_id if block_count > 1 else None
    section = block_list[2] if block_count > 2 else None
    position = None

    if block_count > 3:
        position = 1
        for block in section.children:
            if block.name == block_list[3].url_name:
                break
            position += 1

    kwargs = {'course_id': unicode(course_id)}
    if chapter_id is None:
        course_url = reverse("courseware", kwargs=kwargs, request=request)
        return course_url, course_url

    kwargs['chapter'] = chapter_id
    if section is None:
        chapter_url = reverse("courseware_chapter", kwargs=kwargs, request=request)
        return chapter_url, chapter_url

    kwargs['section'] = section.url_name
    section_url = reverse("courseware_section", kwargs=kwargs, request=request)
    if position is None:
        return section_url, section_url

    kwargs['position'] = position
    unit_url = reverse("courseware_position", kwargs=kwargs, request=request)
    return unit_url, section_url


def video_summary(video_profiles, course_id, video_descriptor, request, local_cache):
    """
    returns summary dict for the given video module
    """
    always_available_data = {
        "name": video_descriptor.display_name,
        "category": video_descriptor.category,
        "id": unicode(video_descriptor.scope_ids.usage_id),
        "only_on_web": video_descriptor.only_on_web,
    }

    if video_descriptor.only_on_web:
        ret = {
            "video_url": None,
            "video_thumbnail_url": None,
            "duration": 0,
            "size": 0,
            "transcripts": {},
            "language": None,
        }
        ret.update(always_available_data)
        return ret

    # Get encoded videos
    video_data = local_cache['course_videos'].get(video_descriptor.edx_video_id, {})

    # Get highest priority video to populate backwards compatible field
    default_encoded_video = {}

    if video_data:
        for profile in video_profiles:
            default_encoded_video = video_data['profiles'].get(profile, {})
            if default_encoded_video:
                break

    if default_encoded_video:
        video_url = default_encoded_video['url']
    # Then fall back to VideoDescriptor fields for video URLs
    elif video_descriptor.html5_sources:
        video_url = video_descriptor.html5_sources[0]
    else:
        video_url = video_descriptor.source

    # Get duration/size, else default
    duration = video_data.get('duration', None)
    size = default_encoded_video.get('file_size', 0)

    # Transcripts...
    transcripts_info = video_descriptor.get_transcripts_info()
    transcript_langs = video_descriptor.available_translations(transcripts_info, verify_assets=False)

    transcripts = {
        lang: reverse(
            'video-transcripts-detail',
            kwargs={
                'course_id': unicode(course_id),
                'block_id': video_descriptor.scope_ids.usage_id.block_id,
                'lang': lang
            },
            request=request,
        )
        for lang in transcript_langs
    }

    ret = {
        "video_url": video_url,
        "video_thumbnail_url": None,
        "duration": duration,
        "size": size,
        "transcripts": transcripts,
        "language": video_descriptor.get_default_transcript_language(transcripts_info),
        "encoded_videos": video_data.get('profiles')
    }
    ret.update(always_available_data)
    return ret

import os
import pathlib
from tempfile import NamedTemporaryFile
from queue import Queue

from bears.java import CheckstyleBear
from coalib.testing.BearTestHelper import generate_skip_decorator
from coalib.testing.LocalBearTestHelper import LocalBearTestHelper
from coalib.settings.Section import Section
from coalib.settings.Setting import Setting


@generate_skip_decorator(CheckstyleBear.CheckstyleBear)
class CheckstyleBearTest(LocalBearTestHelper):

    GOOGLE_VALUEERROR_RE = 'ValueError: Google checkstyle config'

    def setUp(self):
        self.section = Section('test section')
        self.uut = CheckstyleBear.CheckstyleBear(self.section, Queue())
        test_files = os.path.join(os.path.dirname(__file__), 'test_files')
        self.good_file = os.path.join(test_files, 'CheckstyleGood.java')
        self.bad_file = os.path.join(test_files, 'CheckstyleBad.java')
        self.empty_config = os.path.join(test_files,
                                         'checkstyle_empty_config.xml')

    def test_style_google(self):
        self.section['checkstyle_configs'] = 'google'
        self.check_validity(self.uut, [], self.good_file)
        self.check_validity(self.uut, [], self.bad_file, valid=False)

    def test_style_sun(self):
        self.section['checkstyle_configs'] = 'sun'
        self.check_validity(self.uut, [], self.good_file, valid=False)
        self.check_validity(self.uut, [], self.bad_file, valid=False)

    def test_style_android(self):
        self.section['checkstyle_configs'] = 'android-check-easy'
        self.check_validity(self.uut, [], self.good_file)
        self.check_validity(self.uut, [], self.bad_file, valid=False)

        self.section['checkstyle_configs'] = 'android-check-hard'
        self.check_validity(self.uut, [], self.good_file)
        self.check_validity(self.uut, [], self.bad_file, valid=False)

    def test_config_failure_use_spaces(self):
        self.section['checkstyle_configs'] = 'google'
        self.section.append(Setting('use_spaces', False))
        with self.assertRaisesRegex(AssertionError, self.GOOGLE_VALUEERROR_RE):
            self.check_validity(self.uut, [], self.good_file)

    def test_config_failure_indent_size(self):
        self.section['checkstyle_configs'] = 'google'
        self.section.append(Setting('indent_size', 3))
        with self.assertRaisesRegex(AssertionError, self.GOOGLE_VALUEERROR_RE):
            self.check_validity(self.uut, [], self.good_file)

    def test_with_custom_configfile(self):
        self.section['checkstyle_configs'] = self.empty_config
        self.check_validity(self.uut, [], self.good_file)
        self.check_validity(self.uut, [], self.bad_file)


def known_checkstyle_test(monkeypatch):
    monkeypatch.setattr(CheckstyleBear, 'known_checkstyles', {'such': 'style'})
    assert CheckstyleBear.known_checkstyle_or_path('such') == 'such'


def known_path_test(monkeypatch):
    monkeypatch.setattr(CheckstyleBear, 'known_checkstyles', {'such': 'style'})
    with NamedTemporaryFile() as coafile, NamedTemporaryFile() as style_file:
        coafile_path = pathlib.Path(coafile.name)
        style_path = pathlib.Path(style_file.name)
        setting = Setting(
            'style_path', style_path.name, origin=str(coafile_path))
        assert (
            CheckstyleBear.known_checkstyle_or_path(setting) == str(style_path)
        )

# Authors: Rob Zinkov, Mathieu Blondel
# License: BSD 3 clause

from .stochastic_gradient import BaseSGDClassifier
from .stochastic_gradient import BaseSGDRegressor
from .stochastic_gradient import DEFAULT_EPSILON


class PassiveAggressiveClassifier(BaseSGDClassifier):
    """Passive Aggressive Classifier

    Read more in the :ref:`User Guide <passive_aggressive>`.

    Parameters
    ----------

    C : float
        Maximum step size (regularization). Defaults to 1.0.

    fit_intercept : bool, default=False
        Whether the intercept should be estimated or not. If False, the
        data is assumed to be already centered.

    n_iter : int, optional
        The number of passes over the training data (aka epochs).
        Defaults to 5.

    shuffle : bool, default=True
        Whether or not the training data should be shuffled after each epoch.

    random_state : int seed, RandomState instance, or None (default)
        The seed of the pseudo random number generator to use when
        shuffling the data.

    verbose : integer, optional
        The verbosity level

    n_jobs : integer, optional
        The number of CPUs to use to do the OVA (One Versus All, for
        multi-class problems) computation. -1 means 'all CPUs'. Defaults
        to 1.

    loss : string, optional
        The loss function to be used:
        hinge: equivalent to PA-I in the reference paper.
        squared_hinge: equivalent to PA-II in the reference paper.

    warm_start : bool, optional
        When set to True, reuse the solution of the previous call to fit as
        initialization, otherwise, just erase the previous solution.

    class_weight : dict, {class_label: weight} or "balanced" or None, optional
        Preset for the class_weight fit parameter.

        Weights associated with classes. If not given, all classes
        are supposed to have weight one.

        The "balanced" mode uses the values of y to automatically adjust
        weights inversely proportional to class frequencies in the input data
        as ``n_samples / (n_classes * np.bincount(y))``

    Attributes
    ----------
    coef_ : array, shape = [1, n_features] if n_classes == 2 else [n_classes,\
            n_features]
        Weights assigned to the features.

    intercept_ : array, shape = [1] if n_classes == 2 else [n_classes]
        Constants in decision function.

    See also
    --------

    SGDClassifier
    Perceptron

    References
    ----------
    Online Passive-Aggressive Algorithms
    <http://jmlr.csail.mit.edu/papers/volume7/crammer06a/crammer06a.pdf>
    K. Crammer, O. Dekel, J. Keshat, S. Shalev-Shwartz, Y. Singer - JMLR (2006)

    """
    def __init__(self, C=1.0, fit_intercept=True, n_iter=5, shuffle=True,
                 verbose=0, loss="hinge", n_jobs=1, random_state=None,
                 warm_start=False, class_weight=None):
        BaseSGDClassifier.__init__(self,
                                   penalty=None,
                                   fit_intercept=fit_intercept,
                                   n_iter=n_iter,
                                   shuffle=shuffle,
                                   verbose=verbose,
                                   random_state=random_state,
                                   eta0=1.0,
                                   warm_start=warm_start,
                                   class_weight=class_weight,
                                   n_jobs=n_jobs)
        self.C = C
        self.loss = loss

    def partial_fit(self, X, y, classes=None):
        """Fit linear model with Passive Aggressive algorithm.

        Parameters
        ----------
        X : {array-like, sparse matrix}, shape = [n_samples, n_features]
            Subset of the training data

        y : numpy array of shape [n_samples]
            Subset of the target values

        classes : array, shape = [n_classes]
            Classes across all calls to partial_fit.
            Can be obtained by via `np.unique(y_all)`, where y_all is the
            target vector of the entire dataset.
            This argument is required for the first call to partial_fit
            and can be omitted in the subsequent calls.
            Note that y doesn't need to contain all labels in `classes`.

        Returns
        -------
        self : returns an instance of self.
        """
        if self.class_weight == 'balanced':
            raise ValueError("class_weight 'balanced' is not supported for "
                             "partial_fit. For 'balanced' weights, use "
                             "`sklearn.utils.compute_class_weight` with "
                             "`class_weight='balanced'`. In place of y you "
                             "can use a large enough subset of the full "
                             "training set target to properly estimate the "
                             "class frequency distributions. Pass the "
                             "resulting weights as the class_weight "
                             "parameter.")
        lr = "pa1" if self.loss == "hinge" else "pa2"
        return self._partial_fit(X, y, alpha=1.0, C=self.C,
                                 loss="hinge", learning_rate=lr, n_iter=1,
                                 classes=classes, sample_weight=None,
                                 coef_init=None, intercept_init=None)

    def fit(self, X, y, coef_init=None, intercept_init=None):
        """Fit linear model with Passive Aggressive algorithm.

        Parameters
        ----------
        X : {array-like, sparse matrix}, shape = [n_samples, n_features]
            Training data

        y : numpy array of shape [n_samples]
            Target values

        coef_init : array, shape = [n_classes,n_features]
            The initial coefficients to warm-start the optimization.

        intercept_init : array, shape = [n_classes]
            The initial intercept to warm-start the optimization.

        Returns
        -------
        self : returns an instance of self.
        """
        lr = "pa1" if self.loss == "hinge" else "pa2"
        return self._fit(X, y, alpha=1.0, C=self.C,
                         loss="hinge", learning_rate=lr,
                         coef_init=coef_init, intercept_init=intercept_init)


class PassiveAggressiveRegressor(BaseSGDRegressor):
    """Passive Aggressive Regressor

    Read more in the :ref:`User Guide <passive_aggressive>`.

    Parameters
    ----------

    C : float
        Maximum step size (regularization). Defaults to 1.0.

    epsilon : float
        If the difference between the current prediction and the correct label
        is below this threshold, the model is not updated.

    fit_intercept : bool
        Whether the intercept should be estimated or not. If False, the
        data is assumed to be already centered. Defaults to True.

    n_iter : int, optional
        The number of passes over the training data (aka epochs).
        Defaults to 5.

    shuffle : bool, default=True
        Whether or not the training data should be shuffled after each epoch.

    random_state : int seed, RandomState instance, or None (default)
        The seed of the pseudo random number generator to use when
        shuffling the data.

    verbose : integer, optional
        The verbosity level

    loss : string, optional
        The loss function to be used:
        epsilon_insensitive: equivalent to PA-I in the reference paper.
        squared_epsilon_insensitive: equivalent to PA-II in the reference
        paper.

    warm_start : bool, optional
        When set to True, reuse the solution of the previous call to fit as
        initialization, otherwise, just erase the previous solution.

    Attributes
    ----------
    coef_ : array, shape = [1, n_features] if n_classes == 2 else [n_classes,\
            n_features]
        Weights assigned to the features.

    intercept_ : array, shape = [1] if n_classes == 2 else [n_classes]
        Constants in decision function.

    See also
    --------

    SGDRegressor

    References
    ----------
    Online Passive-Aggressive Algorithms
    <http://jmlr.csail.mit.edu/papers/volume7/crammer06a/crammer06a.pdf>
    K. Crammer, O. Dekel, J. Keshat, S. Shalev-Shwartz, Y. Singer - JMLR (2006)

    """
    def __init__(self, C=1.0, fit_intercept=True, n_iter=5, shuffle=True,
                 verbose=0, loss="epsilon_insensitive",
                 epsilon=DEFAULT_EPSILON, random_state=None, warm_start=False):
        BaseSGDRegressor.__init__(self,
                                  penalty=None,
                                  l1_ratio=0,
                                  epsilon=epsilon,
                                  eta0=1.0,
                                  fit_intercept=fit_intercept,
                                  n_iter=n_iter,
                                  shuffle=shuffle,
                                  verbose=verbose,
                                  random_state=random_state,
                                  warm_start=warm_start)
        self.C = C
        self.loss = loss

    def partial_fit(self, X, y):
        """Fit linear model with Passive Aggressive algorithm.

        Parameters
        ----------
        X : {array-like, sparse matrix}, shape = [n_samples, n_features]
            Subset of training data

        y : numpy array of shape [n_samples]
            Subset of target values

        Returns
        -------
        self : returns an instance of self.
        """
        lr = "pa1" if self.loss == "epsilon_insensitive" else "pa2"
        return self._partial_fit(X, y, alpha=1.0, C=self.C,
                                 loss="epsilon_insensitive",
                                 learning_rate=lr, n_iter=1,
                                 sample_weight=None,
                                 coef_init=None, intercept_init=None)

    def fit(self, X, y, coef_init=None, intercept_init=None):
        """Fit linear model with Passive Aggressive algorithm.

        Parameters
        ----------
        X : {array-like, sparse matrix}, shape = [n_samples, n_features]
            Training data

        y : numpy array of shape [n_samples]
            Target values

        coef_init : array, shape = [n_features]
            The initial coefficients to warm-start the optimization.

        intercept_init : array, shape = [1]
            The initial intercept to warm-start the optimization.

        Returns
        -------
        self : returns an instance of self.
        """
        lr = "pa1" if self.loss == "epsilon_insensitive" else "pa2"
        return self._fit(X, y, alpha=1.0, C=self.C,
                         loss="epsilon_insensitive",
                         learning_rate=lr,
                         coef_init=coef_init,
                         intercept_init=intercept_init)

# -*- coding: utf-8 -*-
"""
2. Adding __str__() or __unicode__() to models

Although it's not a strict requirement, each model should have a
``_str__()`` or ``__unicode__()`` method to return a "human-readable"
representation of the object. Do this not only for your own sanity when dealing
with the interactive prompt, but also because objects' representations are used
throughout Django's automatically-generated admin.

Normally,  you should write ``__unicode__()`` method, since this will work for
all field types (and Django will automatically provide an appropriate
``__str__()`` method). However, you can write a ``__str__()`` method directly,
if you prefer. You must be careful to encode the results correctly, though.
"""

from django.db import models


class Article(models.Model):
    headline = models.CharField(max_length=100)
    pub_date = models.DateTimeField()

    def __str__(self):
        # Caution: this is only safe if you are certain that headline will be
        # in ASCII.
        return self.headline

class InternationalArticle(models.Model):
    headline = models.CharField(max_length=100)
    pub_date = models.DateTimeField()

    def __unicode__(self):
        return self.headline
#
# Copyright (c) 2008-2015 Citrix Systems, Inc.
#
#   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.
#

from nssrc.com.citrix.netscaler.nitro.resource.base.base_resource import base_resource
from nssrc.com.citrix.netscaler.nitro.resource.base.base_resource import base_response
from nssrc.com.citrix.netscaler.nitro.service.options import options
from nssrc.com.citrix.netscaler.nitro.exception.nitro_exception import nitro_exception

from nssrc.com.citrix.netscaler.nitro.util.nitro_util import nitro_util

class responderpolicy_stats(base_resource) :
	ur""" Statistics for responder policy resource.
	"""
	def __init__(self) :
		self._name = ""
		self._clearstats = ""
		self._pipolicyhits = 0
		self._pipolicyhitsrate = 0
		self._pipolicyundefhits = 0
		self._pipolicyundefhitsrate = 0

	@property
	def name(self) :
		ur"""Name of the responder policy for which to show detailed statistics.<br/>Minimum length =  1.
		"""
		try :
			return self._name
		except Exception as e:
			raise e

	@name.setter
	def name(self, name) :
		ur"""Name of the responder policy for which to show detailed statistics.
		"""
		try :
			self._name = name
		except Exception as e:
			raise e

	@property
	def clearstats(self) :
		ur"""Clear the statsistics / counters.<br/>Possible values = basic, full.
		"""
		try :
			return self._clearstats
		except Exception as e:
			raise e

	@clearstats.setter
	def clearstats(self, clearstats) :
		ur"""Clear the statsistics / counters
		"""
		try :
			self._clearstats = clearstats
		except Exception as e:
			raise e

	@property
	def pipolicyundefhitsrate(self) :
		ur"""Rate (/s) counter for pipolicyundefhits.
		"""
		try :
			return self._pipolicyundefhitsrate
		except Exception as e:
			raise e

	@property
	def pipolicyundefhits(self) :
		ur"""Number of undef hits on the policy.
		"""
		try :
			return self._pipolicyundefhits
		except Exception as e:
			raise e

	@property
	def pipolicyhitsrate(self) :
		ur"""Rate (/s) counter for pipolicyhits.
		"""
		try :
			return self._pipolicyhitsrate
		except Exception as e:
			raise e

	@property
	def pipolicyhits(self) :
		ur"""Number of hits on the policy.
		"""
		try :
			return self._pipolicyhits
		except Exception as e:
			raise e

	def _get_nitro_response(self, service, response) :
		ur""" converts nitro response into object and returns the object array in case of get request.
		"""
		try :
			result = service.payload_formatter.string_to_resource(responderpolicy_response, response, self.__class__.__name__.replace('_stats',''))
			if(result.errorcode != 0) :
				if (result.errorcode == 444) :
					service.clear_session(self)
				if result.severity :
					if (result.severity == "ERROR") :
						raise nitro_exception(result.errorcode, str(result.message), str(result.severity))
				else :
					raise nitro_exception(result.errorcode, str(result.message), str(result.severity))
			return result.responderpolicy
		except Exception as e :
			raise e

	def _get_object_name(self) :
		ur""" Returns the value of object identifier argument
		"""
		try :
			if self.name is not None :
				return str(self.name)
			return None
		except Exception as e :
			raise e



	@classmethod
	def  get(cls, service, name="", option_="") :
		ur""" Use this API to fetch the statistics of all responderpolicy_stats resources that are configured on netscaler.
		"""
		try :
			obj = responderpolicy_stats()
			if not name :
				response = obj.stat_resources(service, option_)
			else :
				obj.name = name
				response = obj.stat_resource(service, option_)
			return response
		except Exception as e:
			raise e

	class Clearstats:
		basic = "basic"
		full = "full"

class responderpolicy_response(base_response) :
	def __init__(self, length=1) :
		self.responderpolicy = []
		self.errorcode = 0
		self.message = ""
		self.severity = ""
		self.sessionid = ""
		self.responderpolicy = [responderpolicy_stats() for _ in range(length)]


from example_tree import letter_tree
from utils import is_word


def depth_first_search(tree, target):
    """
    Exercise 1: Implement your depth first search algorithm here

    The 'tree' parameter contains 'tree.left' and 'tree.right'
    child elements - they may be unset (None) if the node does
    not have left or right children.
    """
    return None

def breadth_first_search(tree, target):
    """
    Exercise 2: Implement your depth first search algorithm here

    Breadth-first search should check the root node first, then each of
    the items at the first level in the tree, then each item at the second
    level, and so on.
    """
    return None

def word_search(tree):
    """
    Exercise 2: Implement a word search using either DFS or BFS.
    Why did you choose one algorithm or the other?
    """
    return None


if __name__ == '__main__':
    dfs_result = depth_first_search(letter_tree, 'f')
    print('Depth first search result: {}'.format(dfs_result))

    bfs_result = breadth_first_search(letter_tree, 'l')
    print('Breadth first search result: {}'.format(bfs_result))

    word_results = word_search(letter_tree)
    print('Word search results: {}'.format(word_results))

#!/usr/bin/env python

# (c) 2014, Jonathan Lestrelin <jonathan.lestrelin@gmail.com>
#
# This file is part of Ansible,
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.

"""
Nagios NDO external inventory script.
========================================

Returns hosts and hostgroups from Nagios NDO.

Configuration is read from `nagios_ndo.ini`.
"""

import os
import argparse
import sys
try:
    import configparser
except ImportError:
    import ConfigParser
    configparser = ConfigParser
import json

try:
    from sqlalchemy import text
    from sqlalchemy.engine import create_engine
except ImportError:
    sys.exit("Error: SQLAlchemy is needed. Try something like: pip install sqlalchemy")


class NagiosNDOInventory(object):

    def read_settings(self):
        config = configparser.SafeConfigParser()
        config.read(os.path.dirname(os.path.realpath(__file__)) + '/nagios_ndo.ini')
        if config.has_option('ndo', 'database_uri'):
            self.ndo_database_uri = config.get('ndo', 'database_uri')

    def read_cli(self):
        parser = argparse.ArgumentParser()
        parser.add_argument('--host', nargs=1)
        parser.add_argument('--list', action='store_true')
        self.options = parser.parse_args()

    def get_hosts(self):
        engine = create_engine(self.ndo_database_uri)
        connection = engine.connect()
        select_hosts = text("SELECT display_name \
                            FROM nagios_hosts")
        select_hostgroups = text("SELECT alias \
                                 FROM nagios_hostgroups")
        select_hostgroup_hosts = text("SELECT h.display_name \
                                       FROM nagios_hostgroup_members hgm, nagios_hosts h, nagios_hostgroups hg \
                                       WHERE hgm.hostgroup_id = hg.hostgroup_id \
                                       AND hgm.host_object_id = h.host_object_id \
                                       AND hg.alias =:hostgroup_alias")

        hosts = connection.execute(select_hosts)
        self.result['all']['hosts'] = [host['display_name'] for host in hosts]

        for hostgroup in connection.execute(select_hostgroups):
            hostgroup_alias = hostgroup['alias']
            self.result[hostgroup_alias] = {}
            hosts = connection.execute(select_hostgroup_hosts, hostgroup_alias=hostgroup_alias)
            self.result[hostgroup_alias]['hosts'] = [host['display_name'] for host in hosts]

    def __init__(self):

        self.defaultgroup = 'group_all'
        self.ndo_database_uri = None
        self.options = None

        self.read_settings()
        self.read_cli()

        self.result = {}
        self.result['all'] = {}
        self.result['all']['hosts'] = []
        self.result['_meta'] = {}
        self.result['_meta']['hostvars'] = {}

        if self.ndo_database_uri:
            self.get_hosts()
            if self.options.host:
                print(json.dumps({}))
            elif self.options.list:
                print(json.dumps(self.result))
            else:
                sys.exit("usage: --list or --host HOSTNAME")
        else:
            sys.exit("Error: Database configuration is missing. See nagios_ndo.ini.")

NagiosNDOInventory()

"""Support for Radio Thermostat wifi-enabled home thermostats."""
import logging

import voluptuous as vol
import radiotherm

from homeassistant.components.climate import ClimateDevice, PLATFORM_SCHEMA
from homeassistant.components.climate.const import (
    HVAC_MODE_AUTO,
    HVAC_MODE_COOL,
    HVAC_MODE_HEAT,
    HVAC_MODE_OFF,
    FAN_ON,
    FAN_OFF,
    CURRENT_HVAC_IDLE,
    CURRENT_HVAC_HEAT,
    CURRENT_HVAC_COOL,
    SUPPORT_TARGET_TEMPERATURE,
    SUPPORT_FAN_MODE,
)
from homeassistant.const import (
    ATTR_TEMPERATURE,
    CONF_HOST,
    PRECISION_HALVES,
    TEMP_FAHRENHEIT,
    STATE_ON,
)
from homeassistant.util import dt as dt_util
import homeassistant.helpers.config_validation as cv

_LOGGER = logging.getLogger(__name__)

ATTR_FAN_ACTION = "fan_action"

CONF_HOLD_TEMP = "hold_temp"

STATE_CIRCULATE = "circulate"

OPERATION_LIST = [HVAC_MODE_AUTO, HVAC_MODE_COOL, HVAC_MODE_HEAT, HVAC_MODE_OFF]
CT30_FAN_OPERATION_LIST = [STATE_ON, HVAC_MODE_AUTO]
CT80_FAN_OPERATION_LIST = [STATE_ON, STATE_CIRCULATE, HVAC_MODE_AUTO]

# Mappings from radiotherm json data codes to and from HASS state
# flags.  CODE is the thermostat integer code and these map to and
# from HASS state flags.

# Programmed temperature mode of the thermostat.
CODE_TO_TEMP_MODE = {
    0: HVAC_MODE_OFF,
    1: HVAC_MODE_HEAT,
    2: HVAC_MODE_COOL,
    3: HVAC_MODE_AUTO,
}
TEMP_MODE_TO_CODE = {v: k for k, v in CODE_TO_TEMP_MODE.items()}

# Programmed fan mode (circulate is supported by CT80 models)
CODE_TO_FAN_MODE = {0: HVAC_MODE_AUTO, 1: STATE_CIRCULATE, 2: STATE_ON}
FAN_MODE_TO_CODE = {v: k for k, v in CODE_TO_FAN_MODE.items()}

# Active thermostat state (is it heating or cooling?).  In the future
# this should probably made into heat and cool binary sensors.
CODE_TO_TEMP_STATE = {0: CURRENT_HVAC_IDLE, 1: CURRENT_HVAC_HEAT, 2: CURRENT_HVAC_COOL}

# Active fan state.  This is if the fan is actually on or not.  In the
# future this should probably made into a binary sensor for the fan.
CODE_TO_FAN_STATE = {0: FAN_OFF, 1: FAN_ON}


def round_temp(temperature):
    """Round a temperature to the resolution of the thermostat.

    RadioThermostats can handle 0.5 degree temps so the input
    temperature is rounded to that value and returned.
    """
    return round(temperature * 2.0) / 2.0


PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
    {
        vol.Optional(CONF_HOST): vol.All(cv.ensure_list, [cv.string]),
        vol.Optional(CONF_HOLD_TEMP, default=False): cv.boolean,
    }
)

SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE


def setup_platform(hass, config, add_entities, discovery_info=None):
    """Set up the Radio Thermostat."""
    hosts = []
    if CONF_HOST in config:
        hosts = config[CONF_HOST]
    else:
        hosts.append(radiotherm.discover.discover_address())

    if hosts is None:
        _LOGGER.error("No Radiotherm Thermostats detected")
        return False

    hold_temp = config.get(CONF_HOLD_TEMP)
    tstats = []

    for host in hosts:
        try:
            tstat = radiotherm.get_thermostat(host)
            tstats.append(RadioThermostat(tstat, hold_temp))
        except OSError:
            _LOGGER.exception("Unable to connect to Radio Thermostat: %s", host)

    add_entities(tstats, True)


class RadioThermostat(ClimateDevice):
    """Representation of a Radio Thermostat."""

    def __init__(self, device, hold_temp):
        """Initialize the thermostat."""
        self.device = device
        self._target_temperature = None
        self._current_temperature = None
        self._current_humidity = None
        self._current_operation = HVAC_MODE_OFF
        self._name = None
        self._fmode = None
        self._fstate = None
        self._tmode = None
        self._tstate = None
        self._hold_temp = hold_temp
        self._hold_set = False
        self._prev_temp = None

        # Fan circulate mode is only supported by the CT80 models.
        self._is_model_ct80 = isinstance(self.device, radiotherm.thermostat.CT80)

    @property
    def supported_features(self):
        """Return the list of supported features."""
        return SUPPORT_FLAGS

    async def async_added_to_hass(self):
        """Register callbacks."""
        # Set the time on the device.  This shouldn't be in the
        # constructor because it's a network call.  We can't put it in
        # update() because calling it will clear any temporary mode or
        # temperature in the thermostat.  So add it as a future job
        # for the event loop to run.
        self.hass.async_add_job(self.set_time)

    @property
    def name(self):
        """Return the name of the Radio Thermostat."""
        return self._name

    @property
    def temperature_unit(self):
        """Return the unit of measurement."""
        return TEMP_FAHRENHEIT

    @property
    def precision(self):
        """Return the precision of the system."""
        return PRECISION_HALVES

    @property
    def device_state_attributes(self):
        """Return the device specific state attributes."""
        return {ATTR_FAN_ACTION: self._fstate}

    @property
    def fan_modes(self):
        """List of available fan modes."""
        if self._is_model_ct80:
            return CT80_FAN_OPERATION_LIST
        return CT30_FAN_OPERATION_LIST

    @property
    def fan_mode(self):
        """Return whether the fan is on."""
        return self._fmode

    def set_fan_mode(self, fan_mode):
        """Turn fan on/off."""
        code = FAN_MODE_TO_CODE.get(fan_mode, None)
        if code is not None:
            self.device.fmode = code

    @property
    def current_temperature(self):
        """Return the current temperature."""
        return self._current_temperature

    @property
    def current_humidity(self):
        """Return the current temperature."""
        return self._current_humidity

    @property
    def hvac_mode(self):
        """Return the current operation. head, cool idle."""
        return self._current_operation

    @property
    def hvac_modes(self):
        """Return the operation modes list."""
        return OPERATION_LIST

    @property
    def hvac_action(self):
        """Return the current running hvac operation if supported."""
        if self.hvac_mode == HVAC_MODE_OFF:
            return None
        return self._tstate

    @property
    def target_temperature(self):
        """Return the temperature we try to reach."""
        return self._target_temperature

    def update(self):
        """Update and validate the data from the thermostat."""
        # Radio thermostats are very slow, and sometimes don't respond
        # very quickly.  So we need to keep the number of calls to them
        # to a bare minimum or we'll hit the HASS 10 sec warning.  We
        # have to make one call to /tstat to get temps but we'll try and
        # keep the other calls to a minimum.  Even with this, these
        # thermostats tend to time out sometimes when they're actively
        # heating or cooling.

        # First time - get the name from the thermostat.  This is
        # normally set in the radio thermostat web app.
        if self._name is None:
            self._name = self.device.name["raw"]

        # Request the current state from the thermostat.
        try:
            data = self.device.tstat["raw"]
        except radiotherm.validate.RadiothermTstatError:
            _LOGGER.warning(
                "%s (%s) was busy (invalid value returned)",
                self._name,
                self.device.host,
            )
            return

        current_temp = data["temp"]

        if self._is_model_ct80:
            try:
                humiditydata = self.device.humidity["raw"]
            except radiotherm.validate.RadiothermTstatError:
                _LOGGER.warning(
                    "%s (%s) was busy (invalid value returned)",
                    self._name,
                    self.device.host,
                )
                return
            self._current_humidity = humiditydata

        # Map thermostat values into various STATE_ flags.
        self._current_temperature = current_temp
        self._fmode = CODE_TO_FAN_MODE[data["fmode"]]
        self._fstate = CODE_TO_FAN_STATE[data["fstate"]]
        self._tmode = CODE_TO_TEMP_MODE[data["tmode"]]
        self._tstate = CODE_TO_TEMP_STATE[data["tstate"]]

        self._current_operation = self._tmode
        if self._tmode == HVAC_MODE_COOL:
            self._target_temperature = data["t_cool"]
        elif self._tmode == HVAC_MODE_HEAT:
            self._target_temperature = data["t_heat"]
        elif self._tmode == HVAC_MODE_AUTO:
            # This doesn't really work - tstate is only set if the HVAC is
            # active. If it's idle, we don't know what to do with the target
            # temperature.
            if self._tstate == CURRENT_HVAC_COOL:
                self._target_temperature = data["t_cool"]
            elif self._tstate == CURRENT_HVAC_HEAT:
                self._target_temperature = data["t_heat"]
        else:
            self._current_operation = HVAC_MODE_OFF

    def set_temperature(self, **kwargs):
        """Set new target temperature."""
        temperature = kwargs.get(ATTR_TEMPERATURE)
        if temperature is None:
            return

        temperature = round_temp(temperature)

        if self._current_operation == HVAC_MODE_COOL:
            self.device.t_cool = temperature
        elif self._current_operation == HVAC_MODE_HEAT:
            self.device.t_heat = temperature
        elif self._current_operation == HVAC_MODE_AUTO:
            if self._tstate == CURRENT_HVAC_COOL:
                self.device.t_cool = temperature
            elif self._tstate == CURRENT_HVAC_HEAT:
                self.device.t_heat = temperature

        # Only change the hold if requested or if hold mode was turned
        # on and we haven't set it yet.
        if kwargs.get("hold_changed", False) or not self._hold_set:
            if self._hold_temp:
                self.device.hold = 1
                self._hold_set = True
            else:
                self.device.hold = 0

    def set_time(self):
        """Set device time."""
        # Calling this clears any local temperature override and
        # reverts to the scheduled temperature.
        now = dt_util.now()
        self.device.time = {
            "day": now.weekday(),
            "hour": now.hour,
            "minute": now.minute,
        }

    def set_hvac_mode(self, hvac_mode):
        """Set operation mode (auto, cool, heat, off)."""
        if hvac_mode in (HVAC_MODE_OFF, HVAC_MODE_AUTO):
            self.device.tmode = TEMP_MODE_TO_CODE[hvac_mode]

        # Setting t_cool or t_heat automatically changes tmode.
        elif hvac_mode == HVAC_MODE_COOL:
            self.device.t_cool = self._target_temperature
        elif hvac_mode == HVAC_MODE_HEAT:
            self.device.t_heat = self._target_temperature

"""collect scripts from a directory and create documentation
stubs.

Files starting with lower case characters are put into
the directory :file:`scripts`, while those starting with
upper case characters are put into :file:`modules`.
"""

TEMPLATE_SCRIPT = '''
.. automodule:: %(prefix)s

.. program-output:: python ../scripts/%(prefix)s.py --help

'''

TEMPLATE_MODULE = '''
.. automodule:: %(prefix)s
   :members:
   :show-inheritance:
'''

TEMPLATE_PIPELINE = '''
.. image:: ../images/%(prefix)s.svg

.. automodule:: %(prefix)s
   :members:
   :show-inheritance:

'''

TEMPLATE_PIPELINEMODULE = '''
.. automodule:: %(prefix)s
   :members:
   :show-inheritance:
'''

import glob
import os
import CGAT.Experiment as E

if __name__ == "__main__":

    E.Start()

    dirs = (("../scripts/*.py", TEMPLATE_SCRIPT, 'scripts'),
            ("../CGAT/*.py", TEMPLATE_MODULE, 'modules'),
            ("../CGATPipelines/pipeline*.py",
             TEMPLATE_PIPELINE,
             'pipelines'),
            ("../CGATPipelines/[A-Z]*.py",
             TEMPLATE_PIPELINEMODULE,
             'pipelinemodules'))

    ncreated, nskipped = 0, 0

    for glob_expression, template, dest in dirs:

        if not os.path.exists(dest):
            os.mkdir(dest)

        files = glob.glob(os.path.abspath(glob_expression))

        for filename in files:
            dirname, name = os.path.split(filename)
            prefix = name[:-3]

            # if os.path.exists( os.path.join( dirname, "_%s.pyx" % prefix )):
            #     E.warn( "ignoring pyximport file _%s.pyx" % prefix )
            #     continue

            filename = os.path.join(os.path.abspath(dest), "%s.rst" % prefix)
            if os.path.exists(filename):
                nskipped += 1
                continue

            E.debug("adding %s" % filename)
            outfile = open(filename, "w")
            outfile.write(template % locals())
            outfile.close()

            ncreated += 1

    E.info("ncreated=%i, nskipped=%i" % (ncreated, nskipped))

    E.Stop()

#!/usr/bin/env python3
# Copyright (c) 2017-2017 The Bitcoin Core developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.

#
# Test getblockstats rpc call
#
from test_framework.test_framework import BitcoinTestFramework
from test_framework.util import (
    assert_equal,
    assert_raises_rpc_error,
)
import json
import os
import time

TESTSDIR = os.path.dirname(os.path.realpath(__file__))

class GetblockstatsTest(BitcoinTestFramework):

    start_height = 101
    max_stat_pos = 2
    STATS_NEED_TXINDEX = [
        'avgfee',
        'avgfeerate',
        'maxfee',
        'maxfeerate',
        'medianfee',
        'medianfeerate',
        'minfee',
        'minfeerate',
        'totalfee',
        'utxo_size_inc',
    ]

    def add_options(self, parser):
        parser.add_option('--gen-test-data', dest='gen_test_data',
                          default=False, action='store_true',
                          help='Generate test data')
        parser.add_option('--test-data', dest='test_data',
                          default='data/rpc_getblockstats.json',
                          action='store', metavar='FILE',
                          help='Test data file')

    def set_test_params(self):
        self.num_nodes = 2
        self.extra_args = [['-txindex'], ['-paytxfee=0.003']]
        self.setup_clean_chain = True

    def get_stats(self):
        return [self.nodes[0].getblockstats(hash_or_height=self.start_height + i) for i in range(self.max_stat_pos+1)]

    def generate_test_data(self, filename):
        mocktime = time.time()
        self.nodes[0].generate(101)

        self.nodes[0].sendtoaddress(address=self.nodes[1].getnewaddress(), amount=10, subtractfeefromamount=True)
        self.nodes[0].generate(1)
        self.sync_all()

        self.nodes[0].sendtoaddress(address=self.nodes[0].getnewaddress(), amount=10, subtractfeefromamount=True)
        self.nodes[0].sendtoaddress(address=self.nodes[0].getnewaddress(), amount=10, subtractfeefromamount=False)
        self.nodes[1].sendtoaddress(address=self.nodes[0].getnewaddress(), amount=1, subtractfeefromamount=True)
        self.sync_all()
        self.nodes[0].generate(1)

        self.expected_stats = self.get_stats()

        blocks = []
        tip = self.nodes[0].getbestblockhash()
        blockhash = None
        height = 0
        while tip != blockhash:
            blockhash = self.nodes[0].getblockhash(height)
            blocks.append(self.nodes[0].getblock(blockhash, 0))
            height += 1

        to_dump = {
            'blocks': blocks,
            'mocktime': int(mocktime),
            'stats': self.expected_stats,
        }
        with open(filename, 'w', encoding="utf8") as f:
            json.dump(to_dump, f, sort_keys=True, indent=2)

    def load_test_data(self, filename):
        with open(filename, 'r', encoding="utf8") as f:
            d = json.load(f)
            blocks = d['blocks']
            mocktime = d['mocktime']
            self.expected_stats = d['stats']

        # Set the timestamps from the file so that the nodes can get out of Initial Block Download
        self.nodes[0].setmocktime(mocktime)
        self.nodes[1].setmocktime(mocktime)

        for b in blocks:
            self.nodes[0].submitblock(b)

    def run_test(self):
        test_data = os.path.join(TESTSDIR, self.options.test_data)
        if self.options.gen_test_data:
            self.generate_test_data(test_data)
        else:
            self.load_test_data(test_data)

        self.sync_all()
        stats = self.get_stats()
        expected_stats_noindex = []
        for stat_row in stats:
            expected_stats_noindex.append({k: v for k, v in stat_row.items() if k not in self.STATS_NEED_TXINDEX})

        # Make sure all valid statistics are included but nothing else is
        expected_keys = self.expected_stats[0].keys()
        assert_equal(set(stats[0].keys()), set(expected_keys))

        assert_equal(stats[0]['height'], self.start_height)
        assert_equal(stats[self.max_stat_pos]['height'], self.start_height + self.max_stat_pos)

        for i in range(self.max_stat_pos+1):
            self.log.info('Checking block %d\n' % (i))
            assert_equal(stats[i], self.expected_stats[i])

            # Check selecting block by hash too
            blockhash = self.expected_stats[i]['blockhash']
            stats_by_hash = self.nodes[0].getblockstats(hash_or_height=blockhash)
            assert_equal(stats_by_hash, self.expected_stats[i])

            # Check with the node that has no txindex
            stats_no_txindex = self.nodes[1].getblockstats(hash_or_height=blockhash, stats=list(expected_stats_noindex[i].keys()))
            assert_equal(stats_no_txindex, expected_stats_noindex[i])

        # Make sure each stat can be queried on its own
        for stat in expected_keys:
            for i in range(self.max_stat_pos+1):
                result = self.nodes[0].getblockstats(hash_or_height=self.start_height + i, stats=[stat])
                assert_equal(list(result.keys()), [stat])
                if result[stat] != self.expected_stats[i][stat]:
                    self.log.info('result[%s] (%d) failed, %r != %r' % (
                        stat, i, result[stat], self.expected_stats[i][stat]))
                assert_equal(result[stat], self.expected_stats[i][stat])

        # Make sure only the selected statistics are included (more than one)
        some_stats = {'minfee', 'maxfee'}
        stats = self.nodes[0].getblockstats(hash_or_height=1, stats=list(some_stats))
        assert_equal(set(stats.keys()), some_stats)

        # Test invalid parameters raise the proper json exceptions
        tip = self.start_height + self.max_stat_pos
        assert_raises_rpc_error(-8, 'Target block height %d after current tip %d' % (tip+1, tip),
                                self.nodes[0].getblockstats, hash_or_height=tip+1)
        assert_raises_rpc_error(-8, 'Target block height %d is negative' % (-1),
                                self.nodes[0].getblockstats, hash_or_height=-1)

        # Make sure not valid stats aren't allowed
        inv_sel_stat = 'asdfghjkl'
        inv_stats = [
            [inv_sel_stat],
            ['minfee' , inv_sel_stat],
            [inv_sel_stat, 'minfee'],
            ['minfee', inv_sel_stat, 'maxfee'],
        ]
        for inv_stat in inv_stats:
            assert_raises_rpc_error(-8, 'Invalid selected statistic %s' % inv_sel_stat,
                                    self.nodes[0].getblockstats, hash_or_height=1, stats=inv_stat)

        # Make sure we aren't always returning inv_sel_stat as the culprit stat
        assert_raises_rpc_error(-8, 'Invalid selected statistic aaa%s' % inv_sel_stat,
                                self.nodes[0].getblockstats, hash_or_height=1, stats=['minfee' , 'aaa%s' % inv_sel_stat])

        assert_raises_rpc_error(-8, 'One or more of the selected stats requires -txindex enabled',
                                self.nodes[1].getblockstats, hash_or_height=self.start_height + self.max_stat_pos)

        # Mainchain's genesis block shouldn't be found on regtest
        assert_raises_rpc_error(-5, 'Block not found', self.nodes[0].getblockstats,
                                hash_or_height='000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f')

if __name__ == '__main__':
    GetblockstatsTest().main()

# Copyright (C) 2014 VA Linux Systems Japan K.K.
# Copyright (C) 2014 YAMAMOTO Takashi <yamamoto at valinux co jp>
# All Rights Reserved.
#
#    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.


import mock
from oslo.utils import importutils

import neutron.plugins.ofagent.agent.metadata as meta
from neutron.tests.unit.ofagent import ofa_test_base


class TestOFAgentFlows(ofa_test_base.OFATestBase):

    _MOD = 'neutron.plugins.ofagent.agent.flows'

    def setUp(self):
        super(TestOFAgentFlows, self).setUp()
        self.mod = importutils.import_module(self._MOD)
        self.br = self.mod.OFAgentIntegrationBridge()
        self.br.set_dp(self._mk_test_dp("dp"))

    def test_setup_default_table(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.setup_default_table()
        (dp, ofp, ofpp) = br._get_dp()
        arp = importutils.import_module('ryu.lib.packet.arp')
        ether = importutils.import_module('ryu.ofproto.ether')
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE,
                 match=ofpp.OFPMatch(), out_group=ofp.OFPG_ANY,
                 out_port=ofp.OFPP_ANY, priority=0, table_id=ofp.OFPTT_ALL)),
            call(ofpp.OFPFlowMod(dp, priority=0, table_id=0)),
            call(ofpp.OFPFlowMod(dp, priority=0, table_id=1)),
            call(ofpp.OFPFlowMod(dp, priority=0, table_id=2)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=7)],
                 priority=0, table_id=3)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=5)],
                 priority=0, table_id=4)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=6)],
                 priority=0, table_id=5)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
                 [ofpp.OFPActionOutput(ofp.OFPP_CONTROLLER)])],
                 match=ofpp.OFPMatch(arp_op=arp.ARP_REQUEST,
                 eth_type=ether.ETH_TYPE_ARP), priority=1, table_id=6)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=7)],
                 priority=0, table_id=6)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=8)],
                 priority=0, table_id=7)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=9)],
                 priority=0, table_id=8)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=10)],
                 priority=0, table_id=9)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=11)],
                 priority=0, table_id=10)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=12)],
                 priority=0, table_id=11)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=13)],
                 priority=0, table_id=12)),
            call(ofpp.OFPFlowMod(dp, priority=0, table_id=13)),
        ]
        sendmsg.assert_has_calls(expected_calls, any_order=True)

    def test_install_arp_responder(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.install_arp_responder(table_id=99)
        (dp, ofp, ofpp) = br._get_dp()
        arp = importutils.import_module('ryu.lib.packet.arp')
        ether = importutils.import_module('ryu.ofproto.ether')
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
                 [ofpp.OFPActionOutput(ofp.OFPP_CONTROLLER)])],
                 match=ofpp.OFPMatch(arp_op=arp.ARP_REQUEST,
                 eth_type=ether.ETH_TYPE_ARP), priority=1, table_id=99)),
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionGotoTable(table_id=100)],
                 priority=0, table_id=99)),
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_install_tunnel_output(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.install_tunnel_output(table_id=110, network=111,
                                     segmentation_id=112, ports=[113, 114],
                                     goto_next=True)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(
                ofpp.OFPFlowMod(
                    dp,
                    instructions=[
                        ofpp.OFPInstructionActions(
                            ofp.OFPIT_APPLY_ACTIONS,
                            [
                                ofpp.OFPActionSetField(tunnel_id=112),
                                ofpp.OFPActionOutput(port=113),
                                ofpp.OFPActionOutput(port=114)
                            ]
                        ),
                        ofpp.OFPInstructionGotoTable(table_id=111)
                    ],
                    match=ofpp.OFPMatch(
                        metadata=meta.mk_metadata(111, meta.LOCAL)
                    ),
                    priority=1,
                    table_id=110
                )
            )
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_delete_tunnel_output(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.delete_tunnel_output(table_id=110, network=111)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(
                ofpp.OFPFlowMod(
                    dp,
                    command=ofp.OFPFC_DELETE,
                    match=ofpp.OFPMatch(
                        metadata=meta.mk_metadata(111, meta.LOCAL)
                    ),
                    out_group=ofp.OFPG_ANY,
                    out_port=ofp.OFPP_ANY, priority=0, table_id=110
                )
            )
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_provision_tenant_tunnel(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.provision_tenant_tunnel(network_type="gre", network=150,
                                       segmentation_id=151)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionWriteMetadata(metadata=150,
                 metadata_mask=meta.NETWORK_MASK),
                 ofpp.OFPInstructionGotoTable(table_id=7)],
                 match=ofpp.OFPMatch(tunnel_id=151), priority=1, table_id=1))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_reclaim_tenant_tunnel(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.reclaim_tenant_tunnel(network_type="gre", network=150,
                                     segmentation_id=151)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE,
                 match=ofpp.OFPMatch(tunnel_id=151), out_group=ofp.OFPG_ANY,
                 out_port=ofp.OFPP_ANY, priority=0, table_id=1))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_provision_tenant_physnet(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.provision_tenant_physnet(network_type="vlan", network=150,
                                        segmentation_id=151, phys_port=99)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, instructions=[
                    ofpp.OFPInstructionWriteMetadata(metadata=150,
                        metadata_mask=meta.NETWORK_MASK),
                    ofpp.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, [
                        ofpp.OFPActionPopVlan()]),
                    ofpp.OFPInstructionGotoTable(table_id=3)],
                match=ofpp.OFPMatch(in_port=99,
                                    vlan_vid=151 | ofp.OFPVID_PRESENT),
                priority=1, table_id=0)),
            call(
                ofpp.OFPFlowMod(
                    dp,
                    instructions=[
                        ofpp.OFPInstructionActions(
                            ofp.OFPIT_APPLY_ACTIONS,
                            [
                                ofpp.OFPActionPushVlan(),
                                ofpp.OFPActionSetField(
                                    vlan_vid=151 | ofp.OFPVID_PRESENT
                                ),
                                ofpp.OFPActionOutput(port=99),
                                ofpp.OFPActionPopVlan()
                            ]
                        ),
                        ofpp.OFPInstructionGotoTable(table_id=13)
                    ],
                    match=ofpp.OFPMatch(
                        metadata=meta.mk_metadata(150, meta.LOCAL)
                    ),
                    priority=1,
                    table_id=12
                )
            )
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_reclaim_tenant_physnet(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.reclaim_tenant_physnet(network_type="vlan", network=150,
                                      segmentation_id=151, phys_port=99)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE,
                 match=ofpp.OFPMatch(in_port=99,
                     vlan_vid=151 | ofp.OFPVID_PRESENT),
                 out_group=ofp.OFPG_ANY, out_port=ofp.OFPP_ANY, priority=0,
                 table_id=0)),
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE,
                 match=ofpp.OFPMatch(metadata=meta.mk_metadata(150)),
                 out_group=ofp.OFPG_ANY, out_port=ofp.OFPP_ANY, priority=0,
                 table_id=12))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_check_in_port_add_tunnel_port(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.check_in_port_add_tunnel_port(network_type="gre", port=99)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp,
                 instructions=[ofpp.OFPInstructionGotoTable(table_id=1)],
                 match=ofpp.OFPMatch(in_port=99), priority=1, table_id=0))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_check_in_port_add_local_port(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.check_in_port_add_local_port(network=123, port=99)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp,
                 instructions=[
                     ofpp.OFPInstructionWriteMetadata(
                         metadata=meta.LOCAL | 123,
                         metadata_mask=meta.LOCAL | meta.NETWORK_MASK),
                     ofpp.OFPInstructionGotoTable(table_id=4)],
                 match=ofpp.OFPMatch(in_port=99), priority=1, table_id=0))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_check_in_port_delete_port(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.check_in_port_delete_port(port=99)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE,
                 match=ofpp.OFPMatch(in_port=99), out_group=ofp.OFPG_ANY,
                 out_port=ofp.OFPP_ANY, priority=0, table_id=0))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_local_flood_update(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.local_flood_update(network=1234, ports=[1, 2, 3],
                                  flood_unicast=True)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp,
                 instructions=[ofpp.OFPInstructionActions(
                     ofp.OFPIT_APPLY_ACTIONS, [
                         ofpp.OFPActionOutput(port=1),
                         ofpp.OFPActionOutput(port=2),
                         ofpp.OFPActionOutput(port=3)])],
                     match=ofpp.OFPMatch(metadata=meta.mk_metadata(1234)),
                 priority=1, table_id=13)),
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE_STRICT,
                 match=ofpp.OFPMatch(
                     eth_dst=('01:00:00:00:00:00', '01:00:00:00:00:00'),
                     metadata=meta.mk_metadata(1234)),
                 out_group=ofp.OFPG_ANY, out_port=ofp.OFPP_ANY, priority=1,
                 table_id=13))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_local_flood_delete(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.local_flood_delete(network=1234)
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE,
                 match=ofpp.OFPMatch(metadata=meta.mk_metadata(1234)),
                 out_group=ofp.OFPG_ANY, out_port=ofp.OFPP_ANY, priority=0,
                 table_id=13))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_local_out_add_port(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.local_out_add_port(network=1234, port=7,
                                  mac='12:34:56:78:9a:bc')
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, instructions=[
                 ofpp.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS,
                 [ofpp.OFPActionOutput(port=7)])],
                 match=ofpp.OFPMatch(eth_dst="12:34:56:78:9a:bc",
                 metadata=meta.mk_metadata(1234)), priority=1, table_id=8))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_local_out_delete_port(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.local_out_delete_port(network=1234, mac='12:34:56:78:9a:bc')
        (dp, ofp, ofpp) = br._get_dp()
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, command=ofp.OFPFC_DELETE,
                 match=ofpp.OFPMatch(eth_dst="12:34:56:78:9a:bc",
                 metadata=meta.mk_metadata(1234)), out_group=ofp.OFPG_ANY,
                 out_port=ofp.OFPP_ANY, priority=0, table_id=8))
        ]
        sendmsg.assert_has_calls(expected_calls)

    def test_arp_passthrough(self):
        br = self.br
        with mock.patch.object(br, '_send_msg') as sendmsg:
            br.arp_passthrough(network=1234, tpa='192.0.2.1')
        (dp, ofp, ofpp) = br._get_dp()
        arp = importutils.import_module('ryu.lib.packet.arp')
        ether = importutils.import_module('ryu.ofproto.ether')
        call = mock.call
        expected_calls = [
            call(ofpp.OFPFlowMod(dp, idle_timeout=5,
                 instructions=[ofpp.OFPInstructionGotoTable(table_id=7)],
                 match=ofpp.OFPMatch(arp_op=arp.ARP_REQUEST,
                 arp_tpa="192.0.2.1", eth_type=ether.ETH_TYPE_ARP,
                 metadata=meta.mk_metadata(1234)), priority=1, table_id=5))
        ]
        sendmsg.assert_has_calls(expected_calls)